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

AMP версия сайта
Мобильная версия

Сайт для компьютера
http://www.mat.net.ua

Битовые операторы в JavaScript | Различные операторы побитового в JavaScript

Введение в побитовые операторы в JavaScript

Битовые операторы в JavaScript действуют на своих операндов, оперируя ими в форме представления их двоичных чисел (база 2) (в частности, в форме 32-битных чисел), а не в виде их десятичного числа (база 10), восьмеричных чисел (база 8) или шестнадцатеричное число (Base 16). Например, 1010 — это двоичное представление десятичного числа десять. Побитовые операции в JavaScript выполняются над операндами операторов в их двоичных представлениях, но выходные данные всегда возвращаются в стандартной форме числовых значений.

Побитовый оператор в JavaScript преобразует их операнды в форму дополнения 2 их формы 32-разрядного целого числа со знаком. Следовательно, всякий раз, когда оператор обрабатывается над целым числом, производное значение является формой дополнения к этому целому числу. 2-е дополнение к целому числу — это 1-е дополнение к числу (т. Е. По битам, а не к числу) плюс 1.

Например, ниже приведено 32-битное представление числа 7

00000000000000000000000000000111

Ниже 1 ‘дополнение т.е. ~ 7

11111111111111111111111111111000

Ниже приведена форма дополнения 2, которая равна -7

11111111111111111111111111111001

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

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

1. Побитовое И

Это двоичный оператор, обозначаемый символом амперсанда «&», который выполняет операцию И над последовательной парой соответствующих битов своих аргументов. Оператор «&» вернет 1, только если оба бита 1 будут другими, он вернет 0. Поэтому мы также можем соотнести операцию И с умножением, потому что оба дадут одинаковый ответ.

пример

10 (основание 10) = 00000000000000000000000000001010
13 (база 10) = 00000000000000000000000000001101

—————————-

10 и 13 00000000000000000000000000001000 = 8 (основание 10)

2. Побитовое ИЛИ

Это двоичный оператор, обозначаемый символом вертикальной черты «|», который выполняет операцию ИЛИ на последовательной паре соответствующих битов своих аргументов. Оператор «|» вернет 1, если один из битов равен 1, или оба равны 1, иначе он вернет 0. Битовое ИЛИ «|» отличается от логического ИЛИ «||», так как работает бит за битом. 13 00000000000000000000000000000111 = 7 (основание 10)

4. Побитовое НЕ

Это унарный оператор, обозначаемый символом тильды «~», который выполняет операцию NOT над соответствующими битами своего аргумента. Оператор «~» инвертирует биты операнда, т. Е. Преобразует 0 в 1 или 1 в 0.

пример

10 (основание 10) = 00000000000000000000000000001010

—————————-

~ 10 11111111111111111111111111110101

Битовые операторы сдвига в JavaScript

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

1. Битовый сдвиг влево

Это бинарный оператор, обозначаемый символом «<<». Этот оператор сместит крайние правые биты первого аргумента влево на значение времен второго аргумента. Биты, сдвинутые справа, заменяются на 0 в самой правой части для каждой выполненной операции сдвига.

Пример: 8 << 3 дает 64

8 (основание 10) = 00000000000000000000000000001000

—————————-

8 << 3 00000000000000000000000001000000 = 64 (основание 10)

2. Битовый сдвиг вправо

Это бинарный оператор, обозначаемый символом «>>>». Этот оператор сместит крайние правые биты первого аргумента вправо на значение второго аргумента. Биты, сдвинутые слева, заменяются на 0 в самой левой части для каждой выполненной операции сдвига.

Пример: 8 >>> 3 дает 1

8 (основание 10) = 00000000000000000000000000001000

—————————-

8 >>> 3 00000000000000000000000000000001 = 1 (основание 10)

-8 (база 10) = 11111111111111111111111111111000

—————————-

-8 >>> 3 00011111111111111111111111111111 = 536870911 (база 10)

3. Битовый знак, распространяющийся вправо

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

Пример: 8 >>> 3 дает 1

8 (основание 10) = 00000000000000000000000000001000

—————————-

8 >> 3 00000000000000000000000000000001 = 1 (основание 10)

-8 (база 10) = 11111111111111111111111111111000

—————————-

