| |

O JavaScript divide os dados em tipos, o que ajuda a agrupar os dados e determinar quais valores podem ser atribuídos e quais operações podem ser executadas.

Embora o JavaScript converta muitos valores automaticamente devido à conversão de tipo, é melhor converter os tipos de dados manualmente para obter os resultados esperados.

Este tutorial irá ensiná-lo a converter tipos primitivos Dados JavaScript, incluindo números, strings e elementos booleanos.

Conversão implícita

A linguagem de programação JavaScript é muito boa para lidar com valores inesperados. JavaScript não rejeita valores inesperados, mas sim tenta converter. Essa conversão implícita também é chamada de coerção de tipo.

Certos métodos convertem valores automaticamente para usá-los. O método alert() usa uma string como parâmetro e converte automaticamente outros tipos em strings. Então você pode passar um valor numérico para este método:

Se você executar esta string, o navegador retornará um popup com o valor 8.5, que já estará convertido para uma string.

Ao usar strings de números junto com operadores matemáticos, você descobrirá que o JavaScript pode lidar com valores convertendo implicitamente strings em números:

// Subtração
"15" - "10";
5
//Módulo
"15" % "10";
5

Mas nem todos os operadores trabalham de forma previsível. Isto é especialmente verdadeiro para o operador +: ele realiza adição de números e concatenação de strings.

// Ao trabalhar com strings, + realiza concatenação
"2" + "3";
"23"

Como o operador + tem muitos usos, neste exemplo ele trata os valores 2 e 3 como strings, mesmo que sejam expressos como strings numéricas. Portanto, ele combina as strings “2” e “3” e obtém 23, em vez de somar 2 e 3 e obter 5.

Essa ambigüidade ocorre no código e às vezes causa resultados inesperados, por isso é melhor converter explicitamente os tipos de dados sempre que possível. Isso ajudará na manutenção do código e no tratamento de erros.

Convertendo valores em strings

Para converter explicitamente um valor em uma string, chame o método String() ou n.toString().

Tente converter o valor booleano verdadeiro em uma string usando String().

Isso retornará a string literal "true".

Você também pode tentar passar um número para a função:

Ele retornará uma string literal:

Agora tente usar String() com uma variável. Atribua um valor numérico à variável odyssey e use o operador typeof para verificar o tipo.

deixe odisseia = 2001;
console.log(tipo de odisseia);
número

Sobre no momento A variável odyssey recebe o valor numérico 2001. O operador typeof confirma que o valor é um número.

Agora atribua a variável odyssey ao seu equivalente dentro da função String() e, em seguida, use typeof para garantir que o valor da variável seja convertido com sucesso de um número em uma string.

odisseia = String(odisseia); // "2001"
console.log(tipo de odisseia);
corda

Como você pode ver, a variável odyssey agora contém uma string.

A função n.toString() funciona de maneira semelhante. Substitua n por uma variável.

deixe golpes = 400;
golpes.toString();

A variável golpes conterá a string.

Em vez de uma variável, você pode colocar um valor entre parênteses:

(1776).toString(); // retorna "1776"
(falso).toString(); //retorna "falso"
(100 + 200).toString(); // retorna "300"

String() e n.toString() convertem explicitamente Boolean e valores numéricos em linhas.

Convertendo valores em números

O método Number() pode converter um valor em um número. Freqüentemente, é necessário converter strings que consistem em números, mas às vezes também é necessário converter valores booleanos.

Por exemplo, passe a seguinte string para o método Number():

A string será convertida em um número e não será mais citada.

Você também pode atribuir uma string a uma variável e depois convertê-la.

deixe dálmatas = "101";
Número(dálmatas);
101

A string literal "101" foi convertida no número 101.

Strings de espaços ou strings vazias serão convertidas para o número 0.

Número(" "); //retorna 0
Número(""); //retorna 0

Tenha em mente que strings que não consistem em números são convertidas em NaN, o que significa Não é um Número. Isto também se aplica a números separados por espaços.

Número("doze"); // retorna NaN
Número("20.000"); // retorna NaN
Número("2 3"); // retorna NaN
Número("11-11-11"); // retorna NaN

Em dados booleanos, falso será 0 e verdadeiro será 1.

Convertendo Valores em Valores Booleanos

