Convertire una stringa in un intero?

Question

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

Answer 1

Il modo più semplice sarebbe quella di utilizzare la funzione Number origini:

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])

più unario Se la stringa è già nella forma di un numero intero:

var x = +"1000";

Se la stringa è, o potrebbe essere un galleggiante e si desidera un numero intero:

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

o, se avete intenzione di utilizzare Math.floor più volte:

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

Se siete il tipo che dimentica di mettere il radix in quando si chiama parseInt, è possibile utilizzare parseFloat e rotondo che più vi piace. Qui uso pavimento.

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

È interessante notare che, Math.round (come Math.floor) farà una stringa di conversione numero, quindi se si desidera che il numero arrotondato (o se si dispone di un intero nella stringa), questo è un ottimo modo, forse il mio preferito :

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

Answer 2

Funzione Prova parseInt:

var number = parseInt("10");

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

parseInt(string, radix)

Esempio:

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

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

Si noti che parseInt ignora i dati male, dopo l'analisi di qualsiasi cosa valida.
Questo guid analizzerà come 51:

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

Answer 3

Ci sono due modi principali per convertire una stringa in un numero in javascript. Un modo è quello di analizzarlo e l'altro modo è quello di cambiare il tipo ad un numero. Tutti i trucchi delle altre risposte (per esempio più unario) coinvolgono implicitamente costringere il tipo di stringa in un numero. È anche possibile fare la stessa cosa in modo esplicito con la funzione di numero.

Analisi

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

parseInt e parseFloat sono le due funzioni utilizzate per l'analisi di stringhe in numeri. Di analisi si fermerà in silenzio se colpisce un personaggio che non riconosce, che può essere utile per analizzare le stringhe come "92px", ma è anche un po 'pericoloso, dal momento che non vi darà alcun tipo di errore su input non validi, invece 'll ottenere indietro NaN a meno che la stringa inizia con un numero. Gli spazi bianchi all'inizio della stringa viene ignorato. Ecco un esempio di esso fare qualcosa di diverso da ciò che si vuole, e dando alcuna indicazione che qualcosa è andato storto:

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

E 'buona norma specificare sempre il radix come secondo argomento. In browser più vecchi, se la stringa è iniziato con un 0, sarebbe interpretato come ottale se la radice non è stato specificato che ha preso un sacco di gente di sorpresa. Il comportamento di esadecimale viene attivata facendo iniziare la stringa con 0x se non viene specificato Radix, ad esempio 0xff. Lo standard effettivamente cambiato con ECMAScript 5, i browser in modo da innescare moderni non ottale quando c'è un 0 iniziale, se è stato specificato alcun radix. parseInt capisce radixes fino a base 36, nel qual caso entrambe le lettere maiuscole e minuscole sono trattate come equivalenti.

Modifica del tipo di una stringa in un numero

Tutti gli altri trucchi di cui sopra che non usano parseInt, coinvolgono implicitamente costringere la stringa in un numero. Io preferisco farlo in modo esplicito,

var cast = Number("97");

Questo ha un comportamento diverso dai metodi parse (anche se ancora ignora gli spazi bianchi). E 'più severa: se non capisce l'intera stringa che restituisce NaN, quindi non è possibile utilizzarlo per le stringhe come 97px. Dal momento che si desidera un numero primitiva, piuttosto che un oggetto wrapper numero, assicuratevi di non mettere new davanti alla funzione di numero.

Ovviamente, è la conversione in un numero dà un valore che potrebbe essere un galleggiante piuttosto che un intero, quindi se si vuole un intero, è necessario 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

Un operatore bit a bit (qui ho fatto un bit per bit o, ma si potrebbe anche fare doppia negazione come in una precedente risposta o un Bitshift) converte il valore di un intero a 32 bit, e la maggior parte di loro convertirà ad un firmato numero intero. Si noti che questo sarà non voglio che si desidera per i grandi numeri interi . Se il numero intero non può essere rappresentato in 32bit, esso 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 i numeri più grandi, è necessario utilizzare i metodi di arrotondamento

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

Tenete a mente che tutti questi metodi capire la notazione esponenziale, così 2e2 è 200 piuttosto che NaN. Inoltre, numero capisce "Infinito", mentre i metodi di parsing non lo fanno.

personalizzato

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

Verificare sempre che l'uscita del numero o di uno dei metodi di parsing è il tipo di numero che si aspetta. Sarà quasi certamente desidera utilizzare isNaN per assicurarsi che il numero non è NaN (di solito l'unico modo in cui si scopre che il parse non).

Answer 4

parseInt () e + sono diversi

parseInt("10.3456") // returns 10

+"10.3456" // returns 10.3456

Answer 5

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

Io uso questo modo di convertire stringa int numero

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

Così, quando moltiplicando per 1, il valore non cambia, ma js ritorna automaticamente un numero.

Ma, come si è mostrato di seguito, questo dovrebbe essere utilizzato se si è certi che il str è un numero (o può essere rappresentato come un numero), altrimenti tornerà NaN - non un numero