-8 >> 3 11111111111111111111111111111111 = -1 (база 10)

Вывод

Аргументы преобразуются в 32-битные двоичные числа и выражаются в форме битов (т. Е. 0 и 1). Числа в аргументах, приводящих к более чем 32 битам, отбрасывают их старшие биты. То же правило применяется, когда во время операции сдвига, если сдвиг битов влево, дополнительные биты в msb отбрасываются, а во время сдвига вправо отбрасывается дополнительный бит, растущий в самой правой части.

До: 110011010100011101001000100000001110010010001

—————————-

После: 11101001000100000001110010010001

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

Оператор применяется в каждом бите (для двоичного оператора это должна быть пара битов), поэтому в JavaScript он называется побитовым оператором.

Практическое применение побитового оператора — битовые флаги, связь через сокет / порты, сжатие, шифрование, конечные автоматы, графика и т. Д.

Рекомендуемые статьи

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

1. Компиляторы JavaScript
2. Обратный в JavaScript
3. Для цикла в JavaScript
4. Введение в JavaScript

JavaScript | Двоичные побитовые операторы

Двоичные/Бинарные/Binary — это операции, которые принимают 2 числовых элемента на вход и выдают один на выходе., BitwiseANDExpression).

BitwiseORExpression : BitwiseORExpression | BitwiseXORExpression

1. Вернуть ? EvaluateStringOrNumericBinaryExpression(BitwiseORExpression, |, BitwiseXORExpression).

Информационные ссылки

Стандарт ECMAScript — Раздел «13.12 Binary Bitwise Operators» — https://tc39.es/ecma262/#sec-binary-bitwise-operators

Поделись записью

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

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

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

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

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

a = 0;  // 00000000000000000000000000000000
a = 1;  // 00000000000000000000000000000001
a = 2;  // 00000000000000000000000000000010
a = 3;  // 00000000000000000000000000000011
a = 255;// 00000000000000000000000011111111

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

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

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

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

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

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

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

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

-314 = 11111111111111111111111011000110

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

Дополнительно:

Синтаксис распространения (…) — JavaScript

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

Исходный код этого интерактивного примера хранится в репозитории GitHub.Если вы хотите внести свой вклад в проект интерактивных примеров, клонируйте https://github.com/mdn/interactive-examples и отправьте нам запрос на перенос.

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

В приведенном выше примере определенная функция принимает значения x , y и
z в качестве аргументов и возвращает сумму этих значений. Значение массива также
определенный.

Когда мы вызываем функцию, мы передаем ей все значения в массиве, используя спред
синтаксис и имя массива — ... номера .

Если в массиве более трех чисел, например [1, 2, 3, 4] , тогда это
все равно будет работать нормально, за исключением того, что все четыре будут пройдены, но только первые три
будет использоваться, если вы не добавите в функцию дополнительные аргументы, например:

  function sum (x, y, z, n) {
  вернуть x + y + z + n;
}  

Приведенный выше пример довольно жесткий; реальная ценность синтаксиса распространения в том, что он работает
с одинаковым значением, независимо от того, сколько элементов содержится в объекте, массиве,
и т.п.

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

  пусть numberStore = [0, 1, 2];
let newNumber = 12;
numberStore = [... numberStore, newNumber];  

В приведенном выше примере вы можете повторно запускать последнюю строку столько раз, сколько захотите, чтобы сохранить
добавление дополнительных 12 в конец массива.

Для вызовов функций:

  myFunction (...iterableObj);
  

Для литералов массива или строк:

  [... iterableObj, '4', 'пять', 6];  

Для объектных литералов (новое в ECMAScript 2018):

  пусть objClone = {... obj};  

Синтаксис остального выглядит точно так же, как синтаксис распространения. В некотором смысле синтаксис rest противоположен
синтаксис распространения. Синтаксис Spread «расширяет» массив на его элементы, в то время как синтаксис остального
собирает несколько элементов и «уплотняет» их в один элемент.Видеть
остальные параметры.

Разброс в вызовах функций

Заменить apply ()

Обычно используется Function.prototype.apply () в тех случаях, когда вы хотите
использовать элементы массива в качестве аргументов функции.

  function myFunction (x, y, z) {}
пусть args = [0, 1, 2];
myFunction.apply (нуль, аргументы);  

