How to Check if a String is a Number in JavaScript

When working with user input and data in JavaScript, you’ll often need to validate if a string value contains a valid number format before further processing. Checking strings for number content seems like a trivial task. However, javascript and user input have quirks that require careful handling to robustly test strings for numeric data.

In this guide, you’ll learn the best practices for reliably checking if strings contain number formats in JavaScript. We’ll cover:

  • The challenges of validating numbers in strings
  • Built-in JavaScript number validation methods
  • Custom functions to handle edge cases
  • Differences between integers, floats, exponents, and other formats
  • How to allow only numbers while restricting non-numeric characters
  • Useful applications like validating user input as numeric

Follow along and you’ll be able to precisely check for numbers within strings in both client-side and Node.js JavaScript code. Let’s dive in!

Challenges with Identifying Numbers in Strings

JavaScript strings that contain numeric values come in different shapes and sizes. Some examples:


Each of those are valid ways to represent numbers. But alongside properly formatted values, you also have malformed strings to watch out for:

"10$" // Only partially number
"ten" // Contains text 
""    // Empty string
"-"   // Standalone minus sign

So how do you reliably catch all the quirks? Key challenges include:

  • Recognizing different numeric formats like integers, floats, exponents
  • Allowing negative numbers
  • Rejecting values with non-numeric characters
  • Validating empty inputs that should hold numbers
  • Catching tricky inputs like standalone minus signs

JavaScript by itself doesn’t contain specific number validation methods. So we need robust logic to handle the above cases. Let’s explore solutions…

Validating Numbers Using Built-In JavaScript Functions

JavaScript ships with functions that help detect whether strings harbor valid number values. Let’s demo them:

1. isNaN() Function

The isNaN() function checks if a value equates to NaN (Not a Number). Used negated, it can validate numbers:

const numString1 = "150";
const numString2 = "John"; 

isNaN(numString1)); // false => number content
isNaN(numString2); // true => not number content


  • Returns false positives on empty strings and standalone minus signs
  • Also allows numeric strings with adjoining non-number characters

So isNaN() alone isn’t robust enough to catch all scenarios.

2. Number() type coercion

The Number() method converts values to numbers if possible. We can assert this behavior to force validation:

Number("150"); // => 150
Number("John"); // => NaN

Then check if coercion resulted in NaN to determine if the original value held numbers.

However, again empty inputs and hybrid values with adjoining non-numeric characters slip through unless handling those explicitly.

So built-in functions help identify basic numerical content but don’t address all needs out-of-box. Next we’ll build more contained custom functions.

Crafting Robust Custom Functions for Numeric Strings

To harden validation to catch edge cases that elude built-in methods, crafting our own checks provides reliability.

Let’s explore helpful techniques:

Regular Expressions

Defining a regex that matches accepted numeric formats rejects invalid values:

