A bitenkénti operátorok használata kényelmes, és gyors kódot okozhat. Tudja meg, mik ezek, és hogyan kell használni őket.

A bitenkénti operátorok azok, amelyek bináris szinten működnek. Gyakran nagyon gyorsan végrehajthatók, és jellemzően két operandusra hatnak.

Bitenkénti operátorok segítségével kezelheti a bináris számokat, optimalizálhatja a kódot, tömörítheti az adatokat, és technikákat valósíthat meg grafikus vagy játékprogramozáshoz. A legtöbb más programozási nyelvhez hasonlóan a JavaScript is kiválóan támogatja a bitenkénti műveleteket.

Mik azok az operátorok?

A legtöbb programozási nyelv az „operátor” fogalmát használja – egy szimbólum, amely egy adott matematikai, relációs vagy logikai művelet végrehajtására utasítja az értelmezőt.

Sokan vannak különböző típusú JavaScript operátorok tudnia kell, a szabványos matematikai operátoroknak, például a „+”-nak tűnő operátoroktól a két értéket összehasonlító operátorig. A bitenkénti operátorok egy speciális halmaz, amely bináris számokkal foglalkozik.

instagram viewer

Bitenkénti ÉS (&) operátor

A JavaScript bitenkénti ÉS (&) operátor összehasonlítja kettő megfelelő bitjeit bináris operandusok – olyan számok, amelyek csak 0-t és 1-et tartalmaznak. Minden bemeneti bitpár esetén a megfelelő kimeneti bit „1”, ha mindkét bemeneti bit „1” vagy „0” egyébként.

Íme a bitenkénti ÉS operátor szintaxisa:

a & b

Ebben a példában a és b azok az operandusok, amelyeken a bitenkénti műveletet végrehajtja.

Így működik a bitenkénti ÉS operátor:

  1. Az ÉS művelet minden megfelelő bitpárra vonatkozik a és b jobbról balra.
  2. Ha mindkét bit 1, az eredmény 1. Ha bármelyik bit 0, az eredmény 0.
  3. Az eredmény egy új szám, ahol minden bit az ÉS művelet eredményét jelenti a megfelelő biteken a és b.

Például:

hagyja a = 50; // 00110010
hagyja b = 100; // 01100100
hagyja eredmény = a & b; // 00100000
konzol.log (eredmény); // 32

A fenti példában a tizedesjegyben 50, ami megegyezik a 00110010 bináris számmal, és b tizedesjegyben 100, ami a 01100100 bináris számnak felel meg. Az ÉS operátor összehasonlítja a megfelelő bitpárokat jobbról balra, és az eredményül kapott 00100000 bináris számot állítja elő, amely decimálisan 32.

Bitenkénti VAGY (|) Operátor

A bitenkénti VAGY (|) operátor összehasonlítja két operandus megfelelő bitjeit, és „1”-et ad vissza, ha egyik vagy mindkét bit „1”, és „0”, ha mindkét bit „0”.

Íme a bitenkénti VAGY operátor szintaxisa:

a | b

Ahol a és b a művelet operandusai.

A bitenkénti VAGY (|) operátor ugyanúgy működik, mint a bitenkénti ÉS operátor. Az egyetlen különbség az, hogy a VAGY operátor „1”-et ad vissza, ha „bármelyik” bit „1”, és „0”, ha „mindkét” bit „0”.

Például:

hagyja a = 50; // 00110010
hagyja b = 100; // 01100100
hagyja eredmény = a | b; // 01110110
konzol.log (eredmény); // 118

A fenti példában a bitenkénti VAGY operátor összehasonlítja az egyes bitpárokat jobbról balra (azaz 0 | 0 = 0, 0 | 1 = 1, 1 | 1 = 1, stb). Az eredményül kapott bináris szám: 01110110, ami tizedesjegyben 118.

Bitenkénti XOR (^) operátor

A bitenkénti XOR (^) operátor összehasonlítja két operandus megfelelő bitjeit, és „1”-et ad vissza, ha bármelyik, de nem mindkét operandus „1”, és „0”, ha mindkét operandus „1” vagy „0”.

Íme a bitenkénti XOR operátor szintaxisa:

a ^ b

Ahol a és b a művelet operandusai.

A bitenkénti XOR operátor ugyanúgy működik, mint a bitenkénti VAGY és ÉS operátorok. Az egyetlen különbség az, hogy „1”-et ad vissza, ha „egyik, de nem mindkettő” „1”, és „0”, ha „mindkét operandus” „1” vagy „0”.

Például:

hagyja a = 50; // 00110010
hagyja b = 100; // 01100100
hagyja eredmény = a ^ b; // 01010110
konzol.log (eredmény); // 86

