Logik ist die Grundlage jedes Programms. Daher sollten Sie logische Operatoren beherrschen, um Ihren Code effizient zu strukturieren.

Mit logischen Operatoren können Sie logische Operationen an booleschen Werten durchführen. Sie ermöglichen es Ihnen, boolesche Werte zu kombinieren, zu negieren oder zu vergleichen und auf der Grundlage des Ergebnisses logische Entscheidungen in Ihrem Code zu treffen.

Entdecken Sie die verschiedenen logischen Operatoren, die JavaScript unterstützt, einschließlich des ES6-Nullish-Koaleszenzoperators.

Der logische UND-Operator (&&).

Der UND-Operator (&&) ist ein logischer Operator, der zurückgibt WAHR wenn beide Operanden zu ausgewertet werden WAHR Und FALSCH ansonsten.

Hier ist die Syntax des AND-Operators:

a && b

Hier ist ein Beispiel für den verwendeten AND-Operator:

const a = 5;
const b = 10;
const c = 15;
const result_1 = (a < b) && (b < c);
Konsole.log (Ergebnis_1); // WAHR
const result_2 = (a > b) && (b < c);
Konsole.log (Ergebnis_2); // FALSCH

In diesem Beispiel,

result_1 wertet aus WAHR weil die beiden Operanden im Ausdruck zu ausgewertet werden WAHR. Jedoch, result_2 wertet aus FALSCH weil der erste Operand (a > b) kehrt zurück FALSCH.

Wenn beide Operanden keine booleschen Werte sind, JavaScript wird versuchen, sie zu konvertieren in boolesche Werte umgewandelt, bevor der Ausdruck ausgewertet wird. Um sie in boolesche Werte umzuwandeln, wertet JavaScript zunächst aus, ob die Werte wahr oder falsch sind.

JavaScript betrachtet jeden Wert, der nicht explizit falsch ist, als einen wahren Wert. Bei der Konvertierung werden sie als boolescher Wert ausgewertet WAHR.

Bestimmte Werte und Datentypen in JavaScript sind falsch. Wenn JavaScript sie konvertiert, werden sie als boolescher Wert ausgewertet FALSCH.

Die falschen Werte in JavaScript sind:

  • FALSCH
  • Null
  • nicht definiert
  • NaN (Keine Zahl)
  • 0
  • BigInt (0n)
  • Leerer String ("" oder '' oder ``)
  • nicht definiert

Wenn Sie den AND-Operator verwenden, um nicht-boolesche Werte auszuwerten, gibt der Ausdruck sofort den Wert des ersten Operanden zurück, wenn der Operand falsch ist, ohne den zweiten auszuwerten. Dieses Verhalten wird als Kurzschluss bezeichnet und kann zum Schreiben verwendet werden Bedingte Anweisungen in JavaScript.

Wenn jedoch der erste Operand wahr ist, wertet der Ausdruck den zweiten Operanden aus. Wenn der zweite Operand wahr ist, wird er zurückgegeben.

Zum Beispiel:

const a = 5;
const b = 'Hallo';
const c = Null;
const result_1 = a && b;
Konsole.log (Ergebnis_1); // "Hallo"
const result_2 = c && b;
Konsole.log (Ergebnis_2); // Null

In diesem Beispiel, result_1 ergibt „Hallo“, da beide Operanden im Ausdruck wahr sind. Jedoch, result_2 Kurzschlüsse und Rückschläge Null ohne den zweiten Operanden auszuwerten.

Beachten Sie, dass der AND-Operator bei weiteren Operanden diese solange auswertet, bis er auf einen falschen Wert stößt. Wenn kein falscher Wert gefunden wird, wird der letzte gefundene wahre Wert zurückgegeben.

Der logische ODER-Operator (||).

Der OR-Operator (||) ist ein logischer Operator, der zurückgibt WAHR genau dann, wenn einer oder mehrere seiner Operanden vorhanden sind WAHR. Es kehrt nur zurück FALSCH wenn beide Operanden sind FALSCH.

Hier ist die Syntax des OR-Operators:

ein || B

Hier ist ein Beispiel für den verwendeten OR-Operator:

const a = 5;
const b = 10;
const c = 15;
const result_1 = (a < b) || (b < c);
Konsole.log (Ergebnis_1); // WAHR


const result_2 = (a > b) || (b < c);
Konsole.log (Ergebnis_2); // WAHR
const result_3 = (a > b) || (b > c);
Konsole.log (Ergebnis_3); // FALSCH

