La funzione parseInt() analizza un argomento stringa e restituisce un numero intero della radice specificata (la base nei sistemi numerici matematici).
parseInt(string, radix);
stringstring non è una stringa, viene convertito in una stringa (utilizzando l'operazione astratta ToString). Gli spazi bianchi iniziali nell'argomento stringa vengono ignorati.radixUn numero intero analizzato dalla stringa specificata. Se il primo carattere non può essere convertito in un numero, viene restituito {{jsxref("NaN")}}.
La funzione parseInt converte il suo primo argomento in una stringa, lo analizza e restituisce un numero intero o NaN. Se non è NaN, il valore restituito sarà l'intero che è il primo argomento preso come numero nella radice specificata (base). Ad esempio, una radice di 10 indica la conversione da un numero decimale, 8 ottali, 16 esadecimali e così via. Per le radici sopra 10, le lettere dell'alfabeto indicano numeri maggiori di 9. Ad esempio, per i numeri esadecimali (base 16), vengono utilizzate le lettere da A a F.
Se parseInt incontra un carattere che non è un numero nella radice specificata, lo ignora e tutti i caratteri successivi e restituisce il valore intero analizzato fino a quel punto. parseInt tronca i numeri ai valori interi. Sono ammessi spazi iniziali e finali.
Poiché alcuni numeri includono il carattere e nella loro rappresentazione di stringa (ad esempio 6.022e23), l'uso di parseInt per troncare valori numerici produrrà risultati imprevisti se utilizzato su numeri molto grandi o molto piccoli. parseInt non dovrebbe essere usato come sostituto di {{jsxref("Math.floor()")}}.
Se radix è undefined o 0 (o assente), JavaScript assume quanto segue:
string inizia con "0x" o "0X", radix è 16 (esadecimale) e il resto della stringa viene analizzato.string inizia con "0", radix è otto (ottale) o 10 (decimale). Esattamente quale radix è scelto dipende dall'implementazione. ECMAScript 5 specifica che viene utilizzato 10 (decimale), ma non tutti i browser lo supportano ancora. Per questo motivo specifica sempre una radice quando usi parseInt.string inizia con qualsiasi altro valore, la radice è 10 (decimale).Se il primo carattere non può essere convertito in un numero, parseInt restituisce NaN.
Per scopi aritmetici, il valore NaN vnon è un numero in nessuna radice. È possibile chiamare la funzione {{jsxref("isNaN")}} per determinare se il risultato di parseInt è NaN. Se NaN viene passato alle operazioni aritmetiche, i risultati dell'operazione saranno anche NaN.
Per convertire il numero nella sua stringa letterale in una particolare radix, usa intValue.toString(radix).
Tutti gli esempi seguenti restituiscono 15:
parseInt('0xF', 16);
parseInt('F', 16);
parseInt('17', 8);
parseInt(021, 8);
parseInt('015', 10); // parseInt(015, 10); ritornerà 15
parseInt(15.99, 10);
parseInt('15,123', 10);
parseInt('FXX123', 16);
parseInt('1111', 2);
parseInt('15 * 3', 10);
parseInt('15e2', 10);
parseInt('15px', 10);
parseInt('12', 13);
I seguenti esempi restituiscono tutti NaN:
parseInt('Hello', 8); // Non è un numero
parseInt('546', 2); // Le cifre non sono valide per le rappresentazioni binarie
Tutti gli esempi seguenti restituiscono -15:
parseInt('-F', 16);
parseInt('-0F', 16);
parseInt('-0XF', 16);
parseInt(-15.1, 10);
parseInt('-17', 8);
parseInt('-15', 10);
parseInt('-1111', 2);
parseInt('-15e1', 10);
parseInt('-12', 13);
Tutti gli esempi seguenti restituiscono 4:
parseInt(4.7, 10); parseInt(4.7 * 1e22, 10); // Il numero molto grande diventa 4 parseInt(0.00000000000434, 10); // Il numero molto piccolo diventa 4
L'esempio seguente restituisce 224:
parseInt('0e0', 16);
Sebbene scoraggiato da ECMAScript 3 e proibito da ECMAScript 5, molte implementazioni interpretano una stringa numerica che inizia con uno 0 iniziale come ottale. Il seguente potrebbe avere un risultato ottale o potrebbe avere un risultato decimale. Specifica sempre una radice per evitare questo comportamento inaffidabile.
parseInt('0e0'); // 0
parseInt('08'); // 0, '8' non è una cifra ottale.
La specifica ECMAScript 5 della funzione parseInt non consente più alle implementazioni di trattare le stringhe che iniziano con un carattere 0 come valori ottali. ECMAScript 5 afferma:
La funzione parseInt produce un valore intero dettato dall'interpretazione del contenuto dell'argomento stringa in base alla radice specificata. Lo spazio bianco principale nella stringa viene ignorato. Se radix non è definito o 0, si presume che sia 10 tranne quando il numero inizia con le coppie di caratteri 0x o 0X, nel qual caso si assume una radice di 16.
Ciò differisce da ECMAScript 3, che scoraggiava, ma consentiva l'interpretazione ottale.
Molte implementazioni non hanno adottato questo comportamento a partire dal 2013 e, poiché i browser più vecchi devono essere supportati, specificare sempre una radice.
A volte è utile avere un modo più rigoroso di analizzare i valori int. Le espressioni regolari possono aiutare:
var filterInt = function(value) {
if (/^(-|\+)?(\d+|Infinity)$/.test(value))
return Number(value);
return NaN;
}
console.log(filterInt('421')); // 421
console.log(filterInt('-421')); // -421
console.log(filterInt('+421')); // 421
console.log(filterInt('Infinity')); // Infinity
console.log(filterInt('421e+0')); // NaN
console.log(filterInt('421hop')); // NaN
console.log(filterInt('hop1.61803398875')); // NaN
console.log(filterInt('1.61803398875')); // NaN
| Specifica | Stato | Commento |
|---|---|---|
| {{SpecName('ES1')}} | {{Spec2('ES1')}} | Definizione iniziale. |
| {{SpecName('ES5.1', '#sec-15.1.2.2', 'parseInt')}} | {{Spec2('ES5.1')}} | |
| {{SpecName('ES6', '#sec-parseint-string-radix', 'parseInt')}} | {{Spec2('ES6')}} | |
| {{SpecName('ESDraft', '#sec-parseint-string-radix', 'parseInt')}} | {{Spec2('ESDraft')}} |
{{Compat("javascript.builtins.parseInt")}}