TypeScript String to Number (and Number to String)

To convert a string to a number in TypeScript, call Number(text). The result has type number, and it is NaN when the text is not a valid number. For text with trailing characters, such as "42px", use parseInt(text, 10) or parseFloat(text).

const input: string = "42";

const a = Number(input);       // 42
const b = parseInt(input, 10); // 42 (whole numbers)
const c = parseFloat("3.75");  // 3.75
const d = +input;              // 42 (unary plus, same as Number)

console.log(a + 1, b + 1, c + 1, d + 1); // 43 43 4.75 43

// And back: number to string
const text: string = String(a);
console.log(text, text.length); // 42 2

All four conversions return the type number. TypeScript does not know whether the text was valid; an invalid string still gives a number, whose value is NaN.

Why You Must Convert

Form fields, URL parameters, environment variables and file contents arrive as strings. TypeScript will not let you use one where a number is expected:

// This does not compile: a string is not a number.
const quantity: string = "3";
const total: number = quantity * 10;
console.log(total);

index.ts(3,23): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type.

Arithmetic with -, * and / on a string is an error. + is allowed but concatenates, so "3" + 10 is the string "310", which is why the conversion must come first: Number(quantity) * 10.

A type assertion does not help either. quantity as number is rejected (TS2352), and forcing it through as unknown as number only silences the compiler: the value stays a string at runtime.

Number vs parseInt vs parseFloat vs Unary Plus

The four functions agree on clean input and disagree on everything else. This table is the real output of each on Node:

The rules behind the table:

• Number and unary + are identical. They convert the whole string after trimming whitespace, understand 1e3 and 0x hex, and return NaN if anything is left over. An empty or whitespace-only string becomes 0.
• parseInt and parseFloat read from the start and stop at the first character they cannot use, so "42px" and "1,000" give partial numbers. An empty string is NaN.
• parseInt drops the fractional part and does not understand exponents: "1e3" stops at the e.
• Numeric separators (12_000) are valid in source code, not in strings.

Number is the stricter choice for validating input. parseInt and parseFloat suit text that genuinely carries a unit or suffix, like CSS sizes.

Handling Invalid Input: NaN

NaN has type number, so the compiler never warns about it. Check the result yourself, with Number.isNaN or Number.isFinite:

function toNumber(text: string): number | undefined {
    if (text.trim() === "") return undefined; // Number("") would be 0
    const n = Number(text);
    return Number.isFinite(n) ? n : undefined;
}

for (const s of ["12.5", "", "abc", "7 ", "Infinity"]) {
    console.log(JSON.stringify(s), toNumber(s));
}

const age = toNumber("30");
if (age !== undefined) {
    console.log(age + 1); // age is number here
}

Returning number | undefined makes the failure part of the type, so every caller must handle it before doing arithmetic. Number.isFinite also rejects Infinity, which Number("Infinity") happily returns.

Avoid the global isNaN(x): it converts its argument first, so isNaN("abc") is true in JavaScript. TypeScript's declaration only accepts a number, so passing a string is error TS2345, which is a hint to use Number.isNaN on an already converted value.

String to Integer

Always pass parseInt its second argument, the radix: 10 for decimal text. It is optional, but it documents intent and matters for other bases. To get an integer from a decimal string, convert and then round explicitly.

console.log(parseInt("0042", 10)); // 42
console.log(parseInt("ff", 16));   // 255
console.log(parseInt("1010", 2));  // 10

const price = Number("19.99");
console.log(Math.trunc(price), Math.round(price), Math.floor(price)); // 19 20 19

console.log(Number.isInteger(Number("7")));   // true
console.log(Number.isInteger(Number("7.5"))); // false

console.log(BigInt("9007199254740993")); // 9007199254740993n

parseInt expects a string: parseInt(12.7) is a compile error (TS2345), which is useful, because in JavaScript parseInt on a number converts it to text first and gives wrong answers for values like 0.0000005 (it returns 5). Use Math.trunc for numbers. For integers beyond Number.MAX_SAFE_INTEGER, BigInt(text) parses the full value (and throws a SyntaxError on invalid text instead of returning NaN).

Number to String

Any of String(n), n.toString() and `${n}` converts a number to its shortest string form. Formatting methods give more control:

const n = 1234.5678;

console.log(String(n));            // 1234.5678
console.log(n.toString());         // 1234.5678
console.log(`${n}`);               // 1234.5678
console.log(n.toFixed(2));         // 1234.57
console.log(n.toPrecision(3));     // 1.23e+3
console.log(n.toLocaleString("en-US")); // 1,234.568
console.log((255).toString(16));   // ff
console.log((5).toString().padStart(3, "0")); // 005

const label: string = n.toFixed(1); // every method here returns string
console.log(label);                 // 1234.6

toFixed rounds the binary value, not the decimal you typed, so (1.005).toFixed(2) is "1.00": 1.005 is stored as slightly less than 1.005. For money, keep amounts as integer cents or format with Intl.NumberFormat.

String(n) also works on null and undefined (giving "null" and "undefined"), where n.toString() would be a compile error under strict, since the value might be missing.

Quick Reference