betacode

Битовые операции

Сайт бесплатного изучения языков:
Следуйте за нами на нашей фан-странице, чтобы получать уведомления каждый раз, когда появляются новые статьи. Facebook

1- Bitwise

В цифровом компьютерном программировании. Операция bitwise раотает на одном или нескольких двоичных цифрах (binary numerals), или строках похожие на двоичные цифры. Это простая и быстрая операция, которая поддерживается напрямую процессором (processor). Обычно операции bitwise намного быстрее по сравнению с умножением, делением, иногда значительно быстрее, чем сложение. Вычисления bitwise используют меньше энергии, так как он использует меньше ресурсов.
Имеется 7 оперций bitwise:
ОператорНазваниеОписание
&ANDЕсли оба bit являются 1, возвращается значение 1, если наоборот то возвращает 0.
|ORЕсли один из двух bit является 1, возвращается значение 1, если наоборот то возвращает 0.
^XORЕсли два bit отличаются, возвращается значение 1, если наоборот то возвращает 0.
~NOTИнвертирует все bit, 0 становится 1 и 1 становится 0.
<<Zero fill left shiftСмещает все  bit влево.
>>Signed right shiftСмещает все bit вправо, кроме первого bit.
>>>Zero fill right shiftСмещает все  bit влево.
Bitwise AND
Когда выполняется bitwise AND на паре bit, он возвращает 1, если оба 2 bit являются 1, если наоборот, то возвращает 0.
Пример с 1 bit:
Operation Result
0 & 0 0
0 & 1 0
1 & 0 0
1 & 1 1
Пример с 4 bit:
Operation Result
1111 & 0000 0000
1111 & 0001 0001
1111 & 0010 0010
1111 & 0100 0100
Bitwise OR:
Когда выполняется один bitwise OR на паре bit, он возвращает 1, если один из bit является 1, если наоборот то возвращает 0.
Пример с 1 bit:
Operation Result
0 | 0 0
0 | 1
1 | 0 1
1 | 1 1
Пример с 4 bit:
Operation Result
1111 | 0000 1111
1111 | 0001 1111
1111 | 0010 1111
1111 | 0100 1111
Bitwise XOR
Когда выполняется один bitwise XOR на паре bit, он возвращает 1 если все bit разные, если наоборот возвращает 0.
Пример с 1 bit:
Operation Result
0 ^ 0 0
0 ^ 1
1 ^ 0 1
1 ^ 1
Пример с 4 bit:
Operation Result
1111 ^ 0000 1111
1111 ^ 0001 1110
1111 ^ 0010 1101
1111 ^ 0100 1011
Bitwise NOT
Когда используется один Bitwise NOT он инвертирует все bit. 1 становится 0, и 0 становится 1.
Пример с 1 bit:
Operation Result
~ 0 1
~ 1 0
Пример с 4 bit:
Operation Result
~ 0000 1111
~ 0001 0001
~ 0010 1101
~ 1100 0011

2- Операция Bitwise на числах

Разные языки могут иметь несколько видов данных для представления чисел.
  • Java: byte, short, int, long, double.
  • C#: byte, sbyte, short, ushort, int, uint, long, ulong, float, double
  • Javascript: double
  • .....
Javascript хранит числа как числа с плавающей точкой 64 bit (64 bits floating point numbers). Но операции bitwise выполненные на целых числах 32 bit. Другие языки как Java, C#,.. операции bitwise так же выполняются на целых числах 32 bit.
Поэтому перед тем как выполнить операцию bitwise с числами вам нужно конвертировать каждое число в последовательность из 32 двоичных чисел.
Base 10 Base 2 32 bits
5 101 00000000000000000000000000000101
218 11011010 00000000000000000000000011011010
В Javascript метод toString(base) помогает вам поменять любое число из десятичной системы (base 10) в другую.
toString-base-example.js (Javascript)

let a = 8; 
// Base 2 string.
console.log( a.toString(2) );// 1000

// Base 8 string
console.log( a.toString(8) ); // 10

