How to Check for NaN in JavaScript Using isNaN() Function

Learn how to detect NaN values in JavaScript using Number.isNaN() and the global isNaN() function. Understand their differences, edge cases, and build reliable numeric validation patterns.

JavaScriptbeginner

RuneHub Team

February 25, 2026

9 min read

RuneHub Team

Feb 25, 2026

9 min read

Detecting NaN (Not a Number) in JavaScript requires dedicated functions because the standard equality operator do not work. Since NaN !== NaN is true, you cannot use === or == to check if a value is NaN. JavaScript provides two functions for this purpose: the modern Number.isNaN() and the legacy global isNaN().

Choosing between these two functions is not a style preference. They behave fundamentally differently, and picking the wrong one introduces bugs that silently pass through your validation logic. This guide explains exactly how each function works, when to use which, and how to build reliable numeric validation for real applications.

The Problem: NaN Cannot Be Compared

Before looking at the solutions, it is important to understand why dedicated NaN detection exists:

javascript

const result = parseInt("hello");
console.log(result);          // NaN
 
// Every comparison with NaN returns false
console.log(result === NaN);  // false
console.log(result == NaN);   // false
console.log(result > 0);      // false
console.log(result < 0);      // false
console.log(result === result); // false (!)

This means any code that tries if (value === NaN) never executes the true branch, even when value is actually NaN. This is the single most common NaN-related bug in JavaScript.

Number.isNaN(): The Reliable Choice

Number.isNaN() was introduced in ES6 (ES2015) to provide a reliable, predictable way to check for NaN. It returns true only when the argument is actually the NaN value, with no type coercion:

javascript

// Actual NaN values
console.log(Number.isNaN(NaN));           // true
console.log(Number.isNaN(0 / 0));         // true
console.log(Number.isNaN(parseInt("abc"))); // true
console.log(Number.isNaN(Math.sqrt(-1)));  // true
 
// Everything else returns false (no coercion)
console.log(Number.isNaN(42));            // false
console.log(Number.isNaN("hello"));       // false
console.log(Number.isNaN(undefined));     // false
console.log(Number.isNaN(null));          // false
console.log(Number.isNaN(true));          // false
console.log(Number.isNaN(""));            // false
console.log(Number.isNaN("NaN"));         // false
console.log(Number.isNaN(Infinity));      // false

Use Number.isNaN() in Modern Code

Number.isNaN() is the recommended way to check for NaN in all modern JavaScript. It has no false positives, no surprising behavior, and works exactly as its name suggests. If the value is NaN, it returns true. If the value is anything else, it returns false.

How Number.isNaN() Works Internally

The implementation is straightforward: it checks that the argument is of type number AND that it is NaN:

javascript

// Simplified polyfill of Number.isNaN
function numberIsNaN(value) {
  return typeof value === "number" && value !== value;
}
 
// The value !== value trick works because NaN is the only value
// in JavaScript that is not equal to itself
console.log(numberIsNaN(NaN));       // true
console.log(numberIsNaN("hello"));   // false (typeof is "string")
console.log(numberIsNaN(undefined)); // false (typeof is "undefined")

Global isNaN(): The Legacy Function

The global isNaN() function has been in JavaScript since version 1.0. Unlike Number.isNaN(), it first coerces the argument to a number using Number(), then checks if the converted result is NaN:

javascript

// Step 1: convert argument with Number()
// Step 2: check if the result is NaN
 
console.log(isNaN(NaN));           // true (NaN → NaN → true)
console.log(isNaN(0 / 0));        // true (NaN → NaN → true)
 
// These return true because Number() conversion produces NaN
console.log(isNaN("hello"));      // true (Number("hello") → NaN → true)
console.log(isNaN(undefined));    // true (Number(undefined) → NaN → true)
console.log(isNaN("abc123"));     // true (Number("abc123") → NaN → true)
console.log(isNaN({a: 1}));       // true (Number({a: 1}) → NaN → true)
 
// These return false because Number() conversion succeeds
console.log(isNaN(null));         // false (Number(null) → 0 → false)
console.log(isNaN(true));         // false (Number(true) → 1 → false)
console.log(isNaN(false));        // false (Number(false) → 0 → false)
console.log(isNaN(""));           // false (Number("") → 0 → false)
console.log(isNaN("42"));         // false (Number("42") → 42 → false)
console.log(isNaN(" 3.14 "));     // false (Number(" 3.14 ") → 3.14 → false)

The question global isNaN() actually answers is: "Would converting this value to a number produce NaN?" That is a very different question from: "Is this value NaN?"

Number.isNaN() vs. Global isNaN(): Complete Comparison

