Division Assignment

The /= (division assignment) operator divides the value of the left operand by the value of the right operand and assigns the resulting quotient to the left operand.

x /= y;

While functionally similar to x = x / y, the /= operator evaluates the left operand x exactly once. This distinction is critical when the left operand is a property access expression with side effects (e.g., getObj().prop /= 2 invokes getObj() only once, whereas getObj().prop = getObj().prop / 2 invokes it twice).

Type Constraints

In TypeScript, the compiler enforces strict type rules for the /= operator:

• Operand Types: Both operands must resolve to type number, bigint, a numeric enum, or any.
• Type Homogeneity: You cannot mix bigint with number or enum types. However, number and numeric enum types are interoperable and can be freely mixed in the same operation.
• Mutability: The left operand must be a mutable reference (e.g., a variable declared with let, var, or a writable object property).

Syntax Visualization

Standard Number and Enum Division:

let num: number = 15;
num /= 3; // num is now 5

enum Divisor { Half = 2 }
let float: number = 5;
float /= Divisor.Half; // float is now 2.5 (freely mixes number and enum)

BigInt Division:

let bigNum: bigint = 10n;
bigNum /= 3n; // bigNum is now 3n (fractional components are truncated towards zero)

TypeScript Compiler Errors:

const constant: number = 10;
constant /= 2; // Error: Cannot assign to 'constant' because it is a constant.

let numVal: number = 10;
numVal /= "2"; // Error: The right-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type.

let mixed: number = 10;
mixed /= 2n; // Error: Operator '/=' cannot be applied to types 'number' and 'bigint'.

Runtime Evaluation Rules

While TypeScript handles compile-time type checking, the runtime execution follows standard IEEE 754 rules inherited from JavaScript:

• Division by Zero (number): If the right operand is 0, the operation evaluates to Infinity, -Infinity, or NaN (if the left operand is also 0), and assigns this value to the left operand.
• Division by Zero (bigint): If the right operand is 0n, the operation throws a runtime RangeError: Division by zero.

Master TypeScript with Deep Grasping Methodology!

Learn More