Arithmetische Operatoren

Arithmetische Operatoren verwenden numerische Werte (Literale oder Variablen) als Operanden und geben einen einzelnen numerischen Rückgabewert zurück. Die arithmetischen Standardoperatoren sind Addition (+), Subtraktion (-), Multiplikation (*) und Division (/).

The source for this interactive example is stored in a GitHub repository. If you'd like to contribute to the interactive examples project, please clone https://github.com/mdn/interactive-examples and send us a pull request.

Addition (+)

Der Additionsoperator berechnet die Summe von numerischen Operanden oder verkettet Strings.

Syntax

Operator: x + y

Beispiele

// Nummer + Nummer -> Addition
1 + 2 // 3

// Boolean + Nummer -> Addition
true + 1 // 2

// Boolean + Boolean -> Addition
false + false // 0

// Nummer + String -> Verkettung
5 + 'foo' // "5foo"

// String + Boolean -> Verkettung
'foo' + false // "foofalse"

// String + String -> Verkettung
'foo' + 'bar' // "foobar"

Subtraktion (-)

Der Subtraktionsoperator berechnet die Differenz von numerischen Operatoren.

Syntax

Operator: x - y

Beispiele

5 - 3 // 2
3 - 5 // -2
'foo' - 3 // NaN

Division (/)

Der Divisionsoperator berechnet den Quotienten von numerischen Operanden. Der linke Operand ist der Dividend und der Rechte der Divisor.

Syntax

Operator: x / y

Beispiele

1 / 2          // gibt in JavaScript 0.5 zurück
1 / 2          // gibt in Java 0 zurück
// (keine Zahl ist ausdrücklich eine Fließkommazahl)

1.0 / 2.0      // 0.5 in JavaScript und Java

2.0 / 0        // Infinity
2.0 / 0.0      // Infinity
2.0 / -0.0     // -Infinity

Multiplikation (*)

Der Multiplikationsoperator berechnet das Produkt von numerischen Operanden.

Syntax

Operator: x * y

Beispiele

2 * 2               // 4
-2 * 2              // -4
Infinity * 0        // NaN
Infinity * Infinity // Infinity
'foo' * 2           // NaN

Divisionsrest (%)

Der Divisionsrestoperator berechnet den Rest bei einer Division zweier Operanden. Das Ergebnis hat immer das Vorzeichen des Dividenden.

Syntax

Operator: x % y

Beispiele

12 % 5 // 2
-1 % 2 // -1
1 % -1 // 1
NaN % 2 // NaN
1 % 2 // 1
2 % 3 // 2
-4 % 2 // -0
5.5 % 2 // 1.5

Potenzierung (**)

Der Potenzierungsoperator gibt das Ergebnis der Potenz zweier Operanden (Basis und Exponent) zurück. Das ist var1var2 in dem folgenden Statement, wobei var1 und var2 Variablen sind. Der Potenzierungsoperator ist rechtsassoziativ. a ** b ** c ist gleichbedeutend mit a ** (b ** c).

Syntax

Operator: var1 ** var2

Hinweise

In den meisten Programmiersprachen wie PHP, Phython und anderen Sprachen mit Potenzierungsoperator (**) hat der Potenzierungsoperator eine höhere Priorität als unäre Operatoren wie das unäre + bzw. -, aber es gibt ein paar Ausnahmen. In Bash hat der Operator zum Beispiel eine niedrigere Priorität. In Javascript sind mehrdeutige Potenzen nicht möglich, z. B. kann man keine unärer Operator  (+/-/~/!/delete/void/typeof) direkt vor der Basis schreiben.

-2 ** 2; 
// 4 in Bash, -4 in anderen Sprachen. 
// In Javascript ist dies ungültig, da es sonst mehrdeutig wäre.


-(2 ** 2); 
// -4 in JavaScript, der Ausdruck ist nicht mehrdeutig.

Beispiele

2 ** 3 // 8
3 ** 2 // 9
3 ** 2.5 // 15.588457268119896
10 ** -1 // 0.1
NaN ** 2 // NaN

2 ** 3 ** 2 // 512
2 ** (3 ** 2) // 512
(2 ** 3) ** 2 // 64

Umkehrung des Vorzeichens vom Ergebnis der Potenz:

-(2 ** 2) // -4

Verwendung einer negativen Basis für die Potenz:

(-2) ** 2 // 4

Inkrement (++)

Der Inkremenoperator vergrößert einen numerischen Operanden um 1 und liefert dessen Wert als Ergebnis.

• Wird der Operator als Postfix (z.B. x++) verwendet, wird der Operand geliefert, bevor dessen Wert inkrementiert wird.
• Wird der Operator als Präfix (z.B. ++x) verwendet, wird der Wert des Operanden erst inkrementiert und anschließend geliefert.

Syntax

Operator: x++ oder ++x

Beispiele

// Postfix
var x = 3;
y = x++; // y = 3, x = 4

// Präfix
var a = 2;
b = ++a; // a = 3, b = 3

Dekrement (--)

Der Dekrementoperator verringert einen numerischen Operanden um 1 und liefert dessen Wert als Ergebnis.

• Wird der Operator als Postfix (z.B. x--) verwendet, wird der Operand geliefert, bevor dessen Wert dekrementiert wird.
• Wird der Operator als Präfix (z.B. --x) verwendet, wird der Wert des Operanden erst dekrementiert und anschließend geliefert.

Syntax

Operator: x-- oder --x

Beispiele

// Postfix
var x = 3;
y = x--; // y = 3, x = 2

// Prefix
var a = 2;
b = --a; // a = 1, b = 1

Unäre Negation (-)

Die unäre Negation steht vor dem Operanden und liefert dessen negierten Wert.

Syntax

Operator: -x

Beispiele

var x = 3;
y = -x; // y = -3, x = 3

// unärer Negationsoperator kann nicht-Nummern in Nummern konvertieren
var x = "4";
y = -x // y = -4

Unäres Plus (+)

Das unäre Plus steht dem Operanden voran und wertet dessen Wert aus. Genau wie bei der unären Negation, werden nicht-numerische Werte in numerische Werte umgewandelt; unäres Plus ist allerdings der vorzuziehende Weg, da keine weiteren Operationen vorgenommen werden. Unäres Plus kann String-Repräsentationen von Ganz- und Kommazahlen in deren numerischen Wert konvertieren,  ebenso wie true, false und null und hexadezimale (mit Präfix 0x) und negative Zahlen in ihre entsprechenden Werte konvertieren. Kann ein Operand nicht konvertiert werden, so wird er als NaN ausgewertet.

Syntax

Operator: +x

Beispiele

+3       // 3
+'3'     // 3
+true    // 1
+false   // 0
+null    // 0
+function(val){ return val} // NaN

Spezifikationen

Browserkompatibilität

Siehe auch

• Zuweisungsoperatoren