Jak przekonwertować ciąg w JavaScript na liczbę całkowitą?

Najprostszym sposobem byłoby użycie Numberfunkcji natywnej :

var x = Number("1000")

Jeśli to nie zadziała, istnieją metody parseInt , unary plus , parseFloat z floor i Math.round .

parsowanie:

var x = parseInt("1000", 10); // you want to use radix 10
    // so you get a decimal number even with a leading 0 and an old browser ([IE8, Firefox 20, Chrome 22 and older][1])

unary plus, jeśli ciąg jest już w postaci liczby całkowitej:

var x = +"1000";

jeśli Twój ciąg jest lub może być liczbą zmiennoprzecinkową i potrzebujesz liczby całkowitej:

var x = Math.floor("1000.01"); //floor automatically converts string to number

lub, jeśli zamierzasz używać Math.floor kilka razy:

var floor = Math.floor;
var x = floor("1000.01");

Jeśli jesteś typem, który zapomina wstawić podstawkę, gdy wywołujesz parseInt, możesz użyć parseFloat i zaokrąglić go, jak chcesz. Tutaj używam podłogi.

var floor = Math.floor;
var x = floor(parseFloat("1000.01"));

Co ciekawe, Math.round (jak Math.floor) wykona konwersję ciągu na liczbę, więc jeśli chcesz zaokrąglić liczbę (lub jeśli masz liczbę całkowitą w ciągu), jest to świetny sposób, być może mój ulubiony:

var round = Math.round;
var x = round("1000"); //equivalent to round("1000",0)

Wypróbuj funkcję parsowania:

var number = parseInt("10");

Ale jest problem. Jeśli spróbujesz przekonwertować „010” za pomocą funkcji parsowania, wykryje ona liczbę ósemkową i zwróci liczbę 8. Tak więc musisz określić podstawkę (od 2 do 36). W tym przypadku podstawa 10.

parseInt(string, radix)

Przykład:

var result = parseInt("010", 10) == 10; // Returns true

var result = parseInt("010") == 10; // Returns false

Pamiętaj, że parseIntignoruje złe dane po przeanalizowaniu dowolnego ważnego elementu.
Ten przewodnik będzie analizował jako 51:

var result = parseInt('51e3daf6-b521-446a-9f5b-a1bb4d8bac36', 10) == 51; // Returns true

Istnieją dwa główne sposoby konwertowania ciągu na liczbę w javascript. Jednym ze sposobów jest parsowanie go, a drugim sposobem jest zmiana jego typu na Liczba. Wszystkie sztuczki w innych odpowiedziach (np. Jednoargumentowy plus) polegają na niejawnym wymuszeniu typu ciągu na liczbę. Możesz również zrobić to samo wyraźnie za pomocą funkcji Number.

Rozbiór gramatyczny zdania

var parsed = parseInt("97", 10);

parseInt i parseFloat to dwie funkcje używane do parsowania ciągów znaków na liczby. Parsowanie zakończy się po cichu, jeśli trafi w znak, którego nie rozpoznaje, co może być przydatne do parsowania ciągów takich jak „92px”, ale jest również nieco niebezpieczne, ponieważ nie spowoduje żadnego błędu przy złym wprowadzaniu, zamiast tego Zwrócę NaN, chyba że ciąg zaczyna się od cyfry. Białe znaki na początku łańcucha są ignorowane. Oto przykład tego, że robi coś innego niż chcesz i nie daje żadnych wskazówek, że coś poszło nie tak:

var widgetsSold = parseInt("97,800", 10); // widgetsSold is now 97

Dobrą praktyką jest zawsze podawanie podstawnika jako drugiego argumentu. W starszych przeglądarkach, jeśli ciąg zaczynałby się od 0, byłby interpretowany jako ósemkowy, gdyby nie podano podstawki, co zaskoczyło wiele osób. Zachowanie w systemie szesnastkowym jest wyzwalane przez rozpoczęcie łańcucha od 0x, jeśli nie podano żadnej podstawki, np 0xff. Standard faktycznie zmienił się wraz z ecmascript 5, więc współczesne przeglądarki nie wyzwalają już ósemki, gdy na początku jest 0, jeśli nie podano podstawnika. parseInt rozumie podstawniki do podstawy 36, w którym to przypadku zarówno duże, jak i małe litery są traktowane jako równoważne.

Zmiana typu ciągu na liczbę

Wszystkie inne sztuczki wspomniane powyżej, które nie używają parseInt, obejmują niejawne zmuszanie łańcucha do liczby. Wolę to robić jawnie,

var cast = Number("97");

