Check Whether a String Is Numeric in TypeScript

You will learn why parseFloat() is not a strict string validator, how Number() and Number.isFinite() can validate numeric input, and when a regular expression is the better choice for decimal-only formats.

A numeric-string check has two separate jobs:

1. Convert or inspect the whole input.
2. Reject formats your application does not allow.

parseFloat() is designed for parsing text that starts with a number. It intentionally stops when it reaches an invalid character:

parseFloat("9BX46B6A"); // 9
parseFloat("12px");     // 12

That behavior is useful when reading values such as CSS-like text, but it is not appropriate when validating user input.

For general JavaScript numeric conversion, use Number() instead. It requires the entire non-whitespace string to be convertible:

Number("9BX46B6A"); // NaN
Number("12px");     // NaN
Number("12.5");     // 12.5

Then use Number.isFinite() to reject NaN, Infinity, and -Infinity:

Think of parseFloat() as a cashier who reads a price label only until it becomes confusing. Given "9BX46B6A", the cashier reads 9 and ignores the remaining letters.

Number() is like a strict scanner: it must understand the entire label or it rejects it.

A regular expression is like a custom admission rule at a door. You can say exactly which characters and layouts are allowed, such as optional + or -, digits, one decimal point, and an optional exponent.

For a general finite JavaScript number, trim whitespace, reject an empty value, convert with Number(), and test with Number.isFinite():

function isNumericString(value: string): boolean {
  const trimmed = value.trim();
  return trimmed !== "" && Number.isFinite(Number(trimmed));
}

console.log(isNumericString("42"));        // true
console.log(isNumericString(" -3.14 "));   // true
console.log(isNumericString("1e6"));       // true
console.log(isNumericString("9BX46B6A"));  // false
console.log(isNumericString("12px"));      
.(());          
.(());  

Consider this function and input:

function isNumericString(value: string): boolean {
  const trimmed = value.trim();
  return trimmed !== "" && Number.isFinite(Number(trimmed));
}

const result = isNumericString(" 9BX46B6A ");

Step by step:

1. value.trim() removes the surrounding spaces, producing "9BX46B6A".
2. trimmed !== "" is true, so evaluation continues.
3. Number("9BX46B6A") attempts to convert the whole string.
4. The letters make the complete conversion invalid, so the result is NaN.
5. Number.isFinite(NaN) is false.
6. The function returns false.

Now try isNumericString(" 9 "):

Numeric-string validation is common when values arrive as text:

• Form inputs: Validate quantities, prices, ages, and measurements before submitting a form.
• Query parameters: Check a URL value such as ?page=3 before using it for pagination.
• CSV imports: Reject rows where an amount contains accidental text like "19USD".
• Configuration files: Validate environment variables such as PORT="3000".
• API boundaries: Verify string fields from external systems before calculations or database writes.

Validation should happen before using the converted number:

const pageText = "3";

if (!isNumericString(pageText)) {
  throw new Error("page must be a finite number");
}

const page = Number(pageText);

In production code, validation usually converts the value once and then uses the converted result. This avoids parsing the same text multiple times.

function parseFiniteNumber(value: string): number | undefined {
  const trimmed = value.trim();

  if (trimmed === "") {
    return undefined;
  }

  const numberValue = Number(trimmed);

  if (!Number.isFinite(numberValue)) {
    return undefined;
  }

  return numberValue;
}

const price = parseFiniteNumber("24.99");

if (price === undefined) {
  console.error("Enter a valid price.");
} else {
  console.log(price * 1.2);
}

This is a guard clause pattern: invalid values return early, leaving the successful path simple.

Projects also often add business rules after numeric validation:

Using parseFloat() as validation

// Broken for strict validation
const valid = !isNaN(parseFloat("12px")); // true

parseFloat() accepts a numeric prefix. Use Number() for whole-string conversion, or use a regular expression for a specific format.

Passing a string to global isNaN()

// TypeScript reports an error with standard typings
isNaN("42");

JavaScript may coerce values at runtime, but TypeScript correctly encourages you to be explicit. Convert first, or use Number.isFinite(Number(value)).

Forgetting empty strings

Number("");    // 0
Number("   "); // 0

Check value.trim() !== "" before conversion if blank input is invalid.

Comparing string lengths after parsing

// General finite numeric string
function isNumericString(value: string): boolean {
  const trimmed = value.trim();
  return trimmed !== "" && Number.isFinite(Number(trimmed));
}

// Decimal notation only: 12, -3.5, .25, 1e6
const isDecimalString = (value: string): boolean =>
  /^[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?$/.test(value.trim());

// Positive whole-number text: 1, 25, 300
const isPositiveIntegerString = (value: string): boolean =>
  /^[1-9]\d*$/.test(value.trim());

Rules to remember:

• Do not use parseFloat() for strict validation.
• Reject blank input before calling .

Why does parseFloat("9BX46B6A") return 9?

parseFloat() parses from the beginning of a string and stops at the first character that cannot be part of a floating-point number. It is not a full-string validator.

Why does TypeScript complain about isNaN("9")?

TypeScript's standard declaration expects a number for isNaN(). This helps prevent implicit conversion mistakes. Convert the string explicitly instead.

Is Number("12px") a number?

No. It returns NaN because Number() requires the entire trimmed string to be a valid numeric representation.

Does Number() accept spaces around a number?

Yes. Number(" 42 ") returns 42. Trim explicitly if you also need to reject whitespace-only input.

Does Number() accept hexadecimal values such as "0xFF"?

Yes, Number("0xFF") returns 255. Use a decimal regular expression if hexadecimal input should be rejected.

• Type conversion — Numeric validation depends on explicitly converting text with Number().
• NaN and Number.isNaN() — Learn how invalid numeric results are represented and tested.
• Number.isFinite() — Ensures a value is a real finite number rather than NaN or infinity.
• Regular expressions — Useful for enforcing exact numeric input formats.
• Form validation — Applies numeric checks to browser and application input.
• Guard clauses — A clean pattern for returning early when validation fails.
• Number.isInteger() and Number.isSafeInteger() — Useful when a field must contain a whole number that can be represented safely.