Em JavaScript, NaN significa "Not a Number". É um valor especial que representa um resultado numérico não representável ou indefinido. NaN é uma propriedade do objeto global e também é considerado um tipo de número em JavaScript, o que pode parecer contraintuitivo no início. NaN é tipicamente o resultado de operações que deveriam retornar um número mas não conseguem produzir um valor numérico significativo. Por exemplo:

let result = 0 / 0;
console.log(result); // NaN

Neste caso, dividir zero por zero é matematicamente indefinido, então o JavaScript retorna NaN. Uma propriedade peculiar de NaN é que ele não é igual a nada, inclusive a ele mesmo:

console.log(NaN === NaN); // false

Esse comportamento único torna desafiador verificar se um valor é NaN usando operadores de comparação padrão. Para resolver isso, o JavaScript fornece a função isNaN(). A propriedade da função isNaN() é usada para determinar se um valor é NaN ou não. No entanto, é importante entender como isNaN() funciona, pois ele pode às vezes produzir resultados inesperados. Veja como isNaN() se comporta:

console.log(isNaN(NaN));       // true
console.log(isNaN(undefined)); // true
console.log(isNaN({}));        // true

console.log(isNaN(true));      // false
console.log(isNaN(null));      // false
console.log(isNaN(37));        // false

console.log(isNaN("37"));      // false: "37" is converted to 37
console.log(isNaN("37.37"));   // false: "37.37" is converted to 37.37
console.log(isNaN(""));        // false: empty string is converted to 0
console.log(isNaN(" "));       // false: string with a space is converted to 0

console.log(isNaN("blabla"));  // true: "blabla" is not a number

Como você pode ver, isNaN() primeiro tenta converter o parâmetro para um número. Se não puder ser convertido, retorna true. Esse comportamento pode levar a alguns resultados surpreendentes, especialmente ao lidar com strings que podem ser convertidas em números. Due to these potential inconsistencies, ES6 (the sixth edition of JavaScript, released in 2015) introduced Number.isNaN(). Este método não tenta converter o parâmetro para um número antes de testar. Ele retorna true somente se o valor for exatamente NaN:

console.log(Number.isNaN(NaN));        // true
console.log(Number.isNaN(Number.NaN)); // true
console.log(Number.isNaN(0 / 0));      // true

console.log(Number.isNaN("NaN"));      // false
console.log(Number.isNaN(undefined));  // false
console.log(Number.isNaN({}));         // false
console.log(Number.isNaN("blabla"));   // false

Number.isNaN() fornece uma maneira mais confiável de verificar valores NaN, especialmente em casos onde coerção de tipo pode levar a resultados inesperados com a função global isNaN(). Na prática, ao lidar com operações numéricas ou entradas do usuário que devem ser números, muitas vezes é necessário verificar NaN para tratar erros ou entradas inesperadas de forma adequada. Por exemplo:

let a = 0;
let b = 0;
let result = a / b;

if (Number.isNaN(result)) {
  result = "Error: Division resulted in NaN";
}

console.log(result); // "Error: Division resulted in NaN"

Neste exemplo, estamos usando Number.isNaN() para capturar casos onde a operação de divisão resulta em NaN, permitindo que lidemos com esse cenário de forma apropriada. Entender NaN e como verificar corretamente sua ocorrência é crucial para escrever código JavaScript robusto, especialmente ao lidar com operações matemáticas ou analisar entradas do usuário.