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

This matters in real programming because user input often arrives as strings:

• form fields
• query parameters
• CSV data
• API payloads
• configuration values

If you do not validate correctly, your program may accept bad input or silently convert unexpected values.

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(""));      // false
console.log(isNumeric("   "));   // false

Why this works

• trim() removes spaces at the start and end
• value.trim() !== "" rejects empty input
• Number(value) converts valid numeric strings to numbers
• Number.isNaN(...) tells you whether conversion failed

If you only want digits

If you want to allow only whole numbers made of digits, use a regular expression:

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

console.log(isDigitsOnly("123"));   // true
console.log(isDigitsOnly("12.5"));  // false
console.log(isDigitsOnly("-10"));   // false
console.log(isDigitsOnly("abc"));   // false

This is stricter than numeric conversion. It accepts only one or more digits from start to end.

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.

Now try:

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

Step by step

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

That is why "ab2" is rejected.

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.argv[2];
if (!isNumeric(input)) {
  console.log("Please provide a number.");
}

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" };
  }

  const quantity = Number(value);
  return { quantity };
}

Configuration and environment variables

Environment variables are strings by default:

const portValue = process.env.PORT || "3000";
const port = isNumeric(portValue) ? Number(portValue) : 3000;

Filtering data

const values = ["10", "x", "25", "", "8.5"];
const numericValues = values.filter(isNumeric).map(Number);

console.log(numericValues); // [10, 25, 8.5]

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 isNaN() without understanding coercion

isNaN("123"); // false
isNaN("abc"); // true

This can work in some cases, but it performs type coercion and can be confusing. Prefer:

Number.isNaN(Number(value))

4. Confusing numeric strings with digit-only strings

These are different rules:

• "12.5" is numeric
• "-7" is numeric
• "1e3" is numeric
• but none of them are digit-only

If you need only digits, use a regex:

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

5. Not deciding what counts as valid

Before writing validation, decide whether you want to allow:

• negative numbers
• decimals
• leading/trailing spaces
• scientific notation like 1e3
• plus signs like +5

Validation depends on your exact rule.

Number() vs parseInt()

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

• Use Number() when the whole string must be numeric.
• Use parseInt() when you intentionally want to extract an integer from the beginning of a string.

General numeric check vs digits-only check

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) → 123

When to use what

• Use Number() + Number.isNaN() for full numeric validation
• Use regex for strict formats like digits only
• Avoid parseInt() when validating the entire string

Safe default

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

Edge cases to remember

• Empty strings need extra checking
• Spaces-only strings need extra checking
• Decide whether decimals and negatives should be allowed
• Decide whether scientific notation like 1e3 should be allowed

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"); // 12.5

Why does an empty string sometimes behave like zero?

Because JavaScript converts "" to 0 when using Number(""). That is why trim() !== "" is usually included in validation.

How do I reject spaces-only input?

Use trim() before checking:

value.trim() !== ""

Can negative numbers be valid?

Yes, if your validation rule allows them. For example, Number("-25") returns -25.

What is the safest default for most cases?

A small helper like this is a good default:

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

• 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.