Come aggirare il comportamento dell'analisi ottale di JavaScript?

Prova a eseguire quanto segue in JavaScript:

parseInt('01'); //equals 1
parseInt('02'); //equals 2
parseInt('03'); //equals 3
parseInt('04'); //equals 4
parseInt('05'); //equals 5
parseInt('06'); //equals 6
parseInt('07'); //equals 7
parseInt('08'); //equals 0 !!
parseInt('09'); //equals 0 !!

Ho appena imparato a mie spese che JavaScript pensa che lo zero iniziale indichi un numero intero ottale , e poiché non esiste "8"o "9"in base-8, la funzione restituisce zero. Piaccia o no, questo è di progettazione .

Quali sono le soluzioni alternative?

Nota: per completezza, sto per pubblicare una soluzione, ma è una soluzione che odio, quindi per favore pubblica altre / risposte migliori.

Aggiornare:

La 5a edizione dello standard JavaScript ( ECMA-262 ) introduce una modifica rivoluzionaria che elimina questo comportamento. Mozilla ha una buona scrittura .

Questo è un gotcha Javascript comune con una soluzione semplice:

Basta specificare la base , o 'radix', in questo modo:

parseInt('08',10); // 8

Puoi anche usare il numero :

Number('08'); // 8

Se sai che il tuo valore sarà compreso nell'intervallo di 32 bit con segno, quindi ~~xfarà la cosa giusta in tutti gli scenari.

~~"08" === 8
~~"foobar" === 0
~~(1.99) === 1
~~(-1.99)  === -1

Se cerchi binary not ( ~), la specifica richiede una conversione "ToInt32" per l'argomento che esegue la conversione ovvia in un Int32 e viene specificato per forzareNaN valori a zero.

Sì, questo è incredibilmente hackish ma è così conveniente ...

Dalla documentazione parseInt , utilizzare l'argomento radix opzionale per specificare base-10:

parseInt('08', 10); //equals 8
parseInt('09', 10); //equals 9

Questo mi sembra pedante, confuso e prolisso (davvero, un argomento in più in ogni singolo test?), Quindi spero che ci sia un modo migliore.

function parseDecimal(s) { return parseInt(s, 10); }

modifica: creare la propria funzione, fare ciò che si vuole veramente, è solo un'opzione se non ti piace aggiungere sempre ", 10" alla chiamata parseInt (). Ha lo svantaggio di essere una funzione non standard: più conveniente per te se la usi molto, ma forse più confusa per gli altri.

Specifica la base:

var number = parseInt(s, 10);

Sarebbe molto cattivo sostituire parseInt con una versione che assume decimali se non ha un secondo parametro? (nota - non testato)

parseIntImpl = parseInt
parseInt = function(str, base){return parseIntImpl(str, base ? base : 10)}

È inoltre possibile, invece di utilizzare parseFloat o parseInt, utilizzare l'operatore unario ( + ).

+"01"
// => 1

+"02"
// => 2

+"03"
// => 3

+"04"
// => 4

+"05"
// => 5

+"06"
// => 6

+"07"
// => 7

+"08"
// => 8

+"09"
// => 9

e per buona misura

+"09.09"
// => 9.09

Collegamento MDN

L'operatore unario positivo precede il suo operando e restituisce il suo operando ma tenta di convertirlo in un numero, se non lo è già. Anche se la negazione unaria (-) può anche convertire i non numeri, il plus unario è il modo più rapido e preferito di convertire qualcosa in un numero , perché non esegue altre operazioni sul numero.

Che ne dici di questo per i decimali:

('09'-0) === 9  // true

('009'-0) === 9 // true

Se hai già fatto un sacco di codice con parseInt e non vuoi aggiungere ", 10" a tutto, puoi semplicemente sovrascrivere la funzione per rendere base 10 l'impostazione predefinita:

window._oldParseInt = window.parseInt;
window.parseInt = function(str, rad) {
    if (! rad) {
        return _oldParseInt(str, 10);
    }
    return _oldParseInt(str, rad);
};

Ciò potrebbe confondere un lettore successivo, quindi creare una funzione parseInt10 () potrebbe essere più autoesplicativo. Personalmente preferisco usare una semplice funzione piuttosto che dover aggiungere ", 10" per tutto il tempo - crea solo più opportunità di errori.

Questo problema non può essere replicato nell'ultimo Chrome o Firefox (2019).