Lógica Y. Establece cada bit en 1 si ambos bits son 1
Lógica O. Establece cada bit en 1 si uno de los dos bits es 1
XOR lógico. Establece cada bit en 1 si solo uno de dos bits es 1
Lógica NO. Invierte todos los bits
Desplazamiento a la izquierda con relleno cero. Se desplaza hacia la izquierda empujando ceros desde la derecha y dejando que los bits más a la izquierda caigan
Desplazamiento a la derecha firmado. Se desplaza hacia la derecha empujando copias del bit más a la izquierda desde la izquierda y dejando que los bits más a la derecha caerse
Desplazamiento a la derecha de relleno cero. Se desplaza hacia la derecha empujando ceros desde la izquierda y deja que los bits más a la derecha caigan
| Operation | Result | Same as | Result |
|---|---|---|---|
| 5 & 1 | 1 | 0101 & 0001 | 0001 |
| 5 | 1 | 5 | 0101 | 0001 | 0101 |
| ~ 5 | 10 | ~0101 | 1010 |
| 5 << 1 | 10 | 0101 << 1 | 1010 |
| 5 ^ 1 | 4 | 0101 ^ 0001 | 0100 |
| 5 >> 1 | 2 | 0101 >> 1 | 0010 |
| 5 >>> 1 | 2 | 0101 >>> 1 | 0010 |
JavaScript almacena números como números de punto flotante de 64 bits, pero todo bit a bit Las operaciones se realizan en números binarios de 32 bits.
Antes de realizar una operación bit a bit, JavaScript convierte números a 32 bits enteros con signo.
Una vez realizada la operación bit a bit, el resultado se vuelve a convertir a JavaScript de 64 bits. números.
Los ejemplos anteriores utilizan números binarios sin signo de 4 bits. Por esta razón ~ 5 devuelve 10.
Dado que JavaScript utiliza enteros con signo de 32 bits, no devolverá 10. Devolverá -6.
00000000000000000000000000000101 (5)
11111111111111111111111111111010 (~5=-6)
Un entero con signo utiliza el bit más a la izquierda como signo menos.
Cuando se realiza un AND bit a bit en un par de bits, devuelve 1 si ambos bits son 1.
0
0
0
1
0000
0001
0010
0100
Cuando se realiza un OR bit a bit en un par de bits, devuelve 1 si uno de los bits es 1:
0
1
1
1
1111
1111
1111
1111
Cuando se realiza un XOR bit a bit en un par de bits, devuelve 1 si los bits son diferentes:
0
1
1
0
1111
1110
1101
1011
Bit a bit AND devuelve 1 solo si ambos bits son 1:
00000000000000000000000000000101
00000000000000000000000000000001
000000000000000000000000000000001 (1)
let x = 5 & 1;Pruébelo usted mismo →
<!DOCTYPE html>
<html>
<body>
<h1>JavaScript Bitwise AND</h1>
<h2>The & Operator</h2>
<p id="demo"></p>
<script>
document.getElementById("demo").innerHTML = 5 & 1;
</script>
</body>
</html>
Bit a bit OR devuelve 1 si uno de los bits es 1:
00000000000000000000000000000101
00000000000000000000000000000001
00000000000000000000000000000101 (5)
let x = 5 | 1;Pruébelo usted mismo →
<!DOCTYPE html>
<html>
<body>
<h1>JavaScript Bitwise OR</h1>
<h2>The | Operator</h2>
<p id="demo"></p>
<script>
document.getElementById("demo").innerHTML = 5 | 1;
</script>
</body>
</html>
Bitwise XOR devuelve 1 si los bits son diferentes:
00000000000000000000000000000101
00000000000000000000000000000001
00000000000000000000000000000100 (4)
let x = 5 ^ 1;Pruébelo usted mismo →
<!DOCTYPE html>
<html>
<body>
<h1>JavaScript Bitwise XOR</h1>
<h2>The ^ Operator</h2>
<p id="demo"></p>
<script>
document.getElementById("demo").innerHTML = 5 ^ 1;
</script>
</body>
</html>
00000000000000000000000000000101
11111111111111111111111111111010 (-6)
let x = ~5;Pruébelo usted mismo →
<!DOCTYPE html>
<html>
<body>
<h1>JavaScript Bitwise NOT</h1>
<h2>The ~ Operator</h2>
<p id="demo"></p>
<script>
document.getElementById("demo").innerHTML = ~ 5;
</script>
</body>
</html>
Este es un desplazamiento a la izquierda con relleno cero. Uno o más bits cero se introducen desde la derecha, y los bits más a la izquierda se caen:
00000000000000000000000000000101
00000000000000000000000000001010 (10)
let x = 5 << 1;Pruébelo usted mismo →
<!DOCTYPE html>
<html>
<body>
<h1>JavaScript Bitwise Left</h1>
<h2>The << Operator</h2>
<p id="demo"></p>
<script>
document.getElementById("demo").innerHTML = 5 << 1;
</script>
</body>
</html>
Esta es una señal que preserva el desplazamiento a la derecha. Se envían copias del bit más a la izquierda. desde la izquierda, y los bits más a la derecha caen:
11111111111111111111111111111011
11111111111111111111111111111101 (-3)
let x = -5 >> 1;Pruébelo usted mismo →
<!DOCTYPE html>
<html>
<body>
<h1>JavaScript Signed Bitwise Right</h1>
<h2>The >> Operator</h2>
<p id="demo"></p>
<script>
document.getElementById("demo").innerHTML = -5 >> 1;
</script>
</body>
</html>
Este es un desplazamiento a la derecha de relleno cero. Uno o más bits cero se introducen desde la izquierda, y los bits de la derecha se caen:
00000000000000000000000000000101
00000000000000000000000000000010 (2)
let x = 5 >>> 1;Pruébelo usted mismo →
<!DOCTYPE html>
<html>
<body>
<h1>JavaScript Unsigned Bitwise Right</h1>
<h2>The >>> Operator</h2>
<p id="demo"></p>
<script>
document.getElementById("demo").innerHTML = 5 >>> 1;
</script>
</body>
</html>
Los números binarios con un solo bit configurado son fáciles de entender:
1
2
4
8
16
32
64
Configurar algunos bits más revela el patrón binario:
5 (4+1)
13 (8+4+1)
45 (32+8+4+1)
Los números binarios de JavaScript se almacenan en formato complemento a dos.
Esto significa que un número negativo es el NO bit a bit del número más 1:
5
-5
6
-6
40
-40
Sólo hay 10 tipos de personas en el mundo: las que entienden el sistema binario y las que no.
function dec2bin(dec){
return (dec >>> 0).toString(2);
}Pruébelo usted mismo →
<!DOCTYPE html>
<html>
<body>
<h1>JavaScript Convert Decimal to Binary</h1>
<p id="demo"></p>
<script>
document.getElementById("demo").innerHTML = dec2bin(-5);
function dec2bin(dec){
return (dec >>> 0).toString(2);
}
</script>
</body>
</html>
function bin2dec(bin){
return parseInt(bin, 2).toString(10);
}Pruébelo usted mismo →
<!DOCTYPE html>
<html>
<body>
<h2>JavaScript Convert Binary to Decimal</h2>
<p id="demo"></p>
<script>
document.getElementById("demo").innerHTML = bin2dec(101);
function bin2dec(bin){
return parseInt(bin, 2).toString(10);
}
</script>
</body>
</html>