7 Operatoren und Ausdrücke

// Grundlegende arithmetische Operationen
let sum = 5 + 3;        // Addition: 8
let difference = 10 - 4; // Subtraktion: 6
let product = 7 * 6;     // Multiplikation: 42
let quotient = 20 / 5;   // Division: 4
let remainder = 10 % 3;  // Modulo (Rest): 1
let power = 2 ** 3;      // Potenzierung (ES7): 8

// Inkrement und Dekrement
let counter = 5;
counter++;               // Postinkrement: counter wird nach der Auswertung um 1 erhöht
++counter;               // Präinkrement: counter wird vor der Auswertung um 1 erhöht
counter--;               // Postdekrement: counter wird nach der Auswertung um 1 verringert
--counter;               // Prädekrement: counter wird vor der Auswertung um 1 verringert

let a = 5;
let b = a++;  // b erhält den Wert 5, dann wird a auf 6 erhöht
console.log(a, b);  // 6, 5

let c = 5;
let d = ++c;  // c wird zuerst auf 6 erhöht, dann erhält d den Wert 6
console.log(c, d);  // 6, 6

let x = 10;           // Einfache Zuweisung

// Kombinierte Zuweisungen
x += 5;               // x = x + 5 (15)
x -= 3;               // x = x - 3 (12)
x *= 2;               // x = x * 2 (24)
x /= 4;               // x = x / 4 (6)
x %= 4;               // x = x % 4 (2)
x **= 3;              // x = x ** 3 (8)

// Bitweise Zuweisungen
let y = 5;            // Binär: 101
y &= 3;               // y = y & 3 (Binär: 001) = 1
y |= 6;               // y = y | 6 (Binär: 111) = 7
y ^= 2;               // y = y ^ 2 (Binär: 101) = 5
y <<= 1;              // y = y << 1 (Binär: 1010) = 10
y >>= 2;              // y = y >> 2 (Binär: 10) = 2
y >>>= 1;             // y = y >>> 1 (Binär: 1) = 1

// Gleichheit
console.log(5 == 5);      // true
console.log(5 == "5");    // true (mit Typkonvertierung)
console.log(5 === "5");   // false (strikte Gleichheit ohne Typkonvertierung)
console.log(5 != 8);      // true
console.log(5 != "5");    // false (mit Typkonvertierung)
console.log(5 !== "5");   // true (strikte Ungleichheit)

// Relationaler Vergleich
console.log(5 > 3);       // true (größer als)
console.log(5 < 8);       // true (kleiner als)
console.log(5 >= 5);      // true (größer oder gleich)
console.log(5 <= 4);      // false (kleiner oder gleich)

// Logisches UND (&&)
console.log(true && true);    // true
console.log(true && false);   // false

// Logisches ODER (||)
console.log(true || false);   // true
console.log(false || false);  // false

// Logisches NICHT (!)
console.log(!true);           // false
console.log(!false);          // true

// Komplexer Ausdruck
let a = 5, b = 10, c = 15;
console.log(a < b && b < c);  // true (beide Bedingungen erfüllt)
console.log(a > b || b > c);  // false (keine Bedingung erfüllt)

// Bei && wird der zweite Ausdruck nur ausgewertet, wenn der erste true ist
let result1 = false && someFunction();  // someFunction wird nicht aufgerufen

// Bei || wird der zweite Ausdruck nur ausgewertet, wenn der erste false ist
let result2 = true || someFunction();   // someFunction wird nicht aufgerufen

// Bedingte Ausführung
isAdmin && performAdminAction();  // Führt die Funktion nur aus, wenn isAdmin true ist

// Fallback-Werte (nullish coalescing vor ES11)
let username = userInput || "Gast";  // Verwendet "Gast", wenn userInput falsy ist

// Mit ||
let value1 = 0 || "Fallback";  // "Fallback" (0 ist falsy)
let value2 = "" || "Fallback"; // "Fallback" (leerer String ist falsy)

// Mit ??
let value3 = 0 ?? "Fallback";  // 0 (0 ist weder null noch undefined)
let value4 = "" ?? "Fallback"; // "" (leerer String ist weder null noch undefined)
let value5 = null ?? "Fallback"; // "Fallback" (null ist null)
let value6 = undefined ?? "Fallback"; // "Fallback" (undefined ist undefined)

const user = {
  profile: {
    name: "Max",
    address: null
  }
};

// Ohne Optional Chaining
// const city = user.profile.address.city; // TypeError: Cannot read property 'city' of null

