Logische Operatoren
Logische Operatoren vergleichen zwei bedingte Anweisungen, um zu prüfen, ob eine oder beide Bedingungen true oder false liefern
Bitweise Operatoren führen logische Operationen auf dem Bitlevel aus
Logische Operatoren
NOT
Der !-Operator gibt true zurück, wenn der Operand den Wert false aufweist.
let x = 200;
…
if (!x) // false, denn x ist definiert und initialisiert
Liest sich: Wenn x false ist …
OR – „logisches Oder“
Der ||-Operator gibt true zurück, wenn der linke oder rechte Wert oder beide true sind.
let x = 20;
let y = 200;
if (x > 10 || y < 5) // gibt true zurück, denn x > 10
Liest sich: Wenn x größer als 10 ist oder y kleiner als 5 ist …
Das gibt uns eine komfortable Methode, um Defaultwerte zu deklarieren:
myVal = v || 10;
Wenn der erste Operand false, null, undefined, "" (leere Zeichenkette) oder die Zahl 0 zurückgibt, gibt der ||-Operator den zweiten Operanden zurückgegeben, ansonsten den ersten Operanden.
AND – „logisches Und“
&& gibt true zurück, wenn sowohl der linke als auch der rechte Wert true sind.
let x = 20;
let y = 0;
if (x > 100 && y < 5) // true, denn beide Seiten liefern true
Liest sich: Wenn x größer als 100 ist und y kleiner als 5 ist …
Damit kann man schnell einen null-Check durchführen:
let myVal = p && p.name
Wenn der erste Operand false, null, undefined, "" (leere Zeichenkette) oder die Zahl 0 zurückgibt, gibt der &&-Operator den ersten Operanden zurück, ansonsten den zweiten Operanden.
Bitweise Operationen
Bitweise Operatoren führen logische Operationen und Schiebeoperationen durch. Sie operieren auf den Operanden, als wären diese eine Folge von 32 Bits, geben aber eine Dezimalzahl zurück.
Bitweise AND
Der &-Operator gibt eine 1 für jede Stelle zurück, an der die korrespondierenden Bits beider Operanden 1 ist.
let x = 2; // 0000 0010 let y = 42; // 0010 1010 let z = x & y; // 0000 0010 = 2
Bitweise OR
Der |-Operator gibt eine 1 für jede Stelle zurück, an der eines oder beide der korrespondierenden Bits der Operanden 1 sind.
let x = 2; // 0000 0010 let y = 42; // 0010 1010 let z = x | y; // 0010 1010 = 42
Bitweise XOR
Der ^-Operator gibt eine 1 zurück für jede Stelle, an der genau einer (aber nicht beide) korrespondierenden Bits der Operanden 1 sind.
let x = 2; // 0000 0010 let y = 42; // 0010 1010 let z = x ^ y; // 0010 1000 = 40
Nach links schieben
Der << -Operator schiebt die Bits des ersten Operanden nach links, und zwar um die Anzahl der Stellen, die im zweiten Operanden notiert sind. Die Stellen, die dabei auf der rechten Seite entstehen, werden mit Nullen gefüllt und alle Nullen und Einsen, die auf der linken Seite herausfallen, werden gelöscht. Das Verschieben des binären Werts nach links um n Stellen entspricht der Multiplikation mit 2n.
let x = 1024; // 0100 0000 0000
x = x<<2; // 1000 0000 0000
alert(x); // gibt 4096 aus
um nach links schieben
<p><input type="text" id="opX" size="6" /> um <input type="text" id="opS" size="2" /> nach links schieben <div id="opResult"> </div> <div><button id="shift">Schieb los</button></div>
let shift = document.getElementById('shift'); shift.onclick = function() { let x = parseInt(document.getElementById('opX').value); let s = parseInt(document.getElementById('opS').value); let y = document.getElementById('opResult'); if (isNaN(x) || isNaN(s)) { y.innerHTML = "Fehlerhafte Eingabe"; } else { y.innerHTML = x<<s; } }
Nach rechts verschieben
Der >>-Operator schiebt die Ziffern der Binärdarstellung des ersten Operanden nach rechts, und zwar um die Anzahl der Stellen, die im zweiten Operanden notiert sind und löscht dabei alle Ziffern, die nach rechts herausgeschoben werden. Das Bits der linken Seite werden kopiert, so dass das Vorzeichen der Zahl erhalten bleibt. Das Verschieben des Binärwerts um n Stellen entspricht der Division durch 2n.
let x = -1024; // 1111 1100 0000 0000 x = x>>4; // 1111 1111 1100 0000 = -64 alert(x);
Nach rechts schieben und mit Nullen auffüllen
Der >>>-Operator schiebt die Binärdarstellung des ersten Operanden nach rechts, und zwar um die Anzahl der Stellen, die im zweiten Operanden notiert sind. Bits, die dabei zur rechten Seite herausfallen, werden gelöscht und auf der linken Seite werden Nullen eingesetzt. Der >>>-Operator funktioniert also genauso wie der >>-Operator, aber negative Werte verlieren ihr Vorzeichen.
Bitweises Komplement
Der ~-Operator komplementiert die Stellen des Binärwerts – aus Null wird Eins und aus Eins wird Null.
let y = 42; // ... 0000 0010 1010 let z = ~y; // ... 1111 1101 0101 = -43