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

побитовые операторы интерпретируют операнды как последовательность из 32 битов (нулей и единиц). Они производят операции, используя двоичное представление числа, и возвращают новую последовательность из 32 бит (число) в качестве результата.

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

Формат 32-битного целого числа со знаком

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

Это представление называется «32-битное целое со знаком, старшим битом слева и дополнением до двойки».

Разберем, как устроены числа внутри подробнее, это необходимо знать для битовых операций с ними.

• Что такое двоичная система счисления, вам, надеюсь, уже известно. При разборе побитовых операций мы будем обсуждать именно двоичное представление чисел, из 32 бит.
• Старший бит слева — это научное название для самого обычного порядка записи цифр (от большего разряда к меньшему). При этом, если больший разряд отсутствует, то соответствующий бит равен нулю.

  Примеры представления чисел в двоичной системе:

   

  1	a = 0;  // 00000000000000000000000000000000

  2	a = 1;  // 00000000000000000000000000000001

  3	a = 2;  // 00000000000000000000000000000010

  4	a = 3;  // 00000000000000000000000000000011

  5	a = 255;// 00000000000000000000000011111111

   

  Обратите внимание, каждое число состоит ровно из 32-битов.

   

  Младший бит слева

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

  Именно поэтому спецификация EcmaScript явно говорит «старший бит слева».

   

• Дополнение до двойки — это название способа поддержки отрицательных чисел.

  Двоичный вид числа, обратного данному (например, 5 и -5) получается путем обращения всех битов с прибавлением 1.

  То есть, нули заменяются на единицы, единицы — на нули и к числу прибавляется 1. Получается внутреннее представление того же числа, но со знаком минус.

  Например, вот число 314:

  00000000000000000000000100111010

   

  Чтобы получить -314, первый шаг — обратить биты числа: заменить 0 на 1, а 1 на 0:

  11111111111111111111111011000101

   

  Второй шаг — к полученному двоичному числу приплюсовать единицу, обычным двоичным сложением: 11111111111111111111111011000101 + 1 = 11111111111111111111111011000110.

  Итак, мы получили:

   

  -314 = 11111111111111111111111011000110

   

  Принцип дополнения до двойки делит все двоичные представления на два множества: если крайний-левый бит равен 0 — число положительное, если 1 — число отрицательное. Поэтому этот бит называется знаковым битом.

Список операторов

В следующей таблице перечислены все побитовые операторы.
Далее операторы разобраны более подробно.

Описание работы операторов

Побитовые операторы работают следующим образом:

1. Операнды преобразуются в 32-битные целые числа, представленные последовательностью битов. Дробная часть, если она есть, отбрасывается.
2. Для бинарных операторов — каждый бит в первом операнде рассматривается вместе с соответствующим битом второго операнда: первый бит с первым, второй со вторым и т.п. Оператор применяется к каждой паре бит, давая соответствующий бит результата.
3. Получившаяся в результате последовательность бит интерпретируется как обычное число.

Посмотрим, как работают операторы, на примерах.

& (побитовое И)

Выполняет операцию И над каждой парой бит.

Результат a & b равен единице только когда оба бита a и b равны единице.

Таблица истинности для &:

Пример:

| (Побитовое ИЛИ)

Выполняет операцию ИЛИ над каждой парой бит. Результат a | b равен 1, если хотя бы один бит изa,b равен 1.

Таблица истинности для |:

Пример:

^ (Исключающее ИЛИ)

Выполняет операцию «Исключающее ИЛИ» над каждой парой бит.

a Исключающее ИЛИ b равно 1, если только a=1 или только b=1, но не оба одновременно a=b=1.

Таблица истинности для исключающего ИЛИ:

Как видно, оно дает 1, если ЛИБО слева 1, ЛИБО справа 1, но не одновременно. Поэтому его и называют «исключающее ИЛИ».

Пример:

~ (Побитовое НЕ)

Производит операцию НЕ над каждым битом, заменяя его на обратный ему.

Таблица истинности для НЕ:

Пример:

Из-за внутреннего представления отрицательных чисел получается так, что ~n == -(n+1).

Например:

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

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

Направление сдвига — то же, что и направление стрелок в операторе.

<< (Левый сдвиг)

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

Например, 9 << 2 даст 36:

>> (Правый сдвиг, переносящий знак)

Этот оператор сдвигает биты вправо, отбрасывая лишние. Копии крайнего-левого бита добавляются слева. Так как итоговый крайний-левый бит имеет то же значение, что и исходный, знак числа (представленный крайним-левым битом) не изменяется.

Поэтому он назван «переносящим знак».

Например, 9 >> 2 даст 2:

Аналогично, -9 >> 2 даст -3, так как знак сохранен:

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

Этот оператор сдвигает биты первого операнда вправо. Лишние биты справа отбрасываются. Слева добавляются нулевые биты.

