How to Validate Decimal Numbers in JavaScript

By the end of this page, you will understand how to validate decimal number strings in JavaScript, why simple conversion checks are often not enough, and how to use a regular expression to accept valid decimal input while rejecting invalid formats such as hex values, commas, empty strings, and multiple decimal points.

When people ask whether a value is "numeric" in JavaScript, they often mean one of two different things:

• Can JavaScript convert this value into a number?
• Does this string match a specific numeric format I want to allow?

For input validation, the second meaning is usually the correct one.

JavaScript can convert many surprising strings into numbers:

Number('')       // 0
Number('0x89f')  // 2207
Number('   ')    // 0

Those results are valid JavaScript conversions, but they do not match the rules in this question.

So the real task is not just "is this a number?" but rather:

• Allow optional negative sign
• Allow whole numbers like 0 or -1
• Allow decimals like 0.42 and -1.5
• Allow leading decimal notation like .42
• Reject commas, hex, letters, empty strings, and malformed decimals

This is a classic string format validation problem, and a regular expression is a good fit because you want to check the exact shape of the input.

A good validation pattern for these rules is:

/^[-]?(?:\d+\.\d+|\d+|\.\d+)$/

This pattern says:

• ^ start of string
• [-]? optional minus sign
• (?: ... ) one of these valid forms:
  • \d+\.\d+ digits, dot, digits like 1.5
  • \d+ whole number like 42
  • \.\d+ leading decimal like .42
• $ end of string

That matters because validation should be explicit. If your app expects decimal input, it should accept only decimal input in the formats you intentionally support.

Think of validation like a door policy.

You are not asking, "Can this person somehow get into the building?" You are asking, "Does this person match the entry rules?"

JavaScript's number conversion functions are like a very permissive doorman. They let in values that can be interpreted as numbers somehow, including things like hex strings or empty strings.

A regular expression is like a strict checklist at the door:

• Optional minus sign? Allowed.
• Digits only? Allowed.
• One decimal point in the right place? Allowed.
• Commas, letters, extra dots, or empty input? Rejected.

That is why regex is often better for form input validation than simply calling Number() or parseFloat().

A clean way to validate this specific decimal format is to use a regular expression.

function isNumeric(value) {
  return /^-?(?:\d+\.\d+|\d+|\.\d+)$/.test(value);
}

Example usage

console.log(isNumeric('-1'));      // true
console.log(isNumeric('-1.5'));    // true
console.log(isNumeric('0'));       // true
console.log(isNumeric('0.42'));    // true
console.log(isNumeric('.42'));     // true
console.log(isNumeric('99,999'));  // false
console.log(isNumeric('0x89f'));   // false
console.log(isNumeric('#abcdef')); // false
console.log(isNumeric('1.2.3'));   // false
console.log(isNumeric(''));        // false
console.log(isNumeric('blah'));    // false

Why this works

The regex:

/^-?(?:\d+\.\d+|\d+|\.\d+)$/

accepts three valid numeric shapes:

1. \d+\.\d+ → numbers like 12.34
2. \d+ → integers like 12
3. \.\d+ → decimals like .42

and allows an optional leading -.

Slightly more flexible version

If you want to allow surrounding spaces, trim first:

function isNumeric(value) {
  return /^-?(?:\d+\.\d+|\d+|\.\d+)$/.test(value.trim());
}

Be careful with this choice. Trimming can be helpful for user input fields, but it changes the validation rules slightly.

Consider this function:

function isNumeric(value) {
  return /^-?(?:\d+\.\d+|\d+|\.\d+)$/.test(value);
}

console.log(isNumeric('-1.5'));

Step-by-step

1. The function receives the string '-1.5'.
2. .test(value) checks whether the entire string matches the regex.
3. ^ requires matching to start at the beginning.
4. -? matches the - sign.
5. The regex then tries the allowed numeric forms.
6. \d+\.\d+ matches:
   • 1 as one or more digits
   • . as the decimal point
   • 5 as one or more digits
7. $ requires the match to end at the end of the string.
8. Since the whole string matches exactly, the result is true.

Another example: invalid input

console.log(isNumeric('1.2.3'));

What happens:

1. 1.2 could match part of a decimal pattern.
2. But there is still .3 left over.
3. Because $ requires the whole string to match, the extra characters make the match fail.
4. The result is false.

Why ^ and $ matter

Without them, a regex might match only part of a string:

/\d+/.test('abc123xyz'); // true

That is not what you want for validation. Full-string validation should usually anchor the pattern with ^ and $.

Decimal validation appears in many real applications:

• Form inputs
  • Price fields
  • Discount values
  • Weight, height, temperature, or distance inputs
• API validation
  • Checking JSON request fields before processing data
• Import scripts
  • Validating CSV values before saving them to a database
• Financial tools
  • Accepting decimal amounts while rejecting malformed input
• Configuration parsing
  • Reading numeric settings from text files or environment variables

Example: validating a price input

function isNumeric(value) {
  return /^-?(?:\d+\.\d+|\d+|\.\d+)$/.test(value);
}

function validatePrice(input) {
  if (!isNumeric(input)) {
    return 'Enter a valid decimal price';
  }

  return 'Valid';
}

console.log(validatePrice('19.99')); // Valid
console.log(validatePrice('19,99')); // Enter a valid decimal price

In real apps, validation is often the first step before converting the string to a number.

In real projects, developers usually separate validation from conversion.

