NaN in JavaScript

1. What is NaN
2. When will NaN be returned
3. Judge NaN
4. Reference

What is NaN

It is described in MDN's NaN article:

• The global attribute NaN represents the value of Not-A-Number.
• NaN is a property of a global object.
• The initial value of the NaN attribute is NaN, which is the same as the value of Number.NaN.
• In ES5, the NaN attribute is a non-configurable and non-writable attribute. But in ES3, the value of this property can be changed, but overwriting should be avoided.
• usually appears as the return value of a method of Math when the calculation fails (for example: Math.sqrt(-1)) or when trying to parse a string into number but failed (for example: parseInt("blabla")).

The type of NaN

typeof NaN   // "number"

That is to say, NaN is a special Number type value.

When will NaN be returned?

The authoritative guide to JavaScript has a description in the chapter "3.1.3 Arithmetic Operations in JavaScript":

Infinity divided by infinity, Taking the square root of any negative number or using an arithmetic operator with an operand that is not a number or cannot be converted to a number will return NaN.

can be separately interpreted as the following situations:

• Infinity divided by infinity
• Do the square root operation for any negative number
• Arithmetic Operators used with operands that are not numbers or cannot be converted to numbers
• String parses into a number

The following results are allNaN:

Infinity / Infinity;   // 无穷大除以无穷大
Math.sqrt(-1);         // 给任意负数做开方运算
'a' - 1;               // 算数运算符与不是数字或无法转换为数字的操作数一起使用
'a' * 1;
'a' / 1;
parseInt('a');         // 字符串解析成数字
parseFloat('a');

What the hell is the "operation that cannot be converted into numbers" here?

Let’s first look at the following examples of operations that can be converted to numbers:

Math.sqrt('4');        // 2
2 * '2';               // 4
'4' / 2;               // 2

Operations that cannot be converted to numbers

This involves JavaScript’s type conversion concept.

The JavaScript Definitive Guide "3.8 Type Conversion" chapter describes:

If JavaScript expects a number, it will convert the given value to a number (if the conversion result is meaningless will return NaN).

You can use the Number() method to do explicit type conversion, for example:

Number('1');           // 1
Number(null);          // 0
Number('a');           // NaN

You can also use the unary operator to do implicit type conversion Formula conversion, for example:

+'1';                  // 1
+null;                 // 0
+'a';                  // NaN

You can also use the global functions parseInt() and parseFloat() to parse integers and floating point numbers, for example:

parseInt('12');        // 12
parseInt('12a');       // 12
parseInt('a12');       // NaN
parseInt(null);        // NaN

parseInt() and parseFloat() can be simply understood as:

Parse as many numeric characters as possible and ignore the following content; if If a non-space character is a non-number, NaN

should be noted that Number() and parseInt()``parseFloat (), some input values ​​are treated differently, such as null.

Non-numeric types are converted to numeric types, as summarized in the following table:

isNaN( ) The function cannot strictly determine whether the input value is NaN.

The weird behavior of isNaN()

non-numeric parameters Explanation:

It will first try to convert this parameter into a numerical value, and then judge whether the converted result is

NaN.

Therefore, it may be confusing to return a

false value for a non-NaN value that can be coerced to a valid value.

isNaN('37');      // false: 可以被转换成数值 37
isNaN('');        // false: 空字符串被转换成 0

Number.isNaN() in MDN:

typeof value === 'number' && isNaN(value)

JS Tutorial"

The above is the detailed content of NaN in JavaScript. For more information, please follow other related articles on the PHP Chinese website!