Operatoren-Übersicht

// 1) Float-Falle bei /
console.log(0.1 + 0.2);         // 0.30000000000000004
console.log(1 / 3);             // 0.3333333333333333
console.log(10 / 3);            // 3.3333333333333335 (kein Integer-Divide)

// 2) Modulo behält Vorzeichen des Dividenden
console.log(-7 % 3);            // -1  (nicht 2 wie in Python)
console.log(7 % -3);            //  1

// 3) Power-Operator ** ist RECHTS-assoziativ
console.log(2 ** 3 ** 2);       // 512  — also 2 ** (3 ** 2) = 2 ** 9
console.log((2 ** 3) ** 2);     // 64

// 4) BigInt-Mix-Verbot
// console.log(1n + 1);         // TypeError: Cannot mix BigInt and other types
console.log(1n + 1n);           // 2n

// + mit String konkateniert (links-assoziativ ausgewertet)
console.log('5' + 3);           // '53'
console.log(3 + '5');           // '35'
console.log(1 + 2 + '3');       // '33'   — erst 1+2=3, dann '3'+'3'
console.log('1' + 2 + 3);       // '123'  — erst '12', dann '123'

// - * / % erzwingen Number-Coercion
console.log('5' - 3);           //   2
console.log('5' * '2');         //  10
console.log('10' / '4');        //   2.5
console.log('5' - 'foo');       // NaN

// unärer + als expliziter Number-Cast (idiomatisch)
console.log(+'42');             // 42
console.log(+'');               //  0
console.log(+'abc');            // NaN

// == mit Coercion — die berüchtigten Fälle
console.log(0  == '');          // true
console.log(0  == '0');         // true
console.log('' == '0');         // false  (beides Strings, kein Cast)
console.log(null == undefined); // true   (Sonderregel)
console.log(null == 0);         // false  (== koerziert null nicht zu 0)
console.log([] == false);       // true
console.log([] == 0);           // true
console.log([0] == false);      // true

// === ohne Coercion — kein Spielraum
console.log(0  === '');         // false
console.log(0  === '0');        // false
console.log(null === undefined);// false

console.log(NaN === NaN);          // false  — NaN ist nie gleich
console.log(NaN ==  NaN);          // false

console.log(Number.isNaN(NaN));    // true   — der saubere Test
console.log(Number.isNaN('foo'));  // false  (Coercion-frei!)
console.log(isNaN('foo'));         // true   (legacy: koerziert erst)

// Object.is unterscheidet zusätzlich +0 / -0
console.log(Object.is(NaN, NaN));  // true
console.log(Object.is(+0, -0));    // false  (=== würde true liefern)
console.log(+0 === -0);            // true

// && returnt den ersten falsy oder den letzten Wert
console.log(1 && 2);            // 2     — beide truthy → letzter
console.log(0 && 2);            // 0     — erster falsy
console.log('a' && 'b' && 'c'); // 'c'

// || returnt den ersten truthy oder den letzten Wert
console.log(0 || 'fallback');   // 'fallback'
console.log('x' || 'y');        // 'x'
console.log(null || 0 || '');   // ''    — alle falsy, letzter Wert

// ! liefert IMMER Boolean (Coercion über ToBoolean)
console.log(!0);                // true
console.log(!'');               // true
console.log(!{});               // false — Objekte sind truthy
console.log(!![]);              // true  — doppeltes ! als Boolean-Cast

// Short-Circuit für Side-Effects
const obj = null;
obj && obj.dispose();           // sicher: dispose() wird nicht aufgerufen

// Klassisches Pattern vorher
let cache = undefined;
cache = cache || {};                  // alt
cache ||= {};                         // neu — kürzer, ein Lookup

// Drei Varianten — unterschiedliche Bedingungen
let a = 0;        a ||= 5;            // a=5  (0 ist falsy)
let b = 0;        b ??= 5;            // b=0  (0 ist NICHT nullish)
let c = 1;        c &&= 5;            // c=5  (1 ist truthy → assign)
let d = null;     d &&= 5;            // d=null (null ist falsy → skip)

console.log(a, b, c, d);              // 5 0 5 null