С синтаксисом распространения приведенное выше можно записать как:

  function myFunction (x, y, z) {}
пусть args = [0, 1, 2];
myFunction (...args);  

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

  function myFunction (v, w, x, y, z) {}
пусть args = [0, 1];
myFunction (-1, ... аргументы, 2, ... [3]);  

Подать заявку на нового оператора

При вызове конструктора с new невозможно
напрямую использовать массив и apply () ( apply ()
выполняет [[Call]] , а не [[Construct]] ).Однако массив
может быть легко использован с новый благодаря синтаксису распространения:

  пусть dateFields = [1970, 0, 1];
пусть d = новая дата (... dateFields);
  

Чтобы использовать новый с массивом параметров без синтаксиса распространения, вы должны
должны сделать это косвенно через частичное применение:

  function applyAndNew (конструктор, аргументы) {
   function partial () {
      return constructor.apply (это, аргументы);
   };
   если (тип конструктора.prototype === "объект") {
      partial.prototype = Object.create (constructor.prototype);
   }
   возврат частичный;
}

function myConstructor () {
   console.log ("arguments.length:" + arguments.length);
   console.log (аргументы);
   this.prop1 = "val1";
   this.prop2 = "val2";
};

let myArguments = ["привет", "как", "есть", "вы", "г-н", ноль];
let myConstructorWithArguments = applyAndNew (myConstructor, myArguments);

console.log (новый myConstructorWithArguments);


  

Распространение литералов массива

Более мощный литерал массива

Без синтаксиса распространения, чтобы создать новый массив, используя существующий массив как одну из его частей,
синтаксиса литерала массива уже недостаточно, и необходимо использовать императивный код
вместо этого используйте комбинацию push () ,
splice () , concat () и т. Д.С синтаксисом распространения это становится более лаконичным:

  let parts = ["плечи", "колени"];
let lyrics = ['голова', ... части, 'и', 'пальцы'];

  

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

Копировать массив

  пусть arr = [1, 2, 3];
пусть arr2 = [... arr];

arr2.push (4);


  

Примечание. Синтаксис расширения эффективно расширяется на один уровень при копировании.
массив.Поэтому он может не подходить для копирования многомерных массивов, так как
в следующем примере показано. (То же самое и с Object.assign ()
и синтаксис распространения.)

  пусть a = [[1], [2], [3]];
пусть b = [... a];

б. сдвиг (). сдвиг ();



а

  

Лучший способ объединения массивов

Array.prototype.concat () часто используется для объединения массива до конца
существующего массива. Без синтаксиса распространения это делается как:

  пусть arr1 = [0, 1, 2];
пусть arr2 = [3, 4, 5];


arr1 = arr1.concat (arr2);  

С синтаксисом распространения это становится:

  пусть arr1 = [0, 1, 2];
пусть arr2 = [3, 4, 5];

arr1 = [... arr1, ... arr2];


  

Array.prototype.unshift () часто используется для вставки массива значений в
начало существующего массива. Без синтаксиса распространения это делается как:

  пусть arr1 = [0, 1, 2];
пусть arr2 = [3, 4, 5];


Array.prototype.unshift.apply (arr1, arr2)

  

С синтаксисом распространения это становится:

  пусть arr1 = [0, 1, 2];
пусть arr2 = [3, 4, 5];

arr1 = [...arr2, ... arr1];

  

Примечание: В отличие от unshift () , это создает новый
arr1 и не изменяет исходный массив arr1
на месте.

Спред в литералах объекта

Остальное / Спред
В свойствах предложения ECMAScript (ES2018) добавлены свойства распространения в
литералы объекта . Копирует собственные
перечислимые свойства из предоставленного объекта в новый объект.

Поверхностное клонирование (за исключением прототипа) или слияние объектов теперь возможно с использованием
более короткий синтаксис, чем Object.назначить () .

  let obj1 = {foo: 'bar', x: 42};
пусть obj2 = {foo: 'baz', y: 13};

пусть clonedObj = {... obj1};


let mergedObj = {... obj1, ... obj2};
  

Обратите внимание, что Object.assign () запускает установщиков , тогда как синтаксис распространения — нет.

