с какими данными работают побитовые операторы javascript

Форум

Справочник

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

Описание, примеры

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

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

a

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

9 даст 36 :

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

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

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

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

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

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

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

См. также

^ всё таки работает, как логическое XOR, а не как побитовое. WebKit, FireFox.

зачем вообще нужны побитовые операторы в JavaScript? хотелось бы узнать об их практическом применении

как-бы вот для чего, например:
function toInt(number) <
return number && + number | 0 || 0;
>
функция приводит к int, либо возвращает 0, если это нельзя сделать

Гореть тебе в аду ублюдок!
Удобно ему блять

Зачем web-дизайнерам битовые операции если они кроме сайтов ничего не паяют. Я понимаю реализовывать алгоритм RSA или MD5 на С/С++ с применением SIMD.

дизайнерам не зачем, а при программировании используются например как маска для обработки изображений (так называемые фильтры) и др.
При этом битовый сдвиг работает быстрее умножения, а скорость при обработки большого объема данных в цикле не маловажна даже в таких мелочах (пару миллионов пикселей, где у каждого пикселя по 3 цвета, в цикле умнож на 4, а потом тоже самое только со здвигом на 2 разряда влево и засеки время), а сколько пользы при работе с 3д?

Сейчас js может многое с появлением и канваса, и вебгл, и ArrayBuffer (это дало возможность хоть архивы создавать в браузере или загружать с сервера и тут же их распаковывать (3д сцена в формате коллада весит несколько метров, а в архиве килобайты, так что грузить с сервера проще архив, а затем js-ом распаковать и обрабатывать), хоть напищи компилятор и компилируй исходники на си в ехе. делай все, на что фантазии хватит)

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

