JavaScript Number NaN Property

What You’ll Learn

Number.NaN is a static data property on Number (same API as MDN Number.NaN). It is the Not-A-Number value — the same as global NaN. You get it from invalid math or failed numeric conversion. The gotcha beginners hit first: x === Number.NaN is never true. This tutorial covers detection with Number.isNaN, MDN patterns, five examples, and try-it labs.

Introduction

IEEE-754 floating point includes a special value for results that are not a number — for example 0 / 0 or Math.sqrt(-1). JavaScript exposes that value as both NaN and Number.NaN.

They are the same Not-A-Number value (Object.is(Number.NaN, NaN) is true), but === still returns false because NaN is not equal to anything, including itself. Prefer Number.isNaN(x) to test for it.

This page is part of JavaScript Number Properties. Related tools include Number.isNaN(), Number.isFinite(), and Number.POSITIVE_INFINITY.

Understanding the NaN Property

NaN is still a typeof "number" — it is a special floating-point bit pattern, not a string or an error object. Once a calculation becomes NaN, more math usually stays NaN (poisoning).

• It is a constant number, not a method.
• Same value as global NaN (Object.is).
• Number.NaN === Number.NaN is always false.
• Detect with Number.isNaN(x) (preferred) or Object.is(x, NaN).

📝 Syntax

General form of the static property Number.NaN:

Number.NaN

Value

The number value NaN (Not-A-Number) — same as the global NaN property.

Property attributes

Common patterns

Number.NaN;                         // NaN
Object.is(Number.NaN, NaN);         // true
Number.NaN === Number.NaN;          // false  ← never equals itself
Number.isNaN(Number.NaN);           // true

0 / 0;                              // NaN
Infinity - Infinity;                // NaN
Math.sqrt(-1);                      // NaN
Number("abc");                      // NaN

function sanitize(x) {
  if (Number.isNaN(x)) {
    return Number.NaN;
  }
  return x;
}

Examples Gallery

Examples follow MDN Number.NaN patterns. Use View Output or Try It Yourself for each case.

Number.NaN;
Object.is(Number.NaN, NaN);   // true
typeof Number.NaN;            // "number"

NaN
true
number

Number.NaN === Number.NaN;    // false
Number.NaN === NaN;           // false
Number.isNaN(Number.NaN);     // true
Object.is(Number.NaN, NaN);   // true

false
false
true
true

function clean(x) {
  if (x === Number.NaN) {
    // Can never be true
    return null;
  }
  if (isNaN(x)) {
    return 0;
  }
  return x;
}

clean(Number.NaN);  // 0

0

0 / 0;                 // NaN
Infinity - Infinity;   // NaN
Math.sqrt(-1);         // NaN
Number("abc");         // NaN
parseFloat("xyz");     // NaN

NaN
NaN
NaN
NaN
NaN

function sanitize(x) {
  if (isNaN(x)) {
    return Number.NaN;
  }
  return x;
}

sanitize(42);       // 42
sanitize("abc");    // NaN
Number.isNaN(sanitize("abc"));  // true

42
NaN
true

🚀 Common Use Cases

• Failed conversion signal — return Number.NaN when parsing fails.
• Invalid math marker — detect poisoned results after 0 / 0 style ops.
• Input validation — reject bad numeric fields with Number.isNaN.
• Sentinel values — some APIs use NaN to mean “unknown number”.
• Teaching IEEE-754 — show that NaN ≠ NaN by design.
• Pair with isFinite — reject NaN, Infinity, and -Infinity together.

📝 Notes

• This is a static property — use Number.NaN only.
• Do not write Number.NaN() — it is not a function.
• Number.NaN === Number.NaN is always false.
• Object.is(Number.NaN, NaN) is true.
• Prefer Number.isNaN() over global isNaN when you mean “is this NaN?”.
• typeof NaN is "number" — surprising but correct.

💡 Best Practices