Обратите внимание, что вы не можете заменить или имитировать функцию Object.assign () :

  let obj1 = {foo: 'bar', x: 42};
пусть obj2 = {foo: 'baz', y: 13};
const merge = (...объекты) => ({... объекты});

пусть mergedObj1 = merge (obj1, obj2);


пусть mergedObj2 = merge ({}, obj1, obj2);
  

В приведенном выше примере синтаксис распространения не работает так, как можно было бы ожидать: он распространяется
массив аргументов в литерал объекта из-за оставшегося параметра.

Только для итераций

Сами объекты не повторяются, но становятся итерируемыми при использовании в массиве, или
с итерационными функциями, такими как map () , reduce () и
назначить () .При объединении 2-х объектов вместе с оператором распространения это
Предполагается, что при слиянии используется другая итерационная функция.

Синтаксис спреда (кроме свойств спреда) может применяться только к повторяющимся
объектов:

  let obj = {'ключ1': 'значение1'};
let array = [... obj];
  

Распространение с множеством значений

При использовании синтаксиса распространения для вызовов функций помните о возможности превышения
ограничение длины аргумента движка JavaScript.См. apply () для получения более подробной информации.

Таблицы BCD загружаются только в браузере

Битовые операции JavaScript. Побитовые операторы обрабатывают свои операнды… | by sonia dumitru

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

Например, десятичное число «» имеет двоичное представление 101 . Побитовые операторы выполняют свои операции с такими двоичными представлениями, но возвращают стандартные числовые значения JavaScript.

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

Примеры:

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

В приведенных выше примерах используются 4-битные двоичные числа без знака. Из-за этого ~ 5 возвращает 10 .

Поскольку JavaScript использует 32-битные целые числа со знаком, он не вернет 10. Он вернет -6.

00000000000000000000000000000101 (5)

11111111111111111111111111111010 (~ 5 = -6)

Целое число со знаком использует крайний левый бит как знак минуса.

Побитовое И

Когда побитовое И выполняется над парой битов, оно возвращает 1, если оба бита равны 1.

Один бит против 4 битов

Побитовое ИЛИ

Когда побитовое ИЛИ выполняется над парой битов, он возвращает 1, если один из битов равен 1:

Один бит против 4 битов

Побитовое исключающее ИЛИ

Когда побитовое исключающее ИЛИ выполняется над парой битов, оно возвращает 1, если биты различны:

Один бит против 4 битов

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

Побитовое И возвращает 1, только если оба бита равны 1:

Попробуйте сами:

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

Побитовое ИЛИ возвращает 1, если один из битов равен 1:

JavaScript Побитовое исключающее ИЛИ (^)

Побитовое исключающее ИЛИ возвращает 1, если биты различаются:

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

JavaScript (нулевое заполнение) Побитовый сдвиг влево (

<<)

Это сдвиг влево с заполнением нулями. не существует.y === (x &&! y) || (! x && y)

Второе объяснение: изменение битов числа 1 через число 2.

• И: сохраняет только те биты числа 1, которые установлены в числе 2. Эта операция также называется маскированием, где число2 является маской.
• Или: устанавливает все биты числа 1, которые установлены в числе 2, и сохраняет все остальные биты неизменными.
• Xor: инвертирует все биты числа 1, которые установлены в числе 2, и сохраняет все остальные биты неизменными.

Дополнительная литература

1. Целые числа и операторы сдвига в JavaScript

Полное руководство, 4-е издание)

JavaScript и бит-хаки 🧙🏻‍♂️

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

В JavaScript побитовые операторы преобразуют свои операнды в 32-битных целых числа со знаком в формате дополнения до двух .Однако результаты — стандартные числа. В этом посте подробно рассматриваются побитовые операторы, доступные в JavaScript, и исследуются несколько популярных побитовых трюков / приемов.

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

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

  1. Преобразуйте величину числа в двоичную.
2. Если число положительное, то все готово.
3. Если число отрицательное:
   а.Найдите двоичное дополнение до единицы, инвертируя нули и единицы.
   б. Добавьте 1 к дополнению до единицы.  

Давайте найдем двойное дополнение 5 и -5 с помощью описанного выше метода. Для этого мы будем использовать полубайт (4 бита).

Найти двойное дополнение до 5 несложно. Это положительное число. Таким образом, это дополнение до двух — 0101 .

