Logique ET. Définit chaque bit à 1 si les deux bits sont à 1
OU logique. Définit chaque bit à 1 si l'un des deux bits est 1
Logique XOR. Définit chaque bit sur 1 si un seul des deux bits est 1
Logique NON. Inverse tous les bits
Changement de remplissage à gauche à zéro. Se déplace vers la gauche en poussant les zéros depuis la droite et laisse tomber les bits les plus à gauche
Décalage à droite signé. Se déplace vers la droite en poussant les copies du bit le plus à gauche depuis la gauche, et laisse les bits les plus à droite tomber
Changement de remplissage à droite à zéro. Se déplace vers la droite en poussant les zéros depuis la gauche et laisse les bits les plus à droite tomber
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 stocke les nombres sous forme de nombres à virgule flottante de 64 bits, mais tous au niveau du bit les opérations sont effectuées sur des nombres binaires de 32 bits.
Avant qu'une opération au niveau du bit soit effectuée, JavaScript convertit les nombres en 32 bits entiers signés.
Une fois l'opération au niveau du bit effectuée, le résultat est reconverti en JavaScript 64 bits Nombres.
Les exemples ci-dessus utilisent des nombres binaires non signés de 4 bits. Pour cette raison, ~ 5 renvoie 10.
Puisque JavaScript utilise des entiers signés de 32 bits, il ne renverra pas 10. Il renverra -6.
00000000000000000000000000000101 (5)
1111111111111111111111111111010 (~5=-6)
Un entier signé utilise le bit le plus à gauche comme signe moins.
Lorsqu'un ET au niveau du bit est effectué sur une paire de bits, il renvoie 1 si les deux bits sont 1.
0
0
0
1
0000
0001
0010
0100
Lorsqu'un OU bit à bit est effectué sur une paire de bits, il renvoie 1 si l'un des bits est 1 :
0
1
1
1
1111
1111
1111
1111
Lorsqu'un XOR au niveau du bit est effectué sur une paire de bits, il renvoie 1 si les bits sont différents :
0
1
1
0
1111
1110
1101
1011
AND au niveau du bit renvoie 1 uniquement si les deux bits sont 1 :
00000000000000000000000000000101
00000000000000000000000000000001
00000000000000000000000000000001 (1)
let x = 5 & 1;
Essayez-le vous-même →
<!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>
Bitwise OR renvoie 1 si l'un des bits est 1 :
00000000000000000000000000000101
00000000000000000000000000000001
00000000000000000000000000000101 (5)
let x = 5 | 1;
Essayez-le vous-même →
<!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 renvoie 1 si les bits sont différents :
00000000000000000000000000000101
00000000000000000000000000000001
00000000000000000000000000000100 (4)
let x = 5 ^ 1;
Essayez-le vous-même →
<!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;
Essayez-le vous-même →
<!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>
Il s'agit d'un décalage vers la gauche à remplissage nul. Un ou plusieurs bits zéro sont poussés depuis la droite, et les bits les plus à gauche tombent :
00000000000000000000000000000101
00000000000000000000000000001010 (10)
let x = 5 << 1;
Essayez-le vous-même →
<!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>
C'est un signe préservant le décalage à droite. Les copies du bit le plus à gauche sont poussées depuis la gauche, et les bits les plus à droite tombent :
11111111111111111111111111111011
1111111111111111111111111111101 (-3)
let x = -5 >> 1;
Essayez-le vous-même →
<!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>
Il s'agit d'un décalage vers la droite à remplissage nul. Un ou plusieurs bits zéro sont poussés depuis la gauche, et les bits les plus à droite tombent :
00000000000000000000000000000101
00000000000000000000000000000010 (2)
let x = 5 >>> 1;
Essayez-le vous-même →
<!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>
Les nombres binaires avec un seul bit défini sont faciles à comprendre :
1
2
4
8
16
32
64
La définition de quelques bits supplémentaires révèle le modèle binaire :
5 (4 + 1)
13 (8 + 4 + 1)
45 (32 + 8 + 4 + 1)
Les nombres binaires JavaScript sont stockés au format complément à deux.
Cela signifie qu'un nombre négatif est le NON au niveau du bit du nombre plus 1 :
5
-5
6
-6
40
-40
Il n’existe que 10 types de personnes dans le monde : celles qui comprennent le binaire et celles qui ne le comprennent pas.
function dec2bin(dec){
return (dec >>> 0).toString(2);
}
Essayez-le vous-même →
<!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);
}
Essayez-le vous-même →
<!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>