function isNumeric(str) {
  // Match a digit regex with optional negative sign, decimal point, exponent notation check
  const regex = /^-?\d*(\.\d+)?(?:e-?\d+)?$/i; 

  return regex.test(str);

console.log(isNumeric("150")); // true
console.log(isNumeric("3.14")); // true 

console.log(isNumeric("10 X")); // false (no adjoining characters allowed)

This covers integers, floats, negatives, exponents, but disallows adjoining non-numeric characters robustly.

Empty Input Handling

To prevent empty values from slipping through as “valid” numbers, we need an explicit check:

function isNumeric(str) {
  if(str === "") return false; // reject empties immediately

  // Then apply number checks  
  const regex = /^-?\d*(\.\d+)?(?:e-?\d+)?$/i;

  return regex.test(str);  

isNumeric(""); // false

This additionally flags minus signs themselves as invalid numbers:

isNumeric("-"); // false

Handling empty cases upfront before testing content filters them out.

Parse Floats Safely

We can further reinforce validation by attempting to parse inputs as floats safely:

function isNumeric(str) {
  if(str === "") return false;

  // Use parseFloat instead of Number() to handle exponents, decimals properly
  const value = parseFloat(str);
  return !isNaN(value) && isFinite(value); 

This handles all flavors of valid numbers while keeping the function pure to explicitly just determine number content rather than perform coercion.

Combined gives us:

function isNumeric(str) {
  if(str === "") return false;

  const regex = /^-?\d*(\.\d+)?(?:e-?\d+)?$/i;

  if(!regex.test(str)) return false; 

  const value = parseFloat(str);
  return !isNaN(value) && isFinite(value);

This validation approach handles all key bases like:

  • Null/empty values
  • Invalid characters mixed with numbers
  • Proper identification of any number subtype
  • Disallowing standalone minus signs

…while safely keeping the function optimized just for checking, not transforming values.

Validating Integers vs Floats and Exponents

The above handles floats, integers and exponents universally. But sometimes you want to distinguish those categories explicitly.

Detecting the numeric subtype lets you process strings differently by type.

Let’s explore targeted checks for integers, decimals, floats in isolation:


Use a simplified regex and Number conversion to isolate integers:

function isInteger(str) {
  // Check if string has only digits with optional negative
  const regex = /^-?\d+$/;

  return regex.test(str) && Number(str) === parsed;


To check strings strictly for float formats:

function isFloat(str) {
  const regex = /^-?\d*\.?\d*$/;

  const float = parseFloat(str);

  // Check value matches input to avoid subsets being valid like .5 => 0.5
  return regex.test(str) && float.toString() === str;

Here we parse as float but convert back to a string and compare to the original input to catch differences in precision between input string and parsed number.


Detect exponent notation like 1.5e-5 with:

funcion isExponent(str) {
  const regex = /^-?\d*\.?\d+e-?\d+$/i;

  const value = parseFloat(str);

  return regex.test(str) && !isNaN(value);

Adjust the regular expressions accordingly to constrain to expected formats only. The same parsing principles apply but narrowed to each number type.

Use Cases for Checking Numbers in Strings

Now that we’ve built functions to reliably validate number contents within strings, let’s discuss helpful application examples:

User Input Forms

Typically user input arrives as strings and requires validation before usage in calculations, databases etc.

We can sanitize by checking for numbers on submission:

const age = getUserInput('age'); // from form element 

if(!isNumeric(age)) {
  // Handle invalid entry
} else {
  // Age is numeric - use in app logic  

This protects downstream logic from crashes.

Retrieved Data Sets

External string data from files, databases and APIs also necessitates certification before consumption by JavaScript:

const dataSet = loadDataFromFile('stats'); // string format 

dataSet.forEach(data => {

  if(!isInteger(data.views)) {
    // Skip row
  } else {
   // Plot graph  

Here validating viewer numbers lets us filter out invalid entries when processing.

Formula Calculations

Checking substitution values protects formulas from unexpected outputs:

function calculate(int1, int2) {

  if(!isInteger(int1) || !isInteger(int1)) { 
    return null; // Invalid operand 

  return int1 * int2; // Safe multiply  

This ensures functionality aligns with expectations.

Common Questions on Validating Numbers in JavaScript

While equipping you with robust ways to verify numbers within strings, a few other frequent questions come up:

Should I use parseInt or parseFloat?

parseFloat is generally recommended for testing strings. It can handle larger number ranges and nuances like exponents that parseInt does not support.

What about international formats?

The checks validate numbers in environments conforming to ECMAScript spec formats expected by JavaScript. More localization may be needed for some global use cases.

How do I process strings after validating numbers?

Use Number() or parseInt/parseFloat without checks to then coerce strings to numbers for calculation and processing after already validating content.

What if I want to allow/disallow decimals or exponents?

Adjust the provided regular expressions to tighten/loosen allowed formats based on needs.

This covers common follow-up points when leveraging JavaScript capabilities for verifying numbers inside text strings.


When working with string data in JavaScript, reliably telling valid numeric values apart from other text requires robust validation approaches. We explored solutions spanning built-in functions like isNaN() plus hardening string number testing via custom functions and regular expressions.

Combined, you can now precisely split apart different number types and reject invalid values. Integrating checks in your application logic, formula processing, and user input handling prevents crashes from bad data.

As you process more strings with JavaScript, remember this guide anytime you need to expertly discern numbers hiding within text to optimize workflows!

Leave a Comment