Побитовите оператори са удобни за използване и могат да доведат до невероятно бърз код. Разберете какво представляват те и как да ги използвате.

Побитовите оператори са тези, които действат на двоично ниво. Те често са много бързи за изпълнение и обикновено действат върху два операнда.

Можете да използвате побитови оператори, за да манипулирате двоични числа, да оптимизирате кода, да компресирате данни и да прилагате техники за програмиране на графики или игри. Както повечето други езици за програмиране, JavaScript има отлична поддръжка за битови операции.

Какво представляват операторите?

Повечето езици за програмиране използват концепцията за "оператор" - символ, който казва на интерпретатора да извърши специфична математическа, релационна или логическа операция.

Има много различни видове JavaScript оператори трябва да знаете, от тези, които изглеждат като стандартни математически оператори, като "+", до оператори, които сравняват две стойности. Побитовите оператори са специален набор, който работи с двоични числа.

instagram viewer

Побитово И (&) оператор

JavaScript побитово И (&) оператор сравнява съответните битове от две двоични операнди - числа, които съдържат само 0 и 1. За всяка двойка входни битове съответният изходен бит е „1“, ако и двата входни бита са „1“ или „0“ в противен случай.

Ето синтаксиса на побитовия оператор И:

а и б

В този пример, а и b са операндите, върху които изпълнявате побитовата операция.

Ето как работи побитовият оператор И:

  1. Операцията И се прилага към всяка двойка съответстващи битове в а и b от дясно на ляво.
  2. Ако и двата бита са 1, резултатът е 1. Ако някой от битовете е 0, резултатът е 0.
  3. Резултатът е ново число, където всеки бит представлява резултата от операцията И върху съответните битове на а и b.

Например:

позволявам а = 50; // 00110010
позволявам b = 100; // 01100100
позволявам резултат = a & b; // 00100000
конзола.log (резултат); // 32

В примера по-горе, а е 50 в десетична система, еквивалентно на двоичното число 00110010 и b е 100 в десетична система, еквивалентно на двоичното число 01100100. Операторът AND сравнява всяка двойка съответстващи битове отдясно наляво и произвежда полученото двоично число 00100000, което е 32 в десетична система.

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

Побитовото ИЛИ (|) сравнява съответните битове на два операнда и връща „1“, ако един или двата бита са „1“ и „0“, ако и двата бита са „0“.

Ето синтаксиса на побитовия оператор ИЛИ:

a | b

Където а и b са операндите на операцията.

Побитовият оператор ИЛИ (|) работи по същия начин като побитовия оператор И. Единствената разлика е, че операторът ИЛИ връща „1“, ако „някой“ от битовете е „1“ и „0“, ако „и двата“ бита са „0“.

Например:

позволявам а = 50; // 00110010
позволявам b = 100; // 01100100
позволявам резултат = a | b; // 01110110
конзола.log (резултат); // 118

В горния пример побитовият оператор ИЛИ сравнява всяка двойка битове отдясно наляво (т.е. 0 | 0 = 0, 0 | 1 = 1, 1 | 1 = 1, и така нататък). Полученото двоично число е 01110110, което е 118 в десетична система.

Побитов оператор XOR (^).

Побитовото XOR (^) сравнява съответните битове на два операнда и връща „1“, ако някой от операндите е „1“, но не и двата, и „0“, ако и двата операнда са „1“ или „0“.

Ето синтаксиса на побитовия XOR оператор:

a ^ b

Където а и b са операндите на операцията.

Побитовият оператор XOR работи по същия начин като побитовите оператори OR и AND. Единствената разлика е, че връща „1“, ако „или, но не и двата“ от операндите е „1“ и „0“, ако „и двата“ от операндите са „1“ или „0“.

Например:

позволявам а = 50; // 00110010
позволявам b = 100; // 01100100
позволявам резултат = a ^ b; // 01010110
конзола.log (резултат); // 86

В горния пример операторът XOR сравнява всяка двойка битове отдясно наляво (т.е. 0 ^ 0 = 0, 0 ^ 1 = 1, 1 ^ 1 = 0, и така нататък). Полученото двоично число е 01010110, което е 86 в десетична система.

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

Побитово НЕ (~) е унарен оператор, който оперира с едно цяло число, като обръща всичките му битове. С други думи, той променя всеки бит "0" на "1" и всеки бит "1" на "0".

Ето синтаксиса на побитовия оператор NOT:

~c

Където ° С е операндът.

Побитовият оператор NOT работи, като обръща всички битове на операнд, включително битовете за знак.

Например:

позволявам c = 10; // 00001010
позволявам d = -10; // 11110110 
конзола.log(~c); // 11110101
конзола.log(~d); // 00001001

В горния пример операторът NOT обръща всички битове (т.е. 0 → 1, 1 → 0и т.н.), включително знаковите битове.

Ляв оператор (<

Операторът за ляво преместване измества битовете на дадено число наляво. Операторът приема два операнда: числото, с което да се премести, и броят битове, с които да се премести.

Ето синтаксиса за левия оператор за смяна:

a << b

Където а е операндът за левия оператор за преместване и b е броят битове, с които операторът ще измести операнда.

Операторът за ляво изместване работи, като измества всеки бит от операнд наляво с определен брой позиции и изхвърля излишните битове, изместени наляво.

Например:

позволявам а = 50; // 00110010
позволявам b = 2;
позволявам резултат = a << b; // 11001000
конзола.log (резултат); // 200

В примера по-горе операторът за ляво преместване измести десетичната запетая 50 на двоичния 00110010 с две места. Получената двоична стойност е 11001000, което е 200 като десетична запетая.

Оператор за преместване надясно (>>), разпространяващ знака

Разпространяващото знака надясно изместване (>>) измества битовете на числото надясно, като запазва знака на оригиналното число. Операторът приема два операнда: числото, с което да се премести, и броят битове, с които да се премести.

Ето синтаксиса за оператора за десен преместващ знак:

а >> б

Където а е операндът за десния оператор за преместване и b е броят битове, с които операторът ще измести операнда.

Операторът за десен преместващ знак работи подобно на оператора за ляво преместване; единствената разлика в режима на работа е, че дясната смяна поддържа знака.

Например:

позволявам а = -50; // 11001110
позволявам b = 2;
позволявам резултат = a >> b; // 11110011
конзола.log (резултат); // -13

В примера по-горе операторът за смяна надясно измести десетичната запетая -50 (11001110) с два интервала надясно, което доведе до десетичната запетая -13 (11110011).

Неподписан десен оператор (>>>).

Неподписаното дясно изместване (>>>) измества битовете на числото надясно с определен брой позиции и запълва празните полета отляво с нули. Операторът изхвърля излишните битове, които измества надясно.

Ето синтаксиса за неподписан десен оператор за смяна:

a >>> b

Където а е операндът за десния оператор за преместване и b е броят битове, с които операторът ще измести операнда.

Операторът за неподписано дясно преместване работи подобно на дясното преместване. Въпреки това, за разлика от десния оператор за смяна (>>), не запазва знака на числото при преместване. Вместо това, той третира числото като цяло число без знак и запълва най-левия бит с нула.

Например:

позволявам а = -5; // 11111111 11111111 11111111 11111011
позволявам b = 2;
позволявам резултат = a >>> b; // 00111111 11111111 11111111 11111110
конзола.log (резултат); // 1073741822

В този пример операторът за десен преместване без знак измества „-5“ с два интервала надясно, като ефективно премахва знака и води до десетичната запетая „1073741822“.

Приложенията на побитовите оператори

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

Разбирането как да използвате побитови оператори може да ви помогне да изградите по-ефективни и производителни уеб приложения.