Skip to main content

How to Check if a Character is a Number in JavaScript

When validating or processing strings, you often need to determine if a specific character is a numerical digit (0-9). This is a common requirement for parsing formatted IDs, validating user input, or cleaning data. While JavaScript provides several ways to approach this, some methods are far more reliable than others.

This guide will teach you the two main methods for checking if a character is a number. We will cover the tricky and often misleading isNaN() function and then demonstrate the far superior and recommended approach using a simple regular expression.

The Challenge: Defining a "Number"​

The main challenge is that a "number" can mean different things in different contexts. For this guide, we will focus on the most common use case: checking if a single character is a digit from 0 to 9.

Method 1: The isNaN() Function (and its Pitfalls)​

The isNaN() (Is Not a Number) function seems like a natural choice. The logic is that if isNaN(char) returns false, then the character must be a number. However, this function has quirky behavior that makes it unreliable for this task.

The Problem: isNaN() Coerces Values​

The isNaN() function first tries to convert the value you give it into a number. This leads to unexpected results:

  • isNaN('5') -> false (Correct)
  • isNaN('a') -> true (Correct)
  • isNaN('') -> false (Wrong! An empty string is not a number, but Number('') is 0.)
  • isNaN(' ') -> false (Wrong! A space is not a number, but Number(' ') is 0.)

Because isNaN() considers empty or whitespace-only strings to be valid numbers, it is not a reliable tool for this kind of validation without adding extra checks.

The Complex isNaN Solution​

To make it work, you have to add manual checks for empty and whitespace strings.

function isNumberWithIsNaN(char) {
  if (typeof char !== 'string') {
    return false;
  }
  // You must manually check for empty/whitespace strings
  if (char.trim() === '') {
    return false;
  }
  return !isNaN(char);
}
note

This is overly complex and not recommended.

A regular expression provides a simple, direct, and unambiguous way to define exactly what you are looking for. The .test() method of a regex returns true if the string matches the pattern, and false otherwise. This is the best practice for this task.

The logic:

  • We define a pattern that matches only a single digit.
function isDigit(char) {
  // The regex /^\d$/ matches a string that is exactly one digit long.
  return /^\d$/.test(char);
}

// ✅ Correct results for single characters
console.log(isDigit('7'));  // Output: true
console.log(isDigit('a'));  // Output: false
console.log(isDigit('!'));  // Output: false

// ⛔️ Correctly identifies invalid cases
console.log(isDigit(' '));  // Output: false
console.log(isDigit(''));   // Output: false
console.log(isDigit('77')); // Output: false (because it's not a single character)

How the Methods Work​

  • isNaN(): It works by trying to convert the input to a Number. If the conversion results in the special NaN value, it returns true. Otherwise, it returns false. This coercion is what makes it unreliable for strict checks.
  • Regular Expression (/^\d$/):
    • / ... /: Defines a regular expression.
    • ^: Asserts the position at the start of the string.
    • \d: A special character class that matches any single digit (0 through 9).
    • $: Asserts the position at the end of the string.
    • Together, this pattern means "the string must contain exactly one character from start to end, and that character must be a digit."

How to Check for a Multi-Digit Number String​

You can easily adapt the regex to check if a string contains one or more digits (e.g., to validate "123"). You do this by adding the + quantifier.

function isNumberString(str) {
  // The `+` means "one or more" of the preceding token (\d).
  return /^\d+$/.test(str);
}

console.log(isNumberString('123'));  // Output: true
console.log(isNumberString('9'));    // Output: true
console.log(isNumberString('12a'));  // Output: false
console.log(isNumberString(''));     // Output: false

Conclusion​

While JavaScript offers several ways to check if a character is a number, they are not all equally reliable.

The key takeaways are:

  1. The isNaN() function is not recommended for this task. Its aggressive type coercion considers empty strings and whitespace to be numbers, making it unreliable without extra, clumsy checks.
  2. The regular expression method (/^\d$/ .test(char)) is the overwhelmingly superior and recommended best practice. It is precise, readable, and unambiguously does exactly what you ask it to do.

Table of Contents