Introducción a los operadores de Bitwise en JavaScript
Los operadores Bitwise en JavaScript actúan sobre su operando operando sobre ellos en su forma de representación de número binario (Base 2) (en particular, forma de números de 32 bits), en lugar de en su número decimal (Base 10), números octales (Base 8), o notación de número hexadecimal (Base 16). Por ejemplo, 1010 es la representación binaria del número decimal diez. Las operaciones bit a bit en JavaScript se realizan en los operandos de los operadores en sus representaciones binarias, pero la salida siempre se devuelve en la forma de valor numérico estándar.
Un operador bit a bit en JavaScript convierte sus operandos a la forma complementaria de 2 de su forma entera con signo de 32 bits. Por lo tanto, cada vez que se trabaja un operador sobre un número entero, el valor derivado es la forma complementaria de 2 de ese número entero. El complemento a 2 de un número entero es el complemento a 1 del número (es decir, no a nivel de bit del número) más 1.
Por ejemplo, la siguiente es la representación de 32 bits del número 7
00000000000000000000000000000111
El siguiente es un complemento de 1 ', es decir, ~ 7
11111111111111111111111111111000
La siguiente es la forma del complemento de 2 que es igual a -7
11111111111111111111111111111001
| Operador bit a bit | Uso | Sentido |
| Bitwise Y | x & y | Devolverá 1 en cada posición de bit si los dos bits correspondientes son 1, de lo contrario 0. |
| Bitwise O | x | y | Devolverá 1 en cada posición de bit si alguno de los bits correspondientes es 1, de lo contrario 0. |
| Bitwise XOR | x y | Devolverá 0 en cada posición de bit si los dos bits correspondientes son 1 o 0, de lo contrario, 1 siempre que los bits sean diferentes. |
| Bitwise NO | ~ x | Volteará los bits del operando x de 1 a 0 y viceversa. |
| Shift izquierdo | x << y | Desplazará los bits a su izquierda en el número binario x por y bits mientras presiona 0 en su lugar desde la derecha. |
| Signo propagando desplazamiento a la derecha | x >> y | Desplazará los bits a la derecha en el número binario x por y bits mientras copia los bits más a la izquierda a la izquierda para completar 32 bits. |
| Relleno cero desplazamiento a la derecha | x >>> y | Desplazará los bits a su derecha en el número binario x por y bits mientras presiona 0 en su lugar desde la izquierda. |
Operadores lógicos bit a bit en JavaScript
Los operadores lógicos bit a bit consisten en todos los operadores lógicos utilizados en la mayoría de los lenguajes, pero son diferentes en cierta forma, ya que los operadores lógicos bit a bit funcionan bit a bit. Los siguientes son operadores lógicos bit a bit utilizados en JavaScript:
1. Bitwise Y
Este es un operador binario denotado por el símbolo de ampersand "&" que realiza una operación AND en el par consecutivo de bits correspondientes de sus argumentos. El operador "&" devolvería 1 solo si ambos bits 1 son otros, devolverá 0. Por lo tanto, también podemos correlacionar la operación AND con la multiplicación porque ambos darán la misma respuesta.
| X | Y | X e Y |
| 0 0 | 0 0 | 0 0 |
| 0 0 | 1 | 0 0 |
| 1 | 0 0 | 0 0 |
| 1 | 1 | 1 |
Ejemplo
10 (base 10) = 00000000000000000000000000001010
13 (base 10) = 00000000000000000000000000001101
----------------------------
10 y 13 00000000000000000000000000001000 = 8 (base 10)
2. Bitwise O
Este es un operador binario denotado por el símbolo de una barra vertical "|" que realiza una operación OR en el par consecutivo de bits correspondientes de sus argumentos. El operador "|" devolvería 1 si alguno de los bits es 1 o ambos son 1, de lo contrario devolverá 0. El Bitwise OR "|" es diferente del lógico OR "||" ya que funciona bit a bit.
| X | Y | X | Y |
| 0 0 | 0 0 | 0 0 |
| 0 0 | 1 | 1 |
| 1 | 0 0 | 1 |
| 1 | 1 | 1 |
Ejemplo
10 (base 10) = 00000000000000000000000000001010
13 (base 10) = 00000000000000000000000000001101
----------------------------
10 | 13 00000000000000000000000000001111 = 15 (base 10)
3. Bitwise XOR
Este es un operador binario denotado por el símbolo de caret "^" que realiza una operación XOR en el par consecutivo de bits correspondientes de sus argumentos. El operador "^" devolvería 0 si los dos bits son iguales (es decir, ambos son 1 o ambos son 0) de lo contrario devolverá 1.
| X | Y | X Y |
| 0 0 | 0 0 | 0 0 |
| 0 0 | 1 | 1 |
| 1 | 0 0 | 1 |
| 1 | 1 | 0 0 |
Ejemplo
10 (base 10) = 00000000000000000000000000001010
13 (base 10) = 00000000000000000000000000001101
----------------------------
10 13 00000000000000000000000000000111 = 7 (base 10)
4. NO bit a bit
Este es un operador unario denotado por el símbolo de tilde "~" que realiza una operación NOT en los bits correspondientes de su argumento. El operador "~" invertiría los bits del operando, es decir, convertir 0 a 1 o 1 a 0.
| X | ~ X |
| 0 0 | 1 |
| 1 | 0 0 |
Ejemplo
10 (base 10) = 00000000000000000000000000001010
----------------------------
~ 10 11111111111111111111111111110101
Operadores de desplazamiento bit a bit en JavaScript
En la operación de desplazamiento a nivel de bits también se utilizan dos argumentos en los que el primer argumento es el número binario en el que se realizará la operación de desplazamiento y el segundo argumento especifica el número de bits por los cuales se debe desplazar el primer argumento. El operador que se utiliza especifica la dirección de la operación de cambio en el número binario.
1. Desplazamiento izquierdo bit a bit
Este es un operador binario denotado por el símbolo "<<". Este operador desplazará los bits más a la derecha del primer argumento a su izquierda por el valor de los segundos tiempos de argumento. Los bits desplazados desde la derecha se reemplazan por 0 en la parte más a la derecha para cada operación de desplazamiento realizada.
Ejemplo: 8 << 3 produce 64
8 (base 10) = 00000000000000000000000000001000
----------------------------
8 << 3 00000000000000000000000001000000 = 64 (base 10)
2. Desplazamiento a la derecha bit a bit
Este es un operador binario denotado por el símbolo ">>>". Este operador desplazará los bits más a la derecha del primer argumento a su derecha por el valor de los segundos tiempos de argumento. Los bits desplazados desde la izquierda se reemplazan por 0 en la parte más a la izquierda para cada operación de desplazamiento realizada.
Ejemplo: 8 >>> 3 produce 1
8 (base 10) = 00000000000000000000000000001000
----------------------------
8 >>> 3 00000000000000000000000000000001 = 1 (base 10)
-8 (base 10) = 11111111111111111111111111111000
----------------------------
-8 >>> 3 00011111111111111111111111111111 = 536870911 (base 10)
3. Signo bit a bit que propaga el desplazamiento a la derecha
Este es un operador binario denotado por el símbolo ">>". Este operador desplazará los bits más a la derecha del primer argumento a su derecha por el valor de los segundos tiempos de argumento. Los bits desplazados desde la izquierda se reemplazan por el bit más a la izquierda (es decir, el bit de signo) en la parte más a la izquierda para cada operación de desplazamiento realizada.
Ejemplo: 8 >>> 3 produce 1
8 (base 10) = 00000000000000000000000000001000
----------------------------
8 >> 3 00000000000000000000000000000001 = 1 (base 10)
-8 (base 10) = 11111111111111111111111111111000
----------------------------
-8 >> 3 11111111111111111111111111111111 = -1 (base 10)
Conclusión
Los argumentos se convierten en números binarios de 32 bits y se expresan en forma de bits (es decir, 0 y 1). Los números en los argumentos que resultan con más de 32 bits descartan sus msb (el bit más significativo). La misma regla se aplica cuando durante la operación de desplazamiento si el desplazamiento de bit se fue hacia la izquierda, se descartan los bits adicionales en msb y durante el desplazamiento a la derecha, se descarta el bit adicional que crece en la parte más a la derecha.
Antes: 110011010100011101001000100000001110010010001
----------------------------
Después: 11101001000100000001110010010001
Cada bit correspondiente se empareja entre sí, es decir, el primer bit con el primer bit de otros argumentos, el segundo bit con el segundo bit y así sucesivamente.
El operador se aplica en cada bit (para el operador binario debe ser un par de bits), por lo tanto, se llama operadores bit a bit en JavaScript.
La aplicación práctica del operador bit a bit son las banderas de bits, la comunicación a través de zócalos / puertos, compresión, cifrado, máquinas de estado finito, gráficos, etc.
Artículos recomendados
Esta es una guía para operadores Bitwise en JavaScript. Aquí discutimos la introducción, los tipos de operadores bit a bit en JavaScript, como los operadores lógicos y de desplazamiento junto con sus operaciones. También puede consultar los siguientes artículos para obtener más información.
- Compiladores JavaScript
- Invertir en JavaScript
- Para Loop en JavaScript
- Introducción a JavaScript