JavaScript Operatori bit a bit


Esempio

Notare che tutte le operazioni bit a bit operano su numeri interi a 32 bit passando tutti gli operandi alla funzione interna ToInt32 .

Bitwise o

var a;
a = 0b0011 | 0b1010; // a === 0b1011
// truth table
// 1010 | (or)
// 0011  
// 1011  (result)

Bitwise e

a = 0b0011 & 0b1010; // a === 0b0010
// truth table
// 1010 & (and)
// 0011  
// 0010  (result)

Bitwise no

a = ~0b0011; // a === 0b1100
// truth table
// 10 ~(not)
// 01  (result)

Bitwise xor (esclusivo o)

a = 0b1010 ^ 0b0011; // a === 0b1001
// truth table
// 1010 ^ (xor)
// 0011  
// 1001  (result)

Spostamento a sinistra bit a bit

a = 0b0001 << 1; // a === 0b0010
a = 0b0001 << 2; // a === 0b0100
a = 0b0001 << 3; // a === 0b1000

Maiusc a sinistra equivale all'intero moltiplicato per Math.pow(2, n) . Quando si esegue la matematica intera, lo spostamento può migliorare significativamente la velocità di alcune operazioni matematiche.

var n = 2;
var a = 5.4;
var result = (a << n) === Math.floor(a) * Math.pow(2,n);
// result is true
a = 5.4 << n; // 20

Spostamento a destra bit a bit >> (spostamento di propagazione dei segni) >>> (spostamento a destra di riempimento zero)

a = 0b1001 >> 1; // a === 0b0100
a = 0b1001 >> 2; // a === 0b0010
a = 0b1001 >> 3; // a === 0b0001

a = 0b1001 >>> 1; // a === 0b0100
a = 0b1001 >>> 2; // a === 0b0010
a = 0b1001 >>> 3; // a === 0b0001

Un valore negativo a 32 bit ha sempre il bit più a sinistra su:

a = 0b11111111111111111111111111110111 | 0;   
console.log(a); // -9
b = a >> 2;     // leftmost bit is shifted 1 to the right then new left most bit is set to on (1)
console.log(b); // -3
b = a >>> 2;    // leftmost bit is shifted 1 to the right. the new left most bit is set to off (0)
console.log(b); // 2147483643

Il risultato di un'operazione >>> è sempre positivo.
Il risultato di un >> è sempre lo stesso segno del valore spostato.

Il passaggio a destra su numeri positivi equivale a dividere per Math.pow(2,n) e pavimentare il risultato:

a = 256.67;
n = 4;
result = (a >> n) === Math.floor( Math.floor(a) / Math.pow(2,n) );
// result is true
a = a >> n; //  16

result = (a >>> n) === Math.floor( Math.floor(a) / Math.pow(2,n) );
// result is true
a = a >>> n; //  16

Il riempimento dello zero a destra ( >>> ) sui numeri negativi è diverso. Poiché JavaScript non converte in unsigned quando si eseguono operazioni bit, non esiste un equivalente operativo:

a = -256.67;
result = (a >>> n) === Math.floor( Math.floor(a) / Math.pow(2,n) );
// result is false

Operatori di assegnazione bit a bit

Ad eccezione di ( ~ ) tutti gli operatori bit a bit sopra indicati possono essere utilizzati come operatori di assegnazione:

a |= b;   // same as: a = a | b;
a ^= b;   // same as: a = a ^ b;
a &= b;   // same as: a = a & b;
a >>= b;  // same as: a = a >> b;
a >>>= b; // same as: a = a >>> b;
a <<= b;  // same as: a = a << b;

Attenzione : Javascript utilizza Big Endian per memorizzare interi. Ciò non corrisponderà sempre all'Endian del dispositivo / sistema operativo. Quando si utilizzano array digitati con lunghezze di bit superiori a 8 bit, è necessario verificare se l'ambiente è Little Endian o Big Endian prima di applicare operazioni bit a bit.

Avviso : operatori bit a bit come & e | non sono gli stessi operatori logici && (e) e || (o) . Forniranno risultati errati se usati come operatori logici. L'operatore ^ non è l' operatore di alimentazione ( a b ) .