Como trabalho em torno do comportamento ocular analítico do JavaScript?

Tente executar o seguinte em 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 !!

Acabei de aprender da maneira mais difícil que o JavaScript pensa que o zero inicial indica um número inteiro octal e, como não existe "8"ou "9"na base 8, a função retorna zero. Goste ou não, isso ocorre por design .

Quais são as soluções alternativas?

Nota: Por uma questão de integridade, estou prestes a postar uma solução, mas é uma solução que eu odeio, portanto, publique outras / melhores respostas.

Atualizar:

A 5ª edição do padrão JavaScript ( ECMA-262 ) apresenta uma alteração de última hora que elimina esse comportamento. Mozilla tem uma boa redação .

Esta é uma pegadinha Javascript comum com uma solução simples:

Basta especificar a base , ou 'radix', da seguinte forma:

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

Você também pode usar o Number :

Number('08'); // 8

Se você souber que seu valor estará no intervalo inteiro assinado de 32 bits, ~~xfará a coisa correta em todos os cenários.

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

Se você procurar o binário not ( ~), a especificação exigirá uma conversão "ToInt32" para o argumento que faz a conversão óbvia para um Int32 e é especificado para coagir NaNvalores a zero.

Sim, isso é incrivelmente brincalhão, mas é tão conveniente ...

Na documentação parseInt , use o argumento radix opcional para especificar a base-10:

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

Isso me parece pedante, confuso e detalhado (realmente, um argumento extra em cada análise)? Por isso, espero que exista um caminho melhor.

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

edit: criar sua própria função, para fazer o que você realmente deseja, é apenas uma opção se você não gosta de adicionar o ", 10" o tempo todo à chamada parseInt (). Tem a desvantagem de ser uma função fora do padrão: mais conveniente para você, se você a usa muito, mas talvez mais confusa para os outros.

Especifique a base:

var number = parseInt(s, 10);

Seria muito impertinente substituir parseInt por uma versão que assume decimal se não tiver um segundo parâmetro? (nota - não testado)

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

Você também pode, em vez de usar parseFloat ou parseInt, usar o operador unário ( + ).

+"01"
// => 1

+"02"
// => 2

+"03"
// => 3

+"04"
// => 4

+"05"
// => 5

+"06"
// => 6

+"07"
// => 7

+"08"
// => 8

+"09"
// => 9

e para uma boa medida

+"09.09"
// => 9.09

Link MDN

O operador unary plus precede seu operando e avalia seu operando, mas tenta convertê-lo em um número, se já não estiver. Embora a negação unária (-) também possa converter não-números, o unary plus é a maneira mais rápida e preferida de converter algo em um número , porque não realiza nenhuma outra operação no número.

Que tal isso para decimal:

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

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

Se você já fez um monte de codificação com parseInt e não deseja adicionar ", 10" a tudo, basta substituir a função para tornar a base 10 o padrão:

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

Isso pode confundir um leitor posterior, portanto, criar uma função parseInt10 () pode ser mais auto-explicativa. Pessoalmente, prefiro usar uma função simples do que adicionar ", 10" o tempo todo - apenas cria mais oportunidades para erros.

Esse problema não pode ser replicado no Chrome nem no Firefox (2019) mais recentes.