Signatur
Beschreibung
Der Additions-Operator + ist einer der vielseitigsten Operatoren in JavaScript. Er erfüllt zwei grundlegende Aufgaben: die arithmetische Addition numerischer Werte sowie die Verkettung von Zeichenketten (String Concatenation). Welche Funktion er ausführt, hängt vom Typ der Operanden ab.
Sind beide Operanden Zahlen (oder werden als Zahlen interpretiert), liefert + deren arithmetische Summe. Ist mindestens einer der Operanden eine Zeichenkette, wandelt JavaScript den anderen Operanden ebenfalls in einen String um und verbindet beide. Diese implizite Typumwandlung (Type Coercion) ist eine häufige Quelle von Überraschungen, insbesondere wenn Objekte, Arrays oder null/undefined im Spiel sind.
JavaScript wendet dabei den internen ToPrimitive-Algorithmus auf Nicht-Primitive an: Objekte werden zuerst über valueOf(), dann über toString() in primitive Werte umgewandelt. Arrays serialisieren sich z. B. als komma-separierte Liste ([1,2] + [3] → "1,23"). Um ungewollte Typumwandlungen zu vermeiden, empfiehlt sich der Einsatz von expliziten Konvertierungen wie Number() oder String().
- Zahl + Zahl → Summe (
3 + 4→7) - String + beliebig → Verkettung (
"3" + 4→"34") - beliebig + String → Verkettung (
3 + "4"→"34") - BigInt + BigInt → BigInt-Summe (
2n + 3n→5n)
Parameter
| Name | Typ | Default | Beschreibung |
|---|---|---|---|
| $x Pflicht | number | string | bigint | boolean | null | undefined | object | — | Der linke Operand. Wird bei Bedarf über den ToPrimitive-Algorithmus in einen primitiven Wert umgewandelt. |
| $y Pflicht | number | string | bigint | boolean | null | undefined | object | — | Der rechte Operand. Wird bei Bedarf über den ToPrimitive-Algorithmus in einen primitiven Wert umgewandelt. |
Rückgabewert
BigInt-Wert zurück, wenn beide Operanden vom Typ bigint sind.Beispiele
Arithmetische Addition
const a = 10;
const b = 32;
console.log(a + b); // 42
const pi = 3.14;
const e = 2.72;
console.log(pi + e); // 5.859999999999999
console.log(2n + 8n); // 10n (BigInt)Zeichenkettenverkettung
const vorname = "Ada";
const nachname = "Lovelace";
console.log(vorname + " " + nachname); // "Ada Lovelace"
// Zahl wird automatisch zum String
console.log("Ergebnis: " + 42); // "Ergebnis: 42"
console.log("Wert: " + true); // "Wert: true"
console.log("Nichts: " + null); // "Nichts: null"Typumwandlung und häufige Fallstricke
// Strings statt Zahlen aus einem Formular
const eingabe1 = "5";
const eingabe2 = "3";
console.log(eingabe1 + eingabe2); // "53" — Verkettung!
console.log(Number(eingabe1) + Number(eingabe2)); // 8 — korrekte Addition
// Objekte und Arrays
console.log({} + []); // "[object Object]"
console.log([] + []); // ""
console.log([1, 2] + [3]); // "1,23"
// null und undefined
console.log(1 + null); // 1 (null → 0)
console.log(1 + undefined); // NaN (undefined → NaN)Template-Literal als saubere Alternative zur Verkettung
const artikel = "Laptop";
const preis = 999.99;
// Mit + Operator
console.log("Artikel: " + artikel + ", Preis: " + preis + " €");
// Moderner: Template-Literal
console.log(`Artikel: ${artikel}, Preis: ${preis} €`);// Wichtig · Fallstricke
Gleitkomma-Präzision: Wie in allen IEEE-754-Implementierungen kann die Addition von Dezimalzahlen zu unerwarteten Ergebnissen führen (z. B. 0.1 + 0.2 === 0.30000000000000004). Für geldkritische Berechnungen sollte auf spezialisierte Bibliotheken (z. B. decimal.js) zurückgegriffen werden.
Gemischte Typen mit BigInt: BigInt und number können nicht direkt addiert werden — 1n + 1 wirft einen TypeError. Eine explizite Umwandlung mit BigInt() oder Number() ist nötig.
Unärer +-Operator: Wird + nur vor einem einzelnen Operanden verwendet (z. B. +„42"), handelt es sich um den unären Plus-Operator, der den Wert in eine Zahl umwandelt — nicht um den binären Additions-Operator.