> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# 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.
```javascript theme={"dark"}
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`.
```javascript theme={"dark"}
5 * "4" // 20 (String coerced to Number)
5 * true // 5 (Boolean coerced to 1)
5 * null // 0 (null coerced to 0)
5 * undefined // NaN (undefined coerced to NaN)
5 * "foo" // NaN (Unparseable string coerced to NaN)
5 * [] // 0 (Empty array coerces to "", then to 0)
5 * [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.
```javascript theme={"dark"}
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`.
```javascript theme={"dark"}
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.
```javascript theme={"dark"}
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