To działa inaczej niż metody parsowania (chociaż nadal ignoruje białe znaki). Jest to bardziej rygorystyczne: jeśli nie rozumie całego łańcucha, niż zwraca NaN, więc nie można go używać do takich łańcuchów 97px. Ponieważ chcesz prymitywnej liczby zamiast obiektu opakowującego liczby, upewnij się, że nie umieszczasz jej newprzed funkcją Number.

Oczywiście konwersja na liczbę daje wartość, która może być liczbą zmiennoprzecinkową, a nie liczbą całkowitą, więc jeśli chcesz liczbę całkowitą, musisz ją zmodyfikować. Można to zrobić na kilka sposobów:

var rounded = Math.floor(Number("97.654"));  // other options are Math.ceil, Math.round
var fixed = Number("97.654").toFixed(0); // rounded rather than truncated
var bitwised = Number("97.654")|0;  // do not use for large numbers

Każdy operator bitowy (tutaj zrobiłem bitowo lub, ale możesz również zrobić podwójną negację, jak we wcześniejszej odpowiedzi lub przesunięciu bitów) przekonwertuje wartość na 32-bitową liczbę całkowitą, a większość z nich zamieni się na liczbę całkowitą ze znakiem. Zauważ, że nie będzie to pożądane dla dużych liczb całkowitych . Jeśli liczby całkowitej nie można przedstawić w 32 bitach, zostanie ona zawinięta.

~~"3000000000.654" === -1294967296
// This is the same as
Number("3000000000.654")|0
"3000000000.654" >>> 0 === 3000000000 // unsigned right shift gives you an extra bit
"300000000000.654" >>> 0 === 3647256576 // but still fails with larger numbers

Aby działać poprawnie z większymi liczbami, należy użyć metod zaokrąglania

Math.floor("3000000000.654") === 3000000000
// This is the same as
Math.floor(Number("3000000000.654"))

Należy pamiętać, że wszystkie te metody zrozumieć notacji wykładniczej, więc 2e2jest 200raczej niż Nan. Ponadto Number rozumie „Infinity”, podczas gdy metody analizy nie.

Zwyczaj

Jest mało prawdopodobne, aby którakolwiek z tych metod działała dokładnie tak, jak chcesz. Na przykład zwykle chciałbym, aby błąd był zgłaszany, jeśli parsowanie się nie powiedzie, i nie potrzebuję wsparcia dla nieskończoności, wykładniczej lub wiodących białych znaków. W zależności od przypadku, czasem warto napisać niestandardową funkcję konwersji.

Zawsze sprawdź, czy wynikiem działania metody Number lub jednej z metod analizy jest liczba, której oczekujesz. Prawie na pewno będziesz chciał użyć, isNaNaby upewnić się, że liczba nie jest NaN (zazwyczaj jedyny sposób, aby dowiedzieć się, że analiza nie powiodła się).

ParseInt () i + są różne

parseInt("10.3456") // returns 10

+"10.3456" // returns 10.3456

Najszybszy

var x = "1000"*1;

Test

Oto małe porównanie prędkości (tylko Mac OS) ... :)

Dla chrome „plus” i „mul” są najszybsze (> 700 000,00 operacji na sekundę), „Math.floor” jest najwolniejszy. W przeglądarce Firefox „plus” jest najwolniejszy (!) „Mul” jest najszybszy (> 900 000 000 operacji na sekundę). W Safari „parseInt” jest postem, „liczba” jest najwolniejsza (ale wyniki są dość podobne,> 13 000 000 <31 000 000). Dlatego Safari dla rzutowania ciągu na int jest ponad 10 razy wolniejsze niż inne przeglądarki. Zwycięża więc „ Mul ” :)

Możesz uruchomić go w przeglądarce za pomocą tego linku https://jsperf.com/js-cast-str-to-number/1

Aktualizacja

Testuję również var x = ~~"1000";- w Chrome i Safari jest nieco wolniejszy niż var x = "1000"*1(<1%), w Firefox jest nieco szybszy (<1%). Aktualizuję powyższe zdjęcie i testuję

Choć stare pytanie, ale może to komuś pomóc.

Używam tego sposób konwertowania ciąg do int numer

var str = "25";       // string
var number = str*1;   // number

Tak więc, mnożąc przez 1, wartość się nie zmienia, ale js automatycznie zwraca liczbę.

Ale jak pokazano poniżej, należy tego użyć, jeśli masz pewność, że strjest to liczba (lub może być reprezentowana jako liczba), w przeciwnym razie zwróci NaN - nie liczbę.

możesz stworzyć prostą w użyciu funkcję, np

function toNumber(str) {
   return str*1;
}

