Um mit Beträgen zu rechnen und Bedingungen zu prüfen, braucht unser Haushaltsbuch Operatoren – dieses Kapitel deckt arithmetische, Vergleichs- und logische Operatoren ab, inklusive der berüchtigten Type-Coercion-Fallstricke.

Arithmetische Operatoren

const gehalt = 2400;
const miete = 850;

console.log(gehalt + miete);  // 3250 - Addition
console.log(gehalt - miete);  // 1550 - Subtraktion
console.log(gehalt * 12);     // 28800 - Multiplikation (Jahresgehalt)
console.log(gehalt / 30);     // 80 - Division (Tagessatz)
console.log(gehalt % 1000);   // 400 - Modulo (Rest der Division)
console.log(gehalt ** 2);     // 5760000 - Potenz

Inkrement/Dekrement und zusammengesetzte Zuweisung

let anzahlBuchungen = 0;
anzahlBuchungen++;        // entspricht anzahlBuchungen = anzahlBuchungen + 1
anzahlBuchungen += 5;     // +=, -=, *=, /= als Kurzform

let kontostand = 1500;
kontostand -= 850;        // Miete abbuchen

Vergleichsoperatoren: == vs. ===

Der wichtigste Operator-Unterschied in ganz JavaScript: == vergleicht NACH impliziter Typumwandlung, === vergleicht Wert UND Typ, OHNE Umwandlung.

console.log(100 == '100');   // true  - String wird zu Number umgewandelt, dann verglichen
console.log(100 === '100');  // false - unterschiedliche Typen, kein Vergleich nach Umwandlung
console.log(0 == false);     // true  - false wird zu 0 umgewandelt
console.log(0 === false);    // false - unterschiedliche Typen
console.log(null == undefined);  // true  - Sonderfall: die beiden gelten als "gleich"
console.log(null === undefined); // false - unterschiedliche Typen

Weitere Vergleichsoperatoren

console.log(850 > 500);   // true
console.log(850 < 500);   // false
console.log(850 >= 850);  // true
console.log(850 <= 500);  // false

Logische Operatoren

const istEinnahme = true;
const betragPositiv = 2400 > 0;

console.log(istEinnahme && betragPositiv); // true - UND: beide müssen wahr sein
console.log(istEinnahme || false);          // true - ODER: mindestens eine muss wahr sein
console.log(!istEinnahme);                  // false - NICHT: kehrt den Wahrheitswert um

Truthy und Falsy: Werte in booleschem Kontext

Wird ein Nicht-Boolean-Wert dort verwendet, wo JavaScript einen Wahrheitswert erwartet (z. B. in einer if-Bedingung, Kapitel 6), wandelt die Engine ihn implizit in true oder false um. Genau ACHT Werte gelten als "falsy" – ALLES andere ist "truthy":

• Falsy: false, 0, -0, 0n, '' (leerer String), null, undefined, NaN.
• Truthy: buchstäblich ALLES andere – auch '0' (String mit Inhalt!), 'false' (String mit Inhalt!), leere Arrays [] und leere Objekte {}.

if ('0') {
  console.log('Dieser Zweig läuft! Der String "0" ist truthy.');
}

if ([]) {
  console.log('Dieser Zweig läuft auch! Ein leeres Array ist truthy.');
}

Nullish Coalescing (??) und Optional Chaining (?.)

Zwei moderne Operatoren, die im Umgang mit möglicherweise fehlenden Werten enorm hilfreich sind – wichtig für unser Haushaltsbuch, sobald Transaktionen optionale Felder wie eine Notiz haben:

const notiz = null;
const anzeige = notiz ?? 'Keine Notiz'; // ?? greift NUR bei null/undefined, nicht bei 0 oder ''
console.log(anzeige); // 'Keine Notiz'

const transaktion = { beschreibung: 'Miete' };
console.log(transaktion.kategorie?.name); // undefined statt Fehler - kein Absturz bei fehlender Kategorie

Der entscheidende Unterschied zu ||: 0 || 'Standard' ergibt 'Standard', weil 0 falsy ist – auch wenn 0 hier ein gültiger, gewollter Wert wäre! 0 ?? 'Standard' ergibt korrekt 0, da ?? NUR auf null/undefined reagiert.