Operatoren

Mit Operatoren lassen sich beliebig komplexe Ausdrücke konstruieren:

1.8 * 4 - (2 + 4.23)

Für number (ganze Zahlen, Gleitkommazahlen) gibt es arithmetische Operatoren und Vergleichsoperatoren:

• Arithmetische Operatoren sind u.a. die Addition, Multiplikation, etc.
• Vergleichsoperatoren sind z.B. kleiner (<), größer oder gleich (>=), etc.

Es gibt mehrere einstellige und zweistellige Operatoren. (Ein Operator ist sogar dreistellig.)

Zweistellige numerische Operatoren

• + Addition
• - Substraktion
• * Multiplikation
• / Division
• % Rest einer Division (Modulo-Operator)

Zweistellig heißt hier, dass der Operator mit zwei Zahlen (allgemein: Operanden) zu verwenden ist (z.B. op1 + op2 bei der Addition).

let i = 17 / 10;     // ==> i = ???
let j = 17 % 10;     // ==> j = ???
// ==> z.B. in der Konsole ausprobieren…

Das Ergebnis dieser Operatoren ist wiederum ein numerischer Wert.

Achtung: In JavaScript kann die Division eine Kommazahl ergeben. In anderen Programmiersprachen wie z.B. Java steht / für die ganzzahlige Division.

+ bei Strings

Mit + können zwei Strings zu einem neuen String zusammengesetzt werden. Dies wird als Stringkonkatenation bezeichnet.

let name = prompt("Wie heißt Du?"); console.log("Hallo, " + name + ". Wie geht es Dir?");

Mit Template-Strings ist es evtl. einfacher, Text zusammenzusetzen:

let name = prompt("Wie heißt Du?");
console.log(`Hallo, ${name}. Wie geht es Dir?`)

Template-Strings wurden bereits im Abschnitt über Datentypen vorgestellt.

Vergleichsoperatoren

Bei Vergleichsoperatoren werden hauptsächlich zwei numerische Werte miteinander verglichen.

Das Ergebnis ist ein Wahrheitswert vom Typ boolean (true oder false).

• < kleiner
• <= kleiner oder gleich
• > größer
• >= größer oder gleich
• === gleich
• !== ungleich

Wichtig: Gleichheit sollte mit === bzw. Ungleichheit mit !== getestet werden.

Der „normale“ Test auf Gleichheit mit == ist in JavaScript problematisch, denn dies kann zu unerwarteten Ergebnissen führen:

4 == "4"; // ergibt true!

Hier wird beim schwachen Vergleich mit == eine automatische Typumwandlungen durchgeführt, sodass hier zwei Strings miteinander verglichen werden.

Daher sollte eigentlich immer der starke Vergleich mit === verwendet werden:

4 === "4"; // ergibt nun wie gewünscht false!

Entsprechendes gilt für den Test auf Ungleichheit mit !==.

Logische Operatoren

Logische Operatoren werden auf Wahrheitswerte angewendet. Das Ergebnis ist wiederum ein Wahrheitswert.

Folgende logischen Operatoren sind relevant:

let x = (8 < 9) && (1 > 5); // --> false
let y = (8 < 9) || (1 > 5); // --> true
let z = !x; // --> true

Beispiel

// Mehrfachdeklaration von drei Variablen mit Initialisierungen
let age = 23, age2 = 134, age3 = 17;
 
// UND: Alter eines Erwachsenen liegt zwischen 18 und 120 
age >= 18 && age < 120; // true  (beide sind true)
age2 >= 18 && age2 < 120; // false (eine ist false)
 
// ODER: Alter darf nicht zwischen 14 und 18 liegen
// Situation: Jugendliche dürfen nicht auf den Spielplatz
age >= 18 || age < 14; // true (eine ist true)
age3 >= 18 || age3 < 14; // false (beide sind false)

Besondere einstellige Operatoren

Häufig in for-Schleifen verwendete und daher wichtige einstellige Operatoren sind die folgenden beiden:

Diese Operatoren sind einstellig und werden also nur auf einen Wert (bzw. Operanden) angewendet.

