Como Fazer o Parse de Números em JavaScript

Quando você lê um valor de um campo de formulário, um parâmetro de URL ou uma resposta de API JSON, ele quase sempre chega como uma string. Antes de poder fazer qualquer operação matemática com ele, você precisa convertê-lo para um número. JavaScript oferece várias maneiras de fazer isso, e elas se comportam de forma suficientemente diferente para que escolher a errada cause bugs sutis. Este artigo aborda os principais métodos, quando usar cada um e os casos extremos que mais frequentemente confundem os desenvolvedores.

Comparação Rápida: Métodos de Conversão String-para-Número em JavaScript

parseInt(): Parsing Parcial para Inteiros

parseInt(string, radix) lê caracteres da esquerda para a direita e para no momento em que encontra algo que não pode fazer o parse. Isso o torna útil para strings como "24px" ou "10rem", onde o número vem primeiro.

parseInt("24px", 10)   // 24
parseInt("3.99", 10)   // 3  (ponto decimal interrompe o parsing)
parseInt("abc", 10)    // NaN (primeiro caractere é inválido)

Sempre passe o radix. Sem ele, parseInt trata strings começando com 0x como hexadecimal e, caso contrário, faz o parse na base 10. Embora os motores modernos usem base 10 por padrão, omitir o radix é uma fonte conhecida de bugs e torna sua intenção pouco clara.

parseInt("0xFF", 16)   // 255 — parsing hexadecimal explícito
parseInt("011", 10)    // 11  — radix previne ambiguidade

Um comportamento não óbvio: parseInt para no ponto decimal em "6.022e23", então parseInt("6.022e23", 10) retorna 6, não 602200000000000000000000. Não use parseInt para truncar números de ponto flutuante grandes. Use Math.trunc() em vez disso.

parseFloat(): Parsing Parcial para Decimais

parseFloat() funciona da mesma forma que parseInt, mas preserva a parte decimal. Não possui parâmetro radix e sempre faz o parse na base 10.

parseFloat("3.14rem")  // 3.14
parseFloat("1e3")      // 1000 — entende notação científica
parseFloat("px10")     // NaN  — primeiro caractere é inválido

Use parseFloat quando a entrada pode conter um valor decimal e você deseja preservá-lo.

Number() e o Operador Unário +: Conversão Estrita

Tanto Number() quanto o operador unário + exigem que a string inteira seja um número válido. Se qualquer parte dela não for, você obtém NaN. Essa rigidez é uma vantagem ao trabalhar com respostas de API ou dados de formulário validados, onde um parse parcial seria um erro silencioso.

Number("42")     // 42
Number("3.14")   // 3.14
Number("42px")   // NaN — mais rigoroso que parseInt
Number("")       // 0   — cuidado com isso
+"42"            // 42  — comportamento idêntico, sintaxe mais curta

O caso extremo da string vazia importa no tratamento de formulários. Number("") retorna 0, não NaN, o que pode mascarar um valor ausente. Sempre verifique se há entrada vazia antes de converter.

Separadores Numéricos Não Funcionam em Tempo de Execução

O código-fonte JavaScript permite 1_000_000 como um literal numérico, mas essa sintaxe não se transfere para o parsing de strings.

parseInt("1_000", 10)   // 1 — parsing para no underscore
Number("1_000")         // NaN

Se sua API ou entrada de usuário usa underscores como separadores de milhar, remova-os primeiro com str.replace(/_/g, "").

BigInt(): Parsing de Inteiros Grandes

O tipo Number do JavaScript perde precisão além de Number.MAX_SAFE_INTEGER (2⁵³ − 1). Para valores maiores que isso — IDs de banco de dados, valores criptográficos, inteiros financeiros — use BigInt().

BigInt("9007199254740993")   // 9007199254740993n — exato
Number("9007199254740993")   // 9007199254740992  — erro de um

Passe a string diretamente para BigInt(). Não a passe primeiro por parseInt, porque a precisão já é perdida nesse ponto. Note que valores BigInt não podem ser misturados com valores Number regulares em operações aritméticas sem conversão explícita.

Parsing com Reconhecimento de Localidade

JavaScript não possui uma função integrada para fazer o parse de números formatados por localidade como "1.234,56" (comum em localidades alemãs ou espanholas). Você precisa normalizar a string manualmente antes do parsing:

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

Qual Método Você Deve Usar?

• Entrada de usuário ou valores CSS com unidades → parseInt(str, 10) ou parseFloat()
• Respostas de API ou dados estritamente validados → Number() ou operador unário +
• Inteiros além de 2⁵³ − 1 → BigInt()
• Sempre valide que o resultado não é NaN antes de usá-lo:

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

Use Number.isNaN(), não o isNaN() global. A versão global força a coerção de seu argumento primeiro, o que significa que isNaN("") retorna false mesmo que "" não seja um número.

Conclusão

O método correto de parsing de números em JavaScript depende do que você sabe sobre sua entrada. Use parseInt ou parseFloat quando o parsing parcial é aceitável e esperado. Use Number() ou operador unário + quando a string inteira deve ser um número válido. Recorra a BigInt() quando a precisão importa para inteiros grandes. Em todos os casos, verifique se há NaN antes de usar o resultado.

Perguntas Frequentes

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.