JavaScript
Operatory bitowe

Operatory bitowe

Operatory bitowe wykonują operacje na bitowych wartościach danych. Operatory te przekształcają argumenty na 32-bitowe liczby całkowite w uzupełnieniu do dwóch .

Konwersja na 32-bitowe liczby całkowite

Liczby zawierające więcej niż 32 bity odrzucają swoje najbardziej znaczące bity. Na przykład następująca liczba całkowita z więcej niż 32 bitami jest konwertowana na 32-bitową liczbę całkowitą:

Before: 10100110111110100000000010000011110001000001
After:              10100000000010000011110001000001

Uzupełnienie dwojga

W normalnym pliku binarnym znajdujemy wartość binarną przez dodanie 1 na podstawie ich pozycji jako potęgi 2 - Bit skrajnie prawy to 2^0 a bit skrajny lewy to 2^n-1 gdzie n jest liczbą bitów. Na przykład za pomocą 4 bitów:

// Normal Binary
// 8 4 2 1
   0 1 1 0  => 0 + 4 + 2 + 0 => 6

Format dwóch uzupełnień oznacza, że ujemny odpowiednik liczby (6 vs -6) to wszystkie bity dla liczby odwróconej plus jeden. Odwrócone bity 6 byłyby następujące:

// 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

Uwaga: Dodanie kolejnych 1 na lewo od liczby binarnej nie zmienia jej wartości w komplementie dwóch. Wartości 1010 i 1111111111010 są 1111111111010 -6 .

Bitowe AND

Bitowa operacja AND a & b zwraca wartość binarną z 1 gdzie oba operandy binarne mają 1 w określonej pozycji, a 0 we wszystkich innych pozycjach. Na przykład:

13 & 7 => 5
// 13:     0..01101
//  7:     0..00111
//-----------------
//  5:     0..00101 (0 + 0 + 4 + 0 + 1)

Przykład świata rzeczywistego: kontrola parzystości liczb

Zamiast tego „arcydzieła” (niestety zbyt często spotykanego w wielu prawdziwych częściach kodu):

function isEven(n) {
    return n % 2 == 0;
}

function isOdd(n) {
    if (isEven(n)) {
        return false;
    } else {
        return true;
    }
}

Możesz sprawdzić parzystość liczby (całkowitej) w znacznie bardziej skuteczny i prosty sposób:

if(n & 1) {
    console.log("ODD!");
} else {
    console.log("EVEN!");
}

Bitowe OR

Bitowa operacja LUB a | b zwraca wartość binarną z 1 gdzie albo operandy, albo oba operandy mają 1 w określonej pozycji, a 0 gdy obie wartości mają 0 w pozycji. Na przykład:

13 | 7 => 15
// 13:     0..01101
//  7:     0..00111
//-----------------
// 15:     0..01111 (0 + 8 + 4 + 2 + 1)  

Bitowe NIE

Bitowa operacja NOT ~a odwraca bity podanej wartości a . Oznacza to cały 1 „s staną 0 ” s, a wszystkie 0 „s będzie 1 ” s.

~13 => -14
// 13:     0..01101
//-----------------
//-14:     1..10010 (-16 + 0 + 0 + 2 + 0)

Bitowy XOR

Bitowa operacja XOR ( wyłączna lub ) a ^ b umieszcza 1 tylko wtedy, gdy dwa bity są różne. Wyłączne lub oznacza jedno lub drugie, ale nie jedno i drugie .

13 ^ 7 => 10
// 13:     0..01101
//  7:     0..00111
//-----------------
// 10:     0..01010  (0 + 8 + 0 + 2 + 0)

Przykład ze świata rzeczywistego: zamiana dwóch wartości całkowitych bez dodatkowego przydziału pamięci

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

Operatorzy zmiany biegów

Przesunięcie bitowe można uznać za „przesunięcie” bitów w lewo lub w prawo, a tym samym zmianę wartości operowanych danych.

Lewy Shift

Lewy operator przesunięcia (value) << (shift amount) przesunie bity w lewo o (shift amount) bitów; nowe bity przychodzące z prawej strony będą równe 0 :

5 << 2 => 20
//  5:      0..000101
// 20:      0..010100 <= adds two 0's to the right

Prawy Shift ( propagacja znaków )

Prawy operator przesunięcia (value) >> (shift amount) jest również znany jako „Przesunięcie w prawo przesunięcia znaku”, ponieważ zachowuje znak początkowego argumentu operacji. Prawy operator przesunięcia przesuwa value określonej shift amount bitów w prawo. Nadmiar bitów przesunięty w prawo jest odrzucany. Nowe bity przychodzące od lewej będą oparte na znaku początkowego operandu. Jeżeli najbardziej z lewej strony był nieco 1 następnie nowe bity wszystkie będą 1 i vice-versa 0 „s.

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

Prawy Shift ( wypełnienie zerowe )

Operator przesunięcia w prawo z zerowym wypełnieniem (value) >>> (shift amount) przesunie bity w prawo, a nowe bity będą wynosić 0 . W 0 „y są przemieszczane z lewej strony, a nadmiar bitów w prawo są przenoszone i odrzucono. Oznacza to, że może przekształcić liczby ujemne w dodatnie.

-30 >>> 2 => 1073741816
//       -30:      111..1100010
//1073741816:      001..1111000

Przesunięcie w prawo z zerowym wypełnieniem i przesunięcie w prawo propagujące znaki dają ten sam wynik dla liczb nieujemnych.