.

è possibile creare la funzione semplice da usare, per esempio.

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

Answer 6

Prova parseInt.

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

Answer 7

veloce

var x = "1000"*1;

test

Ecco piccolo confronto della velocità (solo Mac OS) ...:)

Per Chrome 'plus' e 'mul' sono più veloci (> 700,000,00 op / sec), 'Math.floor' è più lento. Per Firefox 'plus' è il più lento (!) 'Mul' è più veloce (> 900 milioni op / sec). In Safari 'parseInt' è fastes, 'numero' è più lento (ma resulats sono abbastanza simili,> 13.000.000 <31 milioni). Così Safari per stringa cast int è più di 10 volte più lento di altri browser. Così il vincitore è ' mul ':)

È possibile eseguire sul proprio browser questo link https://jsperf.com/js-cast-str-to-number/ 1

Aggiorna

Ho anche prova var x = ~~"1000"; - su Chrome e Safari è un po 'più lento rispetto var x = "1000"*1 (<1%), su Firefox è un po' più veloce (<1%). Aggiorno sopra dell'immagine e test

Answer 8

ho postato la risposta sbagliata qui, mi dispiace. fisso.

Questa è una vecchia questione, ma io amo questo trucco:

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

Il negativo doppio bit a bit cade nulla dopo la virgola e lo converte in un formato numerico. Mi è stato detto che è leggermente più veloce di funzioni e quant'altro chiamare, ma non ne sono del tutto convinto.

EDIT: Un altro metodo che ho appena visto qui (una domanda su javaScript >>> operatore, che è uno zero-fill spostamento a destra), che mostra che il passaggio di un numero da 0 a questo operatore converte il numero di una uint32 che è bello se si vuole anche unsigned . Di nuovo, questo si trasforma in un numero intero senza segno , che può portare a strani comportamenti se si utilizza un numero con segno.

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

Answer 9

Attenzione se si utilizza parseInt per convertire un float in notazione scientifica! Ad esempio:

parseInt("5.6e-14") 

si tradurrà in

5 

anziché

0

Answer 10

Anche come nota a margine:. Mootools ha la funzione Toint () che è usato su qualsiasi stringa nativa (o galleggiante (o integer))

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

Answer 11

Per convertire una stringa in intero, mi consiglia di utilizzare parseFloat e non parseInt. Ecco perché:

Utilizzo parseFloat:

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

parseInt Usando:

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

Quindi, se avete notato parseInt scarta i valori dopo i decimali, mentre parseFloat consente di lavorare con i numeri in virgola e quindi più adatto galleggiante, se si desidera mantenere i valori decimali dopo. Utilizzare parseInt se e solo se si è certi che si desidera che il valore intero.

Answer 12

Si prega di vedere il seguito example.It aiuterà chiaro il tuo dubbio

Example                  Result

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

utilizzando funzione parseInt Sarà solo dare op di interi presente e non la stringa

Answer 13

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

Esempio:. +("21") ritorna int di 21 come il parseInt("21")

possiamo usare questo operatore unario "+" per l'analisi del galleggiante troppo ...

Answer 14

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

Qui ci sono due collegamenti 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

Answer 15

Ci sono molti modi in JavaScript per convertire una stringa in un valore numerico ... Tutte semplici e manuali, scegliere il modo che si lavora per voi:

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

Anche qualsiasi Math operazione li converte in numero, per 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 preferiscono modo è usare segno +, che è il modo elegante per convertire una stringa per numerare in JavaScript.

Answer 16

A mio parere, nessuna risposta copre tutti i casi limite, come l'analisi di un galleggiante dovrebbe portare a 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

Answer 17

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

In realtà ho bisogno di "salvare" una stringa come un intero, per un legame tra C e JavaScript, in modo da convertire 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;
}

Answer 18

tutto quanto sopra sono corretti. Si prega di essere sicuri prima che questo è un numero in una stringa facendo "typeot x === 'numero'" altro saggio verrà restituito NaN

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

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

Answer 19

Un'altra opzione è quella di doppio XOR il valore con se stesso:

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

Questa uscita volontà:

i = 12.34
i ⊕ i ⊕ i = 12

Answer 20

function doSth(){
  var a = document.getElementById('input').value;
  document.getElementById('number').innerHTML = toNumber(a) + 1;
}
function toNumber(str){
  return +str;
}

<input id="input" type="text">
<input onclick="doSth()" type="submit">
<span id="number"></span>

Answer 21

Io uso questo

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

in questo modo ottengo sempre un int indietro.

Answer 22

Ho aggiunto solo un segno più (+) prima della stringa e che è stato soluzione!

+"052254" //52254

Speranza che aiuta;)

Answer 23

Riassumendo la moltiplicazione di cifre con la rispettiva potenza di dieci:

Per esempio: 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;

}

Answer 24

Qui è la soluzione più semplice

let myNumber = "123" | 0;

Answer 25

Il modo più sicuro per essere sicuri 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

Answer 26

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