Input Value	`Number.isNaN()`	`isNaN()`	Reason for Difference
`NaN`	`true`	`true`	Both detect actual NaN
`0 / 0`	`true`	`true`	Both detect actual NaN
`"hello"`	`false`	`true`	Global coerces: `Number("hello")` = NaN
`undefined`	`false`	`true`	Global coerces: `Number(undefined)` = NaN
`{}`	`false`	`true`	Global coerces: `Number({})` = NaN
`"NaN"`	`false`	`true`	Global coerces: `Number("NaN")` = NaN
`null`	`false`	`false`	`Number(null)` = 0 (not NaN)
`true`	`false`	`false`	`Number(true)` = 1 (not NaN)
`""`	`false`	`false`	`Number("")` = 0 (not NaN)
`"42"`	`false`	`false`	`Number("42")` = 42 (not NaN)
`42`	`false`	`false`	Already a valid number
`Infinity`	`false`	`false`	Infinity is a number, not NaN

The False Positive Problem

The global isNaN("hello") returns true, but the string "hello" is not NaN. It is a string. This false positive has caused countless bugs in form validation, API response handling, and data processing pipelines. Always prefer Number.isNaN() unless you specifically want the coercion behavior.

Practical NaN Detection Patterns

Validating User Input

javascript

// Form field validation
function validateAge(input) {
  const age = parseInt(input, 10);
 
  if (Number.isNaN(age)) {
    return { valid: false, error: "Please enter a valid number" };
  }
  if (age < 0 || age > 150) {
    return { valid: false, error: "Age must be between 0 and 150" };
  }
  return { valid: true, value: age };
}
 
console.log(validateAge("25"));      // { valid: true, value: 25 }
console.log(validateAge("hello"));   // { valid: false, error: "Please enter a valid number" }
console.log(validateAge(""));        // { valid: false, error: "Please enter a valid number" }
console.log(validateAge("3.7"));     // { valid: true, value: 3 }

Safe Number Parsing with Fallback

javascript

// Parse with a safe default value
function safeParseFloat(input, defaultValue = 0) {
  const parsed = parseFloat(input);
  return Number.isNaN(parsed) ? defaultValue : parsed;
}
 
console.log(safeParseFloat("29.99"));        // 29.99
console.log(safeParseFloat("free", 0));      // 0
console.log(safeParseFloat("", -1));         // -1
console.log(safeParseFloat("$19.99"));       // NaN → 0 ($ is not numeric)
 
// Parse integer with validation
function safeParseInt(input, radix = 10, defaultValue = 0) {
  const parsed = parseInt(input, radix);
  return Number.isNaN(parsed) ? defaultValue : parsed;
}
 
console.log(safeParseInt("42"));         // 42
console.log(safeParseInt("0xFF", 16));   // 255
console.log(safeParseInt("nope"));       // 0

Filtering NaN from Data Arrays

javascript

// API response with mixed data quality
const rawScores = [95, 87, NaN, 72, NaN, 88, 91, NaN, 76];
 
// Remove NaN values
const validScores = rawScores.filter(score => !Number.isNaN(score));
console.log(validScores); // [95, 87, 72, 88, 91, 76]
 
// Calculate average (only valid scores)
const average = validScores.reduce((sum, s) => sum + s, 0) / validScores.length;
console.log(average.toFixed(1)); // "84.8"

Comprehensive Number Validation

javascript

// Production-grade number validator
function isValidNumber(value) {
  return typeof value === "number" && !Number.isNaN(value) && Number.isFinite(value);
}
 
console.log(isValidNumber(42));        // true
console.log(isValidNumber(3.14));      // true
console.log(isValidNumber(0));         // true
console.log(isValidNumber(-100));      // true
 
console.log(isValidNumber(NaN));       // false
console.log(isValidNumber(Infinity));  // false
console.log(isValidNumber(-Infinity)); // false
console.log(isValidNumber("42"));      // false (string, not number)
console.log(isValidNumber(null));      // false
console.log(isValidNumber(undefined)); // false

Alternative NaN Detection Methods

Besides the two isNaN functions, JavaScript offers other ways to detect NaN:

javascript

// Method 1: Self-inequality check (NaN !== NaN)
function isNaNSelfCheck(value) {
  return value !== value;
}
 
// Method 2: Object.is()
console.log(Object.is(NaN, NaN)); // true (unlike ===)
console.log(Object.is(0, -0));    // false (unlike ===)
 
// Method 3: Array.includes uses SameValueZero
const arr = [1, NaN, 3];
console.log(arr.includes(NaN)); // true (works!)
console.log(arr.indexOf(NaN));  // -1 (does NOT work, uses ===)