// Base 16 string
console.log( a.toString(16) ); // 8

let b = 218; 
// Base 2 string.
console.log( b.toString(2) );// 11011010

// Base 8 string
console.log( b.toString(8) ); // 332

// Base 16 string
console.log( b.toString(16) ); // da
Пример:
Decimal Binary
5 00000000000000000000000000000101
1 00000000000000000000000000000001
5 & 1 = 1 00000000000000000000000000000001
5 | 1  = 5 00000000000000000000000000000101
5 ^ 1  = 4 00000000000000000000000000000100
~ 5    = -6 11111111111111111111111111111010
Примечание: В 32 bit, первый bit используется для определения знака (sign) числа, если данный bit является 1, соответствует знаку минус ( - ), если данный bit является 0 соответствует знаку плюс ( + )
Bitwise Left Shift (<<)
Decimal Binary
5 00000000000000000000000000000101
5 << 1  = 10 00000000000000000000000000001010
5 << 2  = 20 00000000000000000000000000010100
Оператор Bitwise Left Shift ( << ) может изменить знак (sign) числа.
(Javascript code)

console.log( 1073741824 << 1); // -2147483648
console.log( 2684354560 << 1); // 1073741824
Bitwise Right Shift (>>)  [Unsigned Right Shift]
Decimal Binary
29 00000000000000000000000000011101
29 >> 1  = 14 00000000000000000000000000001110
29 >> 2  = 7 00000000000000000000000000000111
Оператор Bitwise Right Shift ( >> ) не изменяет знак числа, так как первый bit не перемещен.
Bitwise Right Shift (>>>) [Zero fill right Shift]
Оператор Bitwise Right Shift ( >>> ) может изменить знак числа.
(Javascript Code)

console.log( -1073741824 >>> 1); // 1610612736
console.log( 1073741824 >>> 1); // 536870912

3- Для чего используется Bitwise?

Вычисления bitwise поддерживаются напрямую процессором (processor) компьютера, поэтому он работает очень быстро. Ниже я перечисляю некоторые примеры использования данных вычислений.
Используйте операторы bitwise на String (characters) на языках Java, C#, C/C++ ... Примечание: некоторые языки как Javascript не поддерживает вычисления bitwise с видом String.
Конвертировать прописную букву (Uppercase) в строчную (Lowercase):

// Rule: x | ' '

('A' | ' ') ==> 'a'
('B' | ' ') ==> 'b'

('a' | ' ') => 'a'
Конвертировать строчную букву (Lowercase) в прописную (Uppercase):

// Rule: x & '_'

('a' & '_') ==> 'A'
('b' & '_') ==> 'B'
('A' & '_') ==> 'A'
Переменить прописную букву в строчную, строчную в прописную:

// Rule: x ^ ' '

('a' ^ ' ') ==> 'A'
('A' ^ ' ') ==> 'a'
Просмотреть расположение латинских букв (Latin) (Применяется только к прописным буквам)

// Rule:  x & '?'
'A' & '?'  ==> 1
'B' & '?'  ==> 2
...
'Z' & '?'  ==> 26

// Rule:  x ^ '@' 
'A' ^ '@'  ==> 1
'B' ^ '@'  ==> 2
...
'Z' ^ '@'  ==> 26
Просмотреть расположение латинских букв (Latin) (Применяется только к строчным буквам)

// Rule:  x ^ '`' 
'a' ^ '`'  ==> 1
'b' ^ '`'  ==> 2
...
'z' ^ '`'  ==> 26
// '`' : binary ( 1100000 ), hex('60'),  chr(96)
Просмотреть расположение латинских букв (Latin), применяется и к прописным и к строчным буквам:

// Rule:  x & '\u001F' 
'A' & '\u001F'  ==> 1
'B' & '\u001F'  ==> 2
...
'Z' & '\u001F'  ==> 26

'A' & '\u001F'  ==> 1
'B' & '\u001F'  ==> 2
...
'Z' & '\u001F'  ==> 26