JavaScript
Bitvisa operatörer

Bitvisa operatörer

Bitvisa operatörer utför operationer på bitvärden för data. Dessa operatörer konverterar operander till signerade 32-bitars heltal i två komplement .

Konvertering till 32-bitars heltal

Antal med mer än 32 bitar kasserar sina mest betydelsefulla bitar. Till exempel konverteras följande heltal med mer än 32 bitar till ett 32-bitars heltal:

Before: 10100110111110100000000010000011110001000001
After:              10100000000010000011110001000001

Två komplement

I normal binär hittar vi det binära värdet genom att lägga till 1 : erna baserat på deras position som krafter på 2 - Den högra biten är 2^0 till den vänstra biten är 2^n-1 där n är antalet bitar. Använd till exempel 4 bitar:

// Normal Binary
// 8 4 2 1
   0 1 1 0  => 0 + 4 + 2 + 0 => 6

Två komplementsformat innebär att talets negativa motsvarighet (6 vs -6) är alla bitarna för ett inverterat nummer, plus ett. De inverterade bitarna av 6 skulle vara:

// Normal binary
   0 1 1 0
// One's complement (all bits inverted)
   1 0 0 1  => -8 + 0 + 0 + 1 => -7
// Two's complement (add 1 to one's complement)
   1 0 1 0  => -8 + 0 + 2 + 0 => -6

Obs: Att lägga till fler 1 till vänster om ett binärt nummer förändrar inte dess värde i två komplement. Värdet 1010 och 1111111111010 är båda -6 .

Bitvis OCH

Den bitvisa OCH-operationen a & b returnerar det binära värdet med en 1 där båda binära operanderna har 1 : er i en specifik position och 0 i alla andra positioner. Till exempel:

13 & 7 => 5
// 13:     0..01101
//  7:     0..00111
//-----------------
//  5:     0..00101 (0 + 0 + 4 + 0 + 1)

Exempel på verklig värld: Number's Parity Check

Istället för detta "mästerverk" (tyvärr för ofta sett i många verkliga koddelar):

function isEven(n) {
    return n % 2 == 0;
}

function isOdd(n) {
    if (isEven(n)) {
        return false;
    } else {
        return true;
    }
}

Du kan kontrollera (heltal) -talets paritet på mycket mer effektivt och enkelt sätt:

if(n & 1) {
    console.log("ODD!");
} else {
    console.log("EVEN!");
}

Bitvis ELLER

Den bitvisa ELLER operation a | b returnerar det binära värdet med en 1 där antingen operander eller båda operanderna har 1 : er i en specifik position, och 0 när båda värdena har 0 i en position. Till exempel:

13 | 7 => 15
// 13:     0..01101
//  7:     0..00111
//-----------------
// 15:     0..01111 (0 + 8 + 4 + 2 + 1)  

Bitvis INTE

Den bitvisa INTE-funktionen ~a vänder bitarna med det givna värdet a . Detta betyder att alla 1 : erna blir 0 : er och alla 0 : erna kommer att bli 1 : er.

~13 => -14
// 13:     0..01101
//-----------------
//-14:     1..10010 (-16 + 0 + 0 + 2 + 0)

Bitvis XOR

Den bitvisa XOR-funktionen ( exklusiv eller ) a ^ b placerar a 1 endast om de två bitarna är olika. Exklusivt eller betyder antingen det ena eller det andra, men inte båda .

13 ^ 7 => 10
// 13:     0..01101
//  7:     0..00111
//-----------------
// 10:     0..01010  (0 + 8 + 0 + 2 + 0)

Exempel på verklig värld: byta två heltal utan ytterligare minnesallokering

var a = 11, b = 22;
a = a ^ b;
b = a ^ b;
a = a ^ b;
console.log("a = " + a + "; b = " + b);// a is now 22 and b is now 11

Skiftoperatörer

Bitvis förskjutning kan betraktas som att "flytta" bitarna antingen åt vänster eller höger, och därmed ändra värdet på de data som används.

Vänster Shift

Den vänstra skiftoperatören (value) << (shift amount) kommer att flytta bitarna till vänster med (shift amount) bitar; de nya bitarna som kommer in från höger kommer att vara 0 : er:

5 << 2 => 20
//  5:      0..000101
// 20:      0..010100 <= adds two 0's to the right

Right Shift ( teckenförökande )

Den högra skiftoperatören (value) >> (shift amount) kallas också "Skyltförökande högerskift" eftersom den håller tecknet på den initiala operand. Den högra växlingsoperatören flyttar value den angivna shift amount bitar till höger. Överskottsbitar som flyttas från höger kastas. De nya bitarna som kommer in från vänster kommer att baseras på tecknet på den första operand. Om den vänstra biten var 1 kommer de nya bitarna alla att vara 1 och vice versa för 0 : er.

20 >> 2 => 5
// 20:      0..010100
//  5:      0..000101 <= added two 0's from the left and chopped off 00 from the right

-5 >> 3 => -1
// -5:      1..111011
// -2:      1..111111 <= added three 1's from the left and chopped off 011 from the right

Right Shift ( Nollfyllning )

Den nollfyllda höger växlingsoperatören (value) >>> (shift amount) kommer att flytta bitarna åt höger, och de nya bitarna kommer att vara 0 '. 0 : erna flyttas in från vänster, och överskottet till höger flyttas av och kastas. Detta betyder att det kan göra negativa siffror till positiva.

-30 >>> 2 => 1073741816
//       -30:      111..1100010
//1073741816:      001..1111000

Nollfyllning höger växling och skyltförökande högerskift ger samma resultat för icke-negativa siffror.