> ## 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 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.
```javascript theme={"dark"}
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:
```javascript theme={"dark"}
// 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`.
```javascript theme={"dark"}
let g = 20n;
g -= 5n;
// Result: 15n
let h = 20n;
h -= 5;
// Throws TypeError: Cannot mix BigInt and other types, use explicit conversions
```
Tired of Poor JavaScript Skills? Fix That With Deep Grasping!
Learn More