// Mit Optional Chaining
const city = user.profile.address?.city; // undefined (kein Fehler)
const zipcode = user?.profile?.contact?.zipcode; // undefined (kein Fehler)

// Mit Methoden
const result = user.getData?.(); // undefined, wenn getData nicht existiert (kein Fehler)

// Mit Array-Elementen
const item = array?.[0]; // undefined, wenn array null oder undefined ist (kein Fehler)

// Bitweise UND (&)
console.log(5 & 3);   // 1 (101 & 011 = 001)

// Bitweise ODER (|)
console.log(5 | 3);   // 7 (101 | 011 = 111)

// Bitweise XOR (^)
console.log(5 ^ 3);   // 6 (101 ^ 011 = 110)

// Bitweise NICHT (~)
console.log(~5);      // -6 (invertiert alle Bits und addiert 1)

// Links-Shift (<<)
console.log(5 << 1);  // 10 (verschiebt Bits um 1 Position nach links)

// Rechts-Shift mit Vorzeichen (>>)
console.log(-5 >> 1); // -3 (erhält das Vorzeichen)

// Rechts-Shift ohne Vorzeichen (>>>)
console.log(-5 >>> 1); // 2147483645 (füllt mit 0 auf)

// Syntax: bedingung ? ausdruck1 : ausdruck2
let status = age >= 18 ? "Erwachsener" : "Minderjähriger";

// Verschachtelte ternäre Operatoren (weniger empfehlenswert wegen Lesbarkeit)
let message = score > 85 ? "Ausgezeichnet" 
            : score > 70 ? "Gut" 
            : score > 50 ? "Bestanden" 
            : "Nicht bestanden";

let x = 1;

// Mehrere Ausdrücke in einer Anweisung
let y = (x++, x + 1, x * 2);
console.log(y);  // 4 (x wurde zu 2, dann berechnet 2 * 2)

// Mehrere Deklarationen in einer for-Schleife
for (let i = 0, j = 10; i < j; i++, j--) {
  console.log(i, j);
}

// Ohne Klammern - schwer zu lesen und fehleranfällig
let result = a && b || c && d;

// Mit Klammern - klare Intention
let result = (a && b) || (c && d);

// Berechnungen, die zu einem numerischen Wert führen
let area = width * height;
let circumference = 2 * (width + height);

// Konkatenation
let fullName = firstName + " " + lastName;

// Template-Strings (ES6)
let greeting = `Hallo ${firstName}, willkommen zurück!`;

// Kombinationen von Vergleichs- und logischen Operatoren
let isEligible = age >= 18 && hasValidID;
let shouldAlert = isOutOfStock || (quantity < threshold && isPopularItem);

// Literale
3.14
"text"
true
null
{ x: 1, y: 2 }
[1, 2, 3]

// Identifier
variable
MAX_SIZE

// this-Keyword (kontextabhängig)
this.property

// Gruppierung
(x + y) * z

// Funktionsdeklaration (kein Ausdruck, sondern eine Anweisung)
function add(a, b) {
  return a + b;
}

// Funktionsausdruck
const multiply = function(a, b) {
  return a * b;
};

// Arrow-Function (ES6)
const divide = (a, b) => a / b;

// IIFE (Immediately Invoked Function Expression)
const result = (function() {
  const temp = x * y;
  return temp / 2;
})();

// Objektliterale
const user = {
  name: "Max",
  age: 30,
  isActive: true,
  greet() { return `Hallo, ich bin ${this.name}`; }
};

// Computed Property Names (ES6)
const propertyName = "dynamicKey";
const config = {
  [propertyName]: "dynamischer Wert",
  [`prefix_${propertyName}`]: "anderer Wert"
};

// Array-Literale und -Methoden
const numbers = [1, 2, 3, 4, 5];
const doubled = numbers.map(n => n * 2);

// Array-Destrukturierung
const [first, second, ...rest] = [1, 2, 3, 4, 5];

// Objekt-Destrukturierung
const { name, age, address: { city } = {} } = user;

function* generateSequence() {
  yield 1;
  yield 2;
  return 3;
}

// Zuweisungen
x = 10;  // Ändert den Wert von x

// Inkrement/Dekrement
counter++;  // Ändert den Wert von counter

// Funktionsaufrufe mit Nebeneffekten
console.log("Hat Nebeneffekte");  // Ausgabe in der Konsole
arr.push(element);  // Ändert das Array
localStorage.setItem("key", "value");  // Ändert den Browser-Speicher