Operatoren und Bedingungen

Operatoren und Bedingungen

Operatoren und Bedingungen sind fundamentale Bausteine jeder Programmiersprache. Sie ermöglichen es uns, Berechnungen durchzuführen, Werte zu vergleichen und den Programmfluss basierend auf bestimmten Bedingungen zu steuern. In diesem Kapitel lernen wir die verschiedenen Arten von Operatoren in JavaScript kennen und wie wir mit bedingten Anweisungen arbeiten.

Arithmetische Operatoren

Arithmetische Operatoren werden für mathematische Berechnungen verwendet:

Operator	Beschreibung	Beispiel
+	Addition	5 + 2 = 7
-	Subtraktion	5 - 2 = 3
*	Multiplikation	5 * 2 = 10
/	Division	5 / 2 = 2.5
%	Modulo (Rest)	5 % 2 = 1
**	Potenzierung	5 ** 2 = 25
++	Inkrement	let x = 5; x++; // x ist jetzt 6
--	Dekrement	let x = 5; x--; // x ist jetzt 4

let a = 10;
let b = 3;

console.log(a + b); // 13
console.log(a - b); // 7
console.log(a * b); // 30
console.log(a / b); // 3.3333...
console.log(a % b); // 1 (Rest der Division 10/3)
console.log(a ** b); // 1000 (10 hoch 3)

// Inkrement und Dekrement
let c = 5;
console.log(c++); // 5 (gibt den Wert zurück und erhöht dann)
console.log(c); // 6
console.log(++c); // 7 (erhöht zuerst und gibt dann den Wert zurück)

let d = 5;
console.log(d--); // 5 (gibt den Wert zurück und verringert dann)
console.log(d); // 4
console.log(--d); // 3 (verringert zuerst und gibt dann den Wert zurück)

Zuweisungsoperatoren

Mit Zuweisungsoperatoren werden Werte Variablen zugewiesen:

Operator	Beschreibung	Beispiel	Entspricht
=	Zuweisung	x = y	x = y
+=	Addition + Zuweisung	x += y	x = x + y
-=	Subtraktion + Zuweisung	x -= y	x = x - y
*=	Multiplikation + Zuweisung	x *= y	x = x * y
/=	Division + Zuweisung	x /= y	x = x / y
%=	Modulo + Zuweisung	x %= y	x = x % y
**=	Potenzierung + Zuweisung	x **= y	x = x ** y

let x = 10;

x += 5; // x = x + 5, x ist jetzt 15
x -= 3; // x = x - 3, x ist jetzt 12
x *= 2; // x = x * 2, x ist jetzt 24
x /= 4; // x = x / 4, x ist jetzt 6
x %= 4; // x = x % 4, x ist jetzt 2
x **= 3; // x = x ** 3, x ist jetzt 8

Vergleichsoperatoren

Vergleichsoperatoren werden verwendet, um Werte zu vergleichen und liefern immer einen Boolean-Wert (true oder false) zurück:

Operator	Beschreibung	Beispiel
==	Gleich (Wert)	5 == "5" ist true
===	Streng gleich (Wert und Typ)	5 === "5" ist false
!=	Ungleich (Wert)	5 != "6" ist true
!==	Streng ungleich (Wert oder Typ)	5 !== "5" ist true
>	Grösser als	5 > 3 ist true
<	Kleiner als	5 < 3 ist false
>=	Grösser oder gleich	5 >= 5 ist true
<=	Kleiner oder gleich	5 <= 4 ist false

let a = 5;
let b = "5";
let c = 10;

console.log(a == b); // true (gleicher Wert, Typ wird ignoriert)
console.log(a === b); // false (unterschiedlicher Typ)
console.log(a != c); // true (unterschiedlicher Wert)
console.log(a !== b); // true (gleicher Wert, aber unterschiedlicher Typ)
console.log(a > c); // false (5 ist nicht grösser als 10)
console.log(a < c); // true (5 ist kleiner als 10)
console.log(a >= 5); // true (5 ist gleich 5)
console.log(c <= 5); // false (10 ist nicht kleiner oder gleich 5)

Wichtig: In JavaScript wird empfohlen, die strikten Vergleichsoperatoren (=== und !==) zu verwenden, um unerwartete Typkonvertierungen zu vermeiden.

Logische Operatoren