Нахождение двойного дополнения к -5 включает следующие шаги:

  1. Величина -5 равна 5. 5 в двоичной системе равняется «0101».2. -5 - отрицательное число:
   1. Дополнение «0101» до единицы - «1010».
   2. Дополнение после добавления 1: «1011».  

Дополнение -5 до двух: 1011 .

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

  1. Если двойное дополнение числа начинается с «1»:
   а. Найдите дополнение до единицы, инвертируя нули и единицы.
   б. Добавьте один к своему дополнению.
2. Преобразуйте двоичное число в десятичное.
3. Если дополнение до двух начинается с единицы, добавьте к десятичной дроби знак минус. 

Рассмотрим дополнение до двух 0101 и 1011 и найдем их десятичные значения.

0101 начинается с нуля. Никаких дополнительных действий не требуется. Десятичное значение 0101 равно 5.

Преобразование дополнения до десятичной дроби для 1011 требует следующих шагов:

  1. Дополнение «1011» до «0100».
2. После добавления 1: `0101`.
3. Десятичный эквивалент «0101» равен 5.4. «1011» начинается с единицы. Следовательно, -5.  

Десятичное значение 1011 равно -5.

В формате с дополнением до двух крайний левый бит действует как знаковый бит. Это означает, что n-битная компоновка может безопасно представлять числа от -2 ^{n — 1} до 2 ^{n — 1} — 1 в формате дополнения до двух. Например, полубайт (4-битный макет) может представлять число от -8 до 7 без потери точности.

JavaScript использует 32-битный макет для побитовых операций.Следовательно, диапазон составляет от -2 ³¹ до 2 ³¹ — 1 (эквивалент от -2147483648 до 2147483647 ).

Дополнение до двух 32-битных чисел:

  1 => 00000000000000000000000000000001
 Дополнение => 11111111111111111111111111111110
                                             +1
-----------------------------------------------
Дополнение до 2 111111111111111111111111111111
-----------------------------------------------  

  2147483647 => 01111111111111111111111111111111
-----------------------------------------------
Дополнение до 2 011111111111111111111111111111
-----------------------------------------------  

  2147483648 => 10000000000000000000000000000000
 Дополнение => 01111111111111111111111111111111
                                             +1
-----------------------------------------------
Дополнение до 2 10000000000000000000000000000000
-----------------------------------------------  

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

  console.log ((2 ** 32) >> 0);  

Это потому, что дополнение 2 до 2 ³² равно нулю в 32-битном формате. Мы сдвигаем ноль на нулевые биты и получаем ноль.

  4294967296 => 100000000000000000000000000000000 (33 бита)
    4294967296 => 00000000000000000000000000000000 (32 бита)
-------------------------------------------------- -----------
Дополнение до 2 => 00000000000000000000000000000000 (32 бита)
-------------------------------------------------- -----------  

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

Поразрядные логические операторы соединяют каждый бит одного операнда с другим операндом и выполняют логические операции с этими парами.Вот почему эти операции называются поразрядными операциями .

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

Оператор и выполняет операцию И . Возвращает 1, если оба операнда равны 1, иначе 0.

  1 => 00000000000000000000000000000001
     2 => 00000000000000000000000000000010
------------------------------------------
 1 и 2 => 00000000000000000000000000000000 => 0
------------------------------------------  

Для любого числа x, x & 0 всегда дает 0 .

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

| Оператор выполняет операцию ИЛИ . Возвращает 1, если один из операндов равен 1, иначе 0.

  1 => 00000000000000000000000000000001
     2 => 00000000000000000000000000000010
------------------------------------------
 1 | 2 => 00000000000000000000000000000011 => 3
------------------------------------------  

Для любого числа x, x | 0 всегда дает x .y 0 0 0 0 1 1 1 0 1 1 1 0

  1 => 00000000000000000000000000000001
     2 => 00000000000000000000000000000010
------------------------------------------
 1 ^ 2 => 00000000000000000000000000000011 => 3
------------------------------------------  

Для любого числа x x ^ 0 всегда дает x .

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

Оператор

~ выполняет операцию НЕ . Он инвертирует биты операндов.

  -1 => 11111111111111111111111111111111
