JavaScript Number Constructor

What You’ll Learn

The global Number function creates numbers in JavaScript—either as lightweight primitives or as wrapper objects (same API as MDN Number() constructor). Call it as a function for conversion; avoid new Number() in everyday code. This tutorial covers coercion rules, BigInt conversion, precision loss, five examples, and try-it labs.

Introduction

Almost every number you write in JavaScript is a primitive (typeof "number" value — for example 42, 3.14, or Number("99").

Calling new Number(value) instead wraps that value in a Number object. Objects are heavier, fail some === checks against primitives, and are almost never what you want. MDN’s guidance is clear: you should rarely use Number as a constructor.

Continue with Number methods and Number properties after you understand conversion.

Understanding the Number Constructor

When Number runs as a function, it applies ToNumber-style coercion: strings become numbers (or NaN), booleans become 0/1, null becomes 0, and undefined becomes NaN. BigInts are converted explicitly instead of throwing.

• Number(value) → number primitive.
• new Number(value) → Number object (avoid).
• No argument: Number() returns 0.
• Invalid text: Number("abc") returns NaN.

📝 Syntax

Two forms of the global Number function (from MDN):

Number(value)        // returns a number primitive
new Number(value)    // returns a Number object

Parameters

• value (optional) — the value to convert or wrap. If omitted, the result is 0 (as a function) / a Number object wrapping 0 (with new).

Return value

• Number(value) — value coerced to a number primitive. BigInts convert instead of throwing. Missing value → 0.
• new Number(value) — a Number object wrapping that coerced value (not a primitive).

Common patterns

Number("123");          // 123
Number("");             // 0
Number(true);           // 1
Number(null);           // 0
Number(undefined);      // NaN
Number("abc");          // NaN
Number(1n);             // 1  (explicit BigInt → Number)

const a = new Number("123");
const b = Number("123");
a === 123;              // false
b === 123;              // true
typeof a;               // "object"
typeof b;               // "number"

Examples Gallery

Examples follow MDN Number() constructor patterns. Use View Output or Try It Yourself for each case.

const a = new Number("123"); // a === 123 is false
const b = Number("123");     // b === 123 is true

a instanceof Number;  // true
b instanceof Number;  // false
typeof a;             // "object"
typeof b;             // "number"

false
true
true
false
object
number

Number();            // 0
Number("");          // 0
Number("  42  ");    // 42
Number(true);        // 1
Number(null);        // 0
Number(undefined);   // NaN
Number("abc");       // NaN

0
0
42
1
0
NaN
NaN

// +1n;        // TypeError: Cannot convert a BigInt value to a number
// 0 + 1n;     // TypeError: Cannot mix BigInt and other types

Number(1n);    // 1

1
TypeError
TypeError

BigInt(Number(2n ** 54n + 1n)) === 2n ** 54n + 1n;  // false

Number(2n ** 54n + 1n);  // 18014398509481984  (precision lost)

false
18014398509481984

const wrapped = new Number(10);
const primitive = Number(10);

wrapped === 10;                 // false
primitive === 10;               // true
wrapped.valueOf() === 10;       // true
Number(wrapped) === 10;         // true

false
true
true
true

🚀 Common Use Cases

• Form / API input — Number(input) then validate with Number.isFinite.
• Normalize mixed types — booleans, numeric strings, and nullish values.
• Explicit BigInt bridge — convert when you intentionally accept precision limits.
• Default zero — Number() or Number("") when empty means 0.
• Teaching types — show why new Number breaks ===.
• Not for parsing partial strings — prefer parseInt / parseFloat when text may have trailing junk.

📝 Notes

• Prefer literals and Number(value) — not new Number().
• Number("123abc") is NaN; parseInt("123abc") is 123.
• Unary + also coerces, but throws on BigInt — Number() does not.
• Number objects are still usable with methods via auto-unboxing, but stay with primitives.
• Related constants live under Number properties.
• Formatting helpers live under Number methods.

💡 Best Practices