Para converter números ou strings em valores booleanos, o método Boolean() é usado. Por exemplo, ajuda a determinar se o usuário está inserindo dados em um campo de texto ou não.

Qualquer valor interpretado como vazio, como o número 0, a sequência vazia, indefinido, NaN ou nulo, é convertido em falso.

Booleano(0); //retorna falso
Booleano(""); //retorna falso
Booleano(indefinido); //retorna falso
Booleano(NaN); //retorna falso
Booleano(nulo); //retorna falso

Outros valores, incluindo literais de string que consistem em espaços, serão convertidos em verdadeiros.

Booleano(2000); //retorna verdadeiro
Booleano(" "); //retorna verdadeiro
Boolean("Maníacos"); //retorna verdadeiro

Observe que a string literal "0" é convertida em true porque não é um valor vazio:

Booleano("0"); //retorna verdadeiro

A conversão de números e strings em valores booleanos permite que os dados sejam avaliados em binário e podem ser usados ​​para controlar o fluxo em programas.

Conclusão

Agora você sabe como o JavaScript converte tipos de dados. Freqüentemente, a conversão de tipo faz com que os dados sejam convertidos implicitamente, o que pode resultar em valores inesperados. Recomenda-se converter explicitamente os tipos de dados para garantir que os programas funcionem corretamente.

Em JavaScript, os valores podem ser convertidos livremente (explícita e implicitamente) de um tipo para outro. Por exemplo, se algum operador espera receber um valor certo tipo, e um valor de outro tipo for passado para ele, o interpretador tentará automaticamente realizar conversões para o tipo desejado:

Console.log(10 + "máquinas"); // "10 carros". O número é convertido implicitamente em uma string console.log("7" * "4"); // 28. Ambas as strings são convertidas implicitamente em números

Conversão implícita- é quando o intérprete realiza automaticamente a conversão de tipo, ou seja, sem a participação do programador. Conversão explícita- é quando a conversão é realizada pelo próprio programador. A conversão explícita também é chamada tipo de fundição:

Console.log("7" * "4"); // 28. Conversão implícita console.log(Number("7") * Number("4")); // 28. Conversão explícita

A tabela abaixo descreve como o JavaScript converte valores de um tipo para outro. As células vazias correspondem a situações em que nenhuma conversão é necessária:

Significado	Converter para:
	Corda	Número	Booleano	Objeto
indefinido nulo	"indefinido" "nulo"	NaN 0	falso falso	tipo de erroErro tipo de erroErro
verdadeiro falso	"verdadeiro" "falso"	1 0		novo Booleano (verdadeiro) novo Booleano (falso)
"" (string vazia) "1.2" "um" "-10" "+10" "011" "0xff"		0 1.2 NaN -10 10 11 255	falso verdadeiro verdadeiro verdadeiro verdadeiro verdadeiro verdadeiro	nova String("") nova String("1.2") nova String("um") nova String("-10") nova String("+10") nova String("011") nova String("0xff")
0 -0 NaN Infinidade -Infinidade 3	"0" "0" "NaN" "Infinidade" "-Infinidade" "3"		falso falso falso verdadeiro verdadeiro verdadeiro	novo número (0) novo número (-0) novo número (NaN) novo número (infinito) novo número (-infinito) novo número (3)
() (qualquer objeto) (matriz vazia) (1 elemento numérico) arr (qualquer outro array) function()() (qualquer função)	veja Convertendo Objetos "" "9" veja Convertendo Objetos veja Convertendo Objetos	veja Convertendo Objetos 0 9 NaN NaN	verdadeiro verdadeiro verdadeiro verdadeiro verdadeiro

Para conversão explícita para tipos simples, são utilizadas as seguintes funções: Boolean(), Number(), String(). Para conversão implícita, o interpretador usa as mesmas funções usadas para conversão explícita.

Para conversão explícita, você pode usar operadores em vez de funções. Por exemplo, se um dos operandos do operador + for uma string, o outro operando também será convertido em uma string. O operador unário + converte seu operando em um número. Operador unário! converte o operando em um valor booleano e o inverte. Tudo isso se tornou a razão para o surgimento dos seguintes métodos exclusivos de conversão de tipo que podem ser encontrados na prática:

X + "" // Igual a String(x) +x // Igual a Number(x). Você também pode ver x - 0 !!x // Igual a Boolean(x)

Converter para números