------------------------------------------
 ~ (-1) => 00000000000000000000000000000000 => 0
------------------------------------------  

Для любого числа x, ~ x всегда дает — (x + 1) .

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

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

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

<< (Сдвиг влево)

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

  2 => 00000000000000000000000000000010
-------------------------------------------------- -
          2 << 5 => 00000000000000000000000001000000 => 64
-------------------------------------------------- -  

  -2147483648 => 10000000000000000000000000000000
-------------------------------------------------- -
-2147483648 << 1 => 00000000000000000000000000000000 => 0
-------------------------------------------------- -  

>> (Сдвиг вправо с распространением знака)

Распространяющий знак оператор сдвига вправо сдвигает первый операнд вправо на указанное количество бит.Он отбрасывает биты справа и копирует крайний левый бит слева.

  2 => 00000000000000000000000000000010
-------------------------------------------------- -
          2 >> 1 => 00000000000000000000000000000001 => 1
-------------------------------------------------- -  

  -2147483648 => 10000000000000000000000000000000
-------------------------------------------------- -
-2147483648 >> 4 => 11111000000000000000000000000000 => -134217728
-------------------------------------------------- -  

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

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

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

  -2147483648 => 10000000000000000000000000000000
-------------------------------------------------- ---
-2147483648 >>> 2 => 00100000000000000000000000000000 => 536870912
-------------------------------------------------- ---  

  -2147483648 => 10000000000000000000000000000000
-------------------------------------------------- ---
-2147483648 >>> 0 => 10000000000000000000000000000000 => 2147483648
-------------------------------------------------- ---  

Битовая маска

Битовая маска или маска — это переменная, которая используется в побитовых операциях для установки / сброса битов другой переменной.Например, предположим, что нам нужно проверить, является ли переменная нечетной. Как его найти с помощью побитовых операторов? Мы знаем, что младший бит нечетного числа всегда равен 1. Приведенная ниже функция использует этот факт.

  function isOdd (x) {
  вернуть x & 1;
}
console.log (isOdd (5));
console.log (isOdd (4));  

Функция isOdd сбрасывает биты x с помощью AND x с 1.

  5 => 0000000000000000000000000000101
   1 => 0000000000000000000000000000001
---------------------------------------
   & => 0000000000000000000000000000001 => 1
---------------------------------------  

  4 => 0000000000000000000000000000100
   1 => 0000000000000000000000000000001
---------------------------------------
   & => 0000000000000000000000000000000 => 0
---------------------------------------  

Здесь мы можем сказать, что 1 действует как маска / битовая маска.Следовательно, isOdd можно записать как

  function isOdd (x) {
  const mask = 1;
  вернуть х & маску;
}
console.log (isOdd (5));
console.log (isOdd (4));  

Подробнее о битовой маске можно прочитать здесь.

Уловки

Побитовые трюки похожи на темную магию компьютерного программирования 🔮. Они менее интуитивны и трудны для понимания. Это потому, что они работают с двоичным кодом, а двоичный код создан для машин, а не для людей. Я постараюсь объяснить каждый трюк как можно проще.Не стесняйтесь исправлять / добавлять, если есть какие-либо пробелы.

⚠️ Приведенные ниже приемы показаны только в учебных целях. Их следует тщательно проверить, прежде чем использовать в проекте. Кроме того, эти уловки могут иметь целочисленное переполнение, если требуется более 32 бит.

Усечь целое число

  function truncate (x) {
  
  return ~~ x;
}
усечь (-1234,12);
усечь (1234,12);  

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

Возможно, вы захотите использовать в своем проекте Math.trunc ().

Перевернуть знак целого числа

Для любого целого числа x , ~ x дает - (x + 1) . Следовательно,

  ~ x + 1 => - (x + 1) + 1 => -x - 1 + 1 => -x  

  function negate (x) {
  return ~ x + 1;
}  

Увеличение / уменьшение на 1

  function add1 (x) {
  
  возврат - ~ x;
}

функция subtract1 (x) {
  
  return ~ -x;
}  

Обмен значениями

Значения двух переменных можно поменять местами с помощью оператора XOR.= y;
}

Сила двух