Method	Detects NaN	False Positives	Use Case
`Number.isNaN(x)`	Yes	None	General NaN detection (recommended)
`isNaN(x)`	Yes	Strings, undefined, objects	Checking "is this convertible to a number?"
`x !== x`	Yes	None	One-liner trick, less readable
`Object.is(x, NaN)`	Yes	None	When you also need `-0` vs `0` distinction
`arr.includes(NaN)`	Yes	None	Checking if NaN exists in an array

When to Use Global isNaN() (Rare but Valid)

The global isNaN() is not always wrong. In specific cases, its coercion behavior is exactly what you want:

javascript

// Scenario: checking if a form field can be treated as a number
// You WANT coercion here because form values are always strings
function isNumericInput(formValue) {
  // Global isNaN answers: "Can this string become a valid number?"
  return !isNaN(formValue) && formValue.toString().trim() !== "";
}
 
console.log(isNumericInput("42"));     // true
console.log(isNumericInput("3.14"));   // true
console.log(isNumericInput(" 99 "));   // true (Number trims whitespace)
console.log(isNumericInput("hello"));  // false
console.log(isNumericInput(""));       // false (we explicitly exclude empty)

However, Number() or parseFloat() combined with Number.isNaN() is usually clearer:

javascript

// Equivalent but more explicit
function isNumericInputClear(formValue) {
  const trimmed = formValue.toString().trim();
  if (trimmed === "") return false;
  return !Number.isNaN(Number(trimmed));
}

Best Practices

Reliable NaN Handling Patterns

Following these practices ensures your numeric validation catches every edge case without false positives.

Default to Number.isNaN() for all NaN checks. Unless you have a specific reason to use the coercion behavior of the global isNaN(), always use Number.isNaN(). It has zero false positives and communicates intent clearly.

Validate immediately after parsing. Every call to parseInt(), parseFloat(), or Number() should be followed by a NaN check before the value is used in any calculation:

javascript

const quantity = parseInt(userInput, 10);
if (Number.isNaN(quantity)) {
  // Handle the error immediately
  return { error: "Invalid quantity" };
}
// Safe to use quantity from here

Always pass a radix to parseInt(). Without the radix parameter, parseInt() guesses the base from the string prefix, which can produce unexpected NaN or wrong values:

javascript

console.log(parseInt("08"));      // 8 (decimal in modern engines)
console.log(parseInt("08", 10));  // 8 (explicitly decimal)
console.log(parseInt("0x1F", 16)); // 31 (explicitly hex)

Combine NaN check with Infinity check for robust validation. Number.isNaN() catches NaN but not Infinity. Use Number.isFinite() to get a complete numeric validation in one call:

javascript

// Number.isFinite rejects NaN, Infinity, -Infinity, and non-numbers
console.log(Number.isFinite(42));       // true
console.log(Number.isFinite(NaN));      // false
console.log(Number.isFinite(Infinity)); // false
console.log(Number.isFinite("42"));     // false

Use descriptive error messages. When NaN is detected, tell the user what went wrong. "Invalid input" is better than nothing, but "Please enter a numeric value for quantity" is better still.

Common Mistakes and How to Avoid Them

Watch Out for These Pitfalls

These mistakes are especially common in form validation and API data processing where inputs are always strings.

Comparing with === NaN instead of using a function. This is the most frequent NaN bug. Since NaN !== NaN, the comparison value === NaN always evaluates to false:

javascript

// Bug: this NEVER detects NaN
const result = parseInt("abc");
if (result === NaN) {
  console.log("This never runs");
}
 
// Fix
if (Number.isNaN(result)) {
  console.log("Properly detected");
}

Using global isNaN() for strict type validation. If you need to verify that a value is specifically the NaN type, global isNaN() gives false positives for strings, undefined, and objects. This often causes validation to reject valid non-numeric values that should be handled separately.

Forgetting that parseInt() can partially parse. parseInt("42abc") returns 42, not NaN. If you need strict numeric validation, use Number() instead:

javascript

console.log(parseInt("42abc"));  // 42 (partial parse, no NaN)
console.log(Number("42abc"));    // NaN (strict, the whole string must be numeric)

Not handling the empty string case. Number("") returns 0, not NaN. If an empty string should be treated as invalid input, you need an explicit empty check:

javascript

function validateNumericField(input) {
  if (input.trim() === "") {
    return { valid: false, error: "Field is required" };
  }
  const num = Number(input);
  if (Number.isNaN(num)) {
    return { valid: false, error: "Must be a number" };
  }
  return { valid: true, value: num };
}

Next Steps

Build a form with complete numeric validation

Create a multi-field form (price, quantity, discount percentage) that validates each field with proper NaN detection, range checks, and user-friendly error messages.

Explore undefined and null differences

