JavaScript/Operatoren/Logische Operatoren

Aus SELFHTML-Wiki
Wechseln zu: Navigation, Suche
Mit den logischen Operatoren werden logische Verknüpfungen formuliert, z.B. für Abbruchbedingungen von Schleifen, bedingte Anweisungen bzw. Verzweigungen im Programmfluss. Beim Verknüpfen von booleschen Operanden (true/false) entsprechen die Ergebnisse denen der booleschen Algebra.
  • JavaScript 1.0
  • Chrome
  • Firefox
  • IE
  • Opera
  • Safari

JavaScript ist bei den logischen Operatoren aber nicht nur auf die booleschen Werte false und true beschränkt. Statt dessen richten sie sich nach den Werte-Eigenschaften "truthy" und "falsy" (siehe Artikel zu Boolean) und behandeln truthy-Werte wie true und falsy-Werte wie false.

Mit dem logischen Operator && verknüpfen Sie zwei oder mehrere Bedingungen durch "und", d.h. beide bzw. alle Bedingungen müssen erfüllt sein, damit die gesamte Bedingung erfüllt ist.

Mit dem logischen Operator || verknüpfen Sie zwei oder mehrere Bedingungen inklusiv durch "oder", d.h. es genügt, wenn eine der Bedingungen erfüllt ist, damit die gesamte Bedingung erfüllt ist.

Der logische Operator ! (engl. not) prüft, ob ein Ausdruck unwahr ist. Der Ausdruck if (!name) trifft zu, wenn der Wert von name falsy ist, also ein Leerstring, null, undefiniert oder 0 ist.

Beispiel
    var PLZ = 81000,
        x = 20,
        y = 8,
        name = "";

    if (PLZ >= 80000 && PLZ <= 82000)
        alert("Sie wohnen wohl in München oder Umgebung!");

    if (x > 100 || y == 0)
        return;

    if (!name)
        alert("Sie haben vergessen, einen Namen einzugeben!");

Wahrheitstabellen und Kurzschlussreaktionen[Bearbeiten]

Eine klassische boolesche Wahrheitstabelle würde in den Ergebnisspalten true oder false aufführen. Das ist in JavaScript nicht falsch, aber unvollständig, weil nur der Not-Operator wirklich true oder false liefert. && und || liefern statt dessen einen ihrer Operanden zurück. Wenn man nur wissen will, ob das Ergebnis truthy oder falsy ist, läuft das auf das Gleiche hinaus.

Darüber hinaus ist wichtig, dass JavaScript die in vielen Sprachen übliche Kurzschluss-Auswertung der booleschen Operationen nutzt. Damit ist gemeint, dass der rechte Operand nicht berechnet wird, wenn der linke Operand bereits das Ergebnis der Operation eindeutig festlegt. In der unten stehenden Tabelle kommt es immer dann zum Kurzschluss, wenn das Ergebnis der Operation A lautet.

Eingabe Ergebnis
A B A && B A || B !A
falsy falsy A B true
falsy truthy A B
truthy falsy B A false
truthy truthy B A

Die Kombination dieser beiden Eigenschaften kann man vielfältig nutzen. Das folgende Beispiel zeigt, wie man durch ihre Nutzung in einer Zeile sicherstellen kann, dass Objekte und Eigenschaften existieren, bevor man darauf zugreift, und auch noch einen Default-Wert hinzufügt. Wie es ohne truthy, falsy und Kurzschluss aussehen müsste, ist ebenfalls dargestellt.

Beispiel
   function zeigePlz(o) {
      alert("Die Postleitzahl ist " + (o && o.adresse && o.adresse.plz || "unbekannt"));
   }
   function zeigePlzUmstaendlich(o) {
      var plz = "unbekannt";
      if (o != null) {
         if (o.adresse != null) {
            if (o.adresse.plz != null) {
               if (o.adresse.plz.length > 0) {
                  plz = o.adresse.plz);
               }
            }
         }
      }
      alert("Die Postleitzahl ist " + plz);
   }

   zeigePlz(null);
   zeigePlz({ adresse: { ort: 'Berlin' } });
   zeigePlz({ adresse: { plz: '11011', ort: 'Berlin' } });

Beachten Sie, dass die Klammern um den logischen Ausdruck herum notwendig sind. Weil + eine höhere Priorität hat als &&, würde ohne Klammerung der linke Operator des ersten && ("Die Postleitzahl ist" + o) lauten, was immer truthy wäre ("X"+null ergibt "Xnull"). Den && Teil einzuklammern ist dagegen nicht nötig, weil && eine höhere Priorität hat als ||.

Beachten Sie im umständlichen Beispiel auch, dass die Abfrage mit != und nicht mit !== erfolgt. Der Grund ist, dass (null == undefined) true ergibt, (null === undefined) dagegen false. Würde der - sonst empfohlene - !== Operator genutzt, müsste man explizit auf o !== null || o !== undefined abfragen.

Der NOT-Operator[Bearbeiten]

Da der NOT-Operator immer einen booleschen Wert als Ergebnis liefert, eignet er sich auch zur expliziten Umwandlung eines beliebigen Datentyps zu einem entsprechenden booleschen Wert, indem man einfach eine doppelte Verneinung notiert:

Beispiel
 alert( !!"" );

Die Anweisung gibt false aus, weil die leere Zeichenkette "" intern false ergibt, so dass auch die doppelte NOT-Operation als Ergebnis false liefert. Die Anweisung alert(""); gibt dagegen die leere Zeichenkette selbst aus. Alternativ zum doppelten Not könnte man auch die Boolean-Funktion nutzen, um den falsy-Wert "" zu false zu konvertieren.