Cómo Analizar Números en JavaScript

Cuando lees un valor de un campo de formulario, un parámetro de URL o una respuesta de API JSON, casi siempre llega como una cadena de texto. Antes de poder realizar cualquier operación matemática con él, necesitas convertirlo a número. JavaScript te ofrece varias formas de hacerlo, y se comportan de manera lo suficientemente diferente como para que elegir la incorrecta cause errores sutiles. Este artículo cubre los métodos principales, cuándo usar cada uno y los casos extremos que más frecuentemente confunden a los desarrolladores.

Comparación Rápida: Métodos de Conversión de Cadena a Número en JavaScript

parseInt(): Análisis Parcial para Enteros

parseInt(string, radix) lee caracteres de izquierda a derecha y se detiene en el momento en que encuentra algo que no puede analizar. Esto lo hace útil para cadenas como "24px" o "10rem", donde el número aparece primero.

parseInt("24px", 10)   // 24
parseInt("3.99", 10)   // 3  (el punto decimal detiene el análisis)
parseInt("abc", 10)    // NaN (el primer carácter es inválido)

Siempre pasa el parámetro radix. Sin él, parseInt trata las cadenas que comienzan con 0x como hexadecimales y de lo contrario analiza en base 10. Aunque los motores modernos usan base 10 por defecto, omitir el radix es una fuente conocida de errores y hace que tu intención no sea clara.

parseInt("0xFF", 16)   // 255 — análisis hexadecimal explícito
parseInt("011", 10)    // 11  — radix previene ambigüedad

Un comportamiento no obvio: parseInt se detiene en el punto decimal en "6.022e23", por lo que parseInt("6.022e23", 10) devuelve 6, no 602200000000000000000000. No uses parseInt para truncar números de punto flotante grandes. Usa Math.trunc() en su lugar.

parseFloat(): Análisis Parcial para Decimales

parseFloat() funciona de la misma manera que parseInt pero preserva la porción decimal. No tiene parámetro radix y siempre analiza en base 10.

parseFloat("3.14rem")  // 3.14
parseFloat("1e3")      // 1000 — entiende notación científica
parseFloat("px10")     // NaN  — el primer carácter es inválido

Usa parseFloat cuando la entrada pueda contener un valor decimal y quieras preservarlo.

Number() y el Operador Unario +: Conversión Estricta

Tanto Number() como el operador unario + requieren que toda la cadena sea un número válido. Si alguna parte no lo es, obtienes NaN. Esa rigurosidad es una ventaja cuando trabajas con respuestas de API o datos de formularios validados, donde un análisis parcial sería un error silencioso.

Number("42")     // 42
Number("3.14")   // 3.14
Number("42px")   // NaN — más estricto que parseInt
Number("")       // 0   — ten cuidado con esto
+"42"            // 42  — comportamiento idéntico, sintaxis más corta

El caso extremo de la cadena vacía importa en el manejo de formularios. Number("") devuelve 0, no NaN, lo que puede ocultar un valor faltante. Siempre verifica si la entrada está vacía antes de convertirla.

Los Separadores Numéricos No Funcionan en Tiempo de Ejecución

El código fuente de JavaScript permite 1_000_000 como literal numérico, pero esa sintaxis no se traslada al análisis de cadenas.

parseInt("1_000", 10)   // 1 — el análisis se detiene en el guion bajo
Number("1_000")         // NaN

Si tu API o entrada de usuario usa guiones bajos como separadores de miles, elimínalos primero con str.replace(/_/g, "").

BigInt(): Análisis de Enteros Grandes

El tipo Number de JavaScript pierde precisión más allá de Number.MAX_SAFE_INTEGER (2⁵³ − 1). Para valores mayores que eso — IDs de base de datos, valores criptográficos, enteros financieros — usa BigInt().

BigInt("9007199254740993")   // 9007199254740993n — exacto
Number("9007199254740993")   // 9007199254740992  — desfasado por uno

Pasa la cadena directamente a BigInt(). No la pases primero por parseInt, porque la precisión ya se pierde en ese punto. Ten en cuenta que los valores BigInt no pueden mezclarse con valores Number regulares en operaciones aritméticas sin conversión explícita.

Análisis Consciente de la Configuración Regional

JavaScript no tiene una función integrada para analizar números con formato regional como "1.234,56" (común en configuraciones regionales alemanas o españolas). Necesitas normalizar la cadena manualmente antes de analizarla:

const raw = "1.234,56"
const normalized = raw.replace(/\./g, "").replace(",", ".")
parseFloat(normalized) // 1234.56

¿Qué Método Deberías Usar?

• Entrada de usuario o valores CSS con unidades → parseInt(str, 10) o parseFloat()
• Respuestas de API o datos estrictamente validados → Number() o el operador unario +
• Enteros más allá de 2⁵³ − 1 → BigInt()
• Siempre valida que el resultado no sea NaN antes de usarlo:

const qty = parseInt(input, 10)
if (Number.isNaN(qty)) {
  // manejar entrada inválida
}

Usa Number.isNaN(), no el isNaN() global. La versión global coacciona su argumento primero, lo que significa que isNaN("") devuelve false aunque "" no sea un número.

Conclusión

El método correcto de análisis de números en JavaScript depende de lo que sepas sobre tu entrada. Usa parseInt o parseFloat cuando el análisis parcial sea aceptable y esperado. Usa Number() o el operador unario + cuando toda la cadena deba ser un número válido. Recurre a BigInt() cuando la precisión importe para enteros grandes. En todos los casos, verifica si hay NaN antes de usar el resultado.

Preguntas Frecuentes

Complete picture for complete understanding

Capture every clue your frontend is leaving so you can instantly get to the root cause of any issue with OpenReplay — the open-source session replay tool for developers. Self-host it in minutes, and have complete control over your customer data.

Check our GitHub repo and join the thousands of developers in our community.