Common pattern: validate first, convert second

function isNumeric(value) {
  return /^-?(?:\d+\.\d+|\d+|\.\d+)$/.test(value);
}

function parseDecimal(value) {
  if (!isNumeric(value)) {
    throw new Error('Invalid decimal format');
  }

  return Number(value);
}

This is safer than converting first and hoping bad input is rejected.

Guard clause pattern

function saveScore(input) {
  if (!isNumeric(input)) {
    return { error: 'Score must be a valid decimal number' };
  }

  const score = Number(input);
  return { score };
}

Guard clauses keep invalid input from spreading deeper into your code.

Validation near boundaries

Developers often validate:

• at form submission time
• at API request boundaries
• before database writes
• when reading external files

Reusable utility function

In a codebase, this often becomes a small shared helper:

export function isDecimalString(value) {
  return /^-?(?:\d+\.\d+|\d+|\.\d+)$/.test(value);
}

This makes validation rules consistent across different parts of the app.

Here are common beginner mistakes when validating numeric strings.

1. Using isNaN() alone

isNaN('')      // false
isNaN('0x89f') // false

This is confusing because isNaN() converts the value before checking it.

Better approach

Use a regex when you need a strict input format.

/^-?(?:\d+\.\d+|\d+|\.\d+)$/.test(value)

2. Using parseFloat() as validation

parseFloat('1.2.3') // 1.2

parseFloat() stops when it reaches invalid characters, so it can accept partially valid input.

Broken validation example

function isNumeric(value) {
  return !isNaN(parseFloat(value));
}

This may incorrectly accept strings you want to reject.

3. Forgetting full-string matching

/\d+/.test('abc123') // true

This only checks whether some part contains digits.

Fix

Use anchors:

/^...$/

4. Accidentally allowing empty strings

Number('') // 0

If empty input should be invalid, do not rely on Number() alone.

5. Not deciding what formats are allowed

Before writing validation, define the rules clearly:

• Is +1 allowed?
• Is 1. allowed?
• Are spaces allowed?
• Are commas allowed?
• Is scientific notation like 1e3 allowed?

Validation becomes much easier when the accepted formats are explicit.

6. Confusing numeric values with numeric strings

If your function may receive numbers as well as strings, handle that intentionally:

function isNumeric(value) {
  if (typeof value !== 'string') return false;
  return /^-?(?:\d+\.\d+|\d+|\.\d+)$/.test(value);
}

Or support both types on purpose if needed.

Here is how common approaches compare for this problem.

Regex vs conversion functions

Number('0x89f')           // 2207
parseFloat('1.2.3')       // 1.2
/^-?(?:\d+\.\d+|\d+|\.\d+)$/.test('0x89f')  // false
/^-?(?:\d+\.\d+|\d+|\.\d+)$/.test('1.2.3')  // false

isNaN() vs Number.isNaN()

For string format validation, neither is the best primary tool. A regex is more precise.

function isNumeric(value) {
  return /^-?(?:\d+\.\d+|\d+|\.\d+)$/.test(value);
}

Accepts

• -1
• -1.5
• 0
• 0.42
• .42

Rejects

• 99,999
• 0x89f
• #abcdef
• 1.2.3
• `` (empty string)
• blah

Regex parts

• ^ start of string
• -? optional minus sign
• \d+\.\d+ decimal with digits on both sides
• \d+ integer
• \.\d+ leading decimal like .42
• $ end of string

Rules to remember

• Use regex for strict input format validation
• Use Number() only after validation
• parseFloat() is not strict validation
• isNaN() can be misleading because it converts first

Optional variant with trimming

function isNumeric(value) {
  return /^-?(?:\d+\.\d+|\d+|\.\d+)$/.test(value.trim());
}

Edge cases to decide explicitly

• Should +1 be valid?
• Should 1. be valid?
• Should whitespace be allowed?
• Should scientific notation like 1e3 be valid?
• Should actual number types be accepted, or strings only?

How do I validate a decimal number string in JavaScript?

Use a regular expression that matches only the formats you allow, such as:

/^-?(?:\d+\.\d+|\d+|\.\d+)$/

Why is isNaN() not enough for validating numeric input?

Because isNaN() converts values before checking them. That means some strings you want to reject, such as '' or '0x89f', may not behave as expected.

Should I use parseFloat() to validate decimals?

Usually no. parseFloat() is useful for parsing, but not for strict validation, because it can accept partial input like '1.2.3'.

Does this regex allow negative decimals?

Yes. It accepts values like -1 and -1.5 because of the optional leading -.

Does it allow .42 without a leading zero?

Yes. The \.\d+ part explicitly allows decimals like .42.

Why does Number('') return 0?

Because JavaScript converts the empty string to zero in numeric conversion. That is one reason conversion is different from validation.

Can I allow spaces around the number?

Yes. Trim the input first:

regex.test(value.trim())

Just be sure that matches your application's rules.

Can this validator be used in forms and APIs?

Yes. It is a good fit for validating string input at the boundary of your application before converting it to a number.

• Regular expressions — useful for matching exact string formats
• Number conversion — important after validation when turning strings into numbers
• isNaN() and Number.isNaN() — commonly confused with true input validation
• parseFloat() — useful for parsing but not strict enough for this validation task
• Form validation — this numeric check is a common part of validating user input
• Input sanitization — often used alongside validation to clean and normalize input
• JavaScript data types — helps distinguish strings from actual number values