Subtraktionszuweisung (-=) — Operator · JavaScript-Referenz

Signatur

x -= y

Beschreibung

Der Operator x -= y ist eine Kurzschreibweise für x = x - y. Der einzige Unterschied: Der Ausdruck x wird nur einmal ausgewertet. Das spielt eine Rolle, wenn der linke Operand Seiteneffekte hat, z. B. arr[i++] -= 1 oder ein Getter.

Man nutzt -= vor allem für Zähler, Countdowns, Lagerbestände, Kontostände oder Positionsberechnungen in Animationen. Er funktioniert mit Number und BigInt. Beide Operanden müssen aber vom gleichen numerischen Typ sein.

Anders als += verkettet -= keine Strings. Beide Operanden werden in Zahlen umgewandelt, zuerst über valueOf() bzw. Symbol.toPrimitive. Deshalb ergibt "10" -= 3 die Zahl 7. Nicht umwandelbare Werte ergeben NaN.

Der gesamte Ausdruck liefert den neuen Wert. Der linke Operand muss ein gültiges Zuweisungsziel sein: eine Variable, eine Eigenschaft oder ein Array-Element. Er darf keine const-Bindung sein.

Parameter

Name	Typ	Default	Beschreibung
$x Pflicht	Variable \| Eigenschaftszugriff		Das Zuweisungsziel (L-Wert). Sein aktueller Wert ist der Minuend, danach nimmt es das Ergebnis auf. Darf keine `const`-Bindung sein.
$y Pflicht	number \| bigint \| any		Der Subtrahend. Er wird in eine Zahl umgewandelt, falls er noch keine ist (außer bei `BigInt`).

Rückgabewert

Typ

number | bigint

Beschreibung

Der neue Wert von x, also x - y. Der Rückgabewert kann weiterverwendet werden, z. B. in Bedingungen.

Beispiele

Lagerbestand nach einer Bestellung verringern

const lager = { artikel: 'Tastatur', bestand: 25 };

const bestellen = (menge) => {
  if (menge > lager.bestand) {
    throw new RangeError('Nicht genug auf Lager');
  }
  lager.bestand -= menge;
  return lager.bestand;
};

console.log(bestellen(7));
console.log(lager);

18 { artikel: 'Tastatur', bestand: 18 }

Countdown mit setInterval

let sekunden = 3;

const timer = setInterval(() => {
  console.log(`Noch ${sekunden} s`);
  if ((sekunden -= 1) < 0) {
    clearInterval(timer);
    console.log('Start!');
  }
}, 1000);

Noch 3 s Noch 2 s Noch 1 s Noch 0 s Start!

Typumwandlung und BigInt

let a = '10';
a -= 3;
console.log(a, typeof a);

let b = 'abc';
b -= 1;
console.log(b);

let groß = 10n;
groß -= 3n;
console.log(groß);

try {
  groß -= 1; // Mischung BigInt/Number
} catch (e) {
  console.log(e.constructor.name);
}

7 'number' NaN 7n TypeError

Linker Operand wird nur einmal ausgewertet

const werte = [10, 20, 30];
let i = 0;

werte[i++] -= 5; // i++ wird nur einmal ausgeführt
console.log(werte, i);

[ 5, 20, 30 ] 1

// Wichtig · Fallstricke

Keine String-Verkettung: Im Gegensatz zu += wandelt -= Strings immer in Zahlen um. Aus einer Variable mit String-Wert wird dadurch stillschweigend ein number.
NaN pflanzt sich fort: Ist ein Operand undefined oder nicht numerisch, wird das Ergebnis NaN, und alle folgenden Rechnungen bleiben NaN. Typisch ist eine nicht initialisierte Variable: let x; x -= 1; // NaN.
BigInt und Number nicht mischen: 10n -= 1 wirft einen TypeError.
const: Bei einer const-Bindung wirft -= einen TypeError („Assignment to constant variable“). Eigenschaften eines const-Objekts lassen sich dagegen ändern.
Gleitkomma-Ungenauigkeit: let x = 0.3; x -= 0.1; // 0.19999999999999998. Bei Geldbeträgen besser in Cent (Ganzzahlen) rechnen.
Nicht mit =- verwechseln: x =- 1 bedeutet x = -1 und ist ein häufiger Tippfehler.
Für das Verringern um genau 1 gibt es alternativ den Dekrementoperator --.

Siehe auch

Subtraktion (-) Multiplikationszuweisung (*=) Dekrement (--) BigInt Division-Zuweisung (/=)