Sie werden numerischen Ausdrücken vor- (Präfix) oder nachgestellt (Postfix).

let x = 4;
x++; // --> Erhöht x um 1
--x; // --> Verringert x um 1

Der Wert der Variablen x wird geändert!
(++ und -- führen entsprechende Zuweisungen aus)

Sowohl der vorangestellte Präfix-Operator (++x) und der nachfolgend notierte Postfix-Operator (x++) erhöhen den aktuellen Wert der Variablen x um 1. Dennoch gibt es einen subtilen Unterschied in der Auswertung (Semantik) der beiden Varianten von ++ und --, wie folgendes „Quiz“ veranschaulichen soll (Code in der Konsole des Browsers ausprobieren).

Einstellige Operatoren: Quiz

let x = 8;
// Unten geben wir zuerst den Ausdruck bzw. des Ergebnis des Operators aus
// und dann wird der aktuelle Wert der Variablen ausgegeben
console.log(++x);  // Nr. 1
console.log(x);    // Nr. 2
 
console.log(x++);  // Nr. 3
console.log(x);    // Nr. 4
 
//optional: auch mit x-- und --x durchspielen

Zusammengesetzte Zuweisungsoperatoren

Zunächst betrachten wir folgende Art von Zuweisungen:
a = a OP b

a und b seien numerische Variablen und OP sei ein zweistelliger, arithmetischer Operator.

Ausgehend von dem aktuellen Wert von a wird der Variablen a also ein neuer Wert zugewiesen.

Solch eine Zuweisung kann wie folgt vereinfacht werden:
a OP= b

Beispiele:

let x = 8, y = 9;
 
x += 9; // dies entspricht dem Ausdruck x = x + 9;
	
x -= 9; // dies entspricht dem Ausdruck x = x - 9;
	
x *= y; // dies entspricht dem Ausdruck x = x * y;	
// usw.
	
// diese Abkürzungen sind für zweistellige Operatoren möglich, wenn
// der Operator den gleichen Datentyp wie die beteiligten Werte liefert

Die Verwendung dieser Abkürzung ist gut abzuwägen, denn die Lesbarkeit eines Programms kann sich dadurch verschlechtern.

Bedingungsoperator (dreistellig)

In einigen Programmiersprachen und auch in JavaScript gibt es einen dreistelligen Operator. Mit diesem lassen sich einfache Fallunterscheidungen in kompakten Ausdrücken formulieren (ohne if).

Dieser Operator heißt Bedingungsoperator und wird manchmal auch „inline-if“ oder nach seiner Dreistelligkeit „ternärer Operator“ genannt. Er besteht aus Fragezeichen und Doppelpunkt.

WAHRHEITSWERT ? ERGEBNIS_WENN_TRUE : ERGEBNIS_WENN_FALSE

• Der Ausdruck in WAHRHEITSWERT muss vom Typ boolean sein.
• Durch WAHRHEITSWERT wird also die Bedingung ausgedrückt.
• Für ERGEBNIS_WENN_TRUE und ERGEBNIS_WENN_FALSE sollten die gleichen Typen verwendet werden (z.B. Zahlen oder Strings)
• Das Ergebnis (ERGEBNIS_WENN_TRUE oder ERGEBNIS_WENN_FALSE) kann einer Variablen zugewiesen werden.

Beispiel:

let x = 1000;
let y = 100;
let ergebnis = x > y ? "stimmt" : "leider nicht";

Prioritäten der Operatoren

Aus der Schule kennen wir vielleicht den Merksatz „Punktrechnung vor Strichrechnung“, mit dem ausgedrückt wird, dass in einer Berechnung z.B. mit Multiplikation und Addition zuerst die Multiplikation ausgeführt wird.

In Programmiersprachen gilt hierbei das gleiche. Zusätzlich werden für alle Operatoren Prioritäten definiert, die sich auf die Auswertung von Ausdrücken mit mehreren unterschiedlichen Operatoren auswirken.

Mehr dazu hier:

• Operator Precedence bei javascript.info
• Operator Precedence im Mozilla Developer Network