Если x — степень двойки, то для x — 1 будут включены только самые правые биты. Следовательно, операция И x с x — 1 даст ноль, если x является степенью 2. Например,

  4 => 00000000000000000000000000000100
  4-1 => 00000000000000000000000000000011 => 3
--------------------------------------------
    & => 00000000000000000000000000000000 => 0
--------------------------------------------  

  function isPowerOf2 (x) {
  if (x === 0) {
    вернуть ложь;
  }
  return (x & (x - 1)) === 0;
}

isPowerOf2 (2);
isPowerOf2 (3);  

Абсолютное значение

Давайте найдем абсолютное значение -5 без разветвления .Как мы знаем, для любых x ~ x дает - (x + 1) . Таким образом, мы можем сделать ~ (-5) + 1 , чтобы получить 5.

  -5 => 11111111111111111111111111111011
 ~ (-5) => 00000000000000000000000000000100
                                        +1
 -----------------------------------------
          00000000000000000000000000000101 => 5
 -----------------------------------------  

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

1. Создайте битовую маску для числа x на x >> 31 . Битовая маска будет равна нулю для положительных x и -1 для отрицательных x .

  5 >> 31 => 00000000000000000000000000000000 => 0  

 -5 >> 31 => 11111111111111111111111111111111 => -1  

