JavaScript
Побитовые операторы

Побитовые операторы

Побитовые операторы выполняют операции с битовыми значениями данных. Эти операторы преобразуют операнды в подписанные 32-битные целые числа в двух дополнениях .

Преобразование в 32-битные целые числа

Номера с более чем 32 битами отбрасывают их наиболее значимые биты. Например, следующее целое число с более чем 32 битами преобразуется в 32-разрядное целое число:

Before: 10100110111110100000000010000011110001000001
After:              10100000000010000011110001000001

Два дополнения

В нормальном двоичном выражении мы находим двоичное значение, добавляя 1 на основании их положения как мощности 2. Самый правый бит равен 2^0 а самый левый бит равен 2^n-1 где n - количество бит. Например, используя 4 бита:

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

Формат двух дополнений означает, что отрицательный аналог числа (6 против -6) - это все биты для инвертированного числа, плюс один. Перевернутыми битами 6 будут:

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

Примечание. Добавление большего количества 1 влево от двоичного числа не изменяет его значение в двух комплиментах. Значения 1010 и 1111111111010 равны -6 .

Побитовое И

Побитовое И операция a & b возвращает двоичное значение с 1 где оба двоичных операнда имеют 1 в определенной позиции и 0 во всех других положениях. Например:

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

Пример реального мира: проверка четности числа

Вместо этого «шедевра» (к сожалению, слишком часто наблюдается во многих реальных частях кода):

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

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

Вы можете проверить четность (целое число) гораздо более эффективным и простым способом:

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

Побитовое ИЛИ

Побитовая операция OR a | b возвращает двоичное значение с 1 где либо операнды, либо оба операнда имеют 1 в определенной позиции, а 0 когда оба значения имеют 0 в позиции. Например:

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

Побитовое НЕ

Побитовая операция NOT ~a переворачивает биты заданного значения a . Это означает, что все 1 будут становиться 0 , а все 0 будут 1 .

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

Побитовое XOR

Побитовая операция XOR ( исключая или ) a ^ b помещает 1 только если эти два бита отличаются друг от друга. Эксклюзив или означает либо тот, либо другой, но не тот и другой .

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

Пример реального мира: замена двух целых значений без дополнительного выделения памяти

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

Операторы сдвига

Побитовое смещение можно рассматривать как «перемещение» бит как влево, так и вправо и, следовательно, изменение значения данных.

Сдвиг влево

Оператор сдвига влево (value) << (shift amount) сдвинет биты влево на биты (shift amount) ; новые биты, входящие справа, будут 0 :

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

Правый сдвиг ( распространение сигнала )

Оператор правого сдвига (value) >> (shift amount) также известен как «сдвигающий знак сдвиг справа», потому что он сохраняет знак начального операнда. Оператор правого сдвига сдвигает value указанного value shift amount бит вправо. Избыточные биты, сдвинутые с правой стороны, отбрасываются. Новые биты, поступающие слева, будут основываться на знаке исходного операнда. Если самый левый бит равен 1 то новые биты будут равны 1 а наоборот - 0 .

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

Правый сдвиг ( нулевое заполнение )

Оператор сдвига нулевой заливки (value) >>> (shift amount) переместит биты вправо, а новые биты будут равны 0 . 0 сдвинуты слева, а лишние биты вправо сдвигаются и отбрасываются. Это означает, что он может сделать отрицательные числа положительными.

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

Правый сдвиг нулевой заливки и сдвиг знака сдвига дают тот же результат для не отрицательных чисел.