Come faccio a convertire una stringa in un numero intero in JavaScript?

Il modo più semplice sarebbe usare la Numberfunzione nativa :

var x = Number("1000")

Se questo non funziona per voi, poi ci sono il parseInt , unario più , parseFloat con pavimento e Math.round metodi.

parseInt:

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 se la tua stringa è già nella forma di un numero intero:

var x = +"1000";

se la tua stringa è o potrebbe essere un float e desideri un numero intero:

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

oppure, se utilizzerai Math.floor più volte:

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

Se sei il tipo che dimentica di inserire il radix quando chiami parseInt, puoi usare parseFloat e arrotondarlo come preferisci. Qui uso floor.

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

È interessante notare che Math.round (come Math.floor) eseguirà una conversione da stringa a numero, quindi se vuoi arrotondare il numero (o se hai un numero intero nella stringa), questo è un ottimo modo, forse il mio preferito:

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

Prova la funzione parseInt:

var number = parseInt("10");

Ma c'è un problema. Se si tenta di convertire "010" utilizzando la funzione parseInt, rileva come numero ottale e restituirà il numero 8. Quindi, è necessario specificare una radice (da 2 a 36). In questo caso base 10.

parseInt(string, radix)

Esempio:

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

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

Nota che parseIntignora i dati errati dopo aver analizzato qualcosa di valido.
Questo guid analizzerà come 51:

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

Esistono due modi principali per convertire una stringa in un numero in javascript. Un modo è analizzarlo e l'altro è cambiare il suo tipo in un numero. Tutti i trucchi nelle altre risposte (ad es. Unario più) comportano implicitamente la forzatura del tipo di stringa su un numero. Puoi anche fare la stessa cosa esplicitamente con la funzione Numero.

parsing

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

parseInt e parseFloat sono le due funzioni utilizzate per l'analisi delle stringhe in numeri. L'analisi si interromperà silenziosamente se colpisce un carattere che non riconosce, il che può essere utile per analizzare stringhe come "92px", ma è anche un po 'pericoloso, poiché non ti darà alcun tipo di errore su input errati, invece tu tornerà NaN a meno che la stringa non inizi con un numero. Lo spazio bianco all'inizio della stringa viene ignorato. Ecco un esempio del fatto che fa qualcosa di diverso da quello che vuoi e non dà alcuna indicazione che qualcosa sia andato storto:

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

È buona norma specificare sempre la radice come secondo argomento. Nei browser più vecchi, se la stringa avesse inizio con uno 0, sarebbe interpretata come ottale se non fosse stata specificata la radice che avrebbe sorpreso molte persone. Il comportamento per esadecimali viene attivato facendo iniziare la stringa con 0x se non viene specificata alcuna radice, ad es0xff . Lo standard in realtà è cambiato con ecmascript 5, quindi i browser moderni non attivano più ottale quando c'è uno 0 iniziale se non è stato specificato alcun radix. parseInt comprende i radix fino alla base 36, nel qual caso sia le lettere maiuscole che minuscole sono trattate come equivalenti.

Modifica del tipo di una stringa in un numero

Tutti gli altri trucchi sopra menzionati che non usano parseInt, implicano implicitamente la forzatura della stringa in un numero. Preferisco farlo esplicitamente,

var cast = Number("97");

Ciò ha un comportamento diverso rispetto ai metodi di analisi (sebbene ignori ancora gli spazi bianchi). È più rigoroso: se non comprende l'intera stringa di quanto ritorni NaN, quindi non puoi usarla per stringhe come 97px. Poiché desideri un numero primitivo anziché un oggetto wrapper Numero, assicurati di non inserirlonew davanti alla funzione Numero.

Ovviamente, la conversione in un numero ti dà un valore che potrebbe essere un float anziché un numero intero, quindi se vuoi un numero intero, devi modificarlo. Ci sono alcuni modi per farlo:

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

Qualsiasi operatore bit per bit (qui ho fatto un bit per bit o, ma potresti anche fare una doppia negazione come in una risposta precedente o un bit-shift) convertirà il valore in un numero intero a 32 bit, e la maggior parte di essi convertirà in un numero intero con segno. Si noti che ciò non è necessario per numeri interi di grandi dimensioni . Se l'intero non può essere rappresentato in 32 bit, andrà a capo.

~~"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

Per funzionare correttamente con numeri più grandi, è necessario utilizzare i metodi di arrotondamento

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

Tieni presente che tutti questi metodi comprendono la notazione esponenziale, quindi 2e2è 200piuttosto che NaN. Inoltre, Numero comprende "Infinito", mentre i metodi di analisi no.

costume

È improbabile che uno di questi metodi faccia esattamente quello che vuoi. Ad esempio, di solito vorrei che venisse generato un errore se l'analisi non riesce e non ho bisogno del supporto per Infinity, esponenziali o spazi bianchi iniziali. A seconda del caso d'uso, a volte ha senso scrivere una funzione di conversione personalizzata.

Verificare sempre che l'output di Number o uno dei metodi di analisi sia il tipo di numero previsto. Quasi sicuramente vorrai utilizzarlo isNaNper assicurarti che il numero non sia NaN (di solito l'unico modo per scoprire che l'analisi non è riuscita).

ParseInt () e + sono diversi

parseInt("10.3456") // returns 10

+"10.3456" // returns 10.3456