Understanding how undefined and null interact with Number() conversion and NaN detection completes your understanding of JavaScript's special values.

Practice with array data cleaning

Given a real dataset with mixed types, practice filtering, transforming, and aggregating numeric values while handling NaN at every step.

Learn [JavaScript functions](/tutorials/programming-languages/javascript/what-is-a-function-in-javascript-beginner-guide) in depth

isNaN() and Number.isNaN() are just two of many built-in JavaScript functions. Understanding how built-in functions work prepares you for writing your own utility functions.

Rune AI

Key Insights

Never use === NaN: NaN is not equal to itself, so equality comparisons always return false
Use Number.isNaN(): the only NaN detection method with zero false positives and zero coercion
Global isNaN() coerces: it converts the argument to a number first, causing false positives for strings and undefined
Validate at the boundary: check for NaN immediately after every parseInt(), parseFloat(), or Number() call
Combine with Number.isFinite(): for complete validation that rejects NaN, Infinity, and non-numbers in one check

Frequently Asked Questions

What is the difference between isNaN() and Number.isNaN()?

The global `isNaN()` first converts its argument to a number using `Number()`, then checks if the result is NaN. This means `isNaN("hello")` returns true because `Number("hello")` produces NaN. `Number.isNaN()` does not convert the argument; it only returns true for actual NaN values. In most cases, `Number.isNaN()` is the correct choice because it avoids false positives with strings and other non-numeric types.

Why does NaN === NaN return false?

This behavior is defined by the IEEE 754 floating-point standard, which JavaScript follows. NaN represents the result of an undefined mathematical operation, and since different operations can produce NaN (like 0/0 vs sqrt(-1)), comparing two NaN values is comparing two different error conditions. The standard says these should not be equal. This is why dedicated functions like `Number.isNaN()` exist.

Is Number.isNaN() supported in all browsers?

Yes. `Number.isNaN()` has been supported in all major browsers since ES6 (2015). Chrome 25+, Firefox 15+, Safari 9+, and Edge 12+ all support it. For extremely old environments, you can polyfill it with `function(v) { return typeof v === "number" && v !== v; }`, but this is rarely needed in 2026.

How do I check if a string can be converted to a valid number?

Use `Number()` to attempt the conversion, then check with `Number.isNaN()`: `const num = Number(str); if (!Number.isNaN(num)) { /* valid */ }`. Remember to also check for empty strings since `Number("")` returns `0` rather than NaN. Alternatively, `Number.isFinite(Number(str))` rejects NaN, Infinity, and non-numeric strings in a single check.

Should I ever use the global isNaN() function?

In most modern code, `Number.isNaN()` is the better choice. The global `isNaN()` is only useful when you specifically want to know: "Would this value produce NaN if converted to a number?" This is occasionally useful for form validation where all inputs are strings, but even then, explicitly converting with `Number()` and checking with `Number.isNaN()` is clearer and easier to maintain.

Conclusion

JavaScript provides two NaN detection functions with fundamentally different behaviors. Number.isNaN() checks if a value is specifically NaN with zero false positives, while the global isNaN() coerces its argument first and can misidentify strings and undefined as NaN. For reliable numeric validation, always use Number.isNaN() immediately after parsing input, combine it with Number.isFinite() for complete number validation, and handle edge cases like empty strings explicitly.

How to Check for NaN in JavaScript Using isNaN() Function

The Problem: NaN Cannot Be Compared

Number.isNaN(): The Reliable Choice

Use Number.isNaN() in Modern Code

How Number.isNaN() Works Internally

Global isNaN(): The Legacy Function

Number.isNaN() vs. Global isNaN(): Complete Comparison

The False Positive Problem

Practical NaN Detection Patterns

Validating User Input

Safe Number Parsing with Fallback

Filtering NaN from Data Arrays

Comprehensive Number Validation

Alternative NaN Detection Methods

When to Use Global isNaN() (Rare but Valid)

Best Practices

Reliable NaN Handling Patterns

Common Mistakes and How to Avoid Them

Watch Out for These Pitfalls

Next Steps

Build a form with complete numeric validation

Explore undefined and null differences

Practice with array data cleaning

Learn [JavaScript functions](/tutorials/programming-languages/javascript/what-is-a-function-in-javascript-beginner-guide) in depth

Rune AI

Frequently Asked Questions

What is the difference between isNaN() and Number.isNaN()?

Why does NaN === NaN return false?

Is Number.isNaN() supported in all browsers?

How do I check if a string can be converted to a valid number?

Should I ever use the global isNaN() function?

Conclusion

Tags

More in this topic

OffscreenCanvas API in JS for UI Performance

Advanced Web Workers for High Performance JS

JavaScript Macros and Abstract Code Generation

Stay Updated