Logische Operatoren werden verwendet, um logische Aussagen zu verbinden:

Operator	Beschreibung	Beispiel
&&	Logisches UND	true && true ist true, alle anderen Kombinationen sind false

| \ | \ | | Logisches ODER | false \ | \ | false ist false, alle anderen Kombinationen sind true |

| ! | Logisches NICHT | !true ist false, !false ist true |

let x = 5;
let y = 10;

// Logisches UND (&&)
console.log(x > 0 && y > 0); // true (beide Bedingungen sind wahr)
console.log(x > 7 && y > 0); // false (erste Bedingung ist falsch)

// Logisches ODER (||)
console.log(x > 7 || y > 0); // true (zweite Bedingung ist wahr)
console.log(x > 7 || y > 12); // false (beide Bedingungen sind falsch)

// Logisches NICHT (!)
console.log(!(x > 0)); // false (das Gegenteil von true)
console.log(!(x > 7)); // true (das Gegenteil von false)

Kurzschlussauswertung (Short-Circuit Evaluation)

Logische Operatoren arbeiten mit “Kurzschlussauswertung”:

• &&: Wenn der erste Operand false ist, wird der zweite nicht ausgewertet
• ||: Wenn der erste Operand true ist, wird der zweite nicht ausgewertet

// Beispiel für &&
let a = false && meineFunktion(); // meineFunktion wird nicht aufgerufen

// Beispiel für ||
let defaultWert = 5;
let eingabeWert = null;
let wert = eingabeWert || defaultWert; // wert wird 5 sein

Bedingte (Ternäre) Operatoren

Der ternäre Operator ist eine Kurzform der if-else-Anweisung:

Bedingung ? AusduckWennWahr : AusdruckWennFalsch;

Beispiel:

let alter = 18;
let status = alter >= 18 ? "erwachsen" : "minderjährig";
console.log(status); // "erwachsen"

// Entspricht dem folgenden if-else-Block:
/*
let status;
if (alter >= 18) {
  status = "erwachsen";
} else {
  status = "minderjährig";
}
*/

if-Anweisung

Die if-Anweisung führt einen Codeblock aus, wenn eine bestimmte Bedingung erfüllt ist:

if (Bedingung) {
  // Code, der ausgeführt wird, wenn die Bedingung wahr ist
}

Beispiel:

let temperatur = 22;

if (temperatur > 30) {
  console.log("Es ist heiss!");
}

if-else-Anweisung

Mit else können wir einen alternativen Codeblock angeben, der ausgeführt wird, wenn die Bedingung nicht erfüllt ist:

if (Bedingung) {
  // Code, der ausgeführt wird, wenn die Bedingung wahr ist
} else {
  // Code, der ausgeführt wird, wenn die Bedingung falsch ist
}

Beispiel:

let temperatur = 22;

if (temperatur > 30) {
  console.log("Es ist heiss!");
} else {
  console.log("Es ist nicht heiss.");
}

if-else-if-else-Anweisung

Bei mehreren Bedingungen können wir else if verwenden:

if (Bedingung1) {
  // Code, wenn Bedingung1 wahr ist
} else if (Bedingung2) {
  // Code, wenn Bedingung1 falsch und Bedingung2 wahr ist
} else if (Bedingung3) {
  // Code, wenn Bedingung1 und Bedingung2 falsch und Bedingung3 wahr ist
} else {
  // Code, wenn alle Bedingungen falsch sind
}

Beispiel:

let temperatur = 22;

if (temperatur > 30) {
  console.log("Es ist heiss!");
} else if (temperatur > 20) {
  console.log("Es ist angenehm warm.");
} else if (temperatur > 10) {
  console.log("Es ist kühl.");
} else {
  console.log("Es ist kalt!");
}

switch-Anweisung

Die switch-Anweisung ist eine Alternative zu if-else-if, wenn viele mögliche Bedingungen für eine Variable existieren:

switch (Ausdruck) {
  case Wert1:
    // Code, wenn Ausdruck === Wert1
    break;
  case Wert2:
    // Code, wenn Ausdruck === Wert2
    break;
  // weitere cases...
  default:
  // Code, wenn kein case zutrifft
}

Beispiel:

let tag = new Date().getDay(); // 0 für Sonntag, 1 für Montag, usw.

