> ## 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 Division Assignment
The division assignment operator (`/=`) divides the value of a variable by the value of the right operand and assigns the computed quotient back to the variable. It is a compound assignment operator that combines the standard division operation with variable assignment.
```javascript theme={"dark"}
LeftOperand /= RightOperand;
```
This operation is logically equivalent to `LeftOperand = LeftOperand / RightOperand`, with the distinction that the `LeftOperand` is evaluated only once. The `LeftOperand` must be a valid `LeftHandSideExpression` (such as a variable, object property, or array element), otherwise a `SyntaxError` or `ReferenceError` is thrown.
## Evaluation Mechanics and Type Coercion
When the `/=` operator is executed, the JavaScript engine evaluates the expression strictly left-to-right according to the ECMAScript specification:
1. Evaluates the `LeftOperand` to resolve its memory reference and retrieves its current value.
2. Evaluates the `RightOperand` and retrieves its value.
3. Applies the internal `ToNumeric` abstract operation to both retrieved values. This coerces non-numeric primitives (like strings or booleans) strictly into `Number`s. A value will only evaluate to a `BigInt` during this step if it is already a `BigInt` primitive or an object whose `[Symbol.toPrimitive]` or `valueOf` method explicitly returns a `BigInt`.
4. Performs the division operation on the coerced values.
5. Assigns the resulting quotient back to the resolved reference of the `LeftOperand`.
## Behavior by Data Type
The underlying division logic depends on the numeric types of the operands after coercion:
* **Number:** Performs IEEE 754 double-precision floating-point division.
* **BigInt:** Performs algebraic division and truncates the fractional part towards zero. Mixing `BigInt` and `Number` operands throws a `TypeError`.
```javascript theme={"dark"}
// Standard Number division
let a = 10;
a /= 2;
console.log(a); // 5
// Floating-point precision
let b = 5;
b /= 2;
console.log(b); // 2.5
// BigInt division (truncates towards zero)
let c = 10n;
c /= 3n;
console.log(c); // 3n
```
## Edge Cases and Special Values
Because JavaScript utilizes IEEE 754 math for standard numbers, the `/=` operator handles arithmetic edge cases for `Number` types without throwing runtime errors. However, `BigInt` operations enforce stricter mathematical rules:
```javascript theme={"dark"}
// Implicit coercion of string to Number
let d = 10;
d /= "2";
console.log(d); // 5
// Coercion failure results in NaN (Not-a-Number)
let e = 10;
e /= "text";
console.log(e); // NaN
// Number division by zero yields Infinity or -Infinity
let f = 10;
f /= 0;
console.log(f); // Infinity
let g = -10;
g /= 0;
console.log(g); // -Infinity
// Zero divided by zero (Number) yields NaN
let h = 0;
h /= 0;
console.log(h); // NaN
// BigInt division by zero throws a RangeError
let i = 10n;
i /= 0n; // Uncaught RangeError: Division by zero
```
Tired of Poor JavaScript Skills? Fix That With Deep Grasping!
Learn More
