Logisches UND (&&)

Baseline Widely available

This feature is well established and works across many devices and browser versions. It’s been available across browsers since July 2015.

Der logische UND (&&) (logische Konjunktion) Operator für eine Menge von booleschen Operanden ist true, wenn und nur wenn alle Operanden true sind. Andernfalls ist er false.

Allgemeiner gesagt gibt der Operator den Wert des ersten falsy-Operands zurück, der bei der Auswertung von links nach rechts gefunden wird, oder den Wert des letzten Operanden, wenn alle truthy sind.

Probieren Sie es aus

const a = 3;
const b = -2;

console.log(a > 0 && b > 0);
// Expected output: false

Syntax

js
x && y

Beschreibung

Das logische UND (&&) evaluiert Operanden von links nach rechts und gibt sofort den Wert des ersten falsy-Operands zurück, den es findet. Wenn alle Werte truthy sind, wird der Wert des letzten Operanden zurückgegeben.

Wenn ein Wert in true umgewandelt werden kann, wird er als truthy bezeichnet. Wenn ein Wert in false umgewandelt werden kann, wird er als falsy bezeichnet.

Beispiele für Ausdrücke, die in false umgewandelt werden können, sind:

  • false;
  • null;
  • NaN;
  • 0;
  • leere Zeichenkette ("" oder '' oder ``);
  • undefined.

Der UND-Operator bewahrt nicht-boolesche Werte und gibt sie so zurück, wie sie sind:

js
result = "" && "foo"; // result is assigned "" (empty string)
result = 2 && 0; // result is assigned 0
result = "foo" && 4; // result is assigned 4

Obwohl der &&-Operator mit nicht-booleschen Operanden verwendet werden kann, wird er dennoch als boolescher Operator betrachtet, da sein Rückgabewert immer in einen boolean primalen Datentyp umgewandelt werden kann. Um seinen Rückgabewert (oder jeden Ausdruck im Allgemeinen) explizit in den entsprechenden booleschen Wert umzuwandeln, verwenden Sie einen doppelten NOT-Operator oder den Boolean-Konstruktor.

Kurzschlussauswertung

Der logische UND-Ausdruck ist ein Kurzschluss-Operator. Da jeder Operand in einen booleschen Wert umgewandelt wird, hält der UND-Operator an und gibt den ursprünglichen Wert des falsy-Operators zurück, wenn das Ergebnis einer Umwandlung false ergibt. Es werden keine weiteren Operanden ausgewertet.

Betrachten Sie folgendes Pseudocode:

(some falsy expression) && expr

Der expr-Teil wird niemals ausgewertet, weil der erste Operand (some falsy expression) als falsy ausgewertet wird. Falls expr eine Funktion ist, wird diese Funktion niemals aufgerufen. Siehe das folgende Beispiel:

js
function A() {
  console.log("called A");
  return false;
}
function B() {
  console.log("called B");
  return true;
}

console.log(A() && B());
// Logs "called A" to the console due to the call for function A,
// && evaluates to false (function A returns false), then false is logged to the console;
// the AND operator short-circuits here and ignores function B

Operatorrangfolge

Der UND-Operator hat eine höhere Priorität als der ODER-Operator, was bedeutet, dass der &&-Operator vor dem ||-Operator ausgeführt wird (siehe Operatorrangfolge).

js
true || false && false; // true
true && (false || false); // false
(2 === 3) || (4 < 0) && (1 === 1); // false

Beispiele

Verwendung von UND

Der folgende Code zeigt Beispiele für den && (logischen UND)-Operator.

js
a1 = true && true; // t && t returns true
a2 = true && false; // t && f returns false
a3 = false && true; // f && t returns false
a4 = false && 3 === 4; // f && f returns false
a5 = "Cat" && "Dog"; // t && t returns "Dog"
a6 = false && "Cat"; // f && t returns false
a7 = "Cat" && false; // t && f returns false
a8 = "" && false; // f && f returns ""
a9 = false && ""; // f && f returns false

Umwandlungsregeln für Booleans

Umwandlung von UND in ODER

Die folgende Operation mit Booleans:

js
bCondition1 && bCondition2

ist immer gleich:

js
!(!bCondition1 || !bCondition2)

Umwandlung von ODER in UND

Die folgende Operation mit Booleans:

js
bCondition1 || bCondition2

ist immer gleich:

js
!(!bCondition1 && !bCondition2)

Entfernen von verschachtelten Klammern

Da logische Ausdrücke von links nach rechts ausgewertet werden, ist es immer möglich, Klammern aus einem komplexen Ausdruck zu entfernen, sofern bestimmte Regeln beachtet werden.

Die folgende zusammengesetzte Operation mit Booleans:

js
bCondition1 || (bCondition2 && bCondition3)

ist immer gleich:

js
bCondition1 || bCondition2 && bCondition3

Spezifikationen

Specification
ECMAScript® 2025 Language Specification
# prod-LogicalANDExpression

Browser-Kompatibilität

Report problems with this compatibility data on GitHub
desktopmobileserver
Chrome
Edge
Firefox
Opera
Safari
Chrome Android
Firefox for Android
Opera Android
Safari on iOS
Samsung Internet
WebView Android
WebView on iOS
Deno
Node.js
Logical AND (&&)

Legend

Tip: you can click/tap on a cell for more information.

Full support
Full support

Siehe auch