NaN
Baseline
Widely available
This feature is well established and works across many devices and browser versions. Itโs been available across browsers since โจ2015๋ 7์โฉ.
์ ์ญ NaN ์์ฑ์ Not-A-Number(์ซ์๊ฐ ์๋)๋ฅผ ๋ํ๋
๋๋ค.
์๋ํด ๋ณด๊ธฐ
function sanitize(x) {
if (isNaN(x)) {
return NaN;
}
return x;
}
console.log(sanitize("1"));
// Expected output: "1"
console.log(sanitize("NotANumber"));
// Expected output: NaN
๊ฐ
Number.NaN์ ๋์ผํ ์ซ์ ๊ฐ์
๋๋ค.
Property attributes of NaN | |
|---|---|
| ์ฐ๊ธฐ ๊ฐ๋ฅ | ๋ถ๊ฐ๋ฅ |
| ์ด๊ฑฐ ๊ฐ๋ฅ | ๋ถ๊ฐ๋ฅ |
| ์ค์ ๊ฐ๋ฅ | ๋ถ๊ฐ๋ฅ |
์ค๋ช
NaN์ ์ ์ญ ๊ฐ์ฒด์ ์์ฑ์
๋๋ค. ์ฆ ์ ์ญ ๋ฒ์์ ๋ณ์์
๋๋ค.
์ต์ ๋ธ๋ผ์ฐ์ ์์ NaN์ ์ค์ ๋ถ๊ฐ, ์ฐ๊ธฐ ๋ถ๊ฐ ์์ฑ์
๋๋ค. ๊ทธ๋ ์ง ์๋ค๊ณ ํ๋๋ผ๋ ๋ฎ์ด์ฐ๋ ๊ฑด ํผํ๋ ๊ฒ ์ข์ต๋๋ค.
NaN์ ๋ฐํํ๋ ์ฐ์ฐ์๋ ๋ค์ฏ ๊ฐ์ง ์ข
๋ฅ๊ฐ ์์ต๋๋ค.
- ์ซ์๋ก ๋ณํ ์คํจ (์์:
parseInt("blabla"),Number(undefined)์ ๊ฐ์ ๋ช ์์ ์ธ ๊ฒ ๋๋Math.abs(undefined)์ ๊ฐ์ ์์์ ์ธ ๊ฒ) - ๊ฒฐ๊ณผ๊ฐ ํ์์ธ ์ํ ๊ณ์ฐ์ (์์:
Math.sqrt(-1)) - ์ ์ํ ์ ์๋ ๊ณ์ฐ์ (์์:
0 * Infinity,1 ** Infinity,Infinity / Infinity,Infinity - Infinity) - ํผ์ฐ์ฐ์๊ฐ
NaN์ด๊ฑฐ๋NaN์ผ๋ก ๊ฐ์ ๋ณํ๋๋ ๋ฉ์๋ ๋๋ ํํ์ (์์:7 ** NaN,7 * "blabla") - ์ด๊ฒ์NaN์ด ์ ์ผ์ฑ ์๋ค๋ ๊ฒ์ ์๋ฏธํฉ๋๋ค. - ์ ํจํ์ง ์์ ๊ฐ์ด ์ซ์๋ก ํ์๋๋ ๊ธฐํ ๊ฒฝ์ฐ (์์: ์๋ชป๋ ๋ ์ง
new Date("blabla").getTime(),"".charCodeAt(1))
NaN๊ณผ NaN์ ๋์์ JavaScript์์ ๋ฐ๋ช
ํ ๊ฒ์ด ์๋๋๋ค. ๋ถ๋ ์์์ ์ฐ์ ์ ์๋ฏธ(NaN !== NaN ํฌํจ)๋ IEEE 754์ ์ํด ์ง์ ๋ฉ๋๋ค. NaN์ ๋์์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
NaN์ด ์ํ ์ฐ์ฐ์ ํฌํจ๋ ๊ฒฝ์ฐ (๊ทธ๋ฌ๋ ๋นํธ ์ฐ์ฐ๋ ์๋) ๊ฒฐ๊ณผ๋ ์ผ๋ฐ์ ์ผ๋กNaN์ ๋๋ค. (์๋์ counter-example ์ฐธ์กฐ)NaN์ด ๊ด๊ณ ๋น๊ต(>,<,>=,<=)์ ํผ์ฐ์ฐ์ ์ค ํ๋์ธ ๊ฒฝ์ฐ ๊ฒฐ๊ณผ๋ ํญ์false์ ๋๋ค.NaN์ (==,!=,===๋ฐ!==๋ฅผ ํตํด) ๋ค๋ฅธNaN๊ฐ์ ํฌํจํ์ฌ ๋ค๋ฅธ ๊ฐ๊ณผ ๊ฐ์ง ์์ ๊ฒ์ผ๋ก ๋น๊ต๋ฉ๋๋ค.
NaN์ JavaScript์ falsy ๊ฐ ์ค ํ๋์ด๊ธฐ๋ ํฉ๋๋ค.
์์
>NaN ํ๋ณ
๊ฐ์ด NaN์ธ์ง ํ์ธํ๋ ค๋ฉด, Number.isNaN() ๋๋ isNaN()๋ฅผ ์ฌ์ฉํ์ฌ ๊ฐ์ด NaN์ธ์ง ์ฌ๋ถ๋ฅผ ํ์ธ ํ ์ ์์ต๋๋ค. ๋๋ NaN์ ์์ ๊ณผ ๊ฐ์ง ์๋ค๊ณ ๋น๊ต๋๋ ์ ์ผํ ๊ฐ์ด๋ฏ๋ก x !== x์ ๊ฐ์ ์์ฒด ๋น๊ต๋ฅผ ์ํํ ์ ์์ต๋๋ค.
NaN === NaN; // false
Number.NaN === NaN; // false
isNaN(NaN); // true
isNaN(Number.NaN); // true
function valueIsNaN(v) {
return v !== v;
}
valueIsNaN(1); // false
valueIsNaN(NaN); // true
valueIsNaN(Number.NaN); // true
๊ทธ๋ฌ๋ isNaN()๊ณผ Number.isNaN()์ ์ฐจ์ด๋ฅผ ์ ์ํด์ผ ํฉ๋๋ค. isNaN์ ํ์ฌ ๊ฐ์ด NaN์ด๊ฑฐ๋, ์ซ์๋ก ๋ณํํ์ ๋ NaN์ด ๋๋ฉด ์ฐธ์ ๋ฐํํ์ง๋ง, Number.isNaN์ ํ์ฌ ๊ฐ์ด NaN์ด์ด์ผ๋ง ์ฐธ์ ๋ฐํํฉ๋๋ค.
isNaN("hello world"); // true
Number.isNaN("hello world"); // false
๊ฐ์ ์ด์ ๋ก BigInt ๊ฐ์ ์ฌ์ฉํ๋ฉด Number.isNaN()์ด ์๋ isNaN()์์ ์ค๋ฅ๊ฐ ๋ฐ์ํฉ๋๋ค.
isNaN(1n); // TypeError: Conversion from 'BigInt' to 'number' is not allowed.
Number.isNaN(1n); // false
๋ํ ์ผ๋ถ ๋ฐฐ์ด ๋ฉ์๋๋ NaN์ ์ฐพ์ ์ ์๋ ๋ฐ๋ฉด์ ๋ค๋ฅธ ๋ฐฐ์ด ๋ฉ์๋๋ค์ ์ฐพ์ ์ ์์ต๋๋ค. ์ฆ, (indexOf(), lastIndexOf())๋ NaN์ ์ฐพ์ ์ ์์ง๋ง, includes()๋ ๊ฐ์ ์ฐพ์ ์ ์์ต๋๋ค.
const arr = [2, 4, NaN, 12];
arr.indexOf(NaN); // -1
arr.includes(NaN); // true
// ์ ์ ํ๊ฒ ์ ์๋ ์กฐ๊ฑด์๋ฅผ ํ์ฉํ๋ ๋ฉ์๋๋ ํญ์ NaN์ ์ฐพ์ ์ ์์ต๋๋ค.
arr.findIndex((n) => Number.isNaN(n)); // 2
NaN๊ณผ ๊ทธ ๋น๊ต์ ๋ํ ์์ธํ ๋ด์ฉ์ ํ๋ฑ ๋น๊ต ๋ฐ ๋์ผ์ฑ๋ฅผ ์ฐธ์กฐ.
๋์ ๋๊ฒ ๊ตฌ๋ณ๋๋ NaN ๊ฐ
NaN์ด ์์ ๊ณผ ๋๋ฑํ์ง ์์ ๋ฐ๋ ๋๊ธฐ๊ฐ ์์ต๋๋ค. IEEE 754 ์ธ์ฝ๋ฉ์์ ์ง์ 0x7ff์ 0์ด ์๋ ๊ฐ์๋ถ๊ฐ ์๋ ๋ถ๋ ์์์ ์ซ์๋ NaN์ด๊ธฐ ๋๋ฌธ์ ์๋ก ๋ค๋ฅธ ์ด์ง ํํ์ ๊ฐ์ง ๋ ๊ฐ์ ๋ถ๋ ์์์ ์ซ์๋ฅผ ์์ฑํ ์ ์์ง๋ง ๋ ๋ค NaN์
๋๋ค. JavaScript์์ typed arrays๋ฅผ ์ฌ์ฉํ์ฌ ๋นํธ ์์ค ์กฐ์์ ์ํํ ์ ์์ต๋๋ค.
const f2b = (x) => new Uint8Array(new Float64Array([x]).buffer);
const b2f = (x) => new Float64Array(x.buffer)[0];
// NaN์ byte ํํ์ ๊ฐ์ ธ์ต๋๋ค.
const n = f2b(NaN);
// ๋ถํธ ๋นํธ์ด๊ณ NaN์ ์ค์ํ์ง ์์ ์ฒซ ๋ฒ์งธ ๋นํธ๋ฅผ ๋ณ๊ฒฝํฉ๋๋ค.
n[0] = 1;
const nan2 = b2f(n);
console.log(nan2); // NaN
console.log(Object.is(nan2, NaN)); // true
console.log(f2b(NaN)); // Uint8Array(8) [0, 0, 0, 0, 0, 0, 248, 127]
console.log(f2b(nan2)); // Uint8Array(8) [1, 0, 0, 0, 0, 0, 248, 127]
์กฐ์ฉํ NaN ํ์ถ
NaN์ ์ํ์ ์ฐ์ฐ์ ํตํด ์ ํ๋๋ฏ๋ก ์ผ๋ฐ์ ์ผ๋ก ์ค๋ฅ ์กฐ๊ฑด์ ๊ฐ์งํ๊ธฐ ์ํด ๊ณ์ฐ์ด ๋๋ ๋ ํ ๋ฒ NaN์ ํ
์คํธํ๋ ๊ฒ์ผ๋ก ์ถฉ๋ถํฉ๋๋ค. NaN์ด ์๋์ผ๋ก ์ด์ค์ผ์ดํ๋๋ ์ ์ผํ ๊ฒฝ์ฐ๋ ์ง์๊ฐ 0์ธ ๊ฑฐ๋ญ์ ๊ณฑ์ ์ฌ์ฉํ ๋์
๋๋ค. ๊ทธ๋ฌ๋ฉด ๊ธฐ๋ณธ๊ฐ์ ๊ฒ์ฌํ์ง ์๊ณ ์ฆ์ 1์ด ๋ฐํ๋ฉ๋๋ค.
NaN ** 0 === 1; // true
๋ช ์ธ
| Specification |
|---|
| ECMAScriptยฎ 2026 Languageย Specification> # sec-value-properties-of-the-global-object-nan> |