JavaScript Multiplication

The multiplication operator (*) is a binary arithmetic operator that calculates the product of its two operands. In JavaScript, it operates on both Number (adhering to IEEE 754 double-precision floating-point arithmetic) and BigInt types.

operand1 * operand2

Type Coercion and Evaluation

If an operand is not a primitive Number or BigInt, JavaScript implicitly coerces it using the abstract ToNumeric operation before executing the multiplication. The ToNumeric operation coerces the value to a Numeric type, which can be either a Number or a BigInt, depending on the operand’s primitive representation.

Objects: JavaScript attempts to convert the object to a primitive value by calling its valueOf() method, followed by toString(). The resulting primitive is then coerced to a Numeric type. If the object resolves to a BigInt primitive, it evaluates as a BigInt.
Booleans: true coerces to 1, false coerces to 0.
Strings: Parsed as numeric values. Empty strings ("") coerce to 0. Unparseable strings coerce to NaN.
Null/Undefined: null coerces to 0. undefined coerces to NaN.

* "4"         // 20 (String coerced to Number)
* true        // 5  (Boolean coerced to 1)
* null        // 0  (null coerced to 0)
* undefined   // NaN (undefined coerced to NaN)
* "foo"       // NaN (Unparseable string coerced to NaN)
* []          // 0  (Empty array coerces to "", then to 0)
* [2]         // 10 (Array coerces to "2", then to 2)
2n * Object(3n) // 6n (Object coerced to BigInt primitive, not Number)

IEEE 754 Floating-Point Precision Loss

Because JavaScript Number types are represented as 64-bit floating-point values, the * operator is subject to floating-point precision loss. Operations involving fractional numbers cannot always be represented exactly in binary, leading to rounding errors during multiplication.

0.1 * 0.2       // 0.020000000000000004

IEEE 754 Edge Cases

The * operator follows specific rules for special numeric values (NaN, Infinity, -Infinity, and -0):

NaN: If either operand evaluates to NaN, the result is always NaN.
Infinity: Multiplying Infinity by a non-zero number results in Infinity (or -Infinity depending on the sign).
Infinity and Zero: Multiplying Infinity (or -Infinity) by 0 (or -0) evaluates to NaN.
Signed Zeros: Multiplying two numbers with different signs where the exact mathematical result is zero evaluates to -0.

NaN * 5         // NaN
Infinity * 2    // Infinity
Infinity * -2   // -Infinity
Infinity * 0    // NaN
-1 * 0          // -0

BigInt Operands

The * operator supports BigInt operands, performing arbitrary-precision integer multiplication. However, JavaScript does not allow implicit coercion between Number and BigInt types during arithmetic operations. Both operands must resolve to the same numeric type.

2n * 3n         // 6n
-5n * 4n        // -20n

// Mixing types throws a TypeError
2n * 3          // TypeError: Cannot mix BigInt and other types

Tired of Poor JavaScript Skills? Fix That With Deep Grasping!Learn More

Functions

Methods

Constructors

Classes

Destructuring

Decorators

Modules

Accessors

Variables

Fields

Parameters

Error Handling

Control Flow

Statement Forms

Loops

Primitive Types

Comments

Access Operators

Spread Operators

Call Operators

Conditional Operators

Logical Operators

Equality Operators

Relational Operators

Arithmetic Operators

Assignment Operators

Update Operators

Unary Operators

Yield Operators

Bitwise Operators

Shift Operators

JavaScript Multiplication

Type Coercion and Evaluation

IEEE 754 Floating-Point Precision Loss

IEEE 754 Edge Cases

BigInt Operands

​Type Coercion and Evaluation

​IEEE 754 Floating-Point Precision Loss

​IEEE 754 Edge Cases

​BigInt Operands

Type Coercion and Evaluation

IEEE 754 Floating-Point Precision Loss

IEEE 754 Edge Cases

BigInt Operands