Die vorherigen Wörter
Bit -Operatoren sind sehr zugrunde liegende Operationen und werden nicht häufig verwendet, da sie nicht intuitiv sind. Es ist jedoch extrem schnell und kann bei vernünftigem Einsatz gute Ergebnisse erzielen. In diesem Artikel wird der oft übersehene Operator in JavaScript - Bit Operator vorgestellt
Binäre Darstellung
Alle Werte in ECMascript werden im IEEE-754 64-Bit-Format gespeichert, der Bitbetreiber betreibt jedoch den 64-Bit-Wert nicht direkt, sondern wird als 32-Bit-Signierrundeger berechnet, und der Rückgabewert ist auch eine 32-Bit-Signierzahlen.
Mit dieser Bitkonvertierung können beide Werte als 0 behandelt werden, wenn Bitoperationen auf spezielle NAN- und Infinity -Werte angewendet werden
Wenn ein Bit-Operator auf einen nicht numerischen Wert angewendet wird, wird der Wert zuerst in einen numerischen Wert unter Verwendung von Number () konvertiert, und das Ergebnis ist ein numerischer Wert
// '|' bedeutet bitweise oder, eine Ganzzahl und 0 bitweise oder operation können sich selbst erhalten, und eine Dezimal- und 0 -Bitgewise oder Operation kann die Rundungseffektkonsole erhalten. 0); // 0console.log ('12px' | 0); // 0console.log ('12 '| 0); // 12Eine signierte Ganzzahl verwendet die ersten 31 der 32-Bit, um den Ganzzahlwert darzustellen, den 32-Bit, um das Ganzzahlsymbol darzustellen, 0 die positive Zahl darzustellen, und 1 repräsentiert die negative Zahl. Das Bit, das ein Symbol darstellt, wird als Zeichenbit bezeichnet, und der Wert des Vorzeichenbits bestimmt das Format anderer Bitwerte. Unter ihnen werden positive Zahlen im reinen Binärformat gespeichert, und jeder der 31 Bits repräsentiert eine Leistung von 2. Das erste Bit (Bit 0 bezeichnet) repräsentiert 0 -mal 2 Mal, das zweite Bit repräsentiert 1 Zeit von 2 und so weiter. Unbenutzte Bits sind mit 0 gefüllt, d. H. Sie werden ignoriert.
Beispielsweise ist die binäre Darstellung des numerischen Wertes 18 0000000000000000000000000010010 oder das prägnantere 10010. Dies sind 5 gültige Bits, und diese 5 Bits selbst bestimmen den tatsächlichen Wert
console.log ((18) .ToString (2)); // "10010"
Konsole.log (0B00000000000000000000000000000010010); // 18
Negative Zahlen werden auch in binär gespeichert, aber das verwendete Format ist in zweier Komplement. Um eine numerische Zwei -Komplement zu berechnen, müssen Sie die folgenden 3 Schritte durchlaufen:
【1】 Finden Sie den binären Code des Absolutwerts dieses numerischen Wertes
【2】 Binärer inverser Code finden, dh 0 durch 1 ersetzen, 1 durch 0 ersetzen
【3】 Der erhaltene binäre inverse Code wird zu 1 hinzugefügt
Um beispielsweise eine binäre Darstellung von -18 zu bestimmen, müssen Sie zunächst eine binäre Darstellung von 18 erhalten, wie unten gezeigt:
0000 0000 0000 0000 0000 0000 0001 0010
Berechnen Sie als nächstes den binären inversen Code wie folgt:
1111 1111 1111 1111 1111 1111 1111 1110 1101
Fügen Sie schließlich 1 zum binären Inverse Code hinzu, wie folgt:
1111 1111 1111 1111 1111 1111 1110 1101 1 --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Daher ist die binäre Darstellung von -18 1111 1111 1111 1111 1111 1111 1111 1110 1110
ECMascript wird sein Bestes geben, um alle diese Informationen vor uns zu verbergen. Bei der Ausgabe einer negativen Zahl in Form einer binären Zeichenfolge sehen wir nur, dass dem Binärcode mit dem Absolutwert dieser negativen Zahl ein negatives Vorzeichen vorausgeht.
var num = -18; console.log (num.toString (2)); // ' -10010' '
Der Bitoperator kann 7 Arten von Operationen ausführen, einschließlich bitweise Nicht (nicht), bitweise und (und), bitweise oder (OR), bitweise exklusive oder (xor), linke Verschiebung, signiertes Rechtsverschiebung und unsigned rechtsverschiebung.
Bitweise nicht (nicht)
Der bitweise Nichtoperator wird durch eine gewellte Linie (~) dargestellt. Das Ergebnis der Ausführung des bitweisen Nicht-Operators besteht darin, den inversen Code des Wertes zurückzugeben. Seine Essenz ist abzüglich des negativen Wertes des Operanden um 1
var num1 = 25; var num2 = ~ num1; console.log (num2); //-26
Sie können den Rundungseffekt für eine Ganzzahl doppelt bitweise erzielen. Sie können den Rundungseffekt für eine Dezimalzahl durch doppelte bitweise erhalten.
console.log (~~ 3); // 3console.log (~~ 3.1); // 3console.log (~~ 3.9); // 3
Bitweise und (und)
Der Bitweise und der Bediener werden durch ein Summensymbol (&) dargestellt, das zwei Bedienungsnummern hat. Im Wesentlichen besteht bitweise und der Betrieb, jedes Bit zweier Werte auszurichten und dann eine und den Betrieb auf zwei Zahlen an derselben Position gemäß den Regeln in der folgenden Tabelle auszuführen.
Das erste Wertbit des zweiten Wertes Bit Ergebnis 1 1 11 0 00 1 00 0 0 0 0
Bitweise und der Betrieb werden nur 1 zurückgegeben, wenn die entsprechenden Bits der beiden Werte 1 sind. Jeder Bit beträgt 0 und das Ergebnis 0.
var iResult = 25 & 3; console.log (iresult); // "1"
//Analysis is as follows 25 = 0000 0000 0000 0000 0000 0000 0001 1001 3 = 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0001
bitweise oder (oder)
Der Bitweise oder Operator wird durch ein vertikales Symbol (|) dargestellt, und es gibt auch zwei Operanden. Die Bitweise oder Operation folgt der folgenden Wahrheitstabelle
Das erste Wertbit des zweiten Wertes Bit Ergebnis 1 1 11 0 10 1 10 0 0 0
Bitgewise oder Operation gibt 1 zurück, wenn ein Bit 1 ist, und nur, wenn beide Bits 0 sind.
var iResult = 25 | 3; console.log (iresult); // "27"
// Die Analyse ist wie folgt 25 = 0000 0000 0000 0000 0000 0000 0001 1001 3 = 0000 0000 0000 0000 0000 0000 0000 0000 0001 1011
Eine Ganzzahl und 0 bitweise oder Operation kann es erhalten, und ein Dezimal- und 0 -bitweise oder Betrieb kann den Rundungseffekt erzielen
console.log (3.1 | 0); // 3console.log (3.9 | 0); // 3
Bitweise xor (xor)
Der bitweise XOR -Bediener wird durch eine Pflege (^) dargestellt und hat zwei Operanden. Das Folgende ist die Wahrheitstabelle von Bitwise xor
Das Bit des ersten Wertes Das Bit des zweiten Wertes 1 1 01 0 10 1 10 0 0 0
Gibt 0 zurück, wenn die beiden Werte von Bitwise XOR gleich sind und 1 zurückgeben, wenn dies nicht gleichzeitig ist
var iResult = 25 ^ 3; console.log (iresult); // "26"
// Die Analyse ist wie folgt 25 = 0000 0000 0000 0000 0000 0000 0001 1001 3 = 0000 0000 0000 0000 0000 0000 0000 0000 0001 1010
"Exoroor -Operation" hat eine besondere Verwendung, die in Folge drei XOR -Operationen auf zwei Zahlen A und B ausführt, aˆ = b, bˆ = a, aˆ = b und deren Werte können getauscht werden. Dies bedeutet, dass die Verwendung von "exklusivem oder Betrieb" die Werte zweier Variablen austauschen kann, ohne temporäre Variablen einzuführen
var a = 10, b = 9; a ^= b, b ^= a, a ^= b; Konsole.log (a, b); // 9,10
//Analysis is as follows a = 0000 0000 0000 0000 0000 0000 0000 0000 1010 b = 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0011 b = 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0 0 1001 --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Eine Ganzzahl mit 0 bitgewise xor kann sich selbst behalten, und eine Dezimalzahl mit 0 bitweise xor kann abgerundet werden
console.log (3.1 ^ 0); // 3console.log (3.9 ^ 0); // 3
Links bewegen
Der linke Schaltoperator wird durch zwei weniger als Zeichen (<<) dargestellt. Dieser Bediener verschiebt alle Bits des Wertes nach der angegebenen Anzahl von Bits nach links.
Wenn beispielsweise der Wert 2 (Binärcode 10) 5 Bit nach links verschoben wird, beträgt das Ergebnis 64 (1000000).
var oldValue = 2; var newValue = oldValue << 5; console.log (newValue); // 64
Wenn Sie nach links bewegt werden, wird das Zeichen des Operanden nicht beeinträchtigt. Mit anderen Worten, wenn -2 5 Bit nach links bewegt wird, beträgt das Ergebnis -64 -64
var oldValue = -2; var newValue = oldValue << 5; console.log (newValue); // -64
Die linke Verschiebung von 0 Bit kann einen Rundungseffekt erzielen
console.log (3.1 << 0); // 3console.log (3.9 << 0); // 3
Richtig signiert
Der signierte Rechtsverschiebungsoperator wird durch zwei größere als Zeichen (>>) dargestellt, die den Wert nach rechts bewegt, aber die Zeichenbits (d. H. Zeichenmarken) behält. Der signierte rechte Schichtbetrieb ist genau das Gegenteil der linken Schaltvorstellung, dh, wenn 64 nach rechts 5 Bit bewegt wird, wird das Ergebnis wieder auf 2 geändert.
var oldValue = 64; var newValue = oldValue >> 5; console.log (newValue); // 2
In ähnlicher Weise wird während des Verschiebungsprozesses auch im ursprünglichen Wert Leerstand auftreten. Diesmal erscheint die Stelle jedoch auf der linken Seite des ursprünglichen Wertes und auf der rechten Seite des Zeichenbits. Zu diesem Zeitpunkt füllt ECMascript alle leeren Räume mit dem Wert des Zeichenbits, um einen vollständigen Wert zu erhalten
Bewegen Sie sich rechts, um den Divisor -Betrieb von 2 zu simulieren
console.log (5 >> 1); // 2console.log (15 >> 1); // 7
Unsigniertes Recht
Der nicht signierte rechte Schaltoperator wird durch 3 größer als Zeichen (>>>) dargestellt, was alle 32 Bit des Werts nach rechts bewegt. Bei positiven Zahlen ist das Ergebnis einer nicht signierten rechten Verschiebung mit der signierten rechten Verschiebung dieselbe. Es ist bequem, das Schild direkt vor ihm zu bewegen. Wenn Sie die nicht signierten 64 x 5 Bit bewegen, ist das Ergebnis immer noch 2
var oldValue = 64; var newValue = oldValue >>> 5; console.log (newValue); // 2
Die negative Zahl ist jedoch unterschiedlich. Erstens füllt die nicht signierte rechte Schicht das leere Bit mit 0, anstatt das leere Bit mit dem Wert des signierten Bits wie der signierten rechten Schicht zu füllen. Daher ist das Ergebnis einer nicht signierten rechten Verschiebung zu einer positiven Zahl das gleiche wie das Ergebnis einer Titelverschiebung zu einem Titel, das Ergebnis einer negativen Zahl ist jedoch unterschiedlich. Zweitens behandelt der nicht signierte Rechtsschichtoperator den negativen Binärcode als positiven Binärcode. Da die negative Zahl in der Ergänzung des Absolutwerts der beiden dargestellt wird, ist das Ergebnis nach der nicht signierten rechten Verschiebung sehr groß.
var oldValue = -64; var newValue = oldValue >>> 5; console.log (newValue) // 134217726
Um die binäre Darstellung von -64 zu bestimmen, müssen Sie zunächst die binäre Darstellung von 64 erhalten, wie unten gezeigt:
0000 0000 0000 0000 0000 0000 0100 0000
Berechnen Sie als nächstes den binären inversen Code wie folgt:
1111 1111 1111 1111 1111 1111 1111 1011 11111
Fügen Sie schließlich 1 zum binären inversen Code hinzu, wie unten gezeigt
1111 1111 1111 1111 1111 1111 1111 1011 1111 1 ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Nachdem Sie 5 Bit nach rechts bewegt haben, wie unten gezeigt:
0000 0111 1111 1111 1111 1111 11111 11111 1110Console.Log (0B0000011111111111111111111111111111111111110); // 134217726
Gemeinsame Anwendungen
【1】 Mehrfachoperation
Verwenden Sie die linke Verschiebung (<<), um den Multiplikationsvorgang zu realisieren
console.log (2 << 1); // 4console.log (3 << 1); // 6console.log (4 << 1); // 8
【2】 Operation teilen
Verwenden Sie die signierte rechte Verschiebung (>>), um den Divisor -Betrieb von 2 zu simulieren
console.log (2 >> 1); // 1console.log (5 >> 1); // 2console.log (8 >> 1); // 4console.log (9 >> 1); // 4console.log (9 >> 1); // 4
【3】 Wert Swap
Der Effekt des Wertverteidigers kann unter Verwendung des XOR -Betriebs (^) erreicht werden
var a = 10, b = 9; a ^= b, b ^= a, a ^= b; Konsole.log (a, b); // 9,10
【4】 Fassen Sie die Dezimalzahl zusammen
Der Dezimalrundungseffekt kann erreicht werden, indem zwei bitweise Nichtbits, 0 bitweise oder, 0 bitweise oder 0 Bits links und 0 Bit rechts, eingenommen werden.
console.log (~~ 3.1); // 3console.log (3.1 | 0); // 3console.log (3.1^0); // 3console.log (3.1 << 0); // 3console.log (3.1 >> 0); // 3console.log (3.1 >> 0); // 3
【5】 Schalter
Der Bitoperator kann als Switch zum Setzen von Objekteigenschaften verwendet werden. Angenommen, ein Objekt hat vier Schalter, jeder Schalter ist eine Variable. Anschließend können Sie eine Binärzahl mit vier Bit einstellen, die jeweils einem Schalter entspricht.
var flag_a = 1; // 0001var flag_b = 2; // 0010var flag_c = 4; // 0100var flag_d = 8; // 1000
Der obige Code legt vier Schalter A, B, C und D fest, jeder Schalter hat ein binäres Bit.
Nehmen wir nun an, dass die drei ABD -Switches eingeschaltet werden müssen, wir können eine Maskenvariable erstellen
var mask = flag_a | Flag_b | Flag_d; // 0001 | 0010 | 1000 => 1011
Der obige Code führt in drei Variablen ABD "oder Operation" aus, um 1011 mit einem Maskenwert von Binary zu erhalten
// "Betrieb" stellt sicher, dass der angegebene Schalter eingeschaltet wird. Maske;
// "Association" kann alle Elemente in der aktuellen Einstellung ausschalten, die sich von den Switch -Einstellungen unterscheiden. Flags = Flags & Maske;
// "exklusiv oder operativ" kann auf (umschalten) der aktuellen Einstellung wechseln, dh der umgekehrte Wert der aktuellen Einstellung kann erstmals erhalten werden, und der ursprüngliche Wert kann durch erneutes Ausführen erhalten werden. Flags = Flags ^ Maske;
// "No Operation" kann die aktuelle Einstellung umdrehen, dh die ursprüngliche Einstellung beträgt 0, und sie wird 1 nach der Operation; Die ursprüngliche Einstellung ist 1 und wird nach der Operation = ~ Flags zu 0Flags;
Die obige umfassende Einführung in den JavaScript -Operator - Bit Operator ist der gesamte Inhalt, der vom Editor geteilt wird. Ich hoffe, es kann Ihnen eine Referenz geben und ich hoffe, Sie werden Wulin.com mehr unterstützen.