Anche se una vecchia domanda, ma forse questo può essere utile a qualcuno.

Uso questo modo di convertire la stringa in numero int

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

Quindi, quando si moltiplica per 1, il valore non cambia, ma js restituisce automaticamente un numero.

Ma come mostrato di seguito, questo dovrebbe essere usato se si è certi che str è un numero (o può essere rappresentato come un numero), altrimenti restituirà NaN, non un numero.

puoi creare una semplice funzione da usare, ad es

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

più veloce

var x = "1000"*1;

Test

Ecco un piccolo confronto di velocità (solo Mac Os) ... :)

Per Chrome "più" e "mul" sono i più veloci (> 700.000,00 op / sec), "Math.floor" è il più lento. Per Firefox 'plus' è il più lento (!) 'Mul' è il più veloce (> 900.000.000 op / sec). In Safari "parseInt" è veloce, "numero" è più lento (ma i risultati sono abbastanza simili,> 13.000.000 <31.000.000). Quindi Safari per cast stringa in int è più di 10 volte più lento di altri browser. Quindi il vincitore è ' mul ' :)

Puoi eseguirlo sul tuo browser da questo link https://jsperf.com/js-cast-str-to-number/1

Aggiornare

Ho anche testato var x = ~~"1000";- su Chrome e Safari è un po 'più lento di var x = "1000"*1(<1%), su Firefox è un po' più veloce (<1%). Aggiornamento foto sopra e test

Prova a analizzare.

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

Ho pubblicato la risposta sbagliata qui, scusa. fisso.

Questa è una vecchia domanda, ma adoro questo trucco:

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

Il doppio negativo bit a bit rilascia qualsiasi cosa dopo il punto decimale E lo converte in un formato numerico. Mi è stato detto che è leggermente più veloce di chiamare funzioni e quant'altro, ma non sono del tutto convinto.

EDIT: un altro metodo che ho appena visto qui (una domanda sull'operatore javascript >>>, che è uno spostamento destro a riempimento zero) che mostra che spostare un numero di 0 con questo operatore converte il numero in un uint32 che è bello se tu lo voglio anche senza segno . Ancora una volta, questo viene convertito in un numero intero senza segno , il che può portare a comportamenti strani se si utilizza un numero con segno .

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

Fai attenzione se usi parseInt per convertire un float in notazione scientifica! Per esempio:

parseInt("5.6e-14") 

si tradurrà in

5 

invece di

0

Per convertire una stringa in numero intero, ti consiglio di usare parseFloat e NOT parseInt. Ecco perché:

Utilizzando parseFloat:

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

Utilizzando parseInt:

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

Quindi se hai notato che parseInt elimina i valori dopo i decimali, mentre parseFloat ti consente di lavorare con numeri in virgola mobile e quindi più adatto se vuoi conservare i valori dopo i decimali. Usa parseInt se e solo se sei sicuro di volere il valore intero.

Anche come nota a margine: Mootools ha la funzione toInt () che viene utilizzata su qualsiasi stringa nativa (o float (o intero)).

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

Si prega di vedere l'esempio seguente. Aiuterà a chiarire i tuoi dubbi

Example                  Result

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

usando la funzione parseint Darà solo op dell'intero presente e non della stringa

possiamo usare +(stringOfNumber) invece di usareparseInt(stringOfNumber)

Es: +("21")restituisce int di 21 come ilparseInt("21") .

possiamo usare questo operatore "+" unario anche per l'analisi del float ...

Prova str - 0a convertire stringin 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

Ecco due link per confrontare le prestazioni di diversi modi per convertire la stringa in int

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

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

Esistono molti modi in JavaScript per convertire una stringa in un valore numerico ... Tutto semplice e pratico, scegli il modo in cui uno funziona per te:

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

Inoltre, qualsiasi operazione matematica li converte in numero, ad esempio ...

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

Il mio modo preferito è usare +sign, che è il modo elegante per convertire una stringa in numero in JavaScript.

Google mi ha dato questa risposta come risultato, quindi ...

In realtà avevo bisogno di "salvare" una stringa come numero intero, per un'associazione tra C e JavaScript, quindi converto la stringa in un valore intero:

/*
    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;
}

A mio avviso, nessuna risposta copre tutti i casi limite poiché l'analisi di un float dovrebbe comportare un errore.

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

Ecco la soluzione più semplice

let myNumber = "123" | 0;

Soluzione più semplice

let myNumber = +"123";

tutto quanto sopra è corretto. Si prega di essere sicuri prima che questo sia un numero in una stringa facendo "typeot x === 'numero'" in altro modo tornerà NaN

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

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

Un'altra opzione è raddoppiare XOR il valore con se stesso:

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

Questo produrrà:

i = 12.34
i ⊕ i ⊕ i = 12

Ho aggiunto solo uno più (+) prima della stringa e quella era la soluzione!

+"052254" //52254

Spero che sia d'aiuto ;)

Sommando la moltiplicazione delle cifre con la rispettiva potenza di dieci:

cioè: 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;

}

Io lo uso

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

in questo modo ottengo sempre un ritorno.

Il modo più sicuro per assicurarti di ottenere un numero intero valido:

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

Esempi:

// 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);
}

puoi usare più, ad esempio =>

var personAge = '24'; var personAge1 = (+ personAge)

allora puoi vedere typeof personAge è numero