Главная | Обратная связь | Поможем написать вашу работу!

Левый сдвиг почти равен умножению на 2

Битовый сдвиг << N обычно имеет тот же эффект, что и умножение на два N раз, например:

alert(3 << 1); // 6, умножение на 2

alert(3 << 2); // 12, умножение на 2 два раза

alert(3 << 3); // 24, умножение на 2 три раза

Конечно, следует иметь в виду, что побитовые операторы работают только с 32-битными числами, поэтому верхний порог такого «умножения» ограничен:

alert(10000000000 << 1); // -1474836480, отброшен крайний-левый бит

alert(10000000000 * 2); // 20000000000, обычное умножение

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

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

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

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

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

9 (по осн.10)

= 00000000000000000000000000001001 (по осн.2)

--------------------------------

9 >> 2 (по осн.10)

= 00000000000000000000000000000010 (по осн.2)

= 2 (по осн.10)

Операция >> 2 сдвинула вправо и отбросила два правых бита 01 и добавила слева две копии первого бита 00.

Аналогично, -9 >> 2 даст -3:

-9 (по осн.10)

= 11111111111111111111111111110111 (по осн.2)

--------------------------------

-9 >> 2 (по осн.10)

= 11111111111111111111111111111101 (по осн.2) = -3 (по осн.10)

Здесь операция >> 2 сдвинула вправо и отбросила два правых бита 11 и добавила слева две копии первого бита 11., Знак числа сохранён, так как крайний-левый (знаковый) бит сохранил значение 1.

Правый сдвиг почти равен целочисленному делению на 2

Битовый сдвиг >> N обычно имеет тот же результат, что и целочисленное деление на два N раз:

alert(100 >> 1); // 50, деление на 2

alert(100 >> 2); // 25, деление на 2 два раза

alert(100 >> 3); // 12, деление на 2 три раза, целая часть от результата

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

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

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

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

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

-9 (по осн.10)

= 11111111111111111111111111110111 (по осн.2)

--------------------------------

-9 >>> 2 (по осн.10)

= 00111111111111111111111111111101 (по осн.2)

= 1073741821 (по осн.10)

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

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

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

Осторожно, приоритеты!

В JavaScript побитовые операторы ^, &, | выполняются после сравнений ==.

Например, в сравнении a == b^0 будет сначала выполнено сравнение a == b, а потом уже операция ^0, как будто стоят скобки (a == b)^0.

Обычно это не то, чего мы хотим. Чтобы гарантировать желаемый порядок, нужно ставить скобки: a == (b^0).

Маска

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

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

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

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

Например, Гость может лишь просматривать статьи сайта, а Редактор — ещё и редактировать их, и тому подобное.

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

Пользователь	Просмотр статей	Изменение статей	Просмотр товаров	Изменение товаров	Управление правами
Гость	Да	Нет	Да	Нет	Нет
Редактор	Да	Да	Да	Да	Нет
Админ	Да	Да	Да	Да	Да

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

Пользователь	Просмотр статей	Изменение статей	Просмотр товаров	Изменение товаров	Управление правами	В 10-ной системе
Гость						= 20
Редактор						= 30
Админ						= 31

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

Например, доступ гостя 10100 = 20.

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

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

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

Доступ одновременно на просмотр и изменение статей — это двоичное число с 1 на соответствующих позициях, то есть access = 11000.

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

var ACCESS_ADMIN = 1; // 00001

var ACCESS_GOODS_EDIT = 2; // 00010

var ACCESS_GOODS_VIEW = 4; // 00100

var ACCESS_ARTICLE_EDIT = 8; // 01000

var ACCESS_ARTICLE_VIEW = 16; // 10000

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

var guest = ACCESS_ARTICLE_VIEW | ACCESS_GOODS_VIEW; // 10100

var editor = guest | ACCESS_ARTICLE_EDIT | ACCESS_GOODS_EDIT; // 11110

var admin = editor | ACCESS_ADMIN; // 11111

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

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

alert(editor & ACCESS_ADMIN); // 0, доступа нет

alert(editor & ACCESS_ARTICLE_EDIT); // 8, доступ есть

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

⇐ Предыдущая 1 2 3 4 5 6 7 8910 Следующая ⇒