JavaScript au niveau du bit


Table des matières

    Afficher la table des matières


Opérateurs au niveau du bit JavaScript

&

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

Exemples

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 utilise des opérandes au niveau du bit 32 bits

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.



JavaScript au niveau du bit ET

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

0 & 1

0

1 & 0

0

1 & 1

1

1111 & 0000

0000

1111 & 0001

0001

1111 & 0010

0010

1111 & 0100

0100


JavaScript OU au niveau du bit

Lorsqu'un OU bit à bit est effectué sur une paire de bits, il renvoie 1 si l'un des bits est 1 :

0 | 0

0

0 | 1

1 | 0

1

1 | 1

1

1111 | 0000

1111

1111 | 0001

1111

1111 | 0010

1111

1111 | 0100

1111


XOR au niveau du bit JavaScript

Lorsqu'un XOR au niveau du bit est effectué sur une paire de bits, il renvoie 1 si les bits sont différents :

0 ^ 0

0

0 ^ 1

1 ^ 0

1

1 ^ 1

1111 ^ 0000

1111

1111 ^ 0001

1110

1111 ^ 0010

1101

1111 ^ 0100

1011


JavaScript au niveau du bit AND (&)

AND au niveau du bit renvoie 1 uniquement si les deux bits sont 1 :

5

00000000000000000000000000000101

1

00000000000000000000000000000001

5 & 1

00000000000000000000000000000001 (1)

Exemple

let x = 5 & 1;

Essayez-le vous-même →

<!DOCTYPE html>
<html>
<body>

<h1>JavaScript Bitwise AND</h1>
<h2>The &amp; Operator</h2>

<p id="demo"></p>

<script>
document.getElementById("demo").innerHTML = 5 & 1;
</script>

</body>
</html> 

JavaScript OU au niveau du bit (|)

Bitwise OR renvoie 1 si l'un des bits est 1 :

5

00000000000000000000000000000101

1

00000000000000000000000000000001

5 | 1

00000000000000000000000000000101 (5)

Exemple

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>

XOR au niveau du bit JavaScript (^)

Bitwise XOR renvoie 1 si les bits sont différents :

5

00000000000000000000000000000101

1

00000000000000000000000000000001

5 ^ 1

00000000000000000000000000000100 (4)

Exemple

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>

JavaScript au niveau du bit NON (~)

5

00000000000000000000000000000101

~5

1111111111111111111111111111010 (-6)

Exemple

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>

JavaScript (remplissage zéro) Maj gauche au niveau du bit (<<)

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 :

5

00000000000000000000000000000101

5 << 1

00000000000000000000000000001010 (10)

Exemple

let x = 5 << 1;

Essayez-le vous-même →

<!DOCTYPE html>
<html>
<body>

<h1>JavaScript Bitwise Left</h1>
<h2>The &lt;&lt; Operator</h2>

<p id="demo"></p>

<script>
document.getElementById("demo").innerHTML = 5 << 1;
</script>

</body>
</html>

JavaScript (préservation des signes) Décalage bit à droite vers la droite (>>)

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 :

-5

11111111111111111111111111111011

-5 >> 1

1111111111111111111111111111101 (-3)

Exemple

let x = -5 >> 1;

Essayez-le vous-même →

<!DOCTYPE html>
<html>
<body>

<h1>JavaScript Signed Bitwise Right</h1>
<h2>The &gt;&gt; Operator</h2>

<p id="demo"></p>

<script>
document.getElementById("demo").innerHTML = -5 >> 1;
</script>

</body>
</html>

JavaScript (remplissage zéro) Maj droite (>>>)

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 :

5

00000000000000000000000000000101

5 >>> 1

00000000000000000000000000000010 (2)

Exemple

let x = 5 >>> 1;

Essayez-le vous-même →

<!DOCTYPE html>
<html>
<body>

<h1>JavaScript Unsigned Bitwise Right</h1>
<h2>The &gt;&gt;&gt; Operator</h2>

<p id="demo"></p>

<script>
document.getElementById("demo").innerHTML = 5 >>> 1;
</script>

</body>
</html>

Nombres binaires

Les nombres binaires avec un seul bit défini sont faciles à comprendre :

00000000000000000000000000000001

1

00000000000000000000000000000010

2

00000000000000000000000000000100

4

00000000000000000000000000001000

8

00000000000000000000000000010000

16

00000000000000000000000000100000

32

00000000000000000000000001000000

64

La définition de quelques bits supplémentaires révèle le modèle binaire :

00000000000000000000000000000101

5 (4 + 1)

00000000000000000000000000001101

13 (8 + 4 + 1)

00000000000000000000000000101101

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 :

00000000000000000000000000000101

5

11111111111111111111111111111011

-5

00000000000000000000000000000110

6

11111111111111111111111111111010

-6

00000000000000000000000000101000

40

11111111111111111111111111011000

-40

Blague :

Il n’existe que 10 types de personnes dans le monde : celles qui comprennent le binaire et celles qui ne le comprennent pas.


Conversion de décimal en binaire

Exemple

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>

Conversion de binaire en décimal

Exemple

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>