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:

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.(());   
.(()); 
.(());   
.(());        
.(());    

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.

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.(()); 

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:

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((value));
}

Here is how common approaches compare for this problem.

Regex vs conversion functions

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

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

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 return ?

• 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