switch (tag) {
  case 0:
    console.log("Sonntag");
    break;
  case 1:
    console.log("Montag");
    break;
  case 2:
    console.log("Dienstag");
    break;
  case 3:
    console.log("Mittwoch");
    break;
  case 4:
    console.log("Donnerstag");
    break;
  case 5:
    console.log("Freitag");
    break;
  case 6:
    console.log("Samstag");
    break;
  default:
    console.log("Ungültiger Tag");
}

Das break-Statement ist wichtig, um nach dem Ausführen eines Case-Blocks aus dem Switch auszusteigen. Ohne break würde die Ausführung zum nächsten Case übergehen, unabhängig davon, ob die Bedingung erfüllt ist.

Truthy und Falsy Werte

In JavaScript werden Werte in Bedingungen automatisch in Booleans konvertiert. Dabei gibt es “truthy” (wird als true interpretiert) und “falsy” (wird als false interpretiert) Werte:

Falsy Werte:

• false
• 0 und -0
• "" (leerer String)
• null
• undefined
• NaN (Not a Number)

Truthy Werte:

• Alles, was nicht falsy ist, zum Beispiel:
• true
• Jede Zahl ausser 0 und -0
• Jeder nicht-leere String
• Arrays (auch leere)
• Objekte (auch leere)

let wert1 = "";
let wert2 = "Hallo";
let wert3 = 0;
let wert4 = 42;

if (wert1) {
  console.log("wert1 ist truthy"); // wird nicht ausgeführt
}

if (wert2) {
  console.log("wert2 ist truthy"); // wird ausgeführt
}

if (wert3) {
  console.log("wert3 ist truthy"); // wird nicht ausgeführt
}

if (wert4) {
  console.log("wert4 ist truthy"); // wird ausgeführt
}

Übung: Operatoren und Bedingungen in der Praxis

Aufgabe: Operatoren und Bedingungen in der Praxis

In dieser Übung werden Sie verschiedene Operatoren und bedingte Anweisungen in JavaScript anwenden. Öffnen Sie die Konsole Ihres Browsers oder einen Online-Code-Editor wie JSFiddle, CodePen oder die integrierte Konsole in VS Code, um diese Aufgaben zu lösen.

1. Noten-Umrechnungssystem

   Schreiben Sie ein Programm, das eine Punktzahl (0-100) in eine Schulnote (A-F) umwandelt:

   • 90-100: Note A
   • 80-89: Note B
   • 70-79: Note C
   • 60-69: Note D
   • Unter 60: Note F

   Testen Sie Ihr Programm mit verschiedenen Punktzahlen und geben Sie die entsprechende Note aus.

2. Führerschein-Prüfer

   Erstellen Sie ein Programm, das überprüft, ob jemand Auto fahren darf. Die Person benötigt ein Mindestalter von 18 Jahren und einen Führerschein.

   • Definieren Sie Variablen für das Alter und den Führerschein-Status (true/false)
   • Geben Sie eine passende Nachricht aus, die angibt, ob die Person fahren darf oder nicht
   • Testen Sie verschiedene Kombinationen

3. Tageszeit-Gruss mit if-else-if

   Schreiben Sie ein Programm, das je nach Tageszeit einen anderen Gruss ausgibt:

   • 5-11 Uhr: “Guten Morgen”
   • 12-17 Uhr: “Guten Tag”
   • 18-21 Uhr: “Guten Abend”
   • 22-4 Uhr: “Gute Nacht” Verwenden Sie new Date().getHours(), um die aktuelle Stunde zu erhalten.

Zusammenfassung

• Arithmetische Operatoren (+, -, *, /, %, **) werden für mathematische Berechnungen verwendet
• Zuweisungsoperatoren (=, +=, -=, etc.) weisen Variablen Werte zu
• Vergleichsoperatoren (==, ===, !=, !==, >, <, >=, <=) vergleichen Werte und liefern einen Boolean zurück
• Logische Operatoren (&&, ||, !) verbinden logische Ausdrücke
• if-else-Anweisungen ermöglichen bedingte Codeausführung
• switch-Anweisungen bieten eine Alternative zu if-else-if für viele mögliche Werte
• Truthy und Falsy Werte werden in Bedingungen automatisch in Booleans konvertiert

Im nächsten Kapitel werden wir uns mit Schleifen befassen, die es uns ermöglichen, Code mehrfach auszuführen und durch Datenstrukturen zu iterieren.