A função Number() converte valores de acordo com as seguintes regras:

• Os valores booleanos verdadeiro e falso são convertidos em 1 e 0 respectivamente.
• Os números são retornados inalterados.
• O valor null é convertido em 0 .
• O valor indefinido é convertido em NaN.

Existem regras especiais para strings:

• Se uma string contiver apenas dígitos com sinal + ou - à esquerda, ou sem sinal, ela será sempre convertida em um número inteiro número decimal. Os zeros à esquerda são ignorados; por exemplo, "0011" é convertido em 11.
• Se a string for um número de ponto flutuante com um sinal + ou - ou sem sinal à esquerda, ela será convertida no número de ponto flutuante correspondente (zeros à esquerda também serão ignorados).
• Se a string for um número hexadecimal, ela será convertida no número inteiro decimal correspondente.
• Se a string estiver vazia, ela será convertida em 0.
• Se a string contiver algo diferente das opções anteriores, ela será convertida para NaN.
• O método valueOf() é chamado em objetos e o valor que ele retorna é convertido automaticamente de acordo com as regras anteriores. Se esta conversão resultar em NaN , o método toString() será chamado e as regras para conversão de strings em números serão aplicadas.

Os operadores unários + e - seguem as mesmas regras da função Number().

Convertendo para valores booleanos

A função Boolean() converte um valor em seu equivalente booleano:

• Os seguintes valores são convertidos em falso: undefined , null , 0 , -0 , NaN , "" .
• False é retornado inalterado.
• Todos os outros valores são convertidos em true .

Converter em strings

A função String() converte valores de acordo com as seguintes regras:

• Para todos os valores diferentes de nulo e indefinido, o método toString() é chamado automaticamente e uma representação em string do valor é retornada.
• Para null, a string "null" é retornada.
• Para o valor indefinido, a string "indefinido" é retornada.

Convertendo Tipos Simples em Objetos

Para converter valores simples em objetos, são usados ​​os construtores Boolean() , Number() , String():

Var oNum = novo Número(3); var oStr = new String("1.2"); var oBool = new Boolean(true); alerta(tipo de oNum); // alerta "objeto"(typeof oStr); // alerta "objeto"(typeof oBool); // "objeto"

Convertendo objetos em valores simples

Todos os objetos herdam dois métodos de conversão: toString() e valueOf() .

O método toString() retorna a representação em string do objeto. Por padrão não retorna nada de interessante:

Alerta((x: 1).toString()); // ""

Alguns tipos possuem versões mais especializadas do método toString(). Por exemplo, o método toString() em um array converte todos os seus elementos em strings e então os concatena em uma string, inserindo vírgulas entre eles:

Alerta(.toString()); // "1,2,3"

A função do método valueOf() é definida de forma menos clara: ele deve converter um objeto no valor simples que o representa, se tal valor existir. Os objetos são valores inerentemente compostos, e a maioria dos objetos não pode ser representada como um único valor simples, portanto, por padrão, o método valueOf() retorna uma referência a ele em vez de um valor simples:

Alerta(typeof (x:2).valueOf()); // "objeto"

Ao converter um objeto em uma string, o interpretador JavaScript faz o seguinte:

• Se um objeto possui um método toString(), o intérprete o chama. Se retornar um valor simples, o interpretador converte o valor em uma string (se não for uma string) e retorna o resultado da conversão.
• Se o objeto não tiver um método toString() ou o método não retornar um valor simples, o interpretador verificará a presença de um método valueOf(). Se este método for definido, o intérprete o chama. Se retornar um valor simples, o interpretador converte esse valor em uma string (se não for uma string) e retorna o resultado da conversão.

Ao converter um objeto em um número, o intérprete faz a mesma coisa, mas tenta primeiro o método valueOf():

• Se um objeto possui um método valueOf() que retorna um valor simples, o interpretador converte (se necessário) esse valor em um número e retorna o resultado.
• Se o objeto não tiver um método valueOf() ou o método não retornar um valor simples, o interpretador verificará a presença de um método toString(). Se o objeto possuir um método toString() que retorna um valor simples, o interpretador realiza a conversão e retorna o valor resultante.
• Caso contrário, o intérprete conclui que nem toString() nem valueOf() podem obter um valor simples e gera um TypeError.