2. XOR битовая маска с x для поиска отрицания.y) & маска);
   }

   Альтернативный метод. Он использует оператор сдвига вправо и разницу в числах.

     function min (x, y) {
     
     const mask = (x - y) >> 31;
   
     
     
     вернуть y + ((x - y) & маска);
   }
   
   function max (x, y) {
     
     const mask = (x - y) >> 31;
   
     
     
     вернуть x - ((x - y) & маска);
   }  

   Вы можете использовать в своем проекте Math.min () и Math.max ().

   Обратные биты целого числа без подписи

     function reverseBits (number) {
     const size = 31;
     пусть результат = 0;
     для (пусть я = 1; я <= 31; я + = 1) {
       
       результат | = число & 1;
   
       
       число >> = i;
   
       
       результат << = 1;
     }
     вернуть результат;
   }
   
   приставка.журнал (reverseBits (1));  

   Значения RGB из цветового кода

     function hexToRgb (color) {
     const r = (цвет & 0xff0000) >>> 16;
     const g = (цвет & 0x00ff00) >>> 8;
     const b = цвет & 0x0000ff;
     return [r, g, b] .join (',');
   }
   
   console.log (hexToRgb (0x010203));  

   Последние мысли:

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

   Сказав это, если ситуация потребует, не стесняйтесь встряхнуть несколько бит!

   Побитовые операции в Javascript - ncona.com - Изучение компьютеров

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

   Быстрый поиск дал мне ответ на этот вопрос. Когда вы выполняете двоичные операции с числом, оно будет преобразовано в целое число с дополнением до двух. Еще одна интересная вещь заключается в том, что даже несмотря на то, что числа JavaScript построены с использованием 64 бит, они будут преобразованы в 32 бит при выполнении бинарных операций. Давайте посмотрим, как эти два фактора влияют на нашу деятельность.

   32 бита

   Чтобы упростить этот пример, предположим, что мы говорим о числах без знака. Если у нас 32 бита, наибольшее число, которое мы можем представить, будет: 4 294 967 295.Если мы добавим к этому числу единицу, произойдет целочисленное переполнение, и все биты будут преобразованы в 0. Давай попробуем:

     
    
    
    
    
    1
   2
    
   > 4294967295 + 1
   4294967296
    
    
    Мы видим, что переполнения не произошло. Это связано с тем, что мы используем оператор + для сложения двух 64-битных чисел JavaScript. Представление этого числа возможно с использованием 64 бит, но не с использованием 32 бит.Давайте теперь возьмем это 64-битное число и попробуем выполнить с ним бинарную операцию:
    Результат на этот раз неверный. Правильный ответ должен быть 4 294 967 297, так как мы в основном устанавливаем последний бит, который был от 0 до 1. Причина, по которой данный ответ - 1, заключается в том, что число слишком велико для представления 32 битами, а после его усечения оно выглядит как а 0:
    Дополнение до двух 
    В моем предыдущем объяснении я немного упростил концепцию, предположив, что мы используем целые числа без знака.Дело в том, что число преобразуется в представление с дополнением до двух, что позволяет нам иметь как положительные, так и отрицательные числа.
    Чтобы упростить объяснение, предположим, что у нас есть числовой тип, использующий 8 бит. Если бы это было беззнаковое число, мы могли бы представлять числа от 0 до 255 (от 00000000 до 11111111). Используются все возможные комбинации и нет места для беззнаковых чисел. Если вы добавите 1 к наибольшему числу, произойдет переполнение, и результат станет 0.
    Допустим, мы действительно хотим иметь возможность представлять целые числа со знаком с помощью нашего числового типа. Один из простых способов сделать это - использовать дополнение до двух. Есть конечно недостаток. У нас все еще есть только 8 бит, поэтому нам придется пожертвовать местом для представления отрицательных чисел. Используя дополнение до двух, мы можем представить число 0 (00000000) и положительные числа от 1 до 127 (от 00000001 до 01111111) и от -1 до -128 (от 11111111 до 1000000).
    Положительные числа очень просты.Самый старший бит будет установлен в 0, а все остальные биты представляют число так же, как двоичное число без знака. Отрицательные числа требуют немного большего объяснения, но также очень просты для понимания. Интересно то, что за наибольшим числом (01111111) следует наименьшее возможное число (10000000). Это может показаться запутанным, но на самом деле это не так уж сложно.
    Вы можете преобразовать положительное число в отрицательное, взяв дополнение до единицы (т.е.е. Выполнение двоичной операции not с числом), а затем прибавление 1. Давайте попробуем это с максимально возможным числом 127.
     
    
    
    
    
    1
   2
   3
   4
    
   127 -> 01111111
   ~ 127 -> 10000000
   ~ 127 + 1 -> 10000001
   -127 -> 10000001
    
    
    Теперь посмотрим, как это работает с числом 1:
   .
     
    
    
    
    
    1
   2
   3
   4
    
    1 -> 00000001
   ~ 1 -> 11111110
   ~ 1 + 1 -> 11111111
   -1 -> 11111111
    
    
    Как вы можете видеть отсюда, с этой нотацией выполнять двоичные операции довольно просто:
     
    
    
    
    
    1
   2
   3
   4
   5
    
    10000001 - 00000001 = 10000000
   -127-1 = -128
   
   11111111 + 00000001 = 00000000
   -1 + 1 = 0
    
    
    Теперь, когда мы понимаем, как работает дополнение до двух, и знаем, что JavaScript выполняет двоичные операции, используя 32 бита, стало яснее, что происходит с нашими числами.
    Программное обеспечение подготовки к собеседованию стало проще. Вопросы для собеседования по кодированию. 
    АЛГОДИЧНО
    Упражняться
    Случайная проблема
    Все вызовы
    Базовые массивы
    Деревья двоичного поиска
    Динамическое программирование
    Легкие струны
    Внешний интерфейс
    Графики
    Жесткие массивы
    Жесткие струны
    Хеш-карты
    Связанные списки
    Средние массивы
    Очереди
    Рекурсия
    Сортировка
    Стеки
    Системный дизайн
    Деревья
    Учиться
    Все уроки и руководства
    Памятка по структурам данных
     Бесплатные видео по программированию
    Вопросы на собеседовании по битовой манипуляции
    Вопросы на собеседовании по Javascript
    Вопросы на собеседовании по Python
    Вопросы для собеседования по Java
    Вопросы на собеседовании по SQL
    Вопросы о контроле качества и тестировании на собеседовании
    Вопросы на собеседовании по Data Engineering
    Вопросы на собеседовании по Data Science
    Вопросы на собеседовании по блокчейну
     Горячие темы
    Обновление ускоренного курса: день 4
    Как работают поисковые системы?
    Что такое структура данных связанного списка?
    Решение проблем с рекурсией vs.Итерация
    Стоит ли мне присоединиться к этой компании: оценка финансового здоровья
    Карьера
    Каталог компаний
    Программное обеспечение
     Трендовые компании
    Полоса
    Google
    LinkedIn
    Палантир
    Yelp
    Логин участника
    
    Купить курс скидка 40%
    Отзывы
    Компания
    Узнать о нас
    Связаться с нами
    Политика конфиденциальности
    Условия и положения
    Блог
    .
   No related posts.