Bitwise-operaattorit ovat käteviä käyttää ja voivat johtaa rakkulaan nopeaan koodiin. Ota selvää, mitä ne ovat ja miten niitä käytetään.

Bittioperaattorit ovat niitä, jotka toimivat binääritasolla. Ne ovat usein erittäin nopeita suoritettavissa ja toimivat tyypillisesti kahdella operandilla.

Voit käyttää bittikohtaisia ​​operaattoreita manipuloidaksesi binäärilukuja, optimoidaksesi koodia, pakataksesi tietoja ja toteuttaaksesi tekniikoita grafiikkaa tai pelien ohjelmointia varten. Kuten useimmat muut ohjelmointikielet, JavaScriptillä on erinomainen tuki bittikohtaisille operaatioille.

Mitä ovat operaattorit?

Useimmat ohjelmointikielet käyttävät käsitettä "operaattori" - symboli, joka käskee tulkin suorittamaan tietyn matemaattisen, relaatio- tai loogisen toiminnon.

On olemassa monia erityyppisiä JavaScript-operaattoreita sinun tulee olla tietoinen niistä, jotka näyttävät tavallisilta matemaattisilta operaattoreilta, kuten "+", operaattoreihin, jotka vertaavat kahta arvoa. Bittioperaattorit ovat erityinen joukko, joka käsittelee binäärilukuja.

instagram viewer

Bittikohtainen JA (&) -operaattori

JavaScript bittikohtainen AND (&) -operaattori vertaa kahden vastaavia bittejä binäärioperandit – numerot, jotka sisältävät vain 0 ja 1. Jokaisen tulobittiparin vastaava lähtöbitti on "1", jos molemmat tulobitit ovat "1" tai "0" muuten.

Tässä on bittikohtaisen AND-operaattorin syntaksi:

a & b

Tässä esimerkissä a ja b ovat operandit, joille suoritat bittikohtaisen toiminnon.

Näin bittikohtainen AND-operaattori toimii:

  1. JA-toiminto koskee jokaista vastaavaa bittiparia a ja b oikealta vasemmalle.
  2. Jos molemmat bitit ovat 1, tulos on 1. Jos jompikumpi bitistä on 0, tulos on 0.
  3. Tuloksena on uusi luku, jossa jokainen bitti edustaa JA-operaation tulosta vastaavilla biteillä a ja b.

Esimerkiksi:

antaa a = 50; // 00110010
antaa b = 100; // 01100100
antaa tulos = a & b; // 00100000
konsoli.log (tulos); // 32

Yllä olevassa esimerkissä a on 50 desimaalilukuna, mikä vastaa binaarilukua 00110010, ja b on 100 desimaalilukuna, mikä vastaa binaarilukua 01100100. JA-operaattori vertaa kutakin vastaavien bittien paria oikealta vasemmalle ja tuottaa tuloksena binaariluvun 00100000, joka on 32 desimaalilukuna.

Bittikohtainen TAI (|) Operaattori

Bittikohtainen OR (|) -operaattori vertaa kahden operandin vastaavia bittejä ja palauttaa arvon "1", jos jompikumpi tai molemmat bitit ovat "1" ja "0", jos molemmat bitit ovat "0".

Tässä on bittikohtaisen OR-operaattorin syntaksi:

a | b

Missä a ja b ovat operaation operandit.

Bittikohtainen TAI (|) -operaattori toimii samalla tavalla kuin bittikohtainen AND-operaattori. Ainoa ero on, että TAI-operaattori palauttaa "1", jos "jompikumpi" biteistä on "1" ja "0", jos "molemmat" bitit ovat "0".

Esimerkiksi:

antaa a = 50; // 00110010
antaa b = 100; // 01100100
antaa tulos = a | b; // 01110110
konsoli.log (tulos); // 118

Yllä olevassa esimerkissä bittikohtainen OR-operaattori vertaa jokaista bittiparia oikealta vasemmalle (ts. 0 | 0 = 0, 0 | 1 = 1, 1 | 1 = 1, ja niin edelleen). Tuloksena oleva binääriluku on 01110110, joka on 118 desimaalilukuna.

Bittikohtainen XOR (^) -operaattori

Bittikohtainen XOR (^) -operaattori vertaa kahden operandin vastaavia bittejä ja palauttaa arvon 1, jos jompikumpi mutta ei molemmat operandit ovat "1" ja "0", jos molemmat operandit ovat "1" tai "0".

Tässä on bittikohtaisen XOR-operaattorin syntaksi:

a ^ b

Missä a ja b ovat operaation operandit.

Bittikohtainen XOR-operaattori toimii samalla tavalla kuin bittikohtainen OR- ja AND-operaattori. Ainoa ero on, että se palauttaa "1", jos "jompikumpi mutta ei molemmat" on "1" ja "0", jos "molemmat" operandit ovat "1" tai "0".

Esimerkiksi:

antaa a = 50; // 00110010
antaa b = 100; // 01100100
antaa tulos = a ^ b; // 01010110
konsoli.log (tulos); // 86

Yllä olevassa esimerkissä XOR-operaattori vertaa kutakin bittiparia oikealta vasemmalle (ts. 0 ^ 0 = 0, 0 ^ 1 = 1, 1 ^ 1 = 0, ja niin edelleen). Tuloksena oleva binääriluku on 01010110, joka on 86 desimaalilukuna.

