Правый сдвиг (>>)

Оператор правого сдвига (>>) возвращает число или BigInt, чьё двоичное представление является первым операндом, сдвинутым вправо на указанное количество битов. Избыточные биты, сдвинутые вправо, отбрасываются, а копии самого левого бита сдвигаются слева. Эта операция также называется "правый сдвиг с сохранением знака" или "арифметический правый сдвиг", потому что знак результирующего числа совпадает со знаком первого операнда.

Попробовать

const a = 5; //  00000000000000000000000000000101
const b = 2; //  00000000000000000000000000000010
const c = -5; //  11111111111111111111111111111011

console.log(a >> b); //  00000000000000000000000000000001
// Expected output: 1

console.log(c >> b); //  11111111111111111111111111111110
// Expected output: -2

Синтаксис

x >> y

Описание

Оператор >> перегружен для двух типов операндов: number и BigInt. Для чисел оператор возвращает 32-битное целое число. Для BigInts оператор возвращает BigInt. Сначала он приводит оба операнда к числовым значениям и проверяет их типы. Он выполняет правый сдвиг BigInt, если оба операнда становятся BigInts; в противном случае он преобразует оба операнда в 32-битные целые числа и выполняет правый сдвиг числа. Генерируется TypeError, если один операнд становится BigInt, а другой — числом.

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

Оператор работает с битовым представлением левого операнда в дополнительном коде. Рассмотрим 32-битные двоичные представления десятичных (основание 10) чисел 9 и -9:

     9 (base 10): 00000000000000000000000000001001 (base 2)
    -9 (base 10): 11111111111111111111111111110111 (base 2)

Двоичное представление отрицательного десятичного (основание 10) числа -9 в дополнительном коде формируется путём инвертирования всех битов противоположного числа, которое равно 9 или 00000000000000000000000000001001 в двоичном виде, и добавления 1.

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

Учитывая эти двоичные представления десятичных (основание 10) чисел 9 и -9:

9 >> 2 даёт 2:

     9 (base 10): 00000000000000000000000000001001 (base 2)
                  --------------------------------
9 >> 2 (base 10): 00000000000000000000000000000010 (base 2) = 2 (base 10)

Обратите внимание, как два самых правых бита, 01, были сдвинуты (отброшены), а две копии самого левого бита, 0, были сдвинуты слева.

-9 >> 2 даёт -3:

     -9 (base 10): 11111111111111111111111111110111 (base 2)
                   --------------------------------
-9 >> 2 (base 10): 11111111111111111111111111111101 (base 2) = -3 (base 10)

Обратите внимание, как два самых правых бита, 11, были сдвинуты (отброшены). Что касается самых левых битов: в этом случае крайний левый бит равен 1. Таким образом, две копии этого крайнего левого бита 1 были сдвинуты слева, что сохраняет отрицательный знак.

Двоичное представление 11111111111111111111111111111101 равно отрицательному десятичному (основание 10) числу -3, поскольку все отрицательные целые числа хранятся в дополнительном коде, и это значение может быть вычислено путём инвертирования всех битов двоичного представления положительного десятичного (основание 10) числа 3, которое равно 00000000000000000000000000000011, а затем добавления единицы.

Если левый операнд — число с более чем 32 битами, наиболее значимые биты будут отброшены. Например, следующее целое число с более чем 32 битами будет преобразовано в 32-битное целое число:

Before: 11100110111110100000000000000110000000000001
After:              10100000000000000110000000000001

Правый операнд будет преобразован в беззнаковое 32-битное целое число, а затем будет взят по модулю 32, так что фактическое смещение сдвига всегда будет положительным целым числом в диапазоне от 0 до 31 включительно. Например, 100 >> 32 то же самое, что и 100 >> 0 (и даёт 100), потому что 32 по модулю 32 равно 0.

Для BigInts усечения не происходит. Концептуально, считайте, что положительные BigInts имеют бесконечное число старших битов 0, а отрицательные BigInts имеют бесконечное число старших битов 1.

Примеры

Использование правого сдвига

9 >> 2; // 2
-9 >> 2; // -3

9n >> 2n; // 2n

Спецификации

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

См. также

• Побитовые операторы в руководстве JS
• Присваивание с правым сдвигом (>>=)
• Беззнаковый правый сдвиг (>>>)