Dieser Inhalt wurde automatisch aus dem Englischen übersetzt, und kann Fehler enthalten. Erfahre mehr über dieses Experiment.

View in English Always switch to English

Addition (+)

Baseline
Weitgehend verfügbar

Diese Funktion ist gut etabliert und funktioniert auf vielen Geräten und in vielen Browserversionen. Sie ist seit Juli 2015 browserübergreifend verfügbar.

Der Additionsoperator (+) bildet die Summe numerischer Operanden oder verkettet Zeichenfolgen.

Probieren Sie es aus

console.log(2 + 2);
// Expected output: 4

console.log(2 + true);
// Expected output: 3

console.log("hello " + "everyone");
// Expected output: "hello everyone"

console.log(2001 + ": A Space Odyssey");
// Expected output: "2001: A Space Odyssey"

Syntax

js
x + y

Beschreibung

Der Operator + wird für zwei unterschiedliche Operationen verwendet: numerische Addition und Verkettung von Zeichenfolgen. Bei der Auswertung werden zunächst beide Operanden in primitive Werte umgewandelt. Anschließend werden die Typen der beiden Operanden geprüft:

  • Wenn ein Operand eine Zeichenfolge ist, wird der andere Operand ebenfalls in eine Zeichenfolge umgewandelt, und die beiden werden verkettet.
  • Wenn beide Operanden BigInts sind, wird eine BigInt-Addition durchgeführt. Wenn ein Operand ein BigInt ist, der andere aber nicht, wird ein TypeError ausgelöst.
  • Andernfalls werden beide Operanden in Zahlen umgewandelt, und es wird eine numerische Addition durchgeführt.

Bei der numerischen Addition entsprechen die Ergebnisse im Allgemeinen den mathematischen Ergebnissen (abgesehen von Rundungsfehlern). Das gilt auch für Berechnungen mit Infinity (beispielsweise ergibt Infinity plus eine beliebige endliche Zahl weiterhin Infinity). Einige Sonderfälle:

  • Wenn einer der Operanden NaN ist, ist das Ergebnis NaN.
  • Infinity + -Infinity ergibt NaN.
  • Wenn das mathematische Ergebnis 0 ist, wird 0 zurückgegeben, es sei denn, beide Operanden sind -0. In diesem Fall wird -0 zurückgegeben.

Die Verkettung von Zeichenfolgen wird oft als gleichwertig mit Template-Literalen oder String.prototype.concat() angesehen. Das ist jedoch nicht der Fall. Bei der Addition wird der Ausdruck in einen primitiven Wert umgewandelt, wobei valueOf() bevorzugt aufgerufen wird. Template-Literale und concat() wandeln den Ausdruck dagegen in eine Zeichenfolge um, wobei toString() bevorzugt aufgerufen wird. Wenn der Ausdruck eine [Symbol.toPrimitive]()-Methode besitzt, ruft die Zeichenfolgenverkettung diese mit "default" als Hinweis auf, während Template-Literale "string" verwenden. Das ist wichtig für Objekte, deren Zeichenfolgen- und primitive Darstellung sich unterscheiden – beispielsweise Temporal, bei dessen Objekten die valueOf()-Methoden ausnahmslos Fehler auslösen.

js
const t = Temporal.Now.instant();
"" + t; // Throws TypeError
`${t}`; // '2022-07-31T04:48:56.113918308Z'
"".concat(t); // '2022-07-31T04:48:56.113918308Z'

Verwenden Sie nach Möglichkeit nicht "" + x, um eine Umwandlung in eine Zeichenfolge durchzuführen.

Beispiele

Addition mit Zahlen

js
1 + 2; // 3

Andere Werte, die weder Zeichenfolgen noch BigInts sind, werden in Zahlen umgewandelt:

js
true + 1; // 2
false + false; // 0

Addition mit BigInts

js
1n + 2n; // 3n

Bei der Addition können Sie BigInt- und Zahlenoperanden nicht mischen. null, undefined und boolesche Werte werden in Zahlen umgewandelt und sind daher ebenfalls nicht zulässig.

js
1n + 2; // TypeError: Cannot mix BigInt and other types, use explicit conversions
2 + 1n; // TypeError: Cannot mix BigInt and other types, use explicit conversions

Zeichenfolgen haben Vorrang vor anderen Typen. Daher führt die Addition einer Zeichenfolge und eines BigInt zu einer Zeichenfolgenverkettung statt zu einem TypeError.

js
"1" + 2n; // "12"

Um ein BigInt und einen Wert, der kein BigInt ist, zu addieren, wandeln Sie einen der beiden Operanden um:

js
1n + BigInt(2); // 3n
Number(1n) + 2; // 3

Addition mit Zeichenfolgen

Wenn einer der Operanden eine Zeichenfolge ist, wird der andere in eine Zeichenfolge umgewandelt, und die beiden werden verkettet:

js
"foo" + "bar"; // "foobar"
5 + "foo"; // "5foo"
"foo" + false; // "foofalse"
"2" + 2; // "22"

Fehlende Assoziativität

Achten Sie auf die Reihenfolge der Operationen. Anders als in der Mathematik ist die Addition in JavaScript aufgrund der Rundung von Zwischenergebnissen nicht immer assoziativ. Beispielsweise gilt a + (b + c) !== (a + b) + c:

js
const a = 1e20;
const b = -1e20;
const c = 0.1;

console.log(a + b + c); // 0.1
console.log(a + (b + c)); // 0

Math.sumPrecise() kann dieses Problem abmildern:

js
console.log(Math.sumPrecise([a, b, c])); // 0.1

Spezifikationen

Spezifikation
ECMAScript® 2027 Language Specification
# sec-addition-operator-plus

Browser-Kompatibilität

Siehe auch