> ## 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 Remainder Assignment
The remainder assignment operator (`%=`) evaluates the remainder of dividing the left operand (dividend) by the right operand (divisor) and assigns the resulting value back to the left operand. It is a compound assignment operator that strictly follows IEEE 754 floating-point arithmetic rules for `Number` types and algebraic rules for `BigInt` types.
## Syntax and Evaluation Mechanics
```javascript theme={"dark"}
x %= y;
```
While logically similar to `x = x % y`, the compound assignment operator evaluates the left operand **exactly once**. This mechanical distinction is critical when the left operand contains side effects, such as property accessors or increment operators.
```javascript theme={"dark"}
let i = 0;
let arr = [5, 5];
// The left operand (arr[i++]) is evaluated only once.
arr[i++] %= 2;
// arr is now [1, 5], and i is 1.
// If expanded to `arr[i++] = arr[i++] % 2`, i would be incremented twice.
```
## Technical Mechanics
1. **Evaluation Order:** The operator evaluates the left operand, then the right operand.
2. **Sign Preservation:** The sign of the resulting remainder always matches the sign of the **dividend** (the left operand). The sign of the divisor (the right operand) is ignored.
3. **Type Coercion:** Before the remainder operation occurs, JavaScript applies the internal `ToNumeric` abstract operation. Operands are implicitly coerced into either `Number` or `BigInt` values. Objects can be coerced into `BigInt` values (rather than numbers) if their `valueOf` or `[Symbol.toPrimitive]` methods return a `BigInt`.
4. **BigInt Compatibility:** The operator works with `BigInt` values, but both operands must resolve to the same numeric type. Mixing `BigInt` and `Number` throws a `TypeError`.
## Evaluation Examples
**Standard Evaluation**
```javascript theme={"dark"}
let a = 10;
a %= 3;
// a is now 1 (10 = 3 * 3 + 1)
```
**Sign Preservation (Negative Dividend)**
```javascript theme={"dark"}
let b = -10;
b %= 3;
// b is now -1 (Sign matches the left operand)
let c = 10;
c %= -3;
// c is now 1 (Sign of the right operand is ignored)
```
**Implicit Type Coercion**
```javascript theme={"dark"}
let d = 15;
d %= "4";
// d is now 3 ("4" is coerced to the Number 4)
let e = 5n;
e %= { valueOf: () => 2n };
// e is now 1n (The object is coerced to the BigInt 2n)
```
## Edge Cases
* **Division by Zero:**
* For `Number` types, dividing by zero assigns `NaN` to the left operand.
* For `BigInt` types, dividing by `0n` throws a `RangeError: Division by zero`.
```javascript theme={"dark"}
```
let f = 5;
f %= 0; // f is now NaN
let g = 5n;
g %= 0n; // Throws RangeError
````
* **Infinity Dividend:** If the left operand is `Infinity` or `-Infinity` (Number type), the result is `NaN`.
```javascript
let h = Infinity;
h %= 5; // h is now NaN
````
* **Infinity Divisor:** If the right operand is `Infinity` and the left operand is finite, the left operand remains unchanged.
```javascript theme={"dark"}
```
let j = 5;
j %= Infinity; // j is now 5
```
Tired of Poor JavaScript Skills? Fix That With Deep Grasping!
Learn More
```