A fenti példában az XOR operátor összehasonlítja az egyes bitpárokat jobbról balra (azaz 0 ^ 0 = 0, 0 ^ 1 = 1, 1 ^ 1 = 0, stb). Az eredményül kapott bináris szám 01010110, ami tizedesjegyben 86.

Bitenkénti NEM (~) Operátor

A bitenkénti NEM (~) operátor egy unáris operátor, amely egyetlen egész számra operál úgy, hogy az összes bitjét invertálja. Más szavakkal, minden „0” bitet „1”-re, és minden „1” bitet „0”-ra változtat.

Íme a bitenkénti NOT operátor szintaxisa:

~c

Ahol c az operandus.

A bitenkénti NOT operátor úgy működik, hogy az operandus összes bitjét invertálja, beleértve az előjelbiteket is.

Például:

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

A fenti példában a NOT operátor az összes bitet invertálja (pl. 0 → 1, 1 → 0stb.), beleértve az előjelbiteket is.

Bal Shift (<

A balra váltó operátor egy adott szám bitjeit balra tolja. Az operátor két operandust vesz fel: az eltolni kívánt számot és az eltolni kívánt bitek számát.

Íme a bal oldali shift operátor szintaxisa:

a << b

Ahol a a bal oldali eltolás operátor operandusa, és b az a bitek száma, amennyivel az operátor eltolja az operandust.

A bal oldali eltolás operátor úgy működik, hogy az operandus minden bitjét a megadott számú pozícióval balra tolja, és eldobja a balra eltolt felesleges biteket.

Például:

hagyja a = 50; // 00110010
hagyja b = 2;
hagyja eredmény = a << b; // 11001000
konzol.log (eredmény); // 200

A fenti példában a balra eltolás operátora két hellyel eltolta a 00110010 bináris tizedesvessző 50-ét. A kapott bináris érték 11001000, ami tizedesjegyként 200.

Jel-szaporító jobb váltó (>>) operátor

A jel-szaporító jobbra tolódás (>>) a szám bitjeit jobbra tolja, miközben megőrzi az eredeti szám előjelét. Az operátor két operandust vesz fel: az eltolni kívánt számot és az eltolni kívánt bitek számát.

Íme az előjel-terjesztő jobbra váltó operátor szintaxisa:

a >> b

Ahol a a jobb shift operátor operandusa, és b az a bitek száma, amennyivel az operátor eltolja az operandust.

A jeleket továbbító jobb műszak operátor hasonlóan működik, mint a bal műszak operátor; az egyetlen különbség a működési módban az, hogy a jobbra váltás megtartja a jelet.

Például:

hagyja a = -50; // 11001110
hagyja b = 2;
hagyja eredmény = a >> b; // 11110011
konzol.log (eredmény); // -13

A fenti példában a jobbra eltolás operátora a decimális -50-et (11001110) két szóközzel jobbra tolta, így a -13 (11110011) decimális értéket kapta.

Előjel nélküli jobb műszak (>>>) kezelő

Az előjel nélküli jobb eltolás (>>>) operátor egy szám bitjeit meghatározott számú pozícióval jobbra tolja, a bal oldali üres helyeket pedig nullákkal tölti ki. A kezelő eldobja a felesleges biteket, amelyeket jobbra tol el.

Íme az előjel nélküli jobbra váltó operátor szintaxisa:

a >>> b

Ahol a a jobb shift operátor operandusa, és b az a bitek száma, amennyivel az operátor eltolja az operandust.

Az előjel nélküli jobb műszak operátor a jobb műszakhoz hasonlóan működik. Ellentétben a jobb műszak operátorral (>>), eltoláskor nem őrzi meg a szám előjelét. Ehelyett a számot előjel nélküli egész számként kezeli, és a bal szélső bitet nullával tölti ki.

Például:

hagyja a = -5; // 11111111 11111111 11111111 11111011
hagyja b = 2;
hagyja eredmény = a >>> b; // 00111111 11111111 11111111 11111110
konzol.log (eredmény); // 1073741822

Ebben a példában az előjel nélküli jobbra váltó operátor a „-5”-et két szóközzel jobbra tolta, így gyakorlatilag eltávolította az előjelet, és az „1073741822” decimális értéket eredményezte.

Bitwise operátorok alkalmazásai

Az egyes bitek bináris számokban történő manipulálásával a bitenkénti operátorok olyan összetett funkcionalitást hozhatnak létre, amelyet egyébként nehéz vagy lehetetlen elérni hagyományos aritmetikai műveletekkel.

A bitenkénti operátorok használatának megértése segíthet hatékonyabb és teljesítményesebb webalkalmazások létrehozásában.