Signatur
Beschreibung
Der Logische-UND-Zuweisungsoperator (&&=) ist ein zusammengesetzter Zuweisungsoperator (compound assignment operator), der die Kurzschlussauswertung (short-circuit evaluation) des logischen &&-Operators mit einer Zuweisung kombiniert. Er lässt sich als Kurzschreibweise für x && (x = y) verstehen — die Zuweisung findet nur statt, wenn x einen truthy Wert hat.
Im Unterschied zu einer einfachen &&-Verknüpfung führt &&= die Zuweisung explizit durch und gibt keinen neuen Wert zurück, der weiter verkettet werden müsste. Ist der linke Operand falsy (also false, 0, "", null, undefined, NaN), wird der rechte Operand gar nicht ausgewertet und die Variable bleibt unverändert.
Typische Einsatzszenarien sind das bedingte Überschreiben einer bereits gesetzten Variable, das Aktualisieren von Objekt-Eigenschaften nur wenn diese bereits existieren und truthy sind, oder das prägnante Ersetzen von if (x) { x = newValue; }-Mustern.
x &&= yist semantisch äquivalent zux && (x = y)- Kein Setter-Aufruf wenn der linke Operand falsy ist — wichtig bei Objekt-Accessoren.
- Der Ausdruck gibt den Wert zurück, der nach der (möglichen) Zuweisung in
xsteht.
Parameter
| Name | Typ | Default | Beschreibung |
|---|---|---|---|
| $x Pflicht | any | — | Der linke Operand (Ziel der Zuweisung). Muss eine gültige Zuweisung-Ziel-Referenz sein (Variable, Objekt-Eigenschaft, Array-Element). Ist x truthy, wird y ausgewertet und x zugewiesen. |
| $y Pflicht | any | — | Der rechte Operand (neuer Wert). Wird wegen Kurzschlussauswertung nur dann ausgewertet, wenn x truthy ist. |
Rückgabewert
x steht — entweder der unveränderte falsy Wert von x (keine Zuweisung) oder der neu zugewiesene Wert y.Beispiele
Grundlegende Verwendung — truthy und falsy
let a = 1;
let b = 0;
a &&= 42; // a ist truthy → Zuweisung findet statt
b &&= 42; // b ist falsy → Zuweisung findet NICHT statt
console.log(a); // 42
console.log(b); // 0Objekt-Eigenschaft bedingt aktualisieren
const user = {
name: "Alice",
role: "editor",
};
// Rolle nur überschreiben, wenn sie bereits gesetzt (truthy) ist
user.role &&= "admin";
console.log(user.role); // "admin"
// Nicht vorhandene / falsy Eigenschaft bleibt unberührt
const guest = { name: "Bob", role: "" };
guest.role &&= "admin";
console.log(guest.role); // "" — kein ÜberschreibenKurzschlussauswertung: Seiteneffekte vermeiden
let callCount = 0;
const expensiveValue = () => {
callCount++;
return "neu";
};
let active = false;
active &&= expensiveValue(); // falsy → expensiveValue() wird NICHT aufgerufen
console.log(callCount); // 0
active = "ja";
active &&= expensiveValue(); // truthy → expensiveValue() WIRD aufgerufen
console.log(callCount); // 1
console.log(active); // "neu"Äquivalenz zur Langform
// Alle drei Varianten sind semantisch gleich:
let x = "vorhanden";
// Langform
if (x) { x = "aktualisiert"; }
// Kurzform mit &&
x = x && "nochmal";
// Moderner &&= Operator
x &&= "final";
console.log(x); // "final"// Wichtig · Fallstricke
Browser-Kompatibilität: &&= wurde mit ES2021 eingeführt und wird von allen modernen Browsern sowie Node.js ab Version 15 unterstützt. Internet Explorer unterstützt diesen Operator nicht. Für ältere Umgebungen muss ein Transpiler wie Babel verwendet werden.
Kein Setter-Aufruf bei falsy: Bei Objekt-Eigenschaften mit Getter/Setter wird der Setter nicht aufgerufen, wenn der Getter-Wert falsy ist. Das unterscheidet obj.prop &&= val von obj.prop = obj.prop && val, da letzteres den Setter immer aufruft.
Verwechslungsgefahr: Nicht verwechseln mit dem Bitweise-UND-Zuweisung-Operator (&=), der eine bitweise Operation durchführt und kein Short-Circuiting kennt.