// Defaults für Object-Properties — extrem kompakt
const opts = { timeout: 0 };
opts.retries ??= 3;                   // setzt nur, wenn nullish
opts.timeout ??= 5000;                // 0 bleibt erhalten!
opts.headers ??= {};
console.log(opts);
// { timeout: 0, retries: 3, headers: {} }

// Standard-Operationen
console.log(0b1100 & 0b1010);         // 0b1000 = 8
console.log(0b1100 | 0b1010);         // 0b1110 = 14
console.log(0b1100 ^ 0b1010);         // 0b0110 = 6
console.log(~5);                      // -6  (bitweise NOT)

// Shift-Operatoren
console.log(1 << 4);                  // 16
console.log(-8 >> 1);                 // -4  (sign-propagating)
console.log(-8 >>> 1);                // 2147483644  (unsigned)

// Klassische Tricks
console.log(5.7 | 0);                 // 5    — Truncate via |0
console.log(-5.7 | 0);                // -5   — gegen 0, nicht floor!
console.log(5.7 << 0);                // 5    — gleicher Effekt
console.log(~~5.7);                   // 5    — doppeltes ~

// 32-Bit-Overflow ab 2^31
console.log((2 ** 31) | 0);           // -2147483648  (Overflow!)
console.log((2 ** 32) | 0);           // 0            (komplett weg)

// typeof — gibt einen String, kennt 8 Werte
console.log(typeof undefined);        // 'undefined'
console.log(typeof null);             // 'object'    ← historischer Bug!
console.log(typeof 42);               // 'number'
console.log(typeof 1n);               // 'bigint'
console.log(typeof 'x');              // 'string'
console.log(typeof true);             // 'boolean'
console.log(typeof Symbol());         // 'symbol'
console.log(typeof function(){});     // 'function'  ← eigentlich Object
console.log(typeof {});               // 'object'
console.log(typeof []);               // 'object'    ← Array.isArray() nutzen

// typeof ist sicher gegenüber undeklarierten Variablen
console.log(typeof gibtsNicht);       // 'undefined' (kein ReferenceError)

// instanceof — Prototypen-Check
console.log([] instanceof Array);     // true
console.log([] instanceof Object);    // true (Array erbt von Object)

// in — Property-Existenz (inkl. Prototype-Chain)
console.log('length' in []);          // true
console.log('toString' in {});        // true (geerbt)

// delete — nur auf Object-Properties
const obj = { a: 1 };
console.log(delete obj.a);            // true
console.log(obj);                     // {}

// void — wirft Wert weg, returnt undefined
console.log(void 0);                  // undefined
console.log(void 'irgendwas');        // undefined

// 1) ! bindet enger als && — fast immer wie gewünscht
const found = 0;
const a = !found && 'leer';           // OK: (!found) && 'leer'
console.log(a);                       // 'leer'

// 2) ?? darf NICHT direkt mit || / && gemischt werden
// const x = a || b ?? c;             // SyntaxError!
// Klammern Pflicht:
const x = (1 || 2) ?? 3;              // OK
console.log(x);                       // 1

// 3) ** ist rechts-assoziativ
console.log(2 ** 3 ** 2);             // 512  (= 2 ** 9)
console.log((2 ** 3) ** 2);           // 64

// 4) Comma hat niedrigste Precedence
const y = (1, 2, 3);                  // 3 — letzter Wert
// const z = 1, 2, 3;                 // SyntaxError als Statement!

// SPREAD — am Verbrauchs-Ort
const a = [1, 2, 3];
const b = [...a, 4, 5];               // [1, 2, 3, 4, 5]   Array-Literal
const obj = { x: 1, y: 2 };
const merged = { ...obj, y: 9, z: 3 };// { x: 1, y: 9, z: 3 }
console.log(Math.max(...a));          // 3                 Function-Call
console.log(b);
console.log(merged);

// REST — am Definitions-Ort
function sum(first, ...rest) {        // rest = restliche Args
    return first + rest.reduce((a, b) => a + b, 0);
}
console.log(sum(1, 2, 3, 4));         // 10

// Rest im Destructuring
const [head, ...tail] = [10, 20, 30];
console.log(head, tail);              // 10 [ 20, 30 ]

const { name, ...metadata } = { name: 'X', age: 1, role: 'a' };
console.log(name, metadata);          // X { age: 1, role: 'a' }