Увод у Битвисе операторе у ЈаваСцрипт-у
Оператори бититала у ЈаваСцрипт дјелују на свој операнд радећи на њима у обрасцу репрезентације свог бинарног броја (База 2) (посебно у облику 32-битних бројева), а не у децималном броју (База 10), окталним бројевима (База 8), или шестерокутни број (База 16). На пример, 1010 је бинарни приказ децималног броја десет. Операције у битису у ЈаваСцрипт-у изводе се на операндима оператора у њиховим бинарним репрезентацијама, али излаз се увијек враћа у стандардном облику нумеричке вриједности.
Битни оператор у ЈаваСцрипт-у претвара своје операнде у облик 2 комплемента 32-битног потписаног целог броја. Према томе, кад год се оператор оперира на цели број, изведена вредност је 2 комплементарни облик тог целог броја. 2 комплемента целог броја је 1 комплемента броја (тј. По налогу Не броја) плус 1.
На пример, следеће је 32-битно представљање броја 7
00000000000000000000000000000111
Доље је 1 'комплемента, тј. ~ 7
11111111111111111111111111111000
Испод је 2 комплемента облика који је једнак -7
11111111111111111111111111111001
| Битвисе Оператор | Употреба | Значење |
| Битвисе АНД | к & и | Вратит ће се по 1 у свакој битној позицији ако су оба одговарајућа бита 1 иначе 0. |
| Битвисе ИЛИ | к | и | Вратит ће се 1 у свакој позицији бита ако је било који од одговарајућих битова 1 иначе 0. |
| Битвисе КСОР | к и | Вратит ће 0 у свакој позицији бита ако су оба одговарајућа бита или 1 или 0 друго 1 кад год су битови различити. |
| Битвисе НОТ | ~ к | Преокренуће битове операнда к са 1 на 0 и обрнуто. |
| Лева смјена | к << и | Помагаће битове улево на бинарни број к за и битове, а притом гурајући 0 на десној страни. |
| Потпомажући ширење десног помака | к >> и | Помагаће битове удесно на бинарни број к за и битове, док ће копирати крајње леве битове улево да би се завршило 32 бита. |
| Нула исправног померања | к >>> и | Помераће битове удесно на бинарни број к за и битове, а притом гурајући 0 на левој страни. |
Битвисе Логицал Операторс у ЈаваСцрипт-у
Битвисе Логични оператори састоје се од свих логичких оператера који се користе у већини језика, али они се разликују на начин на који битностно логички оператори дјелују битно. Следе битни логички оператори који се користе у ЈаваСцрипту:
1. Битвисе АНД
Ово је бинарни оператор означен симболом амперсанд „&“ који изводи операцију АНД на узастопном пару одговарајућих бита својих аргумената. Оператор „&“ би вратио 1 само ако су оба бита 1 другачија, вратит ће 0. Зато можемо и корелирати И операцију с множењем, јер ће оба дати исти одговор.
| Икс | И | Кс & И |
| 0 | 0 | 0 |
| 0 | 1 | 0 |
| 1 | 0 | 0 |
| 1 | 1 | 1 |
Пример
10 (база 10) = 00000000000000000000000000001010
13 (база 10) = 00000000000000000000000000001101
-----------------------------
10 и 13 00000000000000000000000000001000 = 8 (база 10)
2. Битно ИЛИ
Ово је бинарни оператор означен симболом вертикалне траке „|“ који изводи операцију ИЛИ на узастопном пару одговарајућих бита својих аргумената. Оператор "|" би вратио 1 ако је било који од битова 1 или оба су 1, а други ће вратити 0. Битвисе ИЛИ "|" се разликују од логичког ИЛИ "||", јер дјелује помало.
| Икс | И | Кс | И |
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 1 |
Пример
10 (база 10) = 00000000000000000000000000001010
13 (база 10) = 00000000000000000000000000001101
-----------------------------
10 | 13 00000000000000000000000000001111 = 15 (база 10)
3. Битвисе КСОР
Ово је бинарни оператор означен симболом царет „^“ који изводи КСОР операцију на узастопном пару одговарајућих бита својих аргумената. Оператор "^" би вратио 0 ако су оба бита иста (тј. Оба су 1 или су оба 0), иначе ће вратити 1.
| Икс | И | Кс И |
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 0 |
Пример
10 (база 10) = 00000000000000000000000000001010
13 (база 10) = 00000000000000000000000000001101
-----------------------------
10 13 00000000000000000000000000000111 = 7 (база 10)
4. Битвисе НОТ
Ово је унри оператор означен симболом тилде „~“ који изводи операцију НОТ на одговарајућим битовима свог аргумента. Оператор "~" би инвертирао битове операнда, тј. Претворио 0 у 1 или 1 у 0.
| Икс | ~ Кс |
| 0 | 1 |
| 1 | 0 |
Пример
10 (база 10) = 00000000000000000000000000001010
-----------------------------
~ 10 11111111111111111111111111110101
Оператори помака помака у ЈаваСцрипт-у
У операцији помака у помацима такође се узимају два аргумента, где је први аргумент бинарни број на коме ће се извршити операција промене, а други аргумент одређује број бита по коме се први аргумент мора померити. Оператор који се користи одређује правац рада смене у бинарном броју.
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 бита одбацују МСБ-ове (најзначајнији бит). Исто правило се примењује када се током рада смене ако се померање бита улево, затим додатни битови на мсб одбацују, а за време десне смене, додатни бит који расте у крајњем десном делу се одбацује.
Пре: 110011010100011101001000100000001110010010001
-----------------------------
После: 11101001000100000001110010010001
Сваки одговарајући бит је упарен један са другим, тј. Први бит с првим битом других аргумената, други бит с другим битом и тако даље.
Оператор се примењује на сваки бит (за бинарни оператор то би требао бити пар бита), отуда се називају битовни оператори у ЈаваСцрипт-у.
Практична примена битног оператора су Бит заставице, комуникација преко утичнице / портова, компресија, шифровање, машине са коначним стањем, графика итд.
Препоручени чланци
Ово је водич за Битвисе Опере у ЈаваСцрипт-у. Овде смо расправљали о уводу, врстама битних оператора у ЈаваСцрипт-у, као што су логички и промени оператори, као и његове операције. Такође можете погледати следеће чланке да бисте сазнали више -
- Компајлери ЈаваСцрипт
- Преокренути у ЈаваСцрипт-у
- За петљу у ЈаваСцрипт-у
- Увод у ЈаваСцрипт