parseInt()

Sommario

La funzione parseInt() analizza un argomento stringa 'string' e restituisce un numero intero (int) utilizzando la base specificata 'radix' (base intesa come nella teoria matematica dei sistemi di numerazione).

Sintassi

parseInt(string, radix);

Parametri

string

Il testo da analizzare. Se string non è di tipo string, viene convertito in string prima della elaborazione. Eventuali spazi iniziali contenuti vengono ignorati.

radix

Un numero intero compreso tra 2 e 36 che rappresenta la base numerica da utilizzare per la elaborazione. Specificare 10 per indicare la base numerica comunemente utilizzata. Specificare sempre questo parametro per eliminare confusione nella lettura e per avere certezza del risultato. Implementazioni differenti producono risultati differenti se 'radix' non è specificato.

Descrizione

La funzione parseInt converte il primo parametro in 'string', lo analizza, e restituisce un numero intero o NaN. Ad esclusione del risultato NaN, il valore restituito sarà la rappresentazione intera decimale del testo contenuto nel primo parametro preso come numero espresso nella base numerica indicata da 'radix'. Per esempio, una base ('radix') 10 indica di elaborare partendo da un numero in base dieci (decimale), 8 ottale, 16 esadecimale, e così via. Per basi maggiori di 10, le lettere dell'alfabeto indicano cifre di valore superiore al 9. Per esempio, per i numeri esadecimali (base 16), vengono usate le lettere da A fino F.

Se parseInt trova un carattere che non è una cifra valida nella base numerica specificata, lo ignora e interrompe l'elaborazione ignorando anche tutti i caratteri seguenti, quindi restituisce il valore intero rilevato fino a quel punto. parseInt tronca i numeri al loro valore intero. Gli spazi all'inizio e alla fine del testo sono ammessi, ma vengono ignorati.

Se 'radix' è un valore undefined o 0 (o è assente), JavaScript si comporta come segue:

• Se il testo string comincia con "0x" o "0X", la base utilizzata è 16 ('x' dall'inglese hexadecimal) e viene elaborato il testo a cominciare dal carattere successivo.
• Se il testo string comincia con "0", la base è otto (ottale) o 10 (decimale).  La base che effettivamente viene scelta dipende dall'implementazione. La specifica ECMAScript 5 indica che venga usato 10 (decimale), ma non tutti i browser la supportano ancora.  Per questo motivo specificare sempre una base numerica alla chiamata di parseInt.
• Se il testo string comincia con un qualunque altro valore, la base numerica è 10 (decimale).

Se il primo carattere non è una cifra valida, parseInt restituisce NaN.

Ai fini aritmetici, il valore NaN non corrisponde ad un numero in nessun caso. Si può chiamare la funzione isNaN per determinare se il risultato di parseInt è NaN. Se viene passato NaN in una operazione numerica, il risultato sarà ugualmente NaN.

Per ottenere il testo corrispondente ad un numero in una determinata base numerica utilizzare intValue.toString(radix).

Esempi

Esempio: Utilizzare parseInt

Le seguenti istruzioni restituiscono tutte 15:

parseInt(" 0xF", 16);
parseInt(" F", 16);
parseInt("17", 8);
parseInt(021, 8); // il valore letterale 021 è ottale e vale 17
parseInt("015", 10);
parseInt(15.99, 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15*3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);

Le seguenti istruzioni restituiscono NaN:

parseInt("Ciao", 8); // Completamente diverso da un numero
parseInt("546", 2);   // Cifre non valide per una rappresentazione binaria

Le seguenti istruzioni 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);

La seguente istruzione restituisce 224:

parseInt("0e0", 16);

Interpretazione ottale implicita

Nonostante fosse sconsigliato nella specificha ECMAScript 3 e vietato nella successiva ECMAScript 5, molte implementazioni interpretano un testo numerico che inizia con uno 0 come fosse ottale. Le istruzioni seguenti possono corrispondere ad un valore ottale come ad uno decimale.  Specificare sempre una base numerica per evitare questi comportamenti indesiderati.

parseInt("0e0"); // 0
parseInt("08"); // 0, '8' non è una cifra ottale.

ECMAScript 5 elimina l'interpretazione ottale

La specifica ECMAScript 5 della funzione parseInt non permette più che le implementazioni trattino stringhe numeriche che cominciano con un carattere 0 come valori ottali. ECMAScript 5 riporta:

The parseInt function produces an integer value dictated by interpretation of the contents of the string argument according to the specified radix. Leading white space in string is ignored. If radix is undefined or 0, it is assumed to be 10 except when the number begins with the character pairs 0x or 0X, in which case a radix of 16 is assumed. If radix is 16, number may also optionally begin with the character pairs 0x or 0X.

[[Non è disponibile una traduzione ufficiale in italiano]] La funzione parseInt produce un valore intero ottenuto interpretando il contenuto dell'argomento testuale in accordo con la radice (ndt: o base numerica) specificata. Gli spazi iniziali nel testo vengono ignorati. Se la radice è 'undefined' o 0, si assume che sia 10 eccetto i casi in cui il numero cominci con le coppie di caratteri 0x o 0X, nel qual caso si assume che la radice sia 16. Se la radice è 16, il numero può eventualmente cominciare con le coppie di caratteri 0x o 0X.

Questo differisce dalla specifica ECMAScript 3, che sconsigliava ma permetteva l'interpretazione ottale.

A tutto il 2013 molte implementazioni non hanno adottato ancora questo comportamento, e dovendo supportare i browser più vecchi, specificare sempre una base numerica.

Una funzione di conversione più specializzata

Talvolta è utile avere un modo più diretto per ottenete un valore intero. Le espressioni regolari possono aiutare:

filterInt = function (value) {
  if(/^(\-|\+)?([0-9]+|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

Compatibilità dei Browser

Vedi anche

• parseFloat()
• Number.parseFloat()
• Number.parseInt()
• isNaN()
• Number.toString()
• Object.valueOf