La funzione parseInt() analizza un argomento stringa e restituisce un numero intero della radice specificata (la base nei sistemi numerici matematici).

Sintassi

parseInt(string, radix);

Parametri

string
Il valore da analizzare. Se l'argomento string non è una stringa, viene convertito in una stringa (utilizzando l'operazione astratta ToString). Gli spazi bianchi iniziali nell'argomento stringa vengono ignorati.
radix
Un numero intero compreso tra 2 e 36 che rappresenta la radice (la base nei sistemi numerici matematici) della stringa sopra menzionata.

Valore di ritorno

Un numero intero analizzato dalla stringa specificata. Se il primo carattere non può essere convertito in un numero, viene restituito NaN.

Descrizione

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 Math.floor().

Se radix è undefined o 0 (o assente), JavaScript assume quanto segue:

  • Se l'input string inizia con "0x" o "0X", radix è 16 (esadecimale) e il resto della stringa viene analizzato.
  • Se l'input 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.
  • Se l'input 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 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).

Esempi

Usare parseInt

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

Interpretazioni ottali senza radix

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.

ECMAScript 5 rimuove l'interpretazione 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 0x0X, 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.

Una funzione di analisi più rigorosa

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

Specifiche

Specifica Stato Commento
ECMAScript 1st Edition (ECMA-262) Standard Definizione iniziale.
ECMAScript 5.1 (ECMA-262)
The definition of 'parseInt' in that specification.
Standard  
ECMAScript 2015 (6th Edition, ECMA-262)
The definition of 'parseInt' in that specification.
Standard  
ECMAScript Latest Draft (ECMA-262)
The definition of 'parseInt' in that specification.
Draft  

Compatibilità con i browser

Update compatibility data on GitHub
DesktopMobileServer
ChromeEdgeFirefoxInternet ExplorerOperaSafariAndroid webviewChrome for AndroidEdge MobileFirefox for AndroidOpera for AndroidSafari on iOSSamsung InternetNode.js
Basic supportChrome Full support YesEdge Full support YesFirefox Full support 1IE Full support YesOpera Full support YesSafari Full support YesWebView Android Full support YesChrome Android Full support YesEdge Mobile Full support YesFirefox Android Full support 4Opera Android Full support YesSafari iOS Full support YesSamsung Internet Android Full support Yesnodejs Full support Yes
Parses leading-zero strings are decimal, not octalChrome Full support 23Edge Full support YesFirefox Full support 21IE Full support 9Opera Full support YesSafari Full support 6WebView Android Full support 4.4Chrome Android Full support YesEdge Mobile Full support YesFirefox Android Full support 21Opera Android Full support YesSafari iOS Full support 6Samsung Internet Android Full support Yesnodejs Full support Yes

Legend

Full support  
Full support

Vedi anche

Tag del documento e collaboratori

Hanno collaborato alla realizzazione di questa pagina: mdnwebdocs-bot, IsibisiDev, Molok
Ultima modifica di: mdnwebdocs-bot,