Знаковый бит становится равным 0, поэтому результат всегда положителен.
Для неотрицательных чисел правый сдвиг с заполнением нулями и правый сдвиг с переносом знака дадут одинаковый результат, т.к в обоих случаях слева добавятся нули.

Для отрицательных чисел — результат работы разный. Например, -9 >>> 2 даст 1073741821, в отличие от -9 >> 2 (дает -3):

Применение побитовых операторов

Побитовые операторы используются редко, но все же используются.

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

Маска

Для этого примера представим, что наш скрипт работает с пользователями:

• Гость
• Редактор
• Админ

У каждого из них есть ряд доступов, которые можно свести в таблицу:

Если вместо «Да» поставить 1, а вместо «Нет» — 0, то каждый набор доступов описывается числом:

Мы «упаковали» много информации в одно число. Это экономит память. Но, кроме этого, по нему очень легко проверить, имеет ли посетитель заданную комбинацию доступов.

Для этого посмотрим, как в 2-ной системе представляется каждый доступ в отдельности.

• Доступ, соответствующий только общему администрированию: 00001 (=1) (все нули кроме 1 на позиции, соответствующей этому доступу).
• Доступ, соответствующий только изменению товаров: 00010 (=2).
• Доступ, соответствующий только просмотру товаров: 00100 (=4).
• Доступ, соответствующий только изменению статей: 01000 (=8).
• Доступ, соответствующий только просмотру статей: 10000 (=16).

Например, просматривать и изменять статьи позволит доступ access = 11000.

Как правило, доступы задаются в виде констант:

Из этих констант получить нужную комбинацию доступов можно при помощи операции |.

Двоичные числа в JavaScript

Для удобной работы с примерами в этой статье пригодятся две функции.

• parseInt("11000", 2) — переводит строку с двоичной записью числа в число.
• n.toString(2) — получает для числа n запись в 2-ной системе в виде строки.

Например:

Проверка доступов

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

Создадим для примера ряд доступов и проверим их:

А теперь та же проверка для посетителя с другими правами:

Такая проверка работает, потому что оператор И ставит 1 на те позиции результата, на которых в обоих операндах стоит 1.

Так что access & 1 для любого числа access поставит все биты в ноль, кроме самого правого. А самый правый станет 1 только если он равен 1 в access.

Для полноты картины также проверим, дает ли доступ 11111 право на изменение товаров. Для этого нужно применить к доступу оператор И (&) с 00010 (=2 в 10-ной системе).**

Можно проверить один из нескольких доступов.

Например, проверим, есть ли права на просмотр ИЛИ изменение товаров. Соответствующие права задаются битом 1 на втором и третьем месте с конца, что дает число 00110 (=6 в 10-ной системе).

Как видно из примера выше, если в аргументе check стоит ИЛИ из нескольких доступов ACCESS_*, то и результат проверки скажет, есть ли хотя бы один из них. А какой — нужно смотреть отдельной проверкой, если это важно.

Итак, маска дает возможность удобно «паковать» много битовых значений в одно число при помощи ИЛИ |, а также, при помощи оператора И (&), проверять маску на комбинацию установленных битов.

Маски в функциях

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

Например:

Округление

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

Например, двойное НЕ (~):

Подойдет и Исключающее ИЛИ (^) с нулем:

Последнее даже более удобно, поскольку отлично читается:

У побитовых операторов достаточно низкий приоритет, он меньше чем у остальной арифметики:

Проверка на -1

Внутренний формат чисел устроен так, что для смены знака нужно все биты заменить на противоположные («обратить») и прибавить 1.

Обращение битов — это побитовое НЕ (~). То есть, при таком формате представления числа-n = ~n + 1. Или, если перенести единицу: ~n = -(n+1).

Как видно из последнего равенства, ~n == 0 только если n == -1. Поэтому можно легко проверить равенство n == -1:

Проверка на -1 пригождается, например, при поиске символа в строке. Вызовstr.indexOf("подстрока") возвращает позицию подстроки в str, или -1 если не нашел.

Умножение и деление на степени 2

Оператор a << b, сдвигая биты, по сути умножает a на 2b.

Например:

Оператор a >> b, сдвигая биты, производит целочисленное деление a на 2b.

Итого

• Бинарные побитовые операторы: & | ^ << >> >>>.
• Унарный побитовый оператор один: ~.

Как правило, битовое представление числа используется для:

• Упаковки нескольких битововых значений («флагов») в одно значение. Это экономит память и позволяет проверять наличие комбинации флагов одним оператором &. Кроме того, такое упакованное значение будет для функции всего одним параметром, это тоже удобно.
• Округления числа: (12.34^0) = 12.
• Проверки на равенство -1: if (~n) { n не -1 }.