Lógica E. Define cada bit como 1 se ambos os bits forem 1
Lógica OU. Define cada bit como 1 se um dos dois bits for 1
Lógica XOR. Define cada bit como 1 se apenas um dos dois bits for 1
Lógica NÃO. Inverte todos os bits
Preenchimento zero, deslocamento à esquerda. Muda para a esquerda pressionando zeros da direita e deixando os bits mais à esquerda caírem
Mudança à direita assinada. Desloca para a direita empurrando cópias do bit mais à esquerda a partir da esquerda e deixando os bits mais à direita caiu fora
Preenchimento zero, deslocamento para a direita. Muda para a direita pressionando zeros da esquerda e deixando os bits mais à direita caírem
| 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 armazena números como números de ponto flutuante de 64 bits, mas todos bit a bit as operações são realizadas em números binários de 32 bits.
Antes de uma operação bit a bit ser executada, o JavaScript converte números em 32 bits inteiros assinados.
Após a operação bit a bit ser executada, o resultado é convertido novamente para JavaScript de 64 bits números.
Os exemplos acima usam números binários não assinados de 4 bits. Por causa disso ~ 5 retorna 10.
Como o JavaScript usa números inteiros assinados de 32 bits, ele não retornará 10. Ele retornará -6.
00000000000000000000000000101 (5)
1111111111111111111111111111010 (~5=-6)
Um inteiro assinado usa o bit mais à esquerda como sinal de menos.
Quando um AND bit a bit é executado em um par de bits, ele retorna 1 se ambos os bits forem 1.
0
0
0
1
0000
0001
0010
0100
Quando um OR bit a bit é executado em um par de bits, ele retorna 1 se um dos bits for 1:
0
1
1
1
1111
1111
1111
1111
Quando um XOR bit a bit é executado em um par de bits, ele retorna 1 se os bits forem diferentes:
0
1
1
0
1111
1110
1101
1011
AND bit a bit retorna 1 somente se ambos os bits forem 1:
00000000000000000000000000000101
00000000000000000000000000000001
00000000000000000000000000001 (1)
let x = 5 & 1;Experimente você mesmo →
<!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>
OR bit a bit retorna 1 se um dos bits for 1:
00000000000000000000000000000101
00000000000000000000000000000001
00000000000000000000000000101 (5)
let x = 5 | 1;Experimente você mesmo →
<!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>
XOR bit a bit retorna 1 se os bits forem diferentes:
00000000000000000000000000000101
00000000000000000000000000000001
00000000000000000000000000100 (4)
let x = 5 ^ 1;Experimente você mesmo →
<!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
1111111111111111111111111111010 (-6)
let x = ~5;Experimente você mesmo →
<!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 é um deslocamento à esquerda com preenchimento zero. Um ou mais bits zero são inseridos da direita, e os bits mais à esquerda caem:
00000000000000000000000000000101
00000000000000000000000001010 (10)
let x = 5 << 1;Experimente você mesmo →
<!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>
Este é um sinal que preserva a mudança para a direita. Cópias do bit mais à esquerda são enviadas da esquerda, e os bits mais à direita caem:
11111111111111111111111111111011
1111111111111111111111111111101 (-3)
let x = -5 >> 1;Experimente você mesmo →
<!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 é um deslocamento para a direita com preenchimento zero. Um ou mais bits zero são inseridos da esquerda, e os bits mais à direita caem:
00000000000000000000000000000101
00000000000000000000000000010 (2)
let x = 5 >>> 1;Experimente você mesmo →
<!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>
Números binários com apenas um bit definido são fáceis de entender:
1
2
4
8
16
32
64
Definir mais alguns bits revela o padrão binário:
5 (4 + 1)
13 (8 + 4 + 1)
45 (32 + 8 + 4 + 1)
Os números binários JavaScript são armazenados no formato de complemento de dois.
Isso significa que um número negativo é o NOT bit a bit do número mais 1:
5
-5
6
-6
40
-40
Existem apenas 10 tipos de pessoas no mundo: aquelas que entendem binário e aquelas que não entendem.
function dec2bin(dec){
return (dec >>> 0).toString(2);
}Experimente você mesmo →
<!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);
}Experimente você mesmo →
<!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>