Bittikohtaisesti EI (~) Operaattori

Bittikohtainen EI (~) -operaattori on unaarinen operaattori, joka toimii yhdellä kokonaisluvulla kääntämällä sen kaikki bitit. Toisin sanoen se muuttaa jokaisen "0" bitin "1":ksi ja joka "1" bitin "0":ksi.

Tässä on bittikohtaisen NOT-operaattorin syntaksi:

~c

Missä c on operandi.

Bittikohtainen NOT-operaattori toimii invertoimalla kaikki operandin bitit, mukaan lukien etumerkkibitit.

Esimerkiksi:

antaa c = 10; // 00001010
antaa d = -10; // 11110110 
konsoli.log(~c); // 11110101
konsoli.log(~d); // 00001001

Yllä olevassa esimerkissä NOT-operaattori invertoi kaikki bitit (ts. 0 → 1, 1 → 0jne.), mukaan lukien merkkibitit.

Vasen Shift (<

Vasemmanpuoleinen siirtooperaattori siirtää tietyn luvun bittejä vasemmalle. Operaattori ottaa kaksi operandia: siirrettävän luvun ja bittien määrän, jolla sitä siirretään.

Tässä on vasemman siirtooperaattorin syntaksi:

a << b

Missä a on operandi vasemmalle siirtooperaattorille ja b on bittien lukumäärä, jolla operaattori siirtää operandia.

Vasemmanpuoleinen siirtooperaattori toimii siirtämällä operandin jokaista bittiä vasemmalle määritetyn määrän paikkoja ja hylkäämällä vasemmalle siirretyt ylimääräiset bitit.

Esimerkiksi:

antaa a = 50; // 00110010
antaa b = 2;
antaa tulos = a << b; // 11001000
konsoli.log (tulos); // 200

Yllä olevassa esimerkissä vasen siirtooperaattori siirsi binaariluvun 00110010 desimaalilukua 50 kahdella paikalla. Tuloksena oleva binääriarvo on 11001000, joka on 200 desimaalina.

Sign-Propagating Right Shift (>>) -operaattori

Merkkejä etenevä siirto oikealle (>>) siirtää luvun bittejä oikealle säilyttäen samalla alkuperäisen luvun etumerkin. Operaattori ottaa kaksi operandia: siirrettävän luvun ja bittien määrän, jolla sitä siirretään.

Tässä on syntaksi etumerkkiä etenevälle oikealle siirtooperaattorille:

a >> b

Missä a on operandi oikealle siirtooperaattorille ja b on bittien lukumäärä, jolla operaattori siirtää operandia.

Merkkejä edistävä oikean vuoron operaattori toimii samalla tavalla kuin vasemman vuoron operaattori; Ainoa ero toimintatavassa on se, että oikea vaihto säilyttää merkin.

Esimerkiksi:

antaa a = -50; // 11001110
antaa b = 2;
antaa tulos = a >> b; // 11110011
konsoli.log (tulos); // -13

Yllä olevassa esimerkissä oikealle siirtooperaattori siirsi desimaalilukua -50 (11001110) kaksi välilyöntiä oikealle, jolloin tuloksena oli desimaali -13 (11110011).

Allekirjoittamaton Oikea Vaihto (>>>) Operaattori

Merkitön siirto oikealle (>>>) -operaattori siirtää luvun bittejä oikealle tietyn määrän paikkoja ja täyttää vasemmalla olevat tyhjät kohdat nolilla. Käyttäjä hylkää ylimääräiset bitit, jotka se siirtää oikealle.

Tässä on syntaksi allekirjoittamattomalle oikealle shift-operaattorille:

a >>> b

Missä a on operandi oikealle siirtooperaattorille ja b on bittien lukumäärä, jolla operaattori siirtää operandia.

Etumerkitön oikean vuoron operaattori toimii samalla tavalla kuin oikea vuoro. Toisin kuin oikean vuoron operaattori (>>), se ei säilytä numeron etumerkkiä siirrettäessä. Sen sijaan se käsittelee numeroa etumerkittömänä kokonaislukuna ja täyttää vasemmanpuoleisimman bitin nollalla.

Esimerkiksi:

antaa a = -5; // 11111111 11111111 11111111 11111011
antaa b = 2;
antaa tulos = a >>> b; // 00111111 11111111 11111111 11111110
konsoli.log (tulos); // 1073741822

Tässä esimerkissä etumerkitön oikeanpuoleinen siirtooperaattori siirsi "-5" kaksi välilyöntiä oikealle, mikä poisti merkin ja johti desimaaliin "1073741822".

Bitwise-operaattoreiden sovellukset

Manipuloimalla yksittäisiä bittejä binääriluvuissa bittikohtaiset operaattorit voivat luoda monimutkaisia ​​toimintoja, joita on muuten vaikea tai mahdoton saavuttaa perinteisillä aritmeettisilla operaatioilla.

Bittioperaattoreiden käytön ymmärtäminen voi auttaa sinua rakentamaan tehokkaampia ja suorituskykyisempiä verkkosovelluksia.