Os métodos toString() e valueOf() são de leitura/gravação, então você pode substituí-los e especificar explicitamente o que será retornado durante a conversão:

Var obj=(); obj.toString = function() ( return "objeto"; ); alerta("Este é " + obj); // "Este é um objeto"

O analisarInt() A função analisa um argumento de string e retorna um número inteiro da base especificada (a base em sistemas numéricos matemáticos).

A fonte deste exemplo interativo está armazenada em um repositório GitHub. Se você quiser contribuir com o projeto de exemplos interativos, clone https://github.com/mdn/interactive-examples e envie-nos uma solicitação pull.

Sintaxe

parseInt(string, base)

Parâmetros

string O valor a ser analisado. Se este argumento não for uma string, ele será convertido em uma usando a operação abstrata ToString. Os espaços em branco iniciais neste argumento são ignorados. raiz Opcional Um número inteiro entre 2 e 36 que representa a raiz (a base em sistemas numéricos matemáticos) da string. Tenha cuidado - isso faz não

padrão para 10!

O explica com mais detalhes o que acontece quando o radix não é fornecido.

Valor de retorno NaN Se a raiz for menor que 11 e o primeiro caractere que não seja um espaço em branco não puder ser convertido em um número,

A propriedade global NaN é um valor que representa Not-A-Number.

é retornado.

Descrição

A função parseInt converte seu primeiro argumento em uma string, analisa essa string e retorna um número inteiro ou NaN .

Se parseInt encontrar um caractere que não seja um numeral na raiz especificada, ele o ignorará e todos os caracteres seguintes e retornará o valor inteiro analisado até aquele ponto. parseInt trunca números em valores inteiros. Espaços iniciais e finais são permitidos.

Porque alguns números usam o caractere e em sua representação de string (por exemplo 6.022e23 para 6,022 × 10 23), usar parseInt para truncar números produzirá resultados inesperados quando usado em números muito grandes ou muito pequenos. parseInt deveria raiz Opcional Um número inteiro entre 2 e 36 que representa a raiz (a base em sistemas numéricos matemáticos) da string. Tenha cuidado - isso faz ser usado como substituto Math.floor().

parseInt entende exatamente dois sinais: + para positivo e - para negativo (desde ECMAScript 1). Isso é feito como uma etapa inicial na análise após a remoção do espaço em branco. Se nenhum sinal for encontrado, o algoritmo passa para a etapa seguinte; caso contrário, ele remove o sinal e executa a análise numérica no restante da string.

Se a raiz for indefinida, 0 ou não especificada, o JavaScript assume o seguinte:

1. Se a string de entrada começar com "0x" ou "0X" (um zero, seguido por X minúsculo ou maiúsculo), a raiz será considerada 16 e o ​​restante da string será analisado como um número hexadecimal.
2. Se a string de entrada começar com "0" (zero), a base será 8 (octal) ou 10 (decimal). Exatamente qual raiz é escolhida depende da implementação. ECMAScript 5 esclarece que 10 (decimal) deve ser usado, mas nem todos os navegadores suportam isso ainda. Por esta razão, sempre especifique uma base ao usar parseInt.
3. Se a string de entrada começar com qualquer outro valor, a raiz será 10 (decimal).

Se o primeiro caractere não puder ser convertido em um número, parseInt retornará NaN, a menos que a base seja maior que 10 .

Para fins aritméticos, o valor NaN não é um número em nenhuma base. Você pode ligar para o éNaN função para determinar se o resultado de parseInt é NaN . Se NaN for passado para operações aritméticas, o resultado da operação também será NaN .

Para converter um número em sua string literal em uma base específica, use thatNumber .toString(radix) .

Exemplos

Usando parseInt

Todos os exemplos a seguir retornam 15:

ParseInt("0xF", 16) parseInt("F", 16) parseInt("17", 8) parseInt(021, 8) parseInt("015", 10) // mas `parseInt(015, 10)` irá return 13 parseInt(15.99, 10) parseInt("15.123", 10) parseInt("FXX123", 16) parseInt("1111", 2) parseInt("15 * 3", 10) parseInt("15e2", 10) parseInt("15px", 10) parseInt("12", 13)

Todos os exemplos a seguir retornam NaN:

ParseInt("Hello", 8) // Não é um número parseInt("546", 2) // Dígitos diferentes de 0 ou 1 são inválidos para base binária

