¿Cómo evito el comportamiento octal parseInt de JavaScript?

Intente ejecutar lo siguiente en 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 !!

Acabo de enterarme por completo que JavaScript cree que el cero inicial indica un número entero octal , y dado que no existe "8"o "9"en base-8, la función devuelve cero. Nos guste o no, esto es por diseño .

¿Cuáles son las soluciones alternativas?

Nota: En aras de la exhaustividad, estoy a punto de publicar una solución, pero es una solución que odio, así que publique otras / mejores respuestas.

Actualizar:

La quinta edición del estándar JavaScript ( ECMA-262 ) introduce un cambio radical que elimina este comportamiento. Mozilla tiene una buena reseña .

Este es un problema común de Javascript con una solución simple:

Simplemente especifique la base , o 'radix', así:

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

También puedes usar Número :

Number('08'); // 8

Si sabe que su valor estará en el rango entero de 32 bits con signo, entonces ~~xhará lo correcto en todos los escenarios.

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

Si busca binary not ( ~), la especificación requiere una conversión "ToInt32" para el argumento que realiza la conversión obvia a Int32 y se especifica para obligar a los NaNvalores a cero.

Sí, esto es increíblemente hack pero es muy conveniente ...

De la documentación de parseInt , use el argumento de la raíz opcional para especificar base-10:

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

Esto me parece pedante, confuso y detallado (¿realmente, un argumento adicional en cada análisis?), Así que espero que haya una mejor manera.

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

editar: hacer su propia función, hacer lo que realmente quiere, es solo una opción si no le gusta agregar ", 10" todo el tiempo a la llamada parseInt (). Tiene la desventaja de ser una función no estándar: más conveniente para usted si la usa mucho, pero quizás más confusa para otros.

Especifique la base:

var number = parseInt(s, 10);

¿Sería muy malo reemplazar parseInt con una versión que asume decimal si no tiene un segundo parámetro? (nota - no probado)

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

También puede, en lugar de usar parseFloat o parseInt, usar el operador unario ( + ).

+"01"
// => 1

+"02"
// => 2

+"03"
// => 3

+"04"
// => 4

+"05"
// => 5

+"06"
// => 6

+"07"
// => 7

+"08"
// => 8

+"09"
// => 9

y por si acaso

+"09.09"
// => 9.09

MDN Link

El operador unario más precede a su operando y lo evalúa, pero intenta convertirlo en un número, si aún no lo está. Aunque la negación unaria (-) también puede convertir no números, unario plus es la forma más rápida y preferida de convertir algo en un número , ya que no realiza ninguna otra operación en el número.

¿Qué tal esto para decimal:

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

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

Si ya ha realizado una gran cantidad de codificación con parseInt y no desea agregar ", 10" a todo, puede anular la función para que la base 10 sea la predeterminada:

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

Eso puede confundir a un lector posterior, por lo que hacer una función parseInt10 () podría explicarse más por sí mismo. Personalmente, prefiero usar una función simple que tener que agregar ", 10" todo el tiempo, solo crea más oportunidades para errores.

Este problema no se puede replicar en las últimas Chrome ni Firefox (2019).