TypeScript Remainder Assignment

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

• 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

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

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)

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.

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

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)

• 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