Todos os exemplos a seguir retornam -15:

ParseInt("-F", 16) parseInt("-0F", 16) parseInt("-0XF", 16) parseInt(-15.1, 10) parseInt("-17", 8) parseInt("-15", 10) parseInt("-1111", 2) parseInt("-15e1", 10) parseInt("-12", 13)

Todos os exemplos a seguir retornam 4:

ParseInt(4.7, 10) parseInt(4.7 * 1e22, 10) // Número muito grande torna-se 4 parseInt(0.00000000000434, 10) // Número muito pequeno torna-se 4

O exemplo a seguir retorna 224:

ParseInt("0e0", 16) parseInt("123_456") // 123

Interpretações octais sem raiz

Embora desencorajado pelo ECMAScript 3 e proibido pelo ECMAScript 5, muitas implementações interpretam uma string numérica começando com 0 como octal. O seguinte pode ter um resultado octal ou um resultado decimal. Sempre especifique uma raiz para evitar esse comportamento não confiável.

ParseInt("0e0") // 0 parseInt("08") // 0, porque "8" não é um dígito octal.

ECMAScript 5 remove interpretação octal

A especificação ECMAScript 5 da função parseInt não permite mais que implementações tratem Strings começando com um caractere 0 como valores octais. ECMAScript 5 afirma:

A função parseInt produz um valor inteiro ditado pela interpretação do conteúdo do argumento string de acordo com a raiz especificada. O espaço em branco inicial na string é ignorado. Se a base for indefinida ou 0 , será assumido como 10, exceto quando o número começar com os pares de caracteres 0x ou 0X , caso em que uma base de 16 será assumida.

Isso difere do ECMAScript 3, que foi desencorajado, mas permitiu interpretação octal.

Muitas implementações não adotaram esse comportamento a partir de 2013 e como navegadores mais antigos devem ser suportados sempre especifique uma raiz.

Uma função de análise mais rigorosa

Às vezes é útil ter uma maneira mais rigorosa de analisar números inteiros.

Expressões regulares podem ajudar:

Função filterInt(value) ( ​​​​if (/^[-+]?(\d+|Infinity)$/.test(value)) ( return Number(value) ) else ( return NaN ) ) console.log(filterInt( "421 ")) // 421 console.log(filterInt("-421")) // -421 console.log(filterInt("+421")) // 421 console.log(filterInt("Infinity")) // Infinity console.log(filterInt("421e+0")) // NaN console.log(filterInt("421hop")) // NaN console.log(filterInt("hop1.61803398875")) // console NaN .log (filterInt("1.61803398875")) //NaN

Especificações

Especificação	Status	Comentário
ECMAScript 1ª Edição (ECMA-262)	Padrão	Definição inicial.
ECMAScript 5.1 (ECMA-262)	Padrão
ECMAScript 2015 (6ª edição, ECMA-262) A definição de "parseInt" nessa especificação.	Padrão
Rascunho mais recente do ECMAScript (ECMA-262) A definição de "parseInt" nessa especificação.	Rascunho

Compatibilidade do navegador

A tabela de compatibilidade nesta página é gerada a partir de dados estruturados. Se você quiser contribuir com os dados, confira https://github.com/mdn/browser-compat-data e envie-nos uma solicitação pull.

Atualizar dados de compatibilidade no GitHub

	Área de trabalho						Móvel						Servidor
	Cromo	Borda	Raposa de fogo	Internet Explorer	Ópera	Safári	Visualização web Android	Chrome para Android	Firefox para Android	Ópera para Android	Safári no iOS	Internet Samsung	Node.js
analisarInt	Suporte completo do Chrome 1	Suporte total de borda 12	Firefox Suporte total 1	IE Suporte total 3	Opera Suporte total Sim	Safari Suporte total Sim	WebView Android Suporte completo 1	Suporte completo para Android Chrome 18	Firefox Android Suporte completo 4		Safari iOS Suporte total Sim	Samsung Internet Android Suporte completo 1.0	nodejs Suporte total Sim
Analisa strings com zeros à esquerda são decimais, não octais	Suporte total do Chrome 23	Suporte total de borda 12	Firefox Suporte total 21	IE Suporte total 9	Opera Suporte total Sim	Safari Suporte total 6	WebView Android Suporte completo 4.4	Suporte completo para Android Chrome 25	Firefox Android Suporte completo 21	Opera Android Suporte completo Sim	Safari iOS Suporte total 6	Samsung Internet Android Suporte completo Sim	nodejs Suporte total Sim

