In JavaScript gibt es vier logische Operatoren: || (ODER), && (UND), ! (NICHT), ?? (Nullisches Zusammenwachsen). Hier behandeln wir die ersten drei, das ?? Operator finden Sie im nächsten Artikel.
Obwohl sie als „logisch“ bezeichnet werden, können sie auf Werte jeden Typs angewendet werden, nicht nur auf boolesche Werte. Auch ihr Ergebnis kann beliebiger Art sein.
Schauen wir uns die Details an.
Der „OR“-Operator wird durch zwei vertikale Liniensymbole dargestellt:
Ergebnis = ein || B;
In der klassischen Programmierung ist das logische ODER nur dazu gedacht, boolesche Werte zu manipulieren. Wenn eines seiner Argumente true ist, wird true zurückgegeben, andernfalls wird false zurückgegeben.
In JavaScript ist der Operator etwas kniffliger und leistungsfähiger. Aber schauen wir uns zunächst einmal an, was mit booleschen Werten passiert.
Es gibt vier mögliche logische Kombinationen:
alarm( true || true ); // WAHR alarm( false || true ); // WAHR alarm( true || false ); // WAHR alarm( false || false ); // FALSCH
Wie wir sehen können, ist das Ergebnis immer true , außer wenn beide Operanden false sind.
Wenn ein Operand kein boolescher Wert ist, wird er für die Auswertung in einen booleschen Wert konvertiert.
Beispielsweise wird die Zahl 1 als true behandelt, die Zahl 0 als false :
if (1 || 0) { // funktioniert genau wie if( true || false )
alarm( 'Wahrheit!' );
} Meistens ODER || wird in einer if -Anweisung verwendet, um zu testen, ob eine der angegebenen Bedingungen true ist.
Zum Beispiel:
sei Stunde = 9;
if (Stunde < 10 || Stunde > 18) {
Alert( 'Das Büro ist geschlossen.' );
}Wir können weitere Bedingungen erfüllen:
sei Stunde = 12;
let isWeekend = true;
if (Stunde < 10 || Stunde > 18 || isWeekend) {
Alert( 'Das Büro ist geschlossen.' ); // es ist Wochenende
}Die oben beschriebene Logik ist etwas klassisch. Lassen Sie uns nun die „zusätzlichen“ Funktionen von JavaScript einbinden.
Der erweiterte Algorithmus funktioniert wie folgt.
Bei mehreren ODER-verknüpften Werten:
Ergebnis = Wert1 || Wert2 || Wert3;
Das ODER || Der Operator führt Folgendes aus:
Wertet Operanden von links nach rechts aus.
Konvertiert jeden Operanden in einen booleschen Wert. Wenn das Ergebnis true ist, stoppt es und gibt den ursprünglichen Wert dieses Operanden zurück.
Wenn alle Operanden ausgewertet wurden (dh alle waren false ), wird der letzte Operand zurückgegeben.
Ein Wert wird in seiner ursprünglichen Form ohne Konvertierung zurückgegeben.
Mit anderen Worten, eine Kette von OR || gibt den ersten wahrheitsgemäßen Wert zurück oder den letzten, wenn kein wahrheitsgemäßer Wert gefunden wird.
Zum Beispiel:
alarm( 1 || 0 ); // 1 (1 ist wahr) alarm( null || 1 ); // 1 (1 ist der erste wahrheitsgemäße Wert) alarm( null || 0 || 1 ); // 1 (der erste wahrheitsgemäße Wert) alarm( undefiniert || null || 0 ); // 0 (alles falsch, gibt den letzten Wert zurück)
Dies führt zu einer interessanten Verwendung im Vergleich zu einem „reinen, klassischen, nur booleschen ODER“.
Den ersten wahren Wert aus einer Liste von Variablen oder Ausdrücken ermitteln.
Zum Beispiel haben wir die Variablen firstName , lastName und nickName , die alle optional sind (dh sie können undefiniert sein oder falsche Werte haben).
Verwenden wir OR || um denjenigen auszuwählen, der die Daten hat, und sie anzuzeigen (oder "Anonymous" wenn nichts eingestellt ist):
let firstName = ""; let lastName = ""; let nickName = "SuperCoder"; Alert( Vorname || Nachname || Spitzname || "Anonymous"); // SuperCoder
Wenn alle Variablen falsch wären, würde "Anonymous" angezeigt.
Kurzschlussauswertung.
Ein weiteres Merkmal von OR || Betreiber ist die sogenannte „Kurzschluss“-Auswertung.
Es bedeutet, dass || verarbeitet seine Argumente, bis der erste wahrheitsgemäße Wert erreicht ist, und dann wird der Wert sofort zurückgegeben, ohne das andere Argument überhaupt zu berühren.
Die Bedeutung dieser Funktion wird deutlich, wenn ein Operand nicht nur ein Wert ist, sondern ein Ausdruck mit einer Nebenwirkung, beispielsweise einer Variablenzuweisung oder einem Funktionsaufruf.
Im folgenden Beispiel wird nur die zweite Nachricht gedruckt:
wahr || Alert("nicht gedruckt");
falsch || alarm("printed"); In der ersten Zeile steht das OR || Der Operator stoppt die Auswertung sofort, wenn true angezeigt wird, sodass die alert nicht ausgeführt wird.
Manchmal verwenden Benutzer diese Funktion nur dann, um Befehle auszuführen, wenn die Bedingung im linken Teil falsch ist.
Der AND-Operator wird durch zwei kaufmännische Und-Zeichen && dargestellt:
Ergebnis = a && b;
In der klassischen Programmierung gibt AND true zurück, wenn beide Operanden wahr sind, andernfalls false :
alarm( true && true ); // WAHR alarm( false && true ); // FALSCH alarm( true && false ); // FALSCH alarm( false && false ); // FALSCH
Ein Beispiel mit if :
sei Stunde = 12;
let Minute = 30;
if (Stunde == 12 && Minute == 30) {
alarm( 'Die Zeit ist 12:30' );
}Genau wie bei OR ist jeder Wert als Operand von AND zulässig:
if (1 && 0) { // als wahr ausgewertet && falsch
alarm( "funktioniert nicht, da das Ergebnis falsch ist" );
}Bei mehreren UND-verknüpften Werten:
Ergebnis = Wert1 && Wert2 && Wert3;
Der AND && Operator bewirkt Folgendes:
Wertet Operanden von links nach rechts aus.
Konvertiert jeden Operanden in einen booleschen Wert. Wenn das Ergebnis false ist, stoppt es und gibt den ursprünglichen Wert dieses Operanden zurück.
Wenn alle Operanden ausgewertet wurden (dh alle waren wahr), wird der letzte Operand zurückgegeben.
Mit anderen Worten: AND gibt den ersten falschen Wert zurück oder den letzten Wert, wenn keiner gefunden wurde.
Die oben genannten Regeln ähneln denen von OR. Der Unterschied besteht darin, dass AND den ersten falschen Wert zurückgibt, während OR den ersten wahren Wert zurückgibt.
Beispiele:
// wenn der erste Operand wahr ist, // AND gibt den zweiten Operanden zurück: alarm( 1 && 0 ); // 0 Warnung( 1 && 5 ); // 5 // wenn der erste Operand falsch ist, // AND gibt es zurück. Der zweite Operand wird ignoriert alarm( null && 5 ); // null alarm( 0 && "egal was" ); // 0
Wir können auch mehrere Werte hintereinander übergeben. Sehen Sie, wie die erste falsche zurückgegeben wird:
alarm( 1 && 2 && null && 3 ); // null
Wenn alle Werte wahr sind, wird der letzte Wert zurückgegeben:
Warnung( 1 && 2 && 3 ); // 3, der letzte
Die Priorität von AND && ist höher als die von OR ||
Die Priorität des Operators AND && ist höher als der Operator OR || .
Also der Code a && b || c && d ist im Wesentlichen dasselbe, als ob die && Ausdrücke in Klammern stünden: (a && b) || (c && d) .
Ersetzen Sie if nicht durch || oder &&
Manchmal verwenden Leute den Operator AND && als „kürzere Schreibweise für if “.
Zum Beispiel:
sei x = 1; (x > 0) && alarm( 'Größer als Null!' );
Die Aktion im rechten Teil von && würde nur ausgeführt, wenn die Auswertung sie erreicht. Das heißt, nur wenn (x > 0) wahr ist.
Wir haben also im Grunde ein Analogon für:
sei x = 1; if (x > 0) alarm( 'Größer als Null!' );
Obwohl die Variante mit && kürzer erscheint, ist if offensichtlicher und tendenziell etwas besser lesbar. Daher empfehlen wir, jedes Konstrukt für seinen Zweck zu verwenden: Verwenden Sie if , wenn wir if möchten, und && wenn wir AND möchten.
Der boolesche NOT-Operator wird durch ein Ausrufezeichen dargestellt ! .
Die Syntax ist ziemlich einfach:
Ergebnis = !Wert;
Der Operator akzeptiert ein einzelnes Argument und führt Folgendes aus:
Konvertiert den Operanden in einen booleschen Typ: true/false .
Gibt den Umkehrwert zurück.
Zum Beispiel:
alarm( !true ); // FALSCH alarm( !0 ); // WAHR
Ein doppeltes NICHT !! wird manchmal zum Konvertieren eines Werts in einen booleschen Typ verwendet:
alarm( !!"nicht leere Zeichenfolge" ); // WAHR alarm( !!null ); // FALSCH
Das heißt, das erste NOT wandelt den Wert in einen booleschen Wert um und gibt die Umkehrung zurück, und das zweite NOT invertiert ihn erneut. Am Ende haben wir eine einfache Konvertierung von Werten in boolesche Werte.
Es gibt eine etwas ausführlichere Möglichkeit, dasselbe zu tun – eine integrierte Boolean Funktion:
alarm( Boolean("non-empty string") ); // WAHR
alarm( Boolean(null) ); // FALSCH Der Vorrang von NOT ! ist der höchste aller logischen Operatoren und wird daher immer zuerst ausgeführt, vor && oder || .
Wichtigkeit: 5
Was wird der folgende Code ausgeben?
alarm( null || 2 || undefiniert );
Die Antwort ist 2 , das ist der erste wahrheitsgemäße Wert.
alarm( null || 2 || undefiniert );
Wichtigkeit: 3
Was wird der folgende Code ausgeben?
alarm( alarm(1) || 2 || alarm(3) );
Die Antwort: erst 1 , dann 2 .
alarm( alarm(1) || 2 || alarm(3) );
Der Aufruf zur alert gibt keinen Wert zurück. Oder mit anderen Worten: Es wird undefined zurückgegeben.
Das erste OR || wertet seinen linken Operanden aus alert(1) . Das zeigt die erste Nachricht mit 1 .
Die alert gibt undefined zurück, sodass OR mit dem zweiten Operanden fortfährt und nach einem wahrheitsgetreuen Wert sucht.
Der zweite Operand 2 ist wahr, daher wird die Ausführung angehalten, 2 zurückgegeben und dann durch die äußere Warnung angezeigt.
Es wird keine 3 geben, da die Auswertung nicht alert(3) erreicht.
Wichtigkeit: 5
Was wird dieser Code zeigen?
alarm( 1 && null && 2 );
Die Antwort: null , weil es der erste falsche Wert aus der Liste ist.
alarm(1 && null && 2);
Wichtigkeit: 3
Was wird dieser Code zeigen?
Alert( Alert(1) && Alert(2) );
Die Antwort: 1 und dann undefined .
Alert( Alert(1) && Alert(2) );
Der Aufruf zur alert gibt undefined zurück (es wird nur eine Nachricht angezeigt, es gibt also keine sinnvolle Rückgabe).
Aus diesem Grund wertet && den linken Operanden aus (gibt 1 aus) und stoppt sofort, da undefined ein falscher Wert ist. Und && sucht nach einem falschen Wert und gibt ihn zurück, also ist es erledigt.
Wichtigkeit: 5
Was wird das Ergebnis sein?
alarm( null || 2 && 3 || 4 );
Die Antwort: 3 .
alarm( null || 2 && 3 || 4 );
Die Priorität von AND && ist höher als || , also wird es zuerst ausgeführt.
Das Ergebnis von 2 && 3 = 3 , also wird der Ausdruck:
null || 3 || 4
Das Ergebnis ist nun der erste Wahrheitswert: 3 .
Wichtigkeit: 3
Schreiben Sie eine if -Bedingung, um zu überprüfen, ob das age zwischen 14 und 90 liegt.
„Inklusive“ bedeutet, dass age die Grenzen von 14 oder 90 erreichen kann.
if (Alter >= 14 && Alter <= 90)
Wichtigkeit: 3
Schreiben Sie eine if -Bedingung, um zu überprüfen, ob age NICHT zwischen 14 und 90 liegt.
Erstellen Sie zwei Varianten: die erste mit NOT ! , der zweite – ohne.
Die erste Variante:
if (!(Alter >= 14 && Alter <= 90))
Die zweite Variante:
wenn (Alter < 14 || Alter > 90)
Wichtigkeit: 5
Welche dieser alert werden ausgeführt?
Was werden die Ergebnisse der Ausdrücke in if(...) sein?
if (-1 || 0) alarm( 'first' ); if (-1 && 0) alarm( 'second' ); if (null || -1 && 1) alarm( 'third' );
Die Antwort: Der erste und der dritte werden ausgeführt.
Einzelheiten:
// Läuft. // Das Ergebnis von -1 || 0 = -1, wahr if (-1 || 0) alarm( 'first' ); // Läuft nicht // -1 && 0 = 0, falsch if (-1 && 0) alarm( 'second' ); // Führt aus // Operator && hat eine höhere Priorität als || // so wird -1 && 1 zuerst ausgeführt und ergibt die Kette: // null || -1 && 1 -> null || 1 -> 1 if (null || -1 && 1) alarm( 'third' );
Wichtigkeit: 3
Schreiben Sie den Code, der nach einer Anmeldung mit prompt fragt.
Wenn der Besucher "Admin" eingibt, werden Sie zur Eingabe eines Passworts prompt . Wenn die Eingabe eine leere Zeile oder Esc ist, wird „Abgebrochen“ angezeigt. Wenn es sich um eine andere Zeichenfolge handelt, wird „Ich kenne Sie nicht“ angezeigt.
Das Passwort wird wie folgt überprüft:
Wenn es gleich „TheMaster“ ist, dann zeigen Sie „Willkommen!“ an.
Eine weitere Zeichenfolge – zeigt „Falsches Passwort“,
Für eine leere Zeichenfolge oder eine abgebrochene Eingabe wird „Abgebrochen“ angezeigt.
Das Schema:
Bitte verwenden Sie verschachtelte if Blöcke. Achten Sie auf die allgemeine Lesbarkeit des Codes.
Hinweis: Die Übergabe einer leeren Eingabe an eine Eingabeaufforderung gibt eine leere Zeichenfolge '' zurück. Wenn Sie während einer Eingabeaufforderung ESC drücken, wird null zurückgegeben.
Führen Sie die Demo aus
let userName = prompt("Wer ist da?", '');
if (userName === 'Admin') {
let pass = prompt('Passwort?', '');
if (pass === 'TheMaster') {
alarm( 'Willkommen!' );
} else if (pass === '' || pass === null) {
alarm( 'Abgebrochen' );
} anders {
alarm( 'Falsches Passwort' );
}
} else if (userName === '' || userName === null) {
alarm( 'Abgebrochen' );
} anders {
alarm( "Ich kenne dich nicht" );
} Beachten Sie die vertikalen Einzüge innerhalb der if Blöcke. Sie sind technisch nicht erforderlich, sorgen aber für eine bessere Lesbarkeit des Codes.