Subtraction Assignment

The subtraction assignment operator (-=) subtracts the value of the right operand from the variable specified by the left operand and assigns the computed result back to that variable.

LeftOperand -= RightOperand;

Semantically, x -= y is equivalent to x = x - y, with the technical distinction that the LeftOperand is evaluated only once. This distinction is relevant when the left operand involves complex property accessors (getters/setters) or function calls.

Execution Mechanics and Type Coercion

Unlike the addition assignment operator (+=), which is overloaded to handle both numeric addition and string concatenation, the -= operator strictly performs mathematical subtraction. Consequently, it forces the JavaScript engine to apply the ToNumeric abstract operation to both operands.

1. L-value Resolution: The engine verifies that the LeftOperand is a valid assignment target (a mutable variable or property).
2. Value Evaluation: The current value of the LeftOperand is retrieved, followed by the evaluation of the RightOperand.
3. Implicit Coercion: Both values are coerced to primitives, and then to Numbers (or BigInts).
4. Computation & Assignment: The subtraction is performed, and the resulting value is written to the memory space of the LeftOperand.

Coercion Behaviors

Because -= forces numeric context, it yields specific results based on the types of the operands:

// Standard numeric operation
let a = 10;
a -= 3; 
// Result: 7

// String coercion: Valid numeric strings are converted to Numbers
let b = 15;
b -= "5"; 
// Result: 10

// String coercion: Non-numeric strings evaluate to NaN
let c = 20;
c -= "text"; 
// Result: NaN (Any further math with c will also be NaN)

// Boolean coercion: true becomes 1, false becomes 0
let d = 5;
d -= true; 
// Result: 4

// Null and Undefined coercion
let e = 10;
e -= null; 
// Result: 10 (null coerces to 0)

let f = 10;
f -= undefined; 
// Result: NaN (undefined coerces to NaN)

BigInt Constraints

The -= operator supports BigInt operands, but strict type matching is enforced. Mixing BigInt and Number types without explicit conversion will throw a TypeError.

let g = 20n;
g -= 5n; 
// Result: 15n

let h = 20n;
h -= 5; 
// Throws TypeError: Cannot mix BigInt and other types, use explicit conversions

Master JavaScript with Deep Grasping Methodology!

Learn More