Existem duas maneiras principais de converter uma string em um número em javascript. Uma maneira é analisá-lo e outra é alterar seu tipo para número. Todos os truques nas outras respostas (como unário plus) envolvem coagir implicitamente o tipo de string para o número. Você também pode fazer o mesmo com a função Number.

Sintático

Var analisado = parseInt("97", 10);

ParseInt e parseFloat são duas funções usadas para analisar strings em números. A análise irá parar silenciosamente se atingir um caractere que não reconhece, o que pode ser útil para analisar strings como "92px", mas também é um tanto perigoso, pois não causará nenhum erro em uma entrada incorreta, em vez disso, você "retornará NaN se a string não começar com um número Um espaço no início da string é ignorado. Aqui está um exemplo que faz outra coisa que você deseja e sem dar nenhuma indicação de que algo deu errado:

Var widgetsVendidos = parseInt("97.800", 10); // widgetsVendidos agora são 97

É uma boa prática sempre especificar um decimal como segundo argumento. Em navegadores mais antigos, se uma string começasse com 0, ela seria interpretada como octal, a menos que um valor de raiz fosse especificado, o que pegou muita gente de surpresa. O comportamento para acionamento hexadecimal será acionado se a string começar com 0x, a menos que um valor de raiz seja especificado. 0xff. Na verdade, o padrão mudou com o ecmascript 5, então os navegadores modernos não disparam mais octais quando há um 0 à esquerda, a menos que nenhuma base seja especificada. parseInt entende radicais até a base 36, caso em que tanto superior quanto inferior letras minúsculas são tratados como equivalentes.

Alterando o tipo de string para número

Todos os outros truques mencionados acima que não usam ParseInt envolvem forçar implicitamente uma string em um número. Eu prefiro fazer isso explicitamente

Var elenco = Número("97");

Isso é diferente dos métodos de análise (embora ainda ignore espaços). Isso é mais rigoroso: se ele não entende a string inteira, retorna NaN , então você não pode usá-lo para strings como 97px . Como você precisa de um número primitivo e não de um objeto wrapper Number, certifique-se de não preceder a função Number com new .

Obviamente, a conversão para um número produz um valor que pode ser flutuante em vez de um número inteiro, portanto, se você quiser um número inteiro, precisará alterá-lo. Existem várias maneiras de fazer isso:

Var arredondado = Math.floor(Number("97.654")); // outras opções são Math.ceil, Math.round var fixa = Number("97.654").toFixed(0); // arredondado em vez de truncado var bitwised = Number("97.654")|0; //não use para números grandes

Qualquer operador bit a bit (aqui fiz bit a bit ou, mas você também pode fazer dupla negação como na resposta anterior ou Bitshift) converterá o valor em um número inteiro de 32 bits, e a maioria deles converterá em um número inteiro assinado. Por favor, note que isso não quero que você pesquise números inteiros grandes. Se um número inteiro não puder ser representado em 32 bits, ele será encerrado.

~~"3000000000.654" === -1294967296 // É o mesmo que Number("3000000000.654")|0 "3000000000.654" >>> 0 === 3000000000 // deslocamento para a direita não assinado fornece um bit extra "300000000000.654" > >> 0 === 3647256576 // mas ainda falha com números maiores

Para funcionar corretamente com grandes números, você deve usar métodos de arredondamento

Math.floor("3000000000.654") === 3000000000 // É o mesmo que Math.floor(Number("3000000000.654"))

Tenha em mente que todos esses métodos entendem a notação exponencial, então 2e2 é 200 e não NaN. Além disso, Number entende "Infinito", enquanto os métodos de análise não.

Personalizado

É improvável que algum desses métodos faça exatamente o que você deseja. Por exemplo, normalmente quero um erro que ocorra quando a análise falha e não preciso de suporte ao Infinity, expoentes ou espaços iniciais. Dependendo do seu uso, às vezes faz sentido escrever uma função de conversão personalizada.

Sempre verifique se a saída numérica ou um dos métodos de análise é o tipo de número esperado. É quase certo que você desejará usar isNaN para garantir que o número não seja NaN (geralmente a única maneira de saber se a análise falhou).