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.
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:
javascriptconst 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)); // falseUse 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")); // 0Filtering 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)); // falseAlternative 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:
javascriptconst quantity = parseInt(userInput, 10);
if (Number.isNaN(quantity)) {
// Handle the error immediately
return { error: "Invalid quantity" };
}
// Safe to use quantity from hereAlways 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:
javascriptconsole.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")); // falseUse 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:
javascriptconsole.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:
javascriptfunction 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(), orNumber()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()?
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
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.
More in this topic
OffscreenCanvas API in JS for UI Performance
Master the OffscreenCanvas API to offload rendering from the main thread. Covers worker-based 2D and WebGL rendering, animation loops inside workers, bitmap transfer, double buffering, chart rendering pipelines, image processing, and performance measurement strategies.
Advanced Web Workers for High Performance JS
Master Web Workers for truly parallel JavaScript execution. Covers dedicated and shared workers, structured cloning, transferable objects, SharedArrayBuffer with Atomics, worker pools, task scheduling, Comlink RPC patterns, module workers, and performance profiling strategies.
JavaScript Macros and Abstract Code Generation
Master JavaScript code generation techniques for compile-time and runtime metaprogramming. Covers AST manipulation, Babel plugin authorship, tagged template literals as macros, code generation pipelines, source-to-source transformation, compile-time evaluation, and safe eval alternatives.