Bitioperaatoreid on mugav kasutada ja need võivad põhjustada kiire koodi villimist. Uurige, mis need on ja kuidas neid kasutada.

Bitioperaatorid on need, mis toimivad binaarsel tasemel. Neid täidetakse sageli väga kiiresti ja need toimivad tavaliselt kahe operandi alusel.

Bitioperaatoreid saate kasutada kahendarvude manipuleerimiseks, koodi optimeerimiseks, andmete tihendamiseks ja graafika või mängude programmeerimise tehnikate rakendamiseks. Nagu enamikul teistel programmeerimiskeeltel, on ka JavaScriptil suurepärane bitipõhiste toimingute tugi.

Mis on operaatorid?

Enamik programmeerimiskeeli kasutab mõistet "operaator" – sümbol, mis käsib tõlgil sooritada konkreetset matemaatilist, relatsioonilist või loogilist operatsiooni.

Seal on palju erinevat tüüpi JavaScripti operaator peaksite olema teadlik, alates nendest, mis näevad välja nagu standardsed matemaatikaoperaatorid (nt "+") ja lõpetades kahe väärtuste võrdlemisega. Bitioperaatorid on spetsiaalne komplekt, mis tegeleb kahendarvudega.

Bitipõhine JA (&) operaator

JavaScripti bitipõhine JA (&) operaator võrdleb kahe vastavaid bitte kahendoperandid – arvud, mis sisaldavad vaid 0 ja 1. Iga sisendbitipaari jaoks on vastav väljundbitt "1", kui mõlemad sisendbitid on "1" või "0" vastasel juhul.

Siin on bitipõhise JA-operaatori süntaks:

a & b

Selles näites a ja b on operandid, millel bitipõhise toimingu sooritate.

Siin on bitipõhise JA-operaatori tööpõhimõte:

  1. AND-operatsioon kehtib iga vastava bitipaari kohta a ja b paremalt vasakule.
  2. Kui mõlemad bitid on 1, on tulemuseks 1. Kui kumbki bitt on 0, on tulemus 0.
  3. Tulemuseks on uus arv, kus iga bitt tähistab JA-operatsiooni tulemust vastavate bittide puhul a ja b.

Näiteks:

lase a = 50; // 00110010
lase b = 100; // 01100100
lase tulemus = a & b; // 00100000
konsool.log (tulemus); // 32

Ülaltoodud näites a on kümnendkohana 50, mis võrdub kahendarvuga 00110010 ja b on 100 kümnendkohana, mis võrdub kahendarvuga 01100100. Operaator JA võrdleb iga vastavate bittide paari paremalt vasakule ja annab tulemuseks kahendarvu 00100000, mis on kümnendkohana 32.

Bitipõhine VÕI (|) Operaator

Bitipõhine VÕI (|) operaator võrdleb kahe operandi vastavaid bitte ja tagastab "1", kui üks või mõlemad bitid on "1" ja "0", kui mõlemad bitid on "0".

Siin on bitipõhise VÕI-operaatori süntaks:

a | b

Kus a ja b on operatsiooni operandid.

Bitipõhine VÕI (|) operaator töötab samamoodi nagu bitipõhine JA operaator. Ainus erinevus on see, et operaator VÕI tagastab "1", kui "kumbki" bitt on "1" ja "0", kui "mõlemad" bitid on "0".

Näiteks:

lase a = 50; // 00110010
lase b = 100; // 01100100
lase tulemus = a | b; // 01110110
konsool.log (tulemus); // 118

Ülaltoodud näites võrdleb operaator biti kaupa VÕI iga bitipaari paremalt vasakule (st 0 | 0 = 0, 0 | 1 = 1, 1 | 1 = 1, ja nii edasi). Saadud kahendarvuks on 01110110, mis on kümnendkohana 118.

Bitipõhine XOR (^) Operaator

Bitipõhine XOR (^) operaator võrdleb kahe operandi vastavaid bitte ja tagastab "1", kui üks, kuid mitte mõlemad operandid on "1" ja "0", kui mõlemad operandid on "1" või "0".

Siin on bitipõhise XOR-operaatori süntaks:

a ^ b

Kus a ja b on operatsiooni operandid.

Bitipõhine XOR-operaator töötab samamoodi nagu bitipõhised VÕI- ja JA-operaatorid. Ainus erinevus seisneb selles, et see tagastab "1", kui "kumbki, kuid mitte mõlemad" on "1" ja "0", kui "mõlemad" operandid on "1" või "0".

Näiteks:

lase a = 50; // 00110010
lase b = 100; // 01100100
lase tulemus = a ^ b; // 01010110
konsool.log (tulemus); // 86

