Las palabras anteriores
Los operadores de bit son operaciones muy subyacentes y no se usan comúnmente porque no son intuitivos. Sin embargo, es extremadamente rápido y puede lograr buenos resultados cuando se usa razonablemente. Este artículo presentará al operador a menudo pasado por alto en JavaScript - Operador BIT
Representación binaria
Todos los valores en ECMAScript se almacenan en formato IEEE-754 de 64 bits, pero el operador de bits no opera directamente el valor de 64 bits, pero se calcula como un entero firmado de 32 bits, y el valor de retorno también es un entero firmado de 32 bits.
Esta conversión de bits permite que ambos valores se traten como 0 al aplicar operaciones de bits a valores especiales de NAN e Infinity
Si se aplica un operador de Bit a un valor no numérico, el valor se convertirá en un valor numérico usando Número () primero, y el resultado es un valor numérico
// '|' significa un bitwise o, un entero y 0 bitwise u operación puede obtenerse, y un decimal y 0 bitwise u operación puede obtener el efecto de redondeo console.log (1.3 | 0); // 1console.log (1.8 | 0); // 1console.log (infinity | 0); // 0console.log (-infinity | 0); // 0console 0); // 0console.log ('12px' | 0); // 0console.log ('12 '| 0); // 12Un entero firmado utiliza el primer 31 de los 32 bits para representar el valor entero, el 32 bits para representar el símbolo entero, 0 representa el número positivo y 1 representa el número negativo. El bit que representa un símbolo se llama bit de signo, y el valor del bit de signo determina el formato de otros valores de bits. Entre ellos, los números positivos se almacenan en formato binario puro, y cada uno de los 31 bits representa un poder de 2. El primer bit (llamado bit 0) representa 0 veces de 2, el segundo bit representa 1 tiempo de 2, y así sucesivamente. Los bits no utilizados están llenos de 0, es decir, se ignoran.
Por ejemplo, la representación binaria del valor numérico 18 es 000000000000000000000000000010010, o los 10010 más concisos. Estos son 5 bits válidos, y estos 5 bits en sí mismos determinan el valor real
console.log ((18) .ToString (2)); // "10010"
console.log (0b000000000000000000000000000000000010010); // 18
Los números negativos también se almacenan en binario, pero el formato utilizado está en el complemento de dos. Para calcular un complemento numérico de dos, debe pasar por los siguientes 3 pasos:
【1】 Encuentre el código binario del valor absoluto de este valor numérico
【2】 Encuentre el código inverso binario, es decir, reemplace 0 con 1, reemplace 1 con 0
【3】 El código inverso binario obtenido se agrega a 1
Por ejemplo, para determinar una representación binaria de -18, primero debe obtener una representación binaria de 18, como se muestra a continuación:
0000 0000 0000 0000 0000 0000 0001 0010
A continuación, calcule el código inverso binario de la siguiente manera:
1111 1111 1111 1111 1111 1111 1111 1110 1101
Finalmente, agregue 1 al código inverso binario, como sigue:
1111 1111 1111 1111 1111 1111 1110 1101 1 --------------------------------------------------------------------------------------- ---------------------------------------------------------------------------------------
Por lo tanto, la representación binaria de -18 es 1111 1111 1111 1111 1111 1111 1111 1111 1110 1110
ECMAScript hará todo lo posible para ocultar toda esta información de nosotros. Al emitir un número negativo en forma de una cadena binaria, todo lo que vemos es que el código binario con el valor absoluto de este número negativo está precedido por un signo negativo.
var num = -18; console.log (num.ToString (2)); // ' -10010'
El operador de bits puede realizar 7 tipos de operaciones, incluidas las no (no (no), no (no), (y), bit a bit o (o), exclusivo de bit a bit o (Xor), desplazamiento izquierdo, cambio derecho firmado y desplazamiento derecho sin firmar.
Bitwise no (no)
El no operador bit a bit está representado por una línea ondulada (~). El resultado de ejecutar el no operador bitwise es devolver el código inverso del valor. Su esencia es menos el valor negativo del operando por 1
var num1 = 25; var num2 = ~ num1; console.log (num2); //-26
Puede obtener el efecto de redacción por doble bit a bit para un entero; Puede obtener el efecto de redacción por doble bit a bit para un decimal.
console.log (~~ 3); // 3console.log (~~ 3.1); // 3console.log (~~ 3.9); // 3
Bit a bit y (y)
El bitwise y el operador están representados por un símbolo de suma (&), que tiene dos números de operador. Esencialmente, Bitwise y la operación es alinear cada bit de dos valores, y luego realizar una operación y una operación en dos números en la misma posición de acuerdo con las reglas en la siguiente tabla.
El primer valor bit del segundo valor de resultado del bit 1 1 11 0 00 1 00 0 0 0 0 0 0
Bit a bit y la operación devolverán 1 solo si los bits correspondientes de los dos valores son 1. Cualquier bit es 0, y el resultado es 0.
var es IRESULT = 25 & 3; console.log (IRESULT); // "1"
//Analysis is as follows 25 = 0000 0000 0000 0000 0000 0000 0001 1001 3 = 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0001
bit a bit o (o)
El bitwise u operador está representado por un símbolo vertical (|), y también hay dos operandos. La operación de bit a bits sigue la siguiente tabla de verdad
El primer valor bit del segundo valor de bit Resultado 1 1 11 0 10 1 10 0 0 0
Bit a bit o la operación devuelve 1 si un bit es 1, y solo si ambos bits son 0.
VAR IRESULT = 25 | 3; console.log (IRESULT); // "27"
// El análisis es el siguiente 25 = 0000 0000 0000 0000 0000 0000 0001 1001 3 = 0000 0000 0000 0000 0000 0000 0000 0000 0001 1011
Un entero y 0 bitwise u operaciones pueden obtenerlo, y un decimal y 0 bitwise u operación puede obtener el efecto de redondeo
console.log (3.1 | 0); // 3console.log (3.9 | 0); // 3
Xor bitwise (Xor)
El operador XOR bitwise está representado por un careto (^) y tiene dos operandos. La siguiente es la tabla de verdad de bitwise xor
El bit del primer valor el bit del segundo valor 1 1 01 0 10 1 10 0 0 0
Devuelve 0 cuando los dos valores de XOR bitwise son los mismos, y regresan 1 cuando no al mismo tiempo
var IResult = 25 ^ 3; console.log (IRESULT); // "26"
// El análisis es el siguiente 25 = 0000 0000 0000 0000 0000 0000 0001 1001 3 = 0000 0000 0000 0000 0000 0000 0000 0000 0001 1010
La "operación de exoroor" tiene un uso especial, que realiza tres operaciones XOR en dos números A y B en sucesión, aˆ = b, bˆ = a, aˆ = b, y sus valores se pueden cambiar. Esto significa que el uso de "exclusiva u operación" puede intercambiar los valores de dos variables sin introducir variables temporales
var a = 10, b = 9; a ^= b, b ^= a, a ^= b; console.log (a, b); // 9,10
// El análisis es el siguiente A = 0000 0000 0000 0000 0000 0000 0000 0000 1010 B = 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0011 B = 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 001 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 IN 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 1001 ------------------------------------------------------------------------------------------- ---------------------------------------------------------------------------------------------------
Un entero con 0 bitwise xor puede mantenerse a sí mismo, y un decimal con 0 bitwise xor puede ser redondeado
console.log (3.1 ^ 0); // 3console.log (3.9 ^ 0); // 3
Mover a la izquierda
El operador de cambio izquierdo está representado por dos signos menos que (<<). Este operador moverá todos los bits del valor hacia la izquierda por el número especificado de bits.
Por ejemplo, si el valor 2 (el código binario es 10) se desplaza 5 bits hacia la izquierda, el resultado es 64 (1000000)
var OldValue = 2; var newValue = OldValue << 5; console.log (newValue); // 64
Mover a la izquierda no afectará el bit de signo del operando. En otras palabras, si -2 se mueve 5 bits a la izquierda, el resultado será -64
var OldValue = -2; var newValue = OldValue << 5; console.log (newValue); // -64
El cambio de izquierda 0 bits puede lograr un efecto de redondeo
console.log (3.1 << 0); // 3console.log (3.9 << 0); // 3
Firmado a la derecha
El operador de cambio derecho firmado está representado por dos signos mayores que (>>), que mueve el valor hacia la derecha, pero conserva los bits de signo (es decir, marcas de signos). La operación de desplazamiento derecho firmado es exactamente lo opuesto a la operación de desplazamiento izquierdo, es decir, si 64 se mueve 5 bits a la derecha, el resultado se cambiará a 2.
var OldValue = 64; var newValue = OldValue >> 5; console.log (newValue); // 2
Del mismo modo, durante el proceso de cambio, la vacante también aparecerá en el valor original. Sin embargo, esta vez la vacante aparece en el lado izquierdo del valor original y en el lado derecho del bit de signo. En este momento, ECMAScript llenará todos los espacios vacíos con el valor del bit de signo para obtener un valor completo
Muévete a la derecha para simular la operación del divisor de 2
console.log (5 >> 1); // 2console.log (15 >> 1); // 7
Derecho sin firmar
El operador de desplazamiento derecho sin firmar está representado por 3 más grandes que los signos (>>>), que mueve los 32 bits del valor a la derecha. Para números positivos, el resultado del cambio derecho sin firmar es el mismo que el cambio derecho firmado. Es conveniente mover el letrero justo en frente. Si mueve el 64 sin firmar por 5 bits, el resultado sigue siendo 2
var OldValue = 64; var newValue = OldValue >>> 5; console.log (newValue); // 2
Sin embargo, el número negativo es diferente. Primero, el cambio derecho sin firmar llena el bit vacío con 0, en lugar de llenar el bit vacío con el valor del bit firmado como el cambio derecho firmado. Por lo tanto, el resultado del cambio derecho sin firmar a un número positivo es el mismo que el resultado de un cambio de título a un título, pero el resultado de un número negativo es diferente. En segundo lugar, el operador de cambio derecho sin firmar tratará el código binario negativo como el código binario positivo. Además, dado que el número negativo está representado en el complemento de los dos de su valor absoluto, el resultado será muy grande después del cambio derecho sin firmar.
var OldValue = -64; var newValue = OldValue >>> 5; Console.log (NewValue) // 134217726
Para determinar la representación binaria de -64, primero debe obtener la representación binaria de 64, como se muestra a continuación:
0000 0000 0000 0000 0000 0000 0100 0000
A continuación, calcule el código inverso binario de la siguiente manera:
1111 1111 1111 1111 1111 1111 1111 1011 11111
Finalmente, agregue 1 al código inverso binario como se muestra a continuación
1111 1111 1111 1111 1111 1111 1111 1011 1111 1 ---------------------------------------------------------------------------
Después de mover 5 bits hacia la derecha, como se muestra a continuación:
0000 0111 1111 1111 1111 1111 11111 11111 1110console.log (0b00000111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
Aplicaciones comunes
【1】 Operación múltiple
Use el desplazamiento izquierdo (<<) para realizar la operación de multiplicación
console.log (2 << 1); // 4console.log (3 << 1); // 6console.log (4 << 1); // 8
【2】 Divide la operación
Use el desplazamiento derecho firmado (>>) para simular la operación del divisor de 2
console.log (2 >> 1); // 1console.log (5 >> 1); // 2console.log (8 >> 1); // 4console.log (9 >> 1); // 4console.log (9 >> 1); // 4
【3】 Swap de valor
El efecto del intercambio de valor se puede lograr utilizando la operación XOR (^)
var a = 10, b = 9; a ^= b, b ^= a, a ^= b; console.log (a, b); // 9,10
【4】 Resume el decimal
El efecto de redondeo decimal se puede lograr tomando dos no bits bitwise, 0 bitwise o, 0 bitwise o, 0 bits izquierda y 0 bits a la derecha.
console.log (~~ 3.1); // 3console.log (3.1 | 0); // 3console.log (3.1^0); // 3console.log (3.1 << 0); // 3console.log (3.1 >> 0); // 3console.log (3.1 >> 0); // 3
【5】 Switch
El operador de bit se puede usar como un interruptor para establecer las propiedades del objeto. Suponga que un objeto tiene cuatro interruptores, cada interruptor es una variable. Luego, puede establecer un número binario de cuatro bits, cada uno de los cuales corresponde a un interruptor.
var flag_a = 1; // 0001var flag_b = 2; // 0010var flag_c = 4; // 0100Var Flag_d = 8; // 1000
El código anterior establece cuatro interruptores A, B, C y D, cada interruptor tiene un bit binario respectivamente.
Ahora suponga que los tres interruptores ABD deben activarse, podemos construir una variable de máscara
Var Mask = flag_a | Flag_b | Flag_d; // 0001 | 0010 | 1000 => 1011
El código anterior realiza "u operación" en tres variables ABD para obtener 1011 con un valor de máscara de binario
// "Operación" asegura que el interruptor especificado se encienda los flags = flags | mascarilla;
// "Association" puede desactivar todos los elementos en la configuración actual que son diferentes de la configuración del conmutador. banderas = banderas y máscara;
// "Exclusivo u operación" puede cambiar (alternar) la configuración actual, es decir, el valor inverso de la configuración actual se puede obtener por primera vez, y el valor original se puede obtener ejecutando nuevamente. Banderas = banderas ^ máscara;
// "Sin operación" puede voltear la configuración actual, es decir, la configuración original es 0, y se convierte en 1 después de la operación; La configuración original es 1, y se convierte en 0flags después de la operación = ~ banderas;
La introducción integral anterior al operador JavaScript - BIT Operator es todo el contenido compartido por el editor. Espero que pueda darle una referencia y espero que apoye más a Wulin.com.