How to Check If a String Is a Number in JavaScript

By the end of this page, you will understand how to determine whether a string is numeric in JavaScript, why this can be trickier than it first appears, and which approaches are safest for real code. You will also learn how to handle edge cases such as empty strings, spaces, decimals, and invalid mixed text.

In JavaScript, checking whether a string is a number is not as simple as asking whether it contains digits. The main question is:

• Should the entire string represent a valid number?
• Or is it enough that JavaScript can partially read a number from it?

For example:

parseInt("123abc", 10); // 123

This does not mean "123abc" is a valid numeric string. It only means parseInt() was able to read the first numeric part.

That is why numeric validation usually means the whole string must be a valid number.

A common modern approach is:

const isNumeric = (value) => value.trim() !== "" && !Number.isNaN(Number(value));

This works because:

• Number(value) tries to convert the whole string into a number
• Number.isNaN(...) checks whether that conversion failed
• trim() !== "" prevents empty strings or only-spaces strings from being treated as valid

Think of numeric validation like checking whether a ticket is fully valid at a gate.

• Number(value) asks: Can this whole ticket be accepted?
• parseInt(value) asks: Can I read something useful from the start of this ticket?

So:

• "123" is like a valid ticket
• "123abc" is like a damaged ticket with extra junk attached
• "abc" is like no ticket at all

If your goal is validation, you usually want the entire string to pass, not just the beginning.

A practical helper function in JavaScript looks like this:

function isNumeric(value) {
  return value.trim() !== "" && !Number.isNaN(Number(value));
}

Example

console.log(isNumeric("abc"));   // false
console.log(isNumeric("123"));   // true
console.log(isNumeric("ab2"));   // false
console.log(isNumeric("12.5"));  // true
console.log(isNumeric("   42")); // true
console.log(isNumeric(""));      
.(());   

Consider this example:

function isNumeric(value) {
  return value.trim() !== "" && !Number.isNaN(Number(value));
}

console.log(isNumeric("123"));

Step by step

1. isNumeric("123") is called.
2. value.trim() returns "123".
3. value.trim() !== "" becomes true.
4. Number("123") returns the number 123.
5. Number.isNaN(123) returns false.
6. !false becomes true.
7. true && true returns true.

Numeric string checks appear in many common situations:

Form validation

const age = "27";
if (!isNumeric(age)) {
  console.log("Age must be a number");
}

Used for:

• age fields
• prices
• quantities
• phone extensions
• zip code rules when numeric-only input is required

API input validation

Servers often receive values as strings:

const page = "3";
if (isNumeric(page)) {
  // safe to convert and use
}

CSV or file import

When reading text files, each value starts as a string:

const rowValue = "45.7";
const amount = isNumeric(rowValue) ? Number(rowValue) : null;

Command-line tools

const input = process.[];
 (!(input)) {
  .();
}

In real projects, developers usually wrap numeric validation in a small helper function instead of repeating conversion logic everywhere.

Common pattern: validation before conversion

function parseAmount(value) {
  if (value.trim() === "") {
    throw new Error("Amount is required");
  }

  const number = Number(value);

  if (Number.isNaN(number)) {
    throw new Error("Amount must be numeric");
  }

  return number;
}

This pattern is useful because it:

• validates input early
• keeps error messages clear
• avoids hidden conversion bugs

Guard clauses

Developers often reject bad data immediately:

function saveQuantity(value) {
  if (!isNumeric(value)) {
    return { error: "Invalid quantity" };
  }

   quantity = (value);
   { quantity };
}

1. Using parseInt() for validation

Broken example:

parseInt("123abc", 10); // 123

Why this is a problem:

• parseInt() stops when it hits invalid characters
• it can make invalid strings appear valid

Use this instead:

!Number.isNaN(Number("123abc")); // false

2. Forgetting about empty strings

Broken example:

Number(""); // 0

This surprises many beginners. An empty string converts to 0, so you often need an extra check:

value.trim() !== "" && !Number.isNaN(Number(value))

3. Using global without understanding coercion

General numeric string check

function isNumeric(value) {
  return value.trim() !== "" && !Number.isNaN(Number(value));
}

Digits-only check

function isDigitsOnly(value) {
  return /^\d+$/.test(value);
}

Useful rules

• Number("123") → 123
• Number("12.5") → 12.5
• Number("abc") → NaN
• Number("") → 0
• Number(" ") → 0
• parseInt("123abc", 10) →

Is there a built-in isNumeric() function in JavaScript?

No. JavaScript does not provide a built-in isNumeric() function. The common approach is to write a helper using Number() and Number.isNaN().

Why not just use parseInt()?

Because parseInt() can accept partial values like "123abc" and return 123. That is usually not strict enough for validation.

How do I check if a string contains only digits?

Use a regular expression:

/^\d+$/.test(value)

This accepts "123" but rejects "12.5", "-1", and "abc".

Does Number() allow decimals?

Yes. For example:

Number("12.5"); 

• Type coercion — Numeric checks often involve converting strings into numbers.
• NaN in JavaScript — Important for understanding failed numeric conversions.
• Regular expressions — Useful when validation rules are stricter than general numeric conversion.
• parseInt() and parseFloat() — Related because they convert strings to numbers differently.
• Input validation — Checking whether a string is numeric is a common validation task.
• String trimming — Removing whitespace is often necessary before validating input.
• Number conversion — Core to turning user input into usable numeric values.