Spróbuj parsować.

var number = parseInt("10", 10); //number will have value of 10.

Przepraszam, wysłałem tutaj złą odpowiedź. naprawiony.

To stare pytanie, ale uwielbiam tę sztuczkę:

~~"2.123"; //2
~~"5"; //5

Podwójnie ujemny bitowy porzuca kropkę po przecinku ORAZ konwertuje ją na format liczbowy. Powiedziano mi, że jest to nieco szybsze niż wywoływanie funkcji i tak dalej, ale nie jestem do końca przekonany.

EDYCJA: Inna metoda, którą właśnie widziałem tutaj (pytanie o javascript >>>, która jest przesunięciem zera w prawo), która pokazuje, że przesunięcie liczby o 0 za pomocą tego operatora przekształca liczbę na uint32, co jest miłe, jeśli też chcę to bez znaku . Ponownie, konwertuje to na liczbę całkowitą bez znaku , co może prowadzić do dziwnych zachowań, jeśli użyjesz podpisanego numeru.

"-2.123" >>> 0; // 4294967294
"2.123" >>> 0; // 2
"-5" >>> 0; // 4294967291
"5" >>> 0; // 5

Uważaj, jeśli używasz parseInt do konwersji pływaka w notacji naukowej! Na przykład:

parseInt("5.6e-14") 

spowoduje

5 

zamiast

0

Aby przekonwertować ciąg na liczbę całkowitą, polecam użycie parseFloat i NOT parseInt. Dlatego:

Za pomocą parseFloat:

parseFloat('2.34cms')  //Output: 2.34
parseFloat('12.5')     //Output: 12.5
parseFloat('012.3')    //Output: 12.3

Za pomocą parseInt:

parseInt('2.34cms')  //Output: 2
parseInt('12.5')     //Output: 12
parseInt('012.3')    //Output: 12

Jeśli zauważyłeś, że parseInt odrzuca wartości po przecinku, podczas gdy parseFloat pozwala pracować z liczbami zmiennoprzecinkowymi, a zatem bardziej odpowiednie, jeśli chcesz zachować wartości po dziesiętnych. Użyj parseInt wtedy i tylko wtedy, gdy masz pewność, że chcesz uzyskać wartość całkowitą.

Również na marginesie: Mootools ma funkcję toInt (), która jest używana na dowolnym natywnym ciągu (lub zmiennoprzecinkowym (lub całkowitym)).

"2".toInt()   // 2
"2px".toInt() // 2
2.toInt()     // 2

Zobacz poniższy przykład, który pomoże ci wyjaśnić swoje wątpliwości

Example                  Result

parseInt("4")            4
parseInt("5aaa")         5
parseInt("4.33333")      4
parseInt("aaa");         NaN (means "Not a Number")

za pomocą funkcji parsowania Podaje tylko liczbę całkowitą występującą, a nie ciąg

możemy użyć +(stringOfNumber) zamiast używaćparseInt(stringOfNumber)

Przykład: +("21")zwraca liczbę całkowitą z 21, jak parseInt("21").

możemy także użyć tego jednoargumentowego operatora „+” do analizowania zmiennoprzecinkowego ...

W JavaScript jest wiele sposobów na konwersję ciągu na wartość liczbową ... Wszystkie proste i przydatne, wybierz sposób, który dla Ciebie działa:

var num = Number("999.5"); //999.5
var num = parseInt("999.5", 10); //999
var num = parseFloat("999.5"); //999.5
var num = +"999.5"; //999.5

Również dowolne operacje matematyczne konwertują je na liczby, na przykład ...

var num = "999.5" / 1; //999.5
var num = "999.5" * 1; //999.5
var num = "999.5" - 1 + 1; //999.5
var num = "999.5" - 0; //999.5
var num = Math.floor("999.5"); //999
var num = ~~"999.5"; //999

Moim ulubionym sposobem jest użycie +znaku, który jest eleganckim sposobem konwersji ciągu znaków na liczbę w JavaScript.

Spróbuj str - 0przekonwertować stringna number.

> str = '0'
> str - 0
  0
> str = '123'
> str - 0
  123
> str = '-12'
> str - 0
  -12
> str = 'asdf'
> str - 0
  NaN
> str = '12.34'
> str - 0
  12.34

Oto dwa łącza do porównania wydajności kilku sposobów konwersji łańcucha na int

https://jsperf.com/number-vs-parseint-vs-plus

http://phrogz.net/js/string_to_number.html

Google dało mi tę odpowiedź, więc ...

