JavaScript: How to check if a number is NaN or finite?

Checking whether a number is NaN (Not a Number) or finite is important while working with numerical computations in JavaScript. NaN (Not a Number) indicates a value that can't be represented as a number, often occurring from invalid operations like dividing zero by zero (0/0). Finite numbers are all real numbers in JavaScript that are neither Infinity, -Infinity, nor NaN.

JavaScript provides several built-in methods to determine if a value is NaN (Not a Number) or if a number is finite. In this article, you will understand how to check if a number is NaN or finite using these built-in methods.

Checking for NaN

There are multiple approaches to check if a value is NaN, each with different behaviors:

Using isNaN() - Type Coercion Method

The isNaN() function converts the argument to a number first, then checks if it's NaN. This can lead to unexpected results with non-numeric values.

// isNaN() converts values to numbers first
console.log(isNaN(NaN));        // true
console.log(isNaN('hello'));    // true (converts to NaN)
console.log(isNaN('123'));      // false (converts to 123)
console.log(isNaN(undefined));  // true (converts to NaN)
console.log(isNaN(null));       // false (converts to 0)

true
true
false
true
false

Using Number.isNaN() - Strict Method (Recommended)

The Number.isNaN() method is more reliable as it doesn't perform type conversion. It only returns true if the value is exactly NaN.

// Number.isNaN() doesn't convert - strict check
console.log(Number.isNaN(NaN));        // true
console.log(Number.isNaN('hello'));    // false (no conversion)
console.log(Number.isNaN('123'));      // false
console.log(Number.isNaN(undefined));  // false
console.log(Number.isNaN(0/0));        // true (actual NaN)

true
false
false
false
true

Checking for Finite Numbers

Similarly, there are different methods to check if a number is finite:

Using isFinite() - Type Coercion Method

The isFinite() function converts non-numeric values to numbers before checking if they are finite.

// isFinite() converts values to numbers first
console.log(isFinite(42));         // true
console.log(isFinite(Infinity));   // false
console.log(isFinite(-Infinity));  // false
console.log(isFinite(NaN));        // false
console.log(isFinite('123'));      // true (converts to 123)
console.log(isFinite('hello'));    // false (converts to NaN)
console.log(isFinite(null));       // true (converts to 0)

true
false
false
false
true
false
true

Using Number.isFinite() - Strict Method (Recommended)

The Number.isFinite() method only returns true for actual finite numbers, without type conversion.

// Number.isFinite() - strict check, no conversion
console.log(Number.isFinite(42));         // true
console.log(Number.isFinite(Infinity));   // false
console.log(Number.isFinite(-Infinity));  // false
console.log(Number.isFinite(NaN));        // false
console.log(Number.isFinite('123'));      // false (no conversion)
console.log(Number.isFinite('hello'));    // false
console.log(Number.isFinite(null));       // false

true
false
false
false
false
false
false

Comparison of Methods

Practical Example: Number Validation Function

function validateNumber(value) {
    if (Number.isNaN(value)) {
        return 'Value is NaN';
    } else if (!Number.isFinite(value)) {
        return 'Value is infinite';
    } else {
        return 'Value is a finite number';
    }
}

// Test the function
console.log(validateNumber(42));          // Value is a finite number
console.log(validateNumber(NaN));         // Value is NaN
console.log(validateNumber(Infinity));    // Value is infinite
console.log(validateNumber(-Infinity));   // Value is infinite
console.log(validateNumber('hello'));     // Value is NaN (for non-numbers)

Value is a finite number
Value is NaN
Value is infinite
Value is infinite
Value is NaN (for non-numbers)

Conclusion

Use Number.isNaN() and Number.isFinite() for reliable number validation without type coercion. These ES6 methods provide precise control over numeric validation in JavaScript applications.