Increment (++) — Operator · JavaScript-Referenz

Signatur

x++ / ++x

Beschreibung

Der Inkrement-Operator ++ ist ein unärer Operator, der den numerischen Wert einer Variable um 1 erhöht. Er existiert in zwei Varianten, die sich darin unterscheiden, wann der veränderte Wert zurückgegeben wird:

Postfix (x++): Der Operator steht nach dem Operanden. Die Auswertung des Ausdrucks liefert zunächst den alten Wert, erhöht die Variable danach um 1.
Präfix (++x): Der Operator steht vor dem Operanden. Die Variable wird zuerst erhöht, anschließend wird der neue Wert zurückgegeben.

Der Operator kann auf Variablen angewendet werden, die Zahlen enthalten oder in Zahlen konvertierbar sind. Enthält die Variable einen Nicht-Zahl-Wert, der nicht sinnvoll konvertiert werden kann (z. B. "abc"), ist das Ergebnis NaN. Strings, die eine Zahl darstellen (z. B. "5"), werden implizit in Number umgewandelt, bevor die Erhöhung stattfindet.

In modernem JavaScript wird ++ häufig in klassischen for-Schleifen verwendet. In funktionalen Mustern (z. B. mit map, reduce) ist er seltener anzutreffen. Bei der Arbeit mit BigInt-Werten funktioniert ++ ebenfalls, jedoch darf ein BigInt nicht mit einer gewöhnlichen Zahl gemischt werden.

Parameter

Name	Typ	Default	Beschreibung
$x Pflicht	number \| bigint \| string	—	Der Operand, dessen Wert um 1 erhöht wird. Muss eine beschreibbare Variable (oder Eigenschaft) sein. Strings, die eine Zahl repräsentieren, werden implizit zu `Number` konvertiert.

Rückgabewert

Typ

number | bigint

Beschreibung

Postfix (x++): Gibt den Wert von x vor der Erhöhung zurück.
Präfix (++x): Gibt den Wert von x nach der Erhöhung zurück.

Beispiele

Postfix vs. Präfix – Grundprinzip

let a = 5;
let b = 5;

const postfixResult = a++;   // gibt 5 zurück, a wird danach 6
const prefixResult  = ++b;   // b wird zuerst 6, gibt 6 zurück

console.log(postfixResult);  // 5
console.log(a);              // 6

console.log(prefixResult);   // 6
console.log(b);              // 6

5 6 6 6

Einsatz in einer for-Schleife

const fruits = ['Apfel', 'Banane', 'Kirsche'];

for (let i = 0; i < fruits.length; i++) {
  console.log(`${i}: ${fruits[i]}`);
}

0: Apfel 1: Banane 2: Kirsche

Implizite Typkonvertierung

let numStr = '7';
numStr++;
console.log(numStr);        // 8  (Number, nicht mehr String)
console.log(typeof numStr); // 'number'

let invalid = 'abc';
invalid++;
console.log(invalid);       // NaN

8 number NaN

Inkrement mit BigInt

let big = 9007199254740991n;  // Number.MAX_SAFE_INTEGER als BigInt
big++;
console.log(big);  // 9007199254740992n – verlustfrei, da BigInt

9007199254740992n

// Wichtig · Fallstricke

Falllstricke:

++ benötigt einen l-value (eine beschreibbare Referenz). ++(x + 1) oder ++"literal" führen zu einem ReferenceError bzw. einem SyntaxError.
Im Strict Mode ("use strict") gelten dieselben Regeln – es gibt hier keinen Unterschied zu normalem Modus. Der Operator selbst ist nicht verboten.
ESLint-Regeln wie no-plusplus verbieten ++ und -- optional, um Verwirrung durch die Postfix/Präfix-Semantik zu vermeiden.
BigInt und Number dürfen nicht gemischt werden: let n = 1n; n = n + 1; wirft einen TypeError. Stattdessen n++ oder n += 1n verwenden.
Der Operator mutiert die Variable direkt – in rein funktionalem Code (z. B. mit const) ist er nicht verwendbar.

Siehe auch

Decrement (--) Addition Assignment (+=) Addition (+) for while