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 (/).

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
1.5 * 2             // 3
Infinity * 0        // NaN
Infinity * Infinity // Infinity
"foo" * 2           // NaN

Divisionsrest (%)

Der Divisionsrestoperator berechnet den Rest der Division zweier Operanden. Das Ergebnis hat immer das Vorzeichen des Dividenden, nicht des Divisors (umgekehrt wie bei modulo). Es läuft ein Antrag auf die Übernahme eines echten Modulooperators in eine zukünftige Version des ECMAScript.

Syntax

Operator: x % y

Beispiele

12 % 5 // 2
-1 % 2 // -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, d.h. var1var2. 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 (typischerweise ^ oder **) hat der Potenzierungsoperator eine höhere Priorität als unäre Operatoren wie das unäre + bzw. -, aber es gibt ein paar Ausnahmen, zum Beispiel Bash. In Javascript sind mehrdeutige Potenzen nicht möglich, i.e. ein unärer Operator direkt vor der Basis.

-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 Inkrementationsoperator 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 Dekrementationsoperator 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
-3      // -3
-"3"    // -3
-"3.3"  // -3.3
-"-3"   // 3
-"0x33" // -51
-true   // -1
-false  // -0
-null   // -0

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
+"3.3"   // 3.3
+"-3"    // -3
+"0x33"  // 51
+true    // 1
+false   // 0
+null    // 0

Spezifikationen

Browserkompatibilität

Siehe auch

• Zuweisungsoperatoren