Boolean & Truthy/Falsy

const aktiv = true;
const sichtbar = false;

typeof aktiv;     // 'boolean'
typeof false;     // 'boolean'

// Vergleichs-Operatoren liefern Boolean
typeof (5 > 3);   // 'boolean'
typeof !sichtbar; // 'boolean'

// Logische Operatoren liefern NICHT immer Boolean (siehe Section 7)
typeof ('a' || 'b');  // 'string' (!)

// alle Boolean-Kontexte
if (wert)        { /* … */ }
while (wert)     { /* … */ }
wert ? 'a' : 'b';
wert && 'next';
wert || 'fallback';
!wert;
Boolean(wert);
!!wert;

// Beispiel: existiert die Antwort?
const response = fetchSync();
if (response) {
    // truthy: response ist gesetzt UND nicht leer
}

// alle 8 falsy
Boolean(false);     // false
Boolean(0);         // false
Boolean(-0);        // false
Boolean(0n);        // false
Boolean('');        // false
Boolean(null);      // false
Boolean(undefined); // false
Boolean(NaN);       // false

// Sonderfall: document.all (Legacy-DOM, im Browser)
// ist ebenfalls falsy — historischer Spec-Hack

// alle Objects sind truthy — auch wenn sie leer sind
Boolean([]);            // true  — leeres Array!
Boolean({});            // true  — leeres Object!
Boolean(new Map());     // true
Boolean(new Date());    // true  — auch Invalid Date

// Strings: Inhalt egal, nur Leerheit zählt
Boolean('0');           // true  — String 'null' wäre auch truthy
Boolean('false');       // true
Boolean(' ');           // true  — Whitespace zählt!

// Numbers: nur Null und NaN sind falsy
Boolean(-1);            // true
Boolean(Infinity);      // true
Boolean(0.0001);        // true

// Funktionen: immer truthy
Boolean(() => {});      // true

// Variante 1: Boolean() als Funktion (NICHT mit new!)
Boolean('hi');     // true
Boolean(0);        // false
Boolean([]);       // true

// Variante 2: doppelte Negation — idiomatischer
!!'hi';            // true   — !'hi' ist false, !!… ist true
!!0;               // false
!![];              // true

// beide äquivalent — Wahl ist Stilfrage
// Linter wie ESLint erlauben meist beide

// praktischer Use-Case: API-Antwort zu sauberem Boolean
const hasItems = !!response?.items?.length;
const isLoggedIn = Boolean(user?.id);

const flag = 1;

// implizit (idiomatisch)
if (flag) {
    // läuft, weil 1 truthy ist
}

// explizit — wird NICHT eintreten!
if (flag === true) {
    // läuft NICHT, weil 1 !== true (verschiedener Typ)
}

// sinnvoll: wenn API garantiert nur Boolean zurückgibt
const isAdmin = checkAdmin();  // gibt streng Boolean zurück
if (isAdmin === true) {
    // okay als Type-Guard / API-Contract-Check
}

// mit ?: für Fallback-Werte
const name = user.name || 'Anonym';     // Fallback bei falsy
const safe = user.name ?? 'Anonym';     // Fallback nur bei null/undefined

// || gibt ersten truthy zurück, sonst letzten Wert
'a' || 'b';        // 'a'
'' || 'b';         // 'b'
0 || null || 'x';  // 'x'
0 || null;         // null  — letzter Wert, alle falsy

// && gibt ersten falsy zurück, sonst letzten Wert
'a' && 'b';        // 'b'
'' && 'b';         // ''
true && null;      // null
true && 'x' && 5;  // 5

// praktischer Einsatz: Default-Wert
const port = config.port || 3000;
// ABER: bei port=0 würde der Fallback ungewollt greifen!

// ?? statt || für "nur null/undefined als leer"
const port2 = config.port ?? 3000;  // nur fallback bei null/undefined

const wrapper = new Boolean(false);

typeof wrapper;          // 'object'  (!)
wrapper === false;       // false
wrapper.valueOf();       // false   — der innere Wert ist false

// aber im Boolean-Kontext: TRUTHY!
if (wrapper) {
    console.log('Das läuft!');  // wird ausgeführt
}

Boolean(wrapper);        // true   — alle Objects sind truthy

// Boolean() OHNE new ist die korrekte Coercion
Boolean(false);          // false  — gut
new Boolean(false);      // Object — schlecht

// gleiche Falle wie new String(''), new Number(0)

// Type-Guard: prüfen, ob der Wert wirklich Boolean ist
function istEchterBoolean(x) {
    return typeof x === 'boolean';
}

// API-Contract: Funktion soll garantiert Boolean liefern
function isValid(input) {
    // … Logik …
    return result === true;  // nur exakt true zählt
}

// bei Drittanbieter-API, wo "truthy" nicht reicht
if (response.success === true) {
    // unterscheidet zwischen 1, 'ok', {…} und echtem Boolean
}

// praktisch: Filter-Predicates
[true, 1, 'true', null].filter(x => x === true);  // [true]
[true, 1, 'true', null].filter(Boolean);          // [true, 1, 'true']