Remainder Assignment

The %= (remainder assignment) operator divides the value of the left operand (dividend) by the value of the right operand (divisor) and assigns the resulting remainder to the left operand. As a compound assignment operator, it evaluates the left-hand side reference only once, distinguishing it from a standard assignment combined with a modulo operation.

x %= y;
// Conceptually similar to x = x % y, but the reference for 'x' is evaluated only once.

Mechanics

1. Evaluation: The left operand is evaluated first to resolve its reference and retrieve its value. Then, the right operand is evaluated.
2. Calculation: The JavaScript engine performs a truncated division (rounding towards zero) of the left operand’s value by the right operand’s value to determine the remainder.
3. Sign Preservation: The sign of the returned remainder strictly matches the sign of the dividend (the left operand), regardless of the sign of the divisor.
4. Assignment: The computed remainder is written back to the resolved memory location of the left operand.

TypeScript Type Constraints

TypeScript enforces strict type checking on the %= operator:

• Valid Types: Both operands must resolve to number or bigint.
• Type Homogeneity: You cannot mix number and bigint operands. Doing so results in a ts(2365) compiler error.
• Mutability: The left operand must be a valid l-value (a mutable reference, such as a variable declared with let or a writable object property). It cannot be a const.

Syntax and Behavior Examples

Standard Numeric Evaluation:

let a: number = 10;
a %= 3; 
// a is now 1 (10 / 3 = 3 with a remainder of 1)

Sign Preservation (Negative Dividend):

let b: number = -10;
b %= 3; 
// b is now -1 (Sign matches the left operand)

let c: number = 10;
c %= -3;
// c is now 1 (Sign of the right operand is ignored)

Single Evaluation of Left Operand: Because the left operand is evaluated only once, %= behaves differently than x = x % y when the left operand contains side effects.

let arr: number[] = [10, 20, 30];
let i: number = 0;

arr[i++] %= 3; 
// i is evaluated and incremented only once. 
// arr[0] becomes 1, and i becomes 1.
// If written as arr[i++] = arr[i++] % 3, i would be incremented twice.

BigInt Evaluation:

let d: bigint = 10n;
d %= 3n;
// d is now 1n

TypeScript Compiler Errors:

let e: number = 10;
e %= "3"; 
// Error ts(2363): The right-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type.

let f: bigint = 10n;
f %= 3; 
// Error ts(2365): Operator '%=' cannot be applied to types 'bigint' and 'number'.

const g: number = 10;
g %= 3; 
// Error ts(2588): Cannot assign to 'g' because it is a constant.

Edge Cases (IEEE 754 Floating Point)

Because TypeScript number types are double-precision 64-bit floats, the operator handles specific edge cases according to the IEEE 754 standard:

• If the dividend is Infinity or -Infinity, the result is NaN.
• If the divisor is 0 or -0, the result is NaN.
• If the dividend is 0 and the divisor is non-zero, the result is 0.

let h: number = Infinity;
h %= 5; 
// h is now NaN

let j: number = 10;
j %= 0; 
// j is now NaN

Master TypeScript with Deep Grasping Methodology!

Learn More