nivel - operadores javascript
¿Qué son los operadores bit a bit? (9)
En la programación digital de la computadora, una operación en modo bit opera en uno o más patrones de bits o números binarios en el nivel de sus bits individuales. Es una acción rápida, primitiva, directamente soportada por el procesador, y se usa para manipular valores para comparaciones y cálculos. opraciones
a nivel de bits Y
a nivel de bit OR
NO a nivel de bit
bit a bit XOR
etc
Artículo de lista
AND|0 1 OR|0 1
---+---- ---+----
0|0 0 0|0 1
1|0 1 1|1 1
XOR|0 1 NOT|0 1
---+---- ---+---
0|0 1 |1 0
1|1 0
P.ej.
203: 1100 1011
AND 15: 0000 1111
------------------
= 11: 0000 1011
Usos del operador bit a bit
- Los operadores de desplazamiento a la izquierda y a la derecha son equivalentes a multiplicación y división por x * 2 y respectivamente.
P.ej.
int main()
{
int x = 19;
printf ("x << 1 = %d/n" , x <<1);
printf ("x >> 1 = %d/n", x >>1);
return 0;
}
// Output: 38 9
- El operador & se puede usar para verificar rápidamente si un número es impar o par
P.ej.
int main()
{
int x = 19;
(x & 1)? printf("Odd"): printf("Even");
return 0;
}
// Output: Odd
- Busque rápidamente un mínimo de xey sin
if elsedeclaración
P.ej.
int min(int x, int y)
{
return y ^ ((x ^ y) & - (x < y))
}
- Conversión de decimal a binario
P.ej.
#include <stdio.h>
int main ()
{
int n , c , k ;
printf("Enter an integer in decimal number system/n " ) ;
scanf( "%d" , & n );
printf("%d in binary number
system is: /n " , n ) ;
for ( c = 31; c >= 0 ; c -- )
{
k = n >> c ;
if ( k & 1 )
printf("1" ) ;
else
printf("0" ) ;
}
printf(" /n " );
return 0 ;
}
- El cifrado de la puerta XOR es una técnica popular, debido a su complejidad y a su uso por parte del programador.
- el operador XOR bit a bit es el operador más útil desde la perspectiva de la entrevista técnica.
El cambio de bitwuse solo funciona con el número + ve
También hay un amplio rango de uso de la lógica bit a bit
Soy alguien que escribe código solo por diversión y no me he adentrado en él ni en un entorno académico ni profesional, así que cosas como estos operadores bit a bit realmente se me escapan.
Estaba leyendo un artículo sobre JavaScript, que aparentemente admite operaciones bit a bit. Sigo viendo esta operación mencionada en algunos lugares, y traté de leer para saber qué es exactamente, pero parece que no la tengo. Entonces, ¿qué son? ¡Los ejemplos claros serían geniales! :RE
Solo unas pocas preguntas más: ¿cuáles son algunas aplicaciones prácticas de las operaciones bit a bit? ¿Cuándo podrías usarlos?
Cuando se menciona el término "bitwise", a veces se aclara que no es un operador "lógico".
Por ejemplo, en JavaScript, los operadores bit a bit tratan sus operandos como una secuencia de 32 bits (ceros y unos) ; Mientras tanto, los operadores lógicos se usan típicamente con valores booleanos (lógicos) pero pueden funcionar con tipos no booleanos.
Tome expr1 && expr2 por ejemplo.
Devuelve expr1 si se puede convertir a falso; de lo contrario, devuelve expr2. Por lo tanto, cuando se usa con valores booleanos, && devuelve verdadero si ambos operandos son verdaderos; de lo contrario, devuelve falso.
a = "Cat" && "Dog" // t && t returns Dog
a = 2 && 4 // t && t returns 4
Como otros han notado, 2 & 4 es un Y a nivel de bits, por lo que devolverá 0.
Puede copiar lo siguiente a test.html o algo así y probar:
<html>
<body>
<script>
alert("/"Cat/" && /"Dog/" = " + ("Cat" && "Dog") + "/n"
+ "2 && 4 = " + (2 && 4) + "/n"
+ "2 & 4 = " + (2 & 4));
</script>
Dado que nadie ha abordado el tema de por qué estos son útiles:
Uso operaciones bit a bit mucho cuando trabajo con banderas. Por ejemplo, si desea pasar una serie de banderas a una operación (por ejemplo, Archivo.Abrir, con el modo Leer y el modo Escritura ambos habilitados), podría pasarlos como un valor único. Esto se logra asignando cada bandera posible su propio bit en un conjunto de bits (byte, corto, int o largo). Por ejemplo:
Read: 00000001
Write: 00000010
Entonces, si quiere pasar a leer Y escribir, pasará (LEER | ESCRIBIR) y luego combinará los dos en
00000011
Que luego se puede descifrar en el otro extremo como:
if ((flag & Read) != 0) { //...
que verifica
00000011 &
00000001
que devuelve
00000001
que no es 0, entonces la bandera especifica LEER.
Puede usar XOR para alternar varios bits. Lo he usado cuando uso una bandera para especificar entradas direccionales (Arriba, Abajo, Izquierda, Derecha). Por ejemplo, si un sprite se mueve horizontalmente, y quiero que dé la vuelta:
Up: 00000001
Down: 00000010
Left: 00000100
Right: 00001000
Current: 00000100
Simplemente XOR el valor actual con (IZQUIERDA | DERECHA) que apagará IZQUIERDA y DERECHO a, en este caso.
El cambio de bit es útil en varios casos.
x << y
es lo mismo que
x * 2 y
si necesita multiplicar rápidamente por una potencia de dos, pero tenga cuidado de cambiar un bit de 1 en el bit superior; esto hace que el número sea negativo a menos que no esté firmado. También es útil cuando se trata de diferentes tamaños de datos. Por ejemplo, leyendo un entero de cuatro bytes:
int val = (A << 24) | (B << 16) | (C << 8) | D;
Suponiendo que A es el byte más significativo y D el menos. Terminaría así:
A = 01000000
B = 00000101
C = 00101011
D = 11100011
val = 01000000 00000101 00101011 11100011
Los colores a menudo se almacenan de esta manera (con el byte más significativo ignorado o usado como Alpha):
A = 255 = 11111111
R = 21 = 00010101
G = 255 = 11111111
B = 0 = 00000000
Color = 11111111 00010101 11111111 00000000
Para encontrar los valores de nuevo, simplemente desplace los bits hacia la derecha hasta que estén en la parte inferior, luego enmascare los bits restantes de orden superior:
Int Alpha = Color >> 24
Int Red = Color >> 16 & 0xFF
Int Green = Color >> 8 & 0xFF
Int Blue = Color & 0xFF
0xFF es lo mismo que 11111111. Entonces, esencialmente, para Red, estarías haciendo esto:
Color >> 16 = (filled in 00000000 00000000)11111111 00010101 (removed 11111111 00000000)
00000000 00000000 11111111 00010101 &
00000000 00000000 00000000 11111111 =
00000000 00000000 00000000 00010101 (The original value)
Estos son los operadores bit a bit, todos soportados en JavaScript:
op1 & op2: el operadorANDcompara dos bits y genera un resultado de 1 si ambos bits son 1; de lo contrario, devuelve 0.op1 | op2op1 | op2: el operadorORcompara dos bits y genera un resultado de 1 si los bits son complementarios; de lo contrario, devuelve 0.op1^ op2- El operadorEXCLUSIVE-ORcompara dos bits y devuelve 1 si cualquiera de los bits es 1 y da 0 si ambos bits son 0 o 1.~op1- El operador COMPLEMENTse usa para invertir todos los bits del operando.op1 << op2- El operadorSHIFT LEFTmueve los bits hacia la izquierda, descarta el bit más a la izquierda y asigna un valor de 0. El movimiento a la izquierda multiplica efectivamente op1 por 2.op1 >> op2-The SHIFT RIGHToperadorThe SHIFT RIGHTmueve los bits hacia la derecha, descarta el bit de la extrema derecha y asigna al bit de la extrema izquierda un valor de 0. Cada movimiento hacia la derecha divide efectivamente op1 por la mitad. El bit de signo más a la izquierda se conserva.op1 >>> op2-The SHIFT RIGHToperadorThe SHIFT RIGHT-ZERO FILLmueve los bits hacia la derecha, descarta el bit de la extrema derecha y asigna al bit de la izquierda un valor de 0. Cada movimiento hacia la derecha divide efectivamente op1 por la mitad. El bit de signo más a la izquierda se descarta.
Los operadores bit a bit son operadores que trabajan de a poco por vez.
AND es 1 solo si sus dos entradas son 1.
O es 1 si una o más de sus entradas son 1.
XOR es 1 solo si exactamente una de sus entradas es 1.
NOT es 1 solo si su entrada es 0.
Estos pueden describirse mejor como tablas de verdad. Las posibilidades de entrada están en la parte superior e izquierda, el bit resultante es uno de los cuatro (dos en el caso de NOT, ya que solo tiene una entrada) valores que se muestran en la intersección de las dos entradas.
AND|0 1 OR|0 1
---+---- ---+----
0|0 0 0|0 1
1|0 1 1|1 1
XOR|0 1 NOT|0 1
---+---- ---+---
0|0 1 |1 0
1|1 0
Un ejemplo es si solo desea los 4 bits más bajos de un entero, usted Y con 15 (1111 binarios) entonces:
203: 1100 1011
AND 15: 0000 1111
------------------
IS 11: 0000 1011
Para dividirlo un poco más, tiene mucho que ver con la representación binaria del valor en cuestión.
For example (in decimal): x = 8 y = 1 would come out to (in binary): x = 1000 y = 0001 From there, you can do computational operations such as ''and'' or ''or''; in this case: x | y = 1000 0001 | ------ 1001 or...9 in decimal
Espero que esto ayude.
Podría ayudar pensar de esta manera. Así es como AND (&) funciona:
Básicamente dice que son ambos números, así que si tienes dos números 5 y 3, se convertirán en binarios y la computadora pensará
5: 00000101
3: 00000011
son ambos uno: 00000001 0 es falso, 1 es verdadero
Entonces el AND de 5 y 3 es uno. El operador OR (|) hace lo mismo, excepto que solo uno de los números debe ser uno para la salida 1, no ambos.
Seguí escuchando acerca de lo lento que eran los operadores bit a bit de JavaScript. Hice algunas pruebas para mi última publicación en el blog y descubrí que eran entre un 40% y un 80% más rápidas que la alternativa aritmética en varias pruebas. Quizás solían ser lentos. En los navegadores modernos, los amo.
Tengo un caso en mi código que será más rápido y fácil de leer debido a esto. Mantendré mis ojos abiertos por más.
Vale la pena señalar que las tablas de verdad de un solo bit enumeradas como otras respuestas solo funcionan en uno o dos bits de entrada a la vez. Qué sucede cuando usas números enteros, como:
int x = 5 & 6;
La respuesta está en la expansión binaria de cada entrada:
5 = 0 0 0 0 0 1 0 1
& 6 = 0 0 0 0 0 1 1 0
---------------------
0 0 0 0 0 1 0 0
Cada par de bits en cada columna se ejecuta a través de la función "Y" para dar el bit de salida correspondiente en la línea inferior. Entonces la respuesta a la expresión anterior es 4. La CPU ha hecho (en este ejemplo) 8 operaciones "Y" separadas en paralelo, una para cada columna.
Menciono esto porque aún recuerdo haber tenido este "¡AHA!" momento en que aprendí sobre esto hace muchos años.