ECMAScript bitoperatorer
- Forrige side Enkel operator
- Næste side Logiske operatorer
Bitoperatører udfører operationer på nummerets bunden (dvs. de 32 cifre, der repræsenterer tallet).
Genoplive heltal
ECMAScript heltal har to typer, nemlig signede heltal (som tillader positive og negative tal) og unsigned heltal (som kun tillader positive tal). I ECMAScript er alle heltalsliterals som standard signede heltal, hvilket betyder hvad?
Signede heltal bruger 31 cifre til at repræsentere tallets værdi, og det 32. ciffer repræsenterer tallets symbol, 0 repræsenterer et positivt tal, og 1 repræsenterer et negativt tal. Værdirangen er fra -2147483648 til 2147483647.
Der er to forskellige måder at gemme binære formaterede signede heltal på, en til at gemme positive tal og en til at gemme negative tal. Positive tal gemmes i sand binær form, hvor hvert af de første 31 cifre repræsenterer 2's potens, fra det første ciffer (bit 0) og fremad.0Den anden plads (bit 1) repræsenterer 21De ubrugte cifre fyldes med 0, hvilket betyder, at de ignoreres. For eksempel viser nedenstående figur repræsentationen af tallet 18.
18's binære version bruger kun de første 5 cifre, som er de gyldige cifre. Konverter tallet til en binær streng, og du kan se de gyldige cifre:
var iNum = 18; alert(iNum.toString(2)); //Udskriver "10010"
Dette kodeudtræk kun udskriver "10010", ikke 18's 32-bit repræsentation. De andre cifre er ikke vigtige, fordi kun de første 5 cifre er nødvendige for at bestemme denne tierværdi. Som vist i nedenstående figur:
Negative tal gemmes også som binære koder, men i form af binær komplementform. Der er tre trin til at beregne binær komplementform for et tal:
- Bestem den ikke-negative versionens binære repræsentation (for eksempel, for at beregne binær komplementform for -18, skal man først bestemme binær repræsentationen af 18)
- Find binær komplementform, hvilket indebærer at erstatte 0 med 1 og 1 med 0
- Tilføj 1 til binær komplementform
For at bestemme binær repræsentationen af -18, skal man først få binær repræsentationen af 18, som vist herunder:
0000 0000 0000 0000 0000 0000 0001 0010
Næste, beregn binær komplementform, som vist herunder:
1111 1111 1111 1111 1111 1111 1110 1101
Til sidst, tilføj 1 til binær komplementform, som vist herunder:
1111 1111 1111 1111 1111 1111 1110 1101
1
---------------------------------------
1111 1111 1111 1111 1111 1111 1110 1110
Derfor er binær repræsentationen af -18 1111 1111 1111 1111 1111 1111 1110 1110. Husk, når man håndterer signede integers, kan udviklere ikke tilgå bit 31.
Det er interessant, at når negative integers konverteres til en binær streng, viser ECMAScript ikke dem i binær komplementform, men i en form med standard binær kode for absolut værdi foran med et minus-tegn. For eksempel:
var iNum = -18; alert(iNum.toString(2)); // output "-10010"
Dette kodeeksempel outputter "-10010", ikke binær komplementform, for at undgå at tilgå bit 31. For at gøre det lettere, håndterer ECMAScript integers på en simpel måde, så udviklere ikke behøver at bekymre sig om deres brug.
På den anden side behandler unsigned integers det sidste bit som en anden bitposition. I dette mønster repræsenterer den 32. bit ikke symbolerne for tallene, men værdien 231På grund af denne ekstra bit, er værdiintervallet for unsigned integers 0 til 4294967295. For integers mindre end 2147483647 ser unsigned integers ud som signede integers, mens integers større end 2147483647 kræver brug af bit 31 (i signede integers er dette bit altid 0).
Når en unsigned integer konverteres til en streng, returneres kun de gyldige bits.
Bemærk:Alle heltalsliterals gemmes som signede integers som standard. Kun ECMAScript's bit-operators kan oprette unsigned integers.
Bit-operators NOT
Bit-operators NOT viseset med et tilbagevendende tegn (~), og det er en af de få operatorer i ECMAScript, der har noget med binær aritmetik at gøre.
Bitoperatoren NOT er en tre-trins proces:
- Konverter operatøren til 32-bit tal
- Konverter binærtal til dets binære komplement
- Konverter binærtal til flydende tal
For eksempel:
var iNum1 = 25; //25 er lig med 00000000000000000000000000011001 var iNum2 = ~iNum1; //Konverter til 11111111111111111111111111100110 alert(iNum2); //Udskriver "-26"
Bitoperatoren NOT er i virkeligheden at tage tallets negativ og derefter trække 1, så 25 bliver -26. Den samme metode kan også bruges som følger:
var iNum1 = 25; var iNum2 = -iNum1 -1; alert(iNum2); //Udskriver -26
Bitoperatoren AND
Bitoperatoren AND repræsenteres ved tegnet (&) og udfører direkte operationer på tallets binære form. Den justerer hver tals cifre, og anvender derefter følgende regler til at udføre AND-operation på cifre på samme position:
| Bitpladserne i det første tal | Bitpladserne i den anden tal | Resultat |
|---|---|---|
| 1 | 1 | 1 |
| 1 | 0 | 0 |
| 0 | 1 | 0 |
| 0 | 0 | 0 |
For eksempel, for at udføre AND-operation på tallene 25 og 3, vises kode som følger:
var iResult = 25 & 3; alert(iResult); //Udskriver "1"
Resultatet af AND-operationsen mellem 25 og 3 er 1. Hvorfor? Analyse som følger:
25 = 0000 0000 0000 0000 0000 0000 0001 1001 3 = 0000 0000 0000 0000 0000 0000 0000 0011 --------------------------------------------- AND = 0000 0000 0000 0000 0000 0000 0000 0001
Det kan ses, at der i 25 og 3 er kun én cifre (cifre 0), der indeholder begge tal, så andre cifre genererer alle 0, og resultatet er 1.
Bitoperatoren OR
Bitoperatoren OR repræsenteres ved tegnet (|) og udfører direkte operationer på tallets binære form. Ved beregning af hvert cifre anvender OR-operatoren følgende regler:
| Bitpladserne i det første tal | Bitpladserne i den anden tal | Resultat |
|---|---|---|
| 1 | 1 | 1 |
| 1 | 0 | 1 |
| 0 | 1 | 1 |
| 0 | 0 | 0 |
Lad os fortsætte med et eksempel på brug af AND-operatoren til at udføre OR-operation på 25 og 3, kode som følger:
var iResult = 25 | 3; alert(iResult); //Udskriver "27"
Resultatet af OR-operationsen mellem 25 og 3 er 27:
25 = 0000 0000 0000 0000 0000 0000 0001 1001 3 = 0000 0000 0000 0000 0000 0000 0000 0011 -------------------------------------------- OR = 0000 0000 0000 0000 0000 0000 0001 1011
Det kan ses, at der i de to tal er 4 cifre, der indeholder 1, og disse cifre overføres til resultatet. Den binære kode 11011 er lig med 27.
Bitoperation XOR
Bitoperation XOR er repræsenteret ved tegnet (^), selvfølgelig udføres det direkte på binær form. XOR er forskellig fra OR, når kun én bitplads indeholder 1, returnerer den 1. Sandhedstabellen ser sådan ud:
| Bitpladserne i det første tal | Bitpladserne i den anden tal | Resultat |
|---|---|---|
| 1 | 1 | 0 |
| 1 | 0 | 1 |
| 0 | 1 | 1 |
| 0 | 0 | 0 |
For at udføre XOR-operationen mellem 25 og 3, se nedenfor:
var iResult = 25 ^ 3; alert(iResult); // udskriver "26"
Resultatet af XOR-operationen mellem 25 og 3 er 26:
25 = 0000 0000 0000 0000 0000 0000 0001 1001 3 = 0000 0000 0000 0000 0000 0000 0000 0011 --------------------------------------------- XOR = 0000 0000 0000 0000 0000 0000 0001 1010
Man kan se, at der i to tal er 4 bitpladser, der indeholder 1, og disse bitpladser overføres til resultatet. Binær kode 11010 er lig med 26.
Venstreflytning
Venstreflytning er repræsenteret ved to mindre end-tegn (<<). Den flytter alle bitpladser i et tal til venstre for den angivne mængde. For eksempel, hvis tallet 2 (lig med binært 10) flyttes 5 pladser til venstre, bliver resultatet 64 (lig med binært 1000000):
var iOld = 2; // lig med binært 10 var iNew = iOld << 5; // lig med binært 1000000 tiendedecimal 64
Bemærk:Når man flytter talsbitpladser til venstre, bliver der flere tomme pladser til højre. Venstreflytning fylder disse pladser med 0, så resultatet bliver et fuldt 32-bit tal.
Bemærk:Venstreflytning bevarer tals signaturbit. For eksempel, hvis -2 flyttes 5 pladser til venstre, får man -64, ikke 64. 'Er signaturbit stadig gemt i den 32. bitplads?' Ja, men dette sker i ECMAScript's backend, og udviklere kan ikke direkte tilgå den 32. bitplads. Selv når negative tal vises som binære strengformer, vises det som minusform (f.eks. -2 vises som -10).
Den betegnende højreflytteoperator
Den betegnende højreflytteoperator er repræsenteret ved to større end-tegn (>>). Den flytter alle bitpladser i et 32-bit tal til højre, samtidig med at den bevarer tals signatur (plus eller minus). Den betegnende højreflytteoperator er præcis det modsatte af venstreflytning. For eksempel, hvis 64 flyttes 5 pladser til højre, bliver det 2:
var iOld = 64; // lig med binært 1000000 var iNew = iOld >> 5; // lig med binært 10 decimalt 2
Ligesom tidligere vil der også opstå tomme pladser efter at have flyttet bitpladserne. Denne gang er de tomme pladser på den venstre side af tallet, men efter symbolpladsen. ECMAScript fylder disse tomme pladser med værdien af symbolpladsen, og skaber dermed et fuldt tal, som vist i det følgende billede:
Unsigned right shift operation
Den unsigned right shift operator repræsenteres af tre store prikker (>>>), og den flytter alle bitpladserne i et unsigned 32-bit tal til højre. For positive tal er resultatet af den unsigned right shift operation det samme som den signed right shift operation.
Med et eksempel på den signed right shift operation, hvis du flytter 64 til højre 5 pladser, bliver det 2:
var iOld = 64; // lig med binært 1000000 var iNew = iOld >>> 5; // lig med binært 10 decimalt 2
For negative tal er situationen anderledes.
Den unsigned right shift operation fylder alle tomme pladser med 0. For positive tal er dette det samme som den signed right shift operation, mens negative tal behandles som positive tal.
Da resultatet af den unsigned right shift operation er et 32-bit positivt tal, får en negativ numbers unsigned right shift operation altid et meget stort tal. For eksempel, hvis du flytter -64 til højre 5 pladser, får du 134217726. Hvordan får man dette resultat?
For at opnå dette skal du konvertere tallet til en unsigned ekvivalent form (selvom tallet selv stadig er signed), hvilket kan opnås ved følgende kode:
var iUnsigned64 = -64 >>> 0;
Dernæst, få dens rigtige bits repræsentation ved hjælp af toString() fra Number-objektet, som bruger basen 2:
alert(iUnsigned64.toString(2));
Dette vil generere 11111111111111111111111111000000, som er den binære komplementrepræsentation af det signede heltal -64, men det er lig med det unsigned heltal 4294967232.
På grund af denne grund skal du være forsigtig med at bruge den unsigned right shift operator.
- Forrige side Enkel operator
- Næste side Logiske operatorer
