JavaScript: How to check if String isNumber()

JavaScript, being a loosely typed language, allows variables to hold any data type. This flexibility sometimes leads to situations where we need to verify the type of a variable, especially when dealing with numbers.
JavaScript doesn’t have a built-in isNumber() function. So let’s explore all the possible alternatives we have.

Best Solution: Using the typeof Operator

The typeof operator in JavaScript returns a string indicating the data type of its operand. Here’s how you can use it to check if a variable is a number:

let x = 5;
console.log(typeof x === 'number');  // Outputs: true

In this case, typeof x returns ‘number’. If x is a number, the result is true; otherwise, it’s false. But be aware, typeof considers NaN (Not-a-Number) as ‘number’, which might not be the desired behavior in some cases.

let y = NaN;
console.log(typeof y === 'number');  // Outputs: true

Despite this, the typeof operator is a handy tool for quick and easy data type verification in JavaScript.

Method 2: Using isNaN()

The isNaN() function in JavaScript determines if a value is an illegal number (NaN). It returns true for NaN values and false otherwise.

let y = 'Hello';
console.log(isNaN(y));  // Outputs: true

However, isNaN() first tries to convert the tested value into a number. Therefore, values that can be coerced into a number return false.

let z = '5';
console.log(isNaN(z));  // Outputs: false

Despite its quirks, isNaN() can be handy when checking if a value can be converted to a number.

Method 3: Using Number.isFinite()

The Number.isFinite() function in JavaScript determines if a value is a finite number. It returns true for finite numbers and false for non-numbers or infinite values.

let a = 5;
console.log(Number.isFinite(a));  // Outputs: true

However, unlike isNaN(), Number.isFinite() doesn’t try to convert the tested value into a number. So, it will return false for strings that could be coerced into numbers.

let b = '5';
console.log(Number.isFinite(b));  // Outputs: false

Number.isFinite() is often used when you want to ensure a value is a finite number without type coercion.

Method 4: Using Number.isInteger()

The Number.isInteger() method in JavaScript checks if a value is an integer. It returns true if it is, false otherwise.

let num = 5;
console.log(Number.isInteger(num));  // Outputs: true

In this example, num is an integer, so Number.isInteger(num) returns true. If the value isn’t an integer, it will return false.

It’s a straightforward way to check if a value is an integer when working with numerical data in JavaScript.

Method 5: Using Number.isNaN()

Number.isNaN() is a static method in JavaScript that checks if a value equals NaN (Not-a-Number). Unlike the global isNaN() function, Number.isNaN() doesn’t convert the value to a number before testing it. Here’s an usage example:

let value = NaN;
console.log(Number.isNaN(value));  // Outputs: true

In this case, value equals NaN, so Number.isNaN(value) returns true. This method is useful for strict NaN checks without type coercion.

Conclusion

When working with JavaScript, ensuring that a variable is a number can be crucial for the correctness of your code. The methods discussed above provide various ways to achieve this.

The typeof operator is the easiest and most straightforward method, but it might not be suitable for all situations due to JavaScript’s type coercion. The isNaN() function is another simple method, but it can lead to false positives due to type coercion. The ES6 methods Number.isFinite(), Number.isInteger(), and Number.isNaN() are more reliable as they do not suffer from type coercion issues, but they are not available in older browsers.

Therefore, the best method to use depends on your specific needs and the browser compatibility requirements of your project. Always remember to test your code thoroughly to ensure that it behaves as expected.