Zoeken…
Bitwise operatoren
Bitwise-operators voeren bewerkingen uit op bitwaarden van gegevens. Deze operators zetten operanden naar 32-bits gehele getallen in two's complement .
Conversie naar 32-bits gehele getallen
Nummers met meer dan 32 bits negeren hun belangrijkste bits. Het volgende gehele getal met meer dan 32 bits wordt bijvoorbeeld geconverteerd naar een 32-bits geheel getal:
Before: 10100110111110100000000010000011110001000001
After: 10100000000010000011110001000001
Twee is complementair
In normaal binair vinden we de binaire waarde door de 1 's toe te voegen op basis van hun positie als machten van 2 - Het meest rechtse bit is 2^0 tot het meest linkse bit is 2^n-1 waarbij n het aantal bits is. Gebruik bijvoorbeeld 4 bits:
// Normal Binary
// 8 4 2 1
0 1 1 0 => 0 + 4 + 2 + 0 => 6
Het formaat van twee complement betekent dat de negatieve tegenhanger van het nummer (6 versus -6) alle bits voor een geïnverteerd nummer is, plus één. De omgekeerde bits van 6 zouden zijn:
// Normal binary
0 1 1 0
// One's complement (all bits inverted)
1 0 0 1 => -8 + 0 + 0 + 1 => -7
// Two's complement (add 1 to one's complement)
1 0 1 0 => -8 + 0 + 2 + 0 => -6
Opmerking: het toevoegen van meer 1 's links van een binair getal verandert niets aan de waarde in het compliment van twee. De waarde 1010 en 1111111111010 zijn beide -6 .
Bitwise AND
De bitsgewijze bewerking a & b terug de binaire waarde met 1 waarin beide binaire operanden 1 'is op een specifieke positie, en 0 in alle andere posities. Bijvoorbeeld:
13 & 7 => 5
// 13: 0..01101
// 7: 0..00111
//-----------------
// 5: 0..00101 (0 + 0 + 4 + 0 + 1)
Voorbeeld uit de echte wereld: Number's Parity Check
In plaats van dit "meesterwerk" (helaas te vaak gezien in veel echte codedelen):
function isEven(n) {
return n % 2 == 0;
}
function isOdd(n) {
if (isEven(n)) {
return false;
} else {
return true;
}
}
U kunt de pariteit van het (gehele getal) getal op een veel effectievere en eenvoudigere manier controleren:
if(n & 1) {
console.log("ODD!");
} else {
console.log("EVEN!");
}
Bitgewijs OF
De bitsgewijze OF-bewerking a | b retourneert de binaire waarde met een 1 waarbij een van beide operanden of beide operanden 1 's op een specifieke positie hebben, en 0 wanneer beide waarden 0 op een positie hebben. Bijvoorbeeld:
13 | 7 => 15
// 13: 0..01101
// 7: 0..00111
//-----------------
// 15: 0..01111 (0 + 8 + 4 + 2 + 1)
Bitwise NIET
De bitgewijze NIET-bewerking ~a draait de bits van de gegeven waarde a . Dit betekent alle 1 's zullen worden 0 s en alle 0 's zullen worden 1 s '.
~13 => -14
// 13: 0..01101
//-----------------
//-14: 1..10010 (-16 + 0 + 0 + 2 + 0)
Bitwise XOR
De bitgewijze XOR ( exclusief of ) bewerking a ^ b plaatst een 1 alleen als de twee bits verschillend zijn. Exclusief of betekent het een of het ander, maar niet beide .
13 ^ 7 => 10
// 13: 0..01101
// 7: 0..00111
//-----------------
// 10: 0..01010 (0 + 8 + 0 + 2 + 0)
Voorbeeld uit de praktijk: het wisselen van twee gehele getallen zonder extra geheugentoewijzing
var a = 11, b = 22;
a = a ^ b;
b = a ^ b;
a = a ^ b;
console.log("a = " + a + "; b = " + b);// a is now 22 and b is now 11
Shift-operators
Bitgewijze verschuiving kan worden beschouwd als het "verplaatsen" van de bits naar links of naar rechts, en daarmee de waarde van de bewerkte gegevens wijzigen.
Linker shift
De linker shift-operator (value) << (shift amount) verplaatst de bits naar links met (shift amount) ; de nieuwe bits die van rechts binnenkomen zijn 0 's:
5 << 2 => 20
// 5: 0..000101
// 20: 0..010100 <= adds two 0's to the right
Right Shift ( teken-propagerend )
De operator voor de juiste ploeg (value) >> (shift amount) wordt ook wel de "teken-voortplantende juiste ploeg" genoemd, omdat deze het teken van de eerste operand behoudt. De operator voor de juiste shift verschuift de value de opgegeven shift amount bits naar rechts. Overtollige bits die van rechts zijn verschoven, worden verwijderd. De nieuwe bits die van links binnenkomen, zijn gebaseerd op het teken van de eerste operand. Als de meest linkse bit is 1 dan is de nieuwe stukken allemaal 1 en vise-versa 0 is.
20 >> 2 => 5
// 20: 0..010100
// 5: 0..000101 <= added two 0's from the left and chopped off 00 from the right
-5 >> 3 => -1
// -5: 1..111011
// -2: 1..111111 <= added three 1's from the left and chopped off 011 from the right
Rechts verschuiven ( nulvulling )
De zero-fill rechts verplaatsen gebruikt (value) >>> (shift amount) zullen de bits naar rechts en de nieuwe bit wordt 0 is. De 0 is verschoven van links, en overtollige bits rechts verschoven en weggegooid. Dit betekent dat het van negatieve getallen positieve cijfers kan maken.
-30 >>> 2 => 1073741816
// -30: 111..1100010
//1073741816: 001..1111000
Zero-fill rechtsverschuiving en teken-voortplantende rechtsverschuiving geven hetzelfde resultaat voor niet-negatieve getallen.