Побитовые операторы JavaScript
- Представление 32 битного целого числа со знаком
- Побитовое И (&)
- Побитовое ИЛИ (|)
- Побитовое ИСКЛЮЧАЮЩЕЕ ИЛИ (^)
- Побитовое НЕ (~)
- Сдвиг битов влево (<<)
- Сдвиг битов вправо с сохранением знака (>>)
- Сдвиг битов вправо с заполнением нулями (>>>)
Побитовые операторы требуют в качестве операндов 32-ух разрядные целые числа, поэтому значения преобразуются из 64-разрядных чисел в 32-разрядные, затем для них выполняется нужная операция, а полученный результат преобразуется обратно в 64-разрядный формат.
Все побитовые операторы преобразуют операнды по тем же правилам, что и функция Number(). Специальные значения NaN и Infinity в поразрядных операциях интерпретируются как 0.
Представление 32 битного целого числа со знаком
В целых числах со знаком все биты, кроме 32-го, представляют само значение, тогда как 32-й бит определяет знак числа: 0 для неотрицательных чисел и 1 для отрицательных. Так как 32-й бит определяет знак числа, его называют знаковым (sign bit). Целые неотрицательные числа хранятся в настоящем двоичном формате. Например, число 18 представляется как 00000000000000000000000000010010, или, сокращённо, как 10010. Эти пять битов и являются фактическим значением числа.
Отрицательные числа также хранятся в двоичном коде, но в формате, который называется дополнительным кодом
. Дополнительный код вычисляется в три этапа:
- Определяется двоичное представление абсолютного значения числа. Например, для числа -18 сначала определяется двоичное представление числа 18 (это абсолютное значение числа -18).
- Находится обратный код числа. Это означает, что каждый нуль заменяется единицей и наоборот.
- К полученному результату прибавляется единица.
К примеру, определим двоичное представление числа -18. Начнём с двоичного представления его абсолютного значения (18):
0000 0000 0000 0000 0000 0000 0001 0010
Далее определяем обратный код:
1111 1111 1111 1111 1111 1111 1110 1101
И прибавляем единицу к обратному двоичному коду числа:
Таким образом, двоичным эквивалентом -18 является 11111111111111111111111111101110. Однако в JavaScript такое двоичное представление чисел скрыто, поэтому, при выводе отрицательного числа в двоичном представлении вы получите двоичный код его абсолютного значения со знаком минус:
var num = -18; alert(num.toString(2)); // "-10010"
Побитовое И (&)
| Оператор | Тип оператора | А | О | Типы значений |
|---|---|---|---|---|
… & … |
Побитовое И | слева направо | 2 | целое, целое → целое |
Оператор & (побитовое И) выполняет операцию И для каждой пары битов в соответствующих разрядах. Ниже приведена таблица истинности для операции И:
| Бит первого числа | Бит второго числа | Результат |
|---|---|---|
0 |
0 |
0 |
0 |
1 |
0 |
1 |
0 |
0 |
1 |
1 |
1 |
В следующем примере операция И выполняется для чисел 14 и 9:
/*
9 = 00000000000000000000000000001001
14 = 00000000000000000000000000001110
--------------------------------
14 & 9 = 00000000000000000000000000001000 = 8
*/
var result = 14 & 9;
alert(result); // 8
Побитовое ИЛИ (|)
| Оператор | Тип оператора | А | О | Типы значений |
|---|---|---|---|---|
… | … |
Побитовое ИЛИ | слева направо | 2 | целое, целое → целое |
Оператор | (побитовое ИЛИ) выполняет операцию ИЛИ для каждой пары битов в соответствующих разрядах. Ниже приведена таблица истинности для операции ИЛИ:
| Бит первого числа | Бит второго числа | Результат |
|---|---|---|
0 |
0 |
0 |
0 |
1 |
1 |
1 |
0 |
1 |
1 |
1 |
1 |
В следующем примере операция ИЛИ выполняется для чисел 14 и 9:
/*
9 = 00000000000000000000000000001001
14 = 00000000000000000000000000001110
--------------------------------
14 | 9 = 00000000000000000000000000001111 = 15
*/
var result = 14 | 9;
alert(result); // 15
Побитовое ИСКЛЮЧАЮЩЕЕ ИЛИ (^)
| Оператор | Тип оператора | А | О | Типы значений |
|---|---|---|---|---|
… ^ … |
Побитовое ИСКЛЮЧАЮЩЕЕ ИЛИ | слева направо | 2 | целое, целое → целое |
Оператор ^ (побитовое ИСКЛЮЧАЮЩЕЕ ИЛИ) выполняет операцию ИСКЛЮЧАЮЩЕЕ ИЛИ для каждой пары битов в соответствующих разрядах. Ниже приведена таблица истинности для операции ИСКЛЮЧАЮЩЕЕ ИЛИ:
| Бит первого числа | Бит второго числа | Результат |
|---|---|---|
0 |
0 |
0 |
0 |
1 |
1 |
1 |
0 |
1 |
1 |
1 |
0 |
В следующем примере операция ИСКЛЮЧАЮЩЕЕ ИЛИ выполняется для чисел 14 и 9:
/*
9 = 00000000000000000000000000001001
14 = 00000000000000000000000000001110
--------------------------------
14 ^ 9 = 00000000000000000000000000000111 = 7
*/
var result = 14 ^ 9;
alert(result); // 7
Побитовое НЕ (~)
| Оператор | Тип оператора | А | О | Типы значений |
|---|---|---|---|---|
~ … |
Побитовое НЕ (инверсия) | справа налево | 1 | целое → целое |
Оператор ~ (побитовое НЕ) выполняет операцию НЕ (инверсию) для каждого бита числа. Ниже приведена таблица истинности для операции НЕ:
| Бит числа | Результат |
|---|---|
0 |
1 |
1 |
0 |
В следующем примере операция НЕ выполняется для числа 9:
/*
9 = 00000000000000000000000000001001
--------------------------------
~9 = 11111111111111111111111111110110 = -10
*/
var num = ~9;
alert(num); // -10
Сдвиг битов влево (<<)
| Оператор | Тип оператора | А | О | Типы значений |
|---|---|---|---|---|
… << … |
Сдвиг битов влево | слева направо | 2 | целое, целое → целое |
Оператор << (сдвиг битов влево) сдвигает все биты числа влево на указанное количество разрядов. Слева от оператора указывается число, биты которого будут сдвинуты, справа от оператора указывается целое число в диапазоне от 0 до 31, которое определяет на сколько разрядов влево будут сдвинуты биты числа. При сдвиге битов влево освободившиеся разряды справа заполняются нулями.
В следующем примере сдвиг битов влево выполняется для числа 9:
/*
9 = 00000000000000000000000000001001
--------------------------------
9 << 2 = 00000000000000000000000000100100 = 36
*/
var result = 9 << 2;
alert(result); // 36
Сдвиг битов вправо с сохранением знака (>>)
| Оператор | Тип оператора | А | О | Типы значений |
|---|---|---|---|---|
… >> … |
Сдвиг битов вправо с сохранением знака | слева направо | 2 | целое, целое → целое |
Оператор >> (сдвиг битов вправо с сохранением знака) сдвигает все биты числа (кроме знакового) вправо на указанное количество разрядов. Слева от оператора указывается число, биты которого будут сдвинуты, справа от оператора указывается целое число в диапазоне от 0 до 31, которое определяет на сколько разрядов вправо будут сдвинуты биты числа. При сдвиге битов вправо в освободившиеся разряды (после знакового бита) копируется знаковый бит.
В следующем примере сдвиг битов вправо выполняется для чисел 9 и -9:
/*
9 = 00000000000000000000000000001001
--------------------------------
9 >> 2 = 00000000000000000000000000000010 = 2
-9 = 11111111111111111111111111110111
--------------------------------
-9 >> 2 = 11111111111111111111111111111101 = -3
*/
var result1 = 9 >> 2;
var result2 = -9 >> 2;
alert(result1); // 2
alert(result2); // -3
Сдвиг битов вправо с заполнением нулями (>>>)
| Оператор | Тип оператора | А | О | Типы значений |
|---|---|---|---|---|
… >>> … |
Сдвиг битов вправо с заполнением нулями | слева направо | 2 | целое, целое → целое |
Оператор >>> (сдвиг битов вправо с заполнением нулями) сдвигает все биты числа вправо на указанное количество разрядов. Слева от оператора указывается число, биты которого будут сдвинуты, справа от оператора указывается целое число в диапазоне от 0 до 31, которое определяет на сколько разрядов вправо будут сдвинуты биты числа. При сдвиге битов вправо освободившиеся разряды слева заполняются нулями.
В следующем примере сдвиг битов вправо выполняется для чисел 9 и -9:
/*
9 = 00000000000000000000000000001001
--------------------------------
9 >>> 2 = 00000000000000000000000000000010 = 2
-9 = 11111111111111111111111111110111
--------------------------------
-9 >>> 2 = 00111111111111111111111111111101 = 1073741821
*/
var result1 = 9 >>> 2;
var result2 = -9 >>> 2;
alert(result1); // 2
alert(result2); // 1 073 741 821
С этой темой смотрят: