Побитовые операторы удобны в использовании и могут привести к быстрому ускорению кода. Узнайте, что они из себя представляют и как их использовать.

Побитовые операторы — это те, которые действуют на двоичном уровне. Они часто очень быстро выполняются и обычно действуют на два операнда.

Вы можете использовать побитовые операторы для управления двоичными числами, оптимизации кода, сжатия данных и реализации методов программирования графики или игр. Как и большинство других языков программирования, JavaScript отлично поддерживает побитовые операции.

Что такое операторы?

В большинстве языков программирования используется понятие «оператор» — символ, который указывает интерпретатору выполнить определенную математическую, реляционную или логическую операцию.

Есть много различные типы операторов JavaScript вы должны знать, от тех, которые выглядят как стандартные математические операторы, такие как «+», до операторов, которые сравнивают два значения. Побитовые операторы — это особый набор операций с двоичными числами.

instagram viewer

Побитовый оператор И (&)

Побитовое И (&) сравнивает соответствующие биты двух двоичные операнды — числа, содержащие только 0 и 1. Для каждой пары входных битов соответствующий выходной бит равен «1», если оба входных бита равны «1», или «0» в противном случае.

Вот синтаксис побитового оператора AND:

а и б

В этом примере а и б - это операнды, над которыми вы выполняете побитовую операцию.

Вот как работает побитовый оператор AND:

  1. Операция И применяется к каждой паре соответствующих битов в а и б справа налево.
  2. Если оба бита равны 1, результат равен 1. Если любой бит равен 0, результат равен 0.
  3. Результатом является новое число, где каждый бит представляет собой результат операции И над соответствующими битами числа. а и б.

Например:

позволять а = 50; // 00110010
позволять б = 100; // 01100100
позволять результат = а и б; // 00100000
консоль.log (результат); // 32

В приведенном выше примере а равно 50 в десятичном виде, что эквивалентно двоичному числу 00110010, и б равно 100 в десятичном виде, что эквивалентно двоичному числу 01100100. Оператор AND сравнивает каждую пару соответствующих битов справа налево и выдает результирующее двоичное число 00100000, что равно 32 в десятичном виде.

Побитовое ИЛИ (|) Оператор

Побитовое ИЛИ (|) сравнивает соответствующие биты двух операндов и возвращает «1», если один или оба бита равны «1», и «0», если оба бита равны «0».

Вот синтаксис побитового оператора ИЛИ:

а | б

Где а и б являются операндами операции.

Побитовый оператор ИЛИ (|) работает так же, как побитовый оператор И. Единственное отличие состоит в том, что оператор ИЛИ возвращает «1», если «любой» бит равен «1», и «0», если «оба» бита равны «0».

Например:

позволять а = 50; // 00110010
позволять б = 100; // 01100100
позволять результат = а | б; // 01110110
консоль.log (результат); // 118

В приведенном выше примере оператор побитового ИЛИ сравнивает каждую пару битов справа налево (т. е. 0 | 0 = 0, 0 | 1 = 1, 1 | 1 = 1, и так далее). В результате получается двоичное число 01110110, что равно 118 в десятичном виде.

Побитовый оператор XOR (^)

Побитовое исключающее ИЛИ (^) сравнивает соответствующие биты двух операндов и возвращает «1», если один из операндов, но не оба, равен «1», и «0», если оба операнда равны «1» или «0».

Вот синтаксис побитового оператора XOR:

а ^ б

Где а и б являются операндами операции.

Побитовый оператор XOR работает так же, как побитовые операторы OR и AND. Единственное отличие состоит в том, что он возвращает «1», если «один из операндов, но не оба», равен «1», и «0», если «оба» операнда равны «1» или «0».

Например:

позволять а = 50; // 00110010
позволять б = 100; // 01100100
позволять результат = а ^ б; // 01010110
консоль.log (результат); // 86

В приведенном выше примере оператор XOR сравнивает каждую пару битов справа налево (т. е. 0 ^ 0 = 0, 0 ^ 1 = 1, 1 ^ 1 = 0, и так далее). В результате получается двоичное число 01010110, что равно 86 в десятичном виде.

Побитовое НЕ (~) Оператор

Побитовое НЕ (~) — это унарный оператор, который работает с одним целым числом, инвертируя все его биты. Другими словами, он изменяет каждый бит «0» на «1» и каждый бит «1» на «0».

Вот синтаксис побитового оператора НЕ:

~ с

Где с является операндом.

Побитовый оператор НЕ инвертирует все биты операнда, включая биты знака.

Например:

позволять с = 10; // 00001010
позволять д = -10; // 11110110 
консоль.лог(~с); // 11110101
консоль.лог(~д); // 00001001

В приведенном выше примере оператор НЕ инвертирует все биты (т. е. 0 → 1, 1 → 0и т. д.), включая знаковые биты.

Оператор сдвига влево (<

Оператор сдвига влево сдвигает биты заданного числа влево. Оператор принимает два операнда: число для сдвига и количество битов для сдвига.

Вот синтаксис оператора сдвига влево:

а << б

Где а является операндом для оператора сдвига влево, и б число битов, на которое оператор сдвинет операнд.

Оператор сдвига влево работает, сдвигая каждый бит операнда влево на указанное число позиций и отбрасывая лишние биты, сдвинутые влево.

Например:

позволять а = 50; // 00110010
позволять б = 2;
позволять результат = а << б; // 11001000
консоль.log (результат); // 200

В приведенном выше примере оператор сдвига влево сдвинул десятичную цифру 50 двоичного числа 00110010 на два разряда. Результирующее двоичное значение равно 11001000, что равно 200 в десятичном виде.

Оператор переноса знака вправо (>>)

Сдвиг вправо с распространением знака (>>) сдвигает биты числа вправо, сохраняя знак исходного числа. Оператор принимает два операнда: число для сдвига и количество битов для сдвига.

Вот синтаксис оператора сдвига вправо с распространением знака:

а >> б

Где а является операндом для оператора сдвига вправо, и б число битов, на которое оператор сдвинет операнд.

Оператор сдвига вправо с распространением знака работает аналогично оператору сдвига влево; единственная разница в режиме работы состоит в том, что правый сдвиг сохраняет знак.

Например:

позволять а = -50; // 11001110
позволять б = 2;
позволять результат = а >> б; // 11110011
консоль.log (результат); // -13

В приведенном выше примере оператор сдвига вправо сдвинул десятичное число -50 (11001110) на два пробела вправо, в результате чего получилось десятичное число -13 (11110011).

Беззнаковый оператор сдвига вправо (>>>)

Беззнаковый сдвиг вправо (>>>) сдвигает биты числа вправо на заданное количество позиций и заполняет пустые места слева нулями. Оператор отбрасывает лишние биты, которые он сдвигает вправо.

Вот синтаксис беззнакового оператора сдвига вправо:

а >>> б

Где а является операндом для оператора сдвига вправо, и б число битов, на которое оператор сдвинет операнд.

Беззнаковый оператор сдвига вправо работает аналогично смещению вправо. Однако, в отличие от оператора сдвига вправо (>>), он не сохраняет знак числа при сдвиге. Вместо этого он обрабатывает число как целое число без знака и заполняет крайний левый бит нулем.

Например:

позволять а = -5; // 11111111 11111111 11111111 11111011
позволять б = 2;
позволять результат = а >>> б; // 00111111 11111111 11111111 11111110
консоль.log (результат); // 1073741822

В этом примере беззнаковый оператор сдвига вправо сдвинул «-5» на два пробела вправо, фактически удалив знак и получив десятичное число «1073741822».

Приложения побитовых операторов

Управляя отдельными битами в двоичных числах, побитовые операторы могут создавать сложные функции, которые в противном случае трудно или невозможно реализовать с помощью традиционных арифметических операций.

Понимание того, как использовать побитовые операторы, может помочь вам создавать более эффективные и производительные веб-приложения.