Ülaltoodud näites võrdleb operaator XOR iga bitipaari paremalt vasakule (st. 0 ^ 0 = 0, 0 ^ 1 = 1, 1 ^ 1 = 0, ja nii edasi). Saadud kahendarvuks on 01010110, mis on kümnendkohana 86.

Bitipõhine EI (~) Operaator

Bitipõhine EI (~) operaator on ühekordne operaator, mis opereerib ühe täisarvuga, pöörates kõik selle bitid ümber. Teisisõnu muudab see iga "0" biti väärtuseks "1" ja iga "1" biti väärtuseks "0".

Siin on bitipõhise operaatori NOT süntaks:

~c

Kus c on operand.

Bitioperaator NOT töötab, pöörates ümber operandi kõik bitid, sealhulgas märgibitid.

Näiteks:

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

Ülaltoodud näites inverteerib operaator NOT kõik bitid (st 0 → 1, 1 → 0jne), sealhulgas märgibitid.

Vasakpoolne tõstuke (<

Vasakpoolse nihke operaator nihutab antud arvu bitte vasakule. Operaator võtab kaks operandi: nihutatava arvu ja bittide arvu, mille võrra seda nihutada.

Siin on vasakpoolse nihkeoperaatori süntaks:

a << b

Kus a on operand vasakpoolse nihke operaatori jaoks ja b on bittide arv, mille võrra operaator operandi nihutab.

Vasakpoolse nihke operaator nihutab operandi iga bitti määratud arvu positsioonide võrra vasakule ja jätab ära vasakule nihutatud üleliigsed bitid.

Näiteks:

lase a = 50; // 00110010
lase b = 2;
lase tulemus = a << b; // 11001000
konsool.log (tulemus); // 200

Ülaltoodud näites nihutas vasakpoolse nihke operaator kahendarvu 00110010 kümnendkoha 50 kahe koha võrra. Saadud kahendväärtus on 11001000, mis on kümnendkohana 200.

Märgi paljundamine parempoolse vahetuse (>>) operaator

Märki leviv paremale nihe (>>) nihutab arvu bitte paremale, säilitades samal ajal algnumbri märgi. Operaator võtab kaks operandi: nihutatava arvu ja bittide arvu, mille võrra seda nihutada.

Siin on märki levitava parempoolse nihke operaatori süntaks:

a >> b

Kus a on operand parempoolse nihke operaatori jaoks ja b on bittide arv, mille võrra operaator operandi nihutab.

Märgi levitav parempoolse vahetuse operaator töötab sarnaselt vasakpoolse vahetuse operaatoriga; ainus erinevus töörežiimis on see, et parem nihe säilitab märgi.

Näiteks:

lase a = -50; // 11001110
lase b = 2;
lase tulemus = a >> b; // 11110011
konsool.log (tulemus); // -13

Ülaltoodud näites nihutas paremale nihutamise operaator kümnendkoha -50 (11001110) kaks tühikut paremale, mille tulemuseks oli koma -13 (11110011).

Signeerimata parempoolse nihke (>>>) operaator

Märgita parem nihe (>>>) operaator nihutab arvu bitte määratud arvu positsioonide võrra paremale ja täidab vasakul olevad tühjad kohad nullidega. Operaator viskab üleliigsed bitid ära, mis nihutab paremale.

Allkirjata parempoolse nihke operaatori süntaks on järgmine:

a >>> b

Kus a on operand parempoolse nihke operaatori jaoks ja b on bittide arv, mille võrra operaator operandi nihutab.

Signeerimata parempoolse vahetuse operaator töötab sarnaselt parempoolse vahetusega. Kuid erinevalt parempoolse vahetuse operaatorist (>>), ei säilita see nihutamisel numbrimärki. Selle asemel käsitleb see arvu märgita täisarvuna ja täidab kõige vasakpoolsema biti nulliga.

Näiteks:

lase a = -5; // 11111111 11111111 11111111 11111011
lase b = 2;
lase tulemus = a >>> b; // 00111111 11111111 11111111 11111110
konsool.log (tulemus); // 1073741822

Selles näites nihutas märgita parempoolse nihke operaator „-5” kaks tühikut paremale, eemaldades märgi tõhusalt ja andes tulemuseks kümnendkoha „1073741822”.

Bitioperaatorite rakendused

Kahendarvudes üksikute bittidega manipuleerides saavad bitipõhised operaatorid luua keerulisi funktsioone, mida traditsiooniliste aritmeetiliste operatsioonidega on muidu raske või võimatu saavutada.

Bitioperaatorite kasutamise mõistmine võib aidata teil luua tõhusamaid ja tulemuslikumaid veebirakendusi.