JavaScript Operadores bitwise


Ejemplo

Tenga en cuenta que todas las operaciones bitwise operan en enteros de 32 bits al pasar cualquier operando a la función interna ToInt32 .

Bitwise o

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

A nivel de bit y

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

Bitwise no

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

Xor bitwise (exclusivo o)

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

Desplazamiento a la izquierda en modo de bits

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

Desplazar a la izquierda equivale a multiplicar enteros por Math.pow(2, n) . Al realizar operaciones matemáticas integrales, el desplazamiento puede mejorar significativamente la velocidad de algunas operaciones matemáticas.

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

Desplazamiento a la derecha en modo de bit >> ( Desplazamiento de signo de propagación) >>> (Desplazamiento a la derecha con relleno)

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 valor negativo de 32 bits siempre tiene el bit más a la izquierda:

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

El resultado de una operación >>> siempre es positivo.
El resultado de un >> es siempre el mismo signo que el valor cambiado.

El cambio a la derecha en números positivos es el equivalente a dividir por Math.pow(2,n) y al suelo el resultado:

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

El desplazamiento a la derecha del relleno cero ( >>> ) en los números negativos es diferente. Como JavaScript no se convierte a entradas sin firmar cuando se realizan operaciones de bits, no hay un equivalente operativo:

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

Operadores de asignación bitwise

Con la excepción de que no ( ~ ) todos los operadores bitwise anteriores se pueden usar como operadores de asignación:

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;

Advertencia : Javascript usa Big Endian para almacenar enteros. Esto no siempre coincidirá con el Endian del dispositivo / SO. Cuando utilice matrices escritas con longitudes de bits superiores a 8 bits, debe comprobar si el entorno es Little Endian o Big Endian antes de aplicar operaciones bitwise.

Advertencia : Operadores bitwise como & y | no son lo mismo que los operadores lógicos && (y) y || (o) . Proporcionarán resultados incorrectos si se utilizan como operadores lógicos. El operador ^ no es el operador de potencia ( a b ) .