Logisches UND (&&)

Das logische UND (&&) wertet Operanden von links nach rechts aus und gibt sofort den Wert des ersten falsy Operanden 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 der Wert truthy genannt. Wenn ein Wert in false umgewandelt werden kann, wird der Wert falsy genannt.

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

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

Der UND-Operator erhält Nicht-Boolean-Werte und gibt sie unverändert zurück:

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-Boolean-Operanden verwendet werden kann, wird er trotzdem als Boolean-Operator angesehen, da sein Rückgabewert immer in eine Boolean-Primitiv umgewandelt werden kann. Um seinen Rückgabewert (oder allgemein jeden Ausdruck) explizit in den entsprechenden Boolean-Wert umzuwandeln, verwenden Sie einen doppelten NOT-Operator oder den Boolean Konstruktor.

Der logische UND-Ausdruck ist ein Kurzschluss-Operator. Jeder Operand wird in einen Boolean umgewandelt; wenn das Ergebnis einer Umwandlung false ist, stoppt der UND-Operator und gibt den ursprünglichen Wert dieses falsy Operanden zurück; er wertet keinen der verbleibenden Operanden aus.

Betrachten Sie den folgenden Pseudocode.

(some falsy expression) && expr

Der expr Teil wird niemals ausgewertet, da der erste Operand (some falsy expression) als falsy ausgewertet wird. Wenn expr eine Funktion ist, wird die Funktion nie aufgerufen. Siehe das folgende Beispiel:

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

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 Operator-Vorrang).

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

Der folgende Code zeigt Beispiele des && (logisches UND) Operators.

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

Umwandlung von UND in ODER

Die folgende Operation, die Booleans beinhaltet:

bCondition1 && bCondition2

ist immer gleich:

!(!bCondition1 || !bCondition2)

Umwandlung von ODER in UND

Die folgende Operation, die Booleans beinhaltet:

bCondition1 || bCondition2

ist immer gleich:

!(!bCondition1 && !bCondition2)

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 befolgt werden.

Die folgende zusammengesetzte Operation, die Booleans beinhaltet:

bCondition1 || (bCondition2 && bCondition3)

ist immer gleich:

bCondition1 || bCondition2 && bCondition3

• Boolean
• Truthy
• Falsy