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

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

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

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

00000000000000000000000000000111

По-долу е 1 'допълнение, т.е. ~ 7

11111111111111111111111111111000

По-долу е допълващата форма на 2, която е равна на -7

11111111111111111111111111111001

Битов операторупотребазначение
Побитово Иx & yЩе върне 1 във всяка битова позиция, ако и двата съответни бита са 1, в противен случай 0.
Побитови ИЛИх | шЩе върне 1 във всяка битова позиция, ако някой от съответните битове е 1, в противен случай 0.
Побитово XORx yЩе върне 0 във всяка битова позиция, ако и двата съответни бита са 1 или 0 в противен случай 1, когато битовете са различни.
Побито НЕ~ хЩе обърне битовете на операнда x от 1 до 0 и обратно.
Ляво изместванеx << yЩе измести битовете отляво върху двоичното число x с y бита, докато натиска 0 на място отдясно.
Знак, разпространяващ десната смянаx >> yЩе измести битовете надясно върху двоичното число x с y бита, докато копира най-левия бит вляво, за да завърши 32 бита.
Нулева смяна на дясната смянаx >>> yЩе измести битовете вдясно върху двоичното число x с y бита, докато натиска 0 на място отляво.

Битови логически оператори в JavaScript

Побитови логически оператори се състоят от всички логически оператори, използвани в повечето езици, но те са различни по начин, тъй като битовите логически оператори оперират по битове. Следните битови логически оператори, използвани в JavaScript:

1. Битово И

Това е двоичен оператор, обозначен със символа ampersand „&“, който извършва операция AND върху последователната двойка от съответните битове на своите аргументи. Операторът „&“ би върнал 1 само ако и двата бита 1 са други, той ще върне 0. Следователно можем също да съпоставим И операцията с умножение, защото и двете ще дадат един и същ отговор.

хYX & Y
000
010
100
111

пример

10 (основа 10) = 00000000000000000000000000001010
13 (основа 10) = 00000000000000000000000000001101

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

10 и 13 00000000000000000000000000001000 = 8 (база 10)

2. Битов ИЛИ

Това е двоичен оператор, обозначен със символа на вертикална лента „|“, която извършва операция ИЛИ на последователната двойка от съответните битове на своите аргументи. Операторът „|“ ще върне 1, ако някой от битовете е 1 или и двата са 1, ще върне 0. Побитовият ИЛИ „|“ е различен от логическия ИЛИ „||“, тъй като работи малко по бит.

хYX | Y
000
011
101
111

пример

10 (основа 10) = 00000000000000000000000000001010
13 (основа 10) = 00000000000000000000000000001101

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

10 | 13 00000000000000000000000000001111 = 15 (база 10)

3. Битово XOR

Това е двоичен оператор, обозначен със символа на caret “^”, който извършва операция XOR върху последователната двойка от съответните битове на своите аргументи. Операторът „^“ би върнал 0, ако и двата бита са еднакви (т.е. и двата са 1 или и двата са 0), в противен случай ще върне 1.

хYX Y
000
011
101
110

пример

10 (основа 10) = 00000000000000000000000000001010
13 (основа 10) = 00000000000000000000000000001101

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

10 13 00000000000000000000000000000111 = 7 (база 10)

4. Побито НЕ

Това е единствен оператор, обозначен със символа на tilde „~”, който извършва операция NOT върху съответните битове на своя аргумент. Операторът "~" би обърнал битовете на операнда, т.е. преобразува 0 в 1 или 1 в 0.

х~ X
01
10

пример

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

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

~ 10 111111111111111111111111111110101

Оператори с битова смяна в 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. Същото правило важи, когато по време на работа на смяна, ако битовото изместване наляво, след това допълнителните битове в msb се изхвърлят и по време на десния смяна, допълнителният бит, растящ в най-дясната част, се изхвърля.

Преди: 110011010100011101001000100000001110010010001

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

След: 11101001000100000001110010010001

Всеки съответен бит се сдвоява помежду си, т.е. първият бит с първия бит на други аргументи, вторият бит с втори бит и така нататък.

Операторът се прилага на всеки бит (за двоичния оператор трябва да е двойка бит), оттук се наричат ​​битови оператори в JavaScript.

Практическо приложение на битови оператори са битови флагове, комуникация през сокет / портове, компресия, криптиране, машини с ограничено състояние, графика и др.

Препоръчителни статии

Това е ръководство за битови оператори в JavaScript. Тук обсъждаме въвеждането, видове битови оператори в JavaScript, като логически оператори и оператори на смяна, заедно с неговите операции. Можете също да разгледате следните статии, за да научите повече-

  1. JavaScript Компилатори
  2. Обратно в JavaScript
  3. За Loop в JavaScript
  4. Въведение в JavaScript

Категория:

Разработване на софтуер