можно сделать аналог округления в меньшую сторону (floor):
alert(

Источник

С какими данными работают побитовые операторы javascript

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

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

Формат 32-битного целого числа со знаком [#signed-format]

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

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

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

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

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

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

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

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

a

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

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

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

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

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

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

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

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

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

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

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

Из-за внутреннего представления отрицательных чисел получается так, что

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

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

Операция сдвинула и отбросила два левых нулевых бита и добавила справа два новых нулевых.

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

Этот оператор сдвигает биты вправо, отбрасывая лишние. При этом слева добавляется копия крайнего-левого бита.

Знак числа (представленный крайним-левым битом) при этом не меняется, так как новый крайний-левый бит имеет то же значение, что и исходном числе.

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

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

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

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

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

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

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

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

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

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

У них могут быть различные роли в проекте:

Каждой роли соответствует ряд доступов к статьям и функционалу сайта.

Что-то в таком духе:

В последней колонке находится десятичное число, которое получится, если прочитать строку доступов в двоичном виде.

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

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

Ненулевой результат будет означать, что доступ есть:

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

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

Битовой маской называют как раз комбинацию двоичных значений ( check в примере выше), которая используется для проверки и выборки единиц на нужных позициях.

Маски могут быть весьма удобны.

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

Пример вызова функции с маской:

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

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

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

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

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

Как видно из последнего равенства,

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

При этом следует иметь в виду, что максимальный верхний порог такого умножения меньше, чем обычно, так как побитовый оператор манипулирует 32-битными целыми, в то время как обычные операторы работают с числами длиной 64 бита.

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

Источник

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

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

0101

Числовые значения в JavaScript хранятся как 64 битные числа с плавающей точкой. Однако все побитовые операции выполняются с 32 битными двоичными числами.

Перед выполнением побитовой операции JavaScript преобразует числовые операнды в 32 битные целые числа со знаком. После завершения побитовой операции результат преобразуется обратно в 64 битное число.

В примерах в таблице выше приведены 4-битные числа без знака. Поэтому

В действительности же JavaScript использует 32-битные числа со знаком. Таким образом, в JavaScript выражение

00000000000000000000000000000101 (5)
11111111111111111111111111111010 (

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

Побитовое И (AND)

Если побитовое И (AND) выполняется с парой бит, то 1 возвращается тогда, когда оба бита равны 1.

Пример с 1-битовыми числами:

Пример с 4-битовыми числами:

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

Если побитовое ИЛИ (OR) выполняется с парой бит, то 1 возвращается тогда, когда один из битов равен 1.

Пример с 1-битовыми числами:

Пример с 4-битовыми числами:

Побитовое ИСКЛЮЧАЮЩЕЕ ИЛИ (XOR)

Если побитовое ИСКЛЮЧАЮЩЕЕ ИЛИ (XOR) выполняется с парой бит, то 1 возвращается тогда, когда биты различны.

Пример с 1-битовыми числами:

Пример с 4-битовыми числами:

Побитовое И в JavaScript (&)

Побитовое И возвращает 1 в том случае, если оба бита равны 1:

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

Побитовое ИЛИ возвращает 1 в том случае, если хотя бы один из двух битов равен 1:

Побитовое ИСКЛЮЧАЮЩЕЕ ИЛИ в JavaScript (^)

Побитовое ИСКЛЮЧАЮЩЕЕ ИЛИ возвращает 1 в том случае, если у битов разное значение:

Побитовое ОТРИЦАНИЕ в JavaScript (

511111111111111111111111111111010 (-6)

Побитовый сдвиг влево в JavaScript ( >)

Побитовый сдвиг вправо с копированием знака (арифметический сдвиг вправо) возвращает значение целого числа со сдвигом его битов на несколько позиций вправо. Все пустые биты заполняются копией крайнего левого (т.е. знакового) бита. Копирование крайнего левого бита гарантирует, что целое число останется положительным или отрицательным:

Побитовый сдвиг вправо в JavaScript (>>>)

Побитовый сдвиг вправо возвращает целое число со сдвинутыми на несколько позиций вправо битами. Появившиеся старшие разряды заполняются нулями:

Источник

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

Эта статья нуждается в редакционном обзоре. Как вы можете помочь.

Перевод не завершен. Пожалуйста, помогите перевести эту статью с английского.

Сводка

Битовые операции обращаются со своими операндами как с 32-х разрядными последовательностями нулей и единиц, а не как с десятичными, восьмеричными или шестнадцатиричными числами. К примеру десятичное число 9 в двоичном представлении будет выглядеть как 1001. Битовые операции производят свои преобразования именно с двоичным представлением числа, но возвращают стандартные числовые значения языка JavaScript.

Следующая таблица содержит сводные данные о битовых операциях в JavaScript:

a

Представление чисел (Signed 32-bit integers)

Возьмем, к примеру, число 314. Представим его в двоичном коде:

Следующая строка представляет собой его обратный код или

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

Число 0 есть число, у которого во ввсех битовых позициях записаны нули.

Побитовые логические операции

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

& (Побитовое AND)

Производит побитовое И над каждой парой битов. Операция a AND b веренет 1 если только и a и b равны 1. Таблица истинности для этой операции выглядит так:

Побитовое AND любого числа x с нулем вернет 0.

| (Побитовое OR)

Производит побитовое ИЛИ над каждой парой битов. Операция a OR b веренет 1 если a или b равны 1. Таблица истинности для этой операции выглядит так:

Побитовое OR любого числа x c нулем вернет x.

^ (Побитовое XOR)

Производит побитовое XOR над каждой парой битов. Операция a XOR b вернет 1 если a и b различны. Таблица истинности для этой операции выглядит так:

Побитовое XOR любого числа x c нулем вернет x.

Производит операцию NOT над каждым битом. NOT a вернет побитово инвертированное значение (обратный код) операнда. Таблица истинности для этой операции выглядит так:

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

The bitwise shift operators take two operands: the first is a quantity to be shifted, and the second specifies the number of bit positions by which the first operand is to be shifted. The direction of the shift operation is controlled by the operator used.

Shift operators convert their operands to 32-bit integers in big-endian order and return a result of the same type as the left operand.

9 yields 36:

>> (Sign-propagating right shift)

This operator shifts the first operand the specified number of bits to the right. Excess bits shifted off to the right are discarded. Copies of the leftmost bit are shifted in from the left. Since the new leftmost bit has the same value as the previous leftmost bit, the sign bit (the leftmost bit) does not change. Hence the name «sign-propagating».

For example, 9 >> 2 yields 2:

>>> (Zero-fill right shift)

This operator shifts the first operand the specified number of bits to the right. Excess bits shifted off to the right are discarded. Zero bits are shifted in from the left. The sign bit becomes 0, so the result is always positive.

For non-negative numbers, zero-fill right shift and sign-propagating right shift yield the same result. For example, 9 >>> 2 yields 2, the same as 9 >> 2 :

Примеры

Example: Flags and bitmasks

The bitwise logical operators are often used to create, manipulate, and read sequences of flags, which are like binary variables. Variables could be used instead of these sequences, but binary flags take much less memory (by a factor of 32).

Suppose there are 4 flags:

These flags are represented by a sequence of bits: DCBA. When a flag is set, it has a value of 1. When a flag is cleared, it has a value of 0. Suppose a variable flags has the binary value 0101:

This value indicates:

Since bitwise operators are 32-bit, 0101 is actually 00000000000000000000000000000101, but the preceding zeroes can be neglected since they contain no meaningful information.

A bitmask is a sequence of bits that can manipulate and/or read flags. Typically, a «primitive» bitmask for each flag is defined:

New bitmasks can be created by using the bitwise logical operators on these primitive bitmasks. For example, the bitmask 1011 can be created by ORing FLAG_A, FLAG_B, and FLAG_D:

Individual flag values can be extracted by ANDing them with a bitmask, where each bit with the value of one will «extract» the corresponding flag. The bitmask masks out the non-relevant flags by ANDing with zeros (hence the term «bitmask»). For example, the bitmask 0100 can be used to see if flag C is set:

A bitmask with multiple set flags acts like an «either/or». For example, the following two are equivalent:

Flags can be set by ORing them with a bitmask, where each bit with the value one will set the corresponding flag, if that flag isn’t already set. For example, the bitmask 1010 can be used to set flags C and D:

Flags can be cleared by ANDing them with a bitmask, where each bit with the value zero will clear the corresponding flag, if it isn’t already cleared. This bitmask can be created by NOTing primitive bitmasks. For example, the bitmask 1010 can be used to clear flags A and C:

The mask could also have been created with

FLAG_C (De Morgan’s law):

Flags can be toggled by XORing them with a bitmask, where each bit with the value one will toggle the corresponding flag. For example, the bitmask 0110 can be used to toggle flags B and C:

Finally, the flags can all be flipped with the NOT operator:

Совместимость с браузерами

)(Да)(Да)(Да)(Да)(Да)Битовый AND ( & )(Да)(Да)(Да)(Да)(Да)Битовый OR ( | )(Да)(Да)(Да)(Да)(Да)Битовый XOR ( ^ )(Да)(Да)(Да)(Да)(Да)Сдвиг влево ( )(Да)(Да)(Да)(Да)(Да)Сдвиг вправо ( >> )(Да)(Да)(Да)(Да)(Да)Беззнаковый сдвиг вправо ( >>> )(Да)(Да)(Да)(Да)(Да)

)(Да)(Да)(Да)(Да)(Да)(Да)Битовый AND ( & )(Да)(Да)(Да)(Да)(Да)(Да)Битовый OR ( | )(Да)(Да)(Да)(Да)(Да)(Да)Битовый XOR ( ^ )(Да)(Да)(Да)(Да)(Да)(Да)Сдвиг влево ( )(Да)(Да)(Да)(Да)(Да)(Да)Сдвиг вправо ( >> )(Да)(Да)(Да)(Да)(Да)(Да)Беззнаковый сдвиг вправо ( >>> )(Да)(Да)(Да)(Да)(Да)(Да)

Смотрите также

Метки документа и участники

© 2005-2016 Mozilla Developer Network и отдельные соучастники.

Содержимое доступно на условиях этих лицензий.

Источник