7.3.3 Operatoren

Operatoren spielen in jeder Programmiersprache eine wichtige Rolle.

Arithmetische Operatoren

Die arithmetischen Operatoren in JavaScript unterscheiden sich nicht von denen in anderen gängigen Programmiersprachen. Zusätzlich bietet JavaScript Kurzschreibweisen, um Werte direkt zu manipulieren.

Operator	Aufgabe des Operators	Beispiel	Anschließender Wert der Variablen
`=`	Zuweisung	`kontoStand = 1000;`	`kontoStand = 1000`
`+`	Addition	`punkte = 10 + 5;`	`punkte = 15`
`-`	Subtraktion	`punkte = 7 - 2;`	`punkte = 5`
`*`	Multiplikation	`punkte = 3 * 4;`	`punkte = 12`
`/`	Division	`punkte = 20 / 4;`	`punkte = 5`
`%`	Modulo (Rest)	`punkte = 15 % 6;`	`punkte = 3` (15 / 6 = 2 Rest 3)
`+=`	Addiere und weise zu	`punkte += 5;`	`punkte = punkte + 5;` → `punkte = 15`
`-=`	Subtrahiere und weise zu	`punkte -= 2;`	`punkte = punkte - 2;` → `punkte = 3`
`*=`	Multipliziere und weise zu	`punkte *= 2;`	`punkte = punkte * 2;` → `punkte = 24`
`/=`	Dividiere und weise zu	`punkte /= 4;`	`punkte = punkte / 4;` → `punkte = 5`
`%=`	Modulo und weise zu	`punkte %= 4;`	`punkte = punkte % 4;` → `punkte = 3`
`x++`	Inkrement (nachher)	`x = 4; y = x++;`	`y = 4, x = 5` (alter Wert, dann +1)
`++x`	Inkrement (vorher)	`x = 4; y = ++x;`	`y = 5, x = 5` (direkt +1)
`x--`	Dekrement (nachher)	`x = 4; y = x--;`	`y = 4, x = 3` (alter Wert, dann -1)
`--x`	Dekrement (vorher)	`x = 4; y = --x;`	`y = 3, x = 3` (direkt -1)
`-`	Negation	`punkte = 10; y = -punkte;`	`y = -10`

JavaScript unterstützt von sich aus die Punkt-vor-Strich-Rechnung, sodass die Berechnungsreihenfolge automatisch korrekt umgesetzt wird.

let kontoStand = 1000; // Startbetrag in Euro
kontoStand = kontoStand + 250; // Einzahlungen
// kontoStand erhält den Wert 1250

JavaScript erlaubt zudem eine Kurzschreibweise:

let punkte = 10;
punkte += 5; // Punkte erhöhen sich um 5
// entspricht
punkte = punkte + 5;

Boolesche Operatoren

Boolesche Operatoren werden verwendet, um Wahrheitswerte zu vergleichen oder zu verknüpfen. Sie spielen eine zentrale Rolle bei Bedingungsprüfungen und logischen Operationen.

Operator	Bedeutung	Beispiel	Ergebnis
`&&`	UND: Liefert `true`, wenn alle Operanden `true` sind	`true && true`	`true`
		`true && false`	`false`
`\|\|`	ODER: Liefert `true`, wenn mindestens einer der Operanden `true` ist	`true \|\| false`	`true`
		`false \|\| false`	`false`
`!`	Negation: Kehrt den Wahrheitswert um	`!true`	`false`
		`!false`	`true`

UND-Operator (`&&`)

Der &&-Operator liefert true, wenn alle Werte true sind.

const w = true;
const f = false;
const test1 = w && f; // false
const test2 = w && w; // true
const test3 = f && f; // false

ODER-Operator (`||`)

Der ||-Operator liefert true, wenn mindestens einer der Werte true ist.

const w = true;
const f = false;
const f2 = false;
const test1 = w || f || f2; // true
const test2 = f || f;       // false

Negation (`!`)

Mit dem !-Operator wird ein Wahrheitswert negiert.

const w = true;
const f = false;
const test1 = !w; // false
const test2 = !f; // true

Vergleichsoperatoren

Vergleichsoperatoren werden genutzt, um Werte zu vergleichen.

Operator	Bedeutung	Beispiel	Ergebnis
`==`	Gleich (Wertevergleich)	`7 == "7"`	`true`
`===`	Strikt gleich (Wert & Typ)	`7 === "7"`	`false` (Typen nicht gleich)
`!=`	Ungleich (Wertevergleich)	`7 != "7"`	`false`
`!==`	Strikt ungleich (Wert & Typ)	`7 !== "7"`	`true` (Typen nicht ungleich)
`<`	Kleiner als	`10 < 10`	`false`
`>`	Größer als	`15 > 3`	`true`
`<=`	Kleiner oder gleich	`10 <= 10`	`true`
`>=`	Größer oder gleich	`12 >= 13`	`false`

Hinweis: Verwenden Sie bevorzugt die strikt gleich (===) und strikt ungleich (!==) Operatoren.

String-Operatoren

Strings können mit dem Plus-Operator (+ sowie mit +=) aneinandergehängt werden.

const vorname = "Johann Wolfgang";
const nachname = "von Goethe";
const name = vorname + " " + nachname; 
// liefert "Johann Wolfgang von Goethe"

JavaScript-Besonderheiten bei Strings

Zusätzliche Methoden für Strings

variable.charAt(x): Liefert das Zeichen an der Position x (Zählung beginnt bei 0).
variable.substring(anfang, ende): Gibt einen Teilstring von anfang bis ende zurück.
variable.length: Liefert die Länge des Strings.
variable.replace("zeichen1", "zeichen2"): Ersetzt zeichen1 durch zeichen2.

const nachname = "Goethe";
const a = nachname.charAt(4);         // "h"
const b = nachname.substring(2, 5);   // "ethe"
const c = nachname.length;            // 6
const d = nachname.replace("e", "u"); // "Gouthu"