This page was translated from English by the community. Learn more and join the MDN Web Docs community.

View in English Always switch to English

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์™€ ๊ฐ™์€ ์ž์ฒด ๋น„๊ต๋ฅผ ์ˆ˜ํ–‰ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

js
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์ด์–ด์•ผ๋งŒ ์ฐธ์„ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.

js
isNaN("hello world"); // true
Number.isNaN("hello world"); // false

๊ฐ™์€ ์ด์œ ๋กœ BigInt ๊ฐ’์„ ์‚ฌ์šฉํ•˜๋ฉด Number.isNaN()์ด ์•„๋‹Œ isNaN()์—์„œ ์˜ค๋ฅ˜๊ฐ€ ๋ฐœ์ƒํ•ฉ๋‹ˆ๋‹ค.

js
isNaN(1n); // TypeError: Conversion from 'BigInt' to 'number' is not allowed.
Number.isNaN(1n); // false

๋˜ํ•œ ์ผ๋ถ€ ๋ฐฐ์—ด ๋ฉ”์„œ๋“œ๋Š” NaN์„ ์ฐพ์„ ์ˆ˜ ์—†๋Š” ๋ฐ˜๋ฉด์— ๋‹ค๋ฅธ ๋ฐฐ์—ด ๋ฉ”์„œ๋“œ๋“ค์€ ์ฐพ์„ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ์ฆ‰, (indexOf(), lastIndexOf())๋Š” NaN์„ ์ฐพ์„ ์ˆ˜ ์—†์ง€๋งŒ, includes()๋Š” ๊ฐ’์„ ์ฐพ์„ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

js
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๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ ๋น„ํŠธ ์ˆ˜์ค€ ์กฐ์ž‘์„ ์ˆ˜ํ–‰ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

js
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์ด ๋ฐ˜ํ™˜๋ฉ๋‹ˆ๋‹ค.

js
NaN ** 0 === 1; // true

๋ช…์„ธ

Specification
ECMAScriptยฎ 2026 Languageย Specification
# sec-value-properties-of-the-global-object-nan

๋ธŒ๋ผ์šฐ์ € ํ˜ธํ™˜์„ฑ

๊ฐ™์ด ๋ณด๊ธฐ