Właściwie musiałem „zapisać” ciąg jako liczbę całkowitą, aby uzyskać powiązanie między C i JavaScript, więc przekonwertowałem ciąg na wartość całkowitą:

/*
    Examples:
        int2str( str2int("test") ) == "test" // true
        int2str( str2int("t€st") ) // "t¬st", because "€".charCodeAt(0) is 8364, will be AND'ed with 0xff
    Limitations:
        max 4 chars, so it fits into an integer
*/
function str2int(the_str) {
    var ret = 0;
    var len = the_str.length;
    if (len >= 1) ret += (the_str.charCodeAt(0) & 0xff) <<  0;
    if (len >= 2) ret += (the_str.charCodeAt(1) & 0xff) <<  8;
    if (len >= 3) ret += (the_str.charCodeAt(2) & 0xff) << 16;
    if (len >= 4) ret += (the_str.charCodeAt(3) & 0xff) << 24;
    return ret;
}
function int2str(the_int) {
    var tmp = [
        (the_int & 0x000000ff) >>  0,
        (the_int & 0x0000ff00) >>  8,
        (the_int & 0x00ff0000) >> 16,
        (the_int & 0xff000000) >> 24
    ];
    var ret = "";
    for (var i=0; i<4; i++) {
        if (tmp[i] == 0)
            break;
        ret += String.fromCharCode(tmp[i]);
    }
    return ret;
}

Moim zdaniem, żadna odpowiedź nie obejmuje wszystkich przypadków krawędzi, ponieważ parsowanie zmiennoprzecinkowe powinno spowodować błąd.

function parseInteger(value) {
    if(value === '') return NaN;
    const number = Number(value);
    return Number.isInteger(number) ? number : NaN;
}

parseInteger("4")            // 4
parseInteger("5aaa")         // NaN
parseInteger("4.33333")      // NaN
parseInteger("aaa");         // NaN

Oto najprostsze rozwiązanie

let myNumber = "123" | 0;

Łatwiejsze rozwiązanie

let myNumber = +"123";

wszystkie powyższe są poprawne. Przedtem upewnij się, że jest to liczba w ciągu znaków, wpisując „typeot x === 'number'”, w przeciwnym razie zwróci NaN

 var num = "fsdfsdf242342";
 typeof num => 'string';

 var num1 = "12423";
 typeof num1 => 'number';
 +num1 = > 12423`

Inną opcją jest podwojenie wartości XOR samą w sobie:

var i = 12.34;
console.log('i = ' + i);
console.log('i ⊕ i ⊕ i = ' + (i ^ i ^ i));

Spowoduje to:

i = 12.34
i ⊕ i ⊕ i = 12

Dodałem tylko jeden plus (+) przed ciągiem i to było rozwiązanie!

+"052254" //52254

Mam nadzieję, że to pomoże ;)

Podsumowując mnożenie cyfr z ich odpowiednią siłą dziesięciu:

tj .: 123 = 100 + 20 + 3 = 1 * 100 + 2 + 10 + 3 * 1 = 1 * (10 ^ 2) + 2 * (10 ^ 1) + 3 * (10 ^ 0)

function atoi(array) {

// use exp as (length - i), other option would be to reverse the array.
// multiply a[i] * 10^(exp) and sum

let sum = 0;

for (let i = 0; i < array.length; i++) {
    let exp = array.length-(i+1);
    let value = array[i] * Math.pow(10,exp);
    sum+=value;
}

return sum;

}

używam tego

String.prototype.toInt = function (returnval) { 
    var i = parseInt(this);
    return isNaN(i) ? returnval !== undefined ? returnval : - 1  :      i; 
}

w ten sposób zawsze odzyskuję int.

Najbezpieczniejszy sposób na uzyskanie prawidłowej liczby całkowitej:

let integer = (parseInt(value, 10) || 0);

Przykłady:

// Example 1 - Invalid value:
let value = null;
let integer = (parseInt(value, 10) || 0);
// => integer = 0

// Example 2 - Valid value:
let value = "1230.42";
let integer = (parseInt(value, 10) || 0);
// => integer = 1230

// Example 3 - Invalid value:
let value = () => { return 412 };
let integer = (parseInt(value, 10) || 0);
// => integer = 0

function parseIntSmarter(str) {
    // ParseInt is bad because it returns 22 for "22thisendsintext"
    // Number() is returns NaN if it ends in non-numbers, but it returns 0 for empty or whitespace strings.
    return isNaN(Number(str)) ? NaN : parseInt(str, 10);
}

możesz użyć plus, na przykład =>

var personAge = „24”; var personAge1 = (+ personAge)

wtedy zobaczysz typ osoby Wiek jest liczbą