Im Beispiel oben: result_1 wertet aus WAHR weil beide Operanden im Ausdruck zu ausgewertet werden WAHR. result_2 wertet aus WAHR weil der zweite Operand zu ausgewertet wird WAHR. result_3 wertet aus FALSCH weil die beiden Operanden im Ausdruck zu ausgewertet werden FALSCH.

Wenn Sie den OR-Operator in nicht-booleschen Kontexten verwenden, versucht JavaScript, vor der Auswertung des Ausdrucks eine Konvertierung in boolesche Werte durchzuführen.

Wenn der Ausdruck ausgewertet wird und der erste Operand wahr ist, schließt der Operator ihn kurz und gibt ihn zurück. Wenn es jedoch falsch ist, wird mit der Auswertung des nächsten Operanden fortgefahren, bis ein wahrer Operand gefunden wird. Wenn der Ausdruck keine wahren Operanden enthält, wird der letzte falsche Wert zurückgegeben, auf den er stößt.

Zum Beispiel:

const a = 5;
const b = 'Hallo';
const c = Null;
const result_1 = a || B;
Konsole.log (Ergebnis_1); // 5


const result_2 = c || B;
Konsole.log (Ergebnis_2); // "Hallo"
const result_3 = c || " ";
Konsole.log (Ergebnis_3); // " "

Im Beispiel oben: result_1 Kurzschlüsse und Rückschläge 5 weil es ein wahrer Wert ist. result_2 gibt „Hallo“ zurück, weil es der erste wahrheitsgemäße Wert ist, den es im Ausdruck findet. result_3 gibt eine leere Zeichenfolge zurück, da es sich um den letzten falschen Wert im Ausdruck handelt.

Der logische NOT(!)-Operator

Der logische NOT-Operator (!) ist ein unärer Operator, der den entgegengesetzten booleschen Wert seines Operanden zurückgibt.

Hier ist die Syntax des NOT-Operators:

!X

Wo X ist ein boolescher Wert oder ein wahrer oder falscher Wert.

Hier ist ein Beispiel für den verwendeten NOT-Operator:

const a = 5;
const b = '';
const c = WAHR;
const result_1 = !a;
Konsole.log (Ergebnis_1); // FALSCH


const result_2 = !b;
Konsole.log (Ergebnis_2); // WAHR
const result_3 = !c;
Konsole.log (Ergebnis_3); // FALSCH

Im obigen Beispiel gibt der NOT-Operator den Umkehrwert der booleschen Operanden zurück. Wenn Sie den NOT-Operator in nicht-booleschen Kontexten verwenden (result_1 & result_2), wandelt es Wahrheitswerte in den Umkehrwert von um WAHR und wandelt die falschen Werte in den Umkehrwert von um FALSCH.

Der Nullish Coalescing (??)-Operator

Der Nullish-Koaleszenzoperator ist ein logischer Operator, der zwei Operanden auswertet und den ersten Operanden zurückgibt, wenn dies nicht der Fall ist Null oder nicht definiert. Andernfalls wird der zweite Operand zurückgegeben.

Auf den ersten Blick scheint der Null-Koaleszenzoperator mit dem logischen ODER-Operator (||) identisch zu sein, aber das ist nicht der Fall. Der Hauptunterschied besteht darin, dass der OR-Operator nicht nur dann den Operanden auf der rechten Seite zurückgibt, wenn der linke Operand „ein beliebiger“ falscher Wert ist Null oder nicht definiert.

Es bietet eine übersichtliche Möglichkeit, bei der Begegnung einen Standardwert auszuwählen Null oder nicht definiert Werte.

Hier ist die Syntax für den Nullish-Koaleszenzoperator:

X?? j

Hier ist ein Beispiel für den verwendeten Nullish-Coalescing-Operator:

const Name = Null;
const defaultName = "John Doe";
const result_1 = Name?? Standardname;
Konsole.log (Ergebnis_1); // "John Doe"


const Alter = 0;
const defaultAge = 25;
const result_2 = Alter?? defaultAge;
Konsole.log (Ergebnis_2); // 0

Im Beispiel oben: result_1 gibt „John Doe“ zurück, da der erste Operand den Wert hatte Null. result_2 kehrt zurück 0 denn obwohl es sich um einen falschen Wert handelt, ist er keiner von beiden Null noch nicht definiert.

Verwenden von logischen Operatoren in Ihrem Code

Logische Operatoren werden häufig verwendet, um bedingte Anweisungen zu schreiben, Standardwerte zuzuweisen oder boolesche Werte basierend auf Bedingungen umzuschalten.

Durch die Verwendung dieser logischen Operatoren können Sie prägnanteren und aussagekräftigeren Code schreiben, der verschiedene Szenarien basierend auf der Wahrhaftigkeit oder Falschheit von Werten behandelt.