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 (**)

This is an experimental technology, part of the ECMAScript 2016 (ES7) proposal.
Because this technology's specification has not stabilized, check the compatibility table for usage in various browsers. Also note that the syntax and behavior of an experimental technology is subject to change in future version of browsers as the spec changes.

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

Specifikation Status Kommentar
ECMAScript 1st Edition (ECMA-262) Standard Initiale Definition.
ECMAScript 5.1 (ECMA-262)
Die Definition von 'Additive operators' in dieser Spezifikation.

ECMAScript 5.1 (ECMA-262)
Die Definition von 'Multiplicative operators' in dieser Spezifikation.

ECMAScript 5.1 (ECMA-262)
Die Definition von 'Postfix expressions' in dieser Spezifikation.

ECMAScript 5.1 (ECMA-262)
Die Definition von 'Unary operators' in dieser Spezifikation.
Standard  
ECMAScript 2015 (6th Edition, ECMA-262)
Die Definition von 'Additive operators' in dieser Spezifikation.

ECMAScript 2015 (6th Edition, ECMA-262)
Die Definition von 'Multiplicative operators' in dieser Spezifikation.

ECMAScript 2015 (6th Edition, ECMA-262)
Die Definition von 'Postfix expressions' in dieser Spezifikation.

ECMAScript 2015 (6th Edition, ECMA-262)
Die Definition von 'Unary operators' in dieser Spezifikation.
Standard  
ECMAScript 2016 (ECMA-262) Standard  
ECMAScript 2017 Draft (ECMA-262) Entwurf  

Browserkompatibilität

Feature Chrome Firefox (Gecko) Internet Explorer Opera Safari
Basic support (Ja) (Ja) (Ja) (Ja) (Ja)
Exponentiation operator 52.0 Nightly build ? ? ?
Feature Android Android Webview Firefox Mobile (Gecko) IE Mobile Opera Mobile Safari Mobile Chrome for Android
Basic support (Ja) (Ja) (Ja) (Ja) (Ja) (Ja) (Ja)
Exponentiation operator Nicht unterstützt 51.0 Nightly build ? ? ? 52.0

Siehe auch

Schlagwörter des Dokuments und Mitwirkende

Schlagwörter: 
 Mitwirkende an dieser Seite: schlagi123, Aloso, occcy
 Zuletzt aktualisiert von: schlagi123,