Dans ce didacticiel, vous découvrirez les opérateurs de bits JavaScript et leurs types à l'aide d'exemples.
Opérateurs JavaScript au niveau du bit
Les opérateurs au niveau du bit traitent ses opérandes comme un ensemble de chiffres binaires 32 bits (zéros et uns) et effectuent des actions. Cependant, le résultat est affiché sous forme de valeur décimale.
| Les opérateurs | Nom | Exemple |
|---|---|---|
& | ET au niveau du bit | x & y |
| | OU au niveau du bit | x | y |
^ | XOR au niveau du bit | x y |
~ | Pas au niveau du bit | ~x |
<< | Décalage à gauche | x << y |
>> | Décalage à droite se propageant par signe | x>> y |
>>> | Décalage à droite sans remplissage | x>>> y |
Remarque : Les nombres entiers minimum et maximum représentables via un nombre signé 32 bits sont compris entre -2147483648 et 2147483647.
JavaScript au niveau du bit ET
ET au niveau du bit &renvoie 1 si les bits correspondants des deux opérandes sont 1, sinon il renvoie 0 .
| Opérande 1 | Opérande 2 | ET Fonctionnement |
|---|---|---|
| 0 | 0 | 0 & 0vaut 0 |
| 0 | 1 | 0 & 1vaut 0 |
| 1 | 0 | 1 & 0vaut 0 |
| 1 | 1 | 1 & 1vaut 1 |
Jetons un coup d'œil à l'opération ET au niveau du bit de deux entiers 12 et 25 .
En binaire, 12 = 01100 25 = 11001 // Bitwise AND Fonctionnement de 12 et 25 00001100 & 00011001 --------- 00001000 = 8 (en décimal)
Remarque : la conversion du binaire 12 en 32 bits nous donne 00000000000000000000000000001100et 25 donne 00000000000000000000000000011001. Cependant, nous avons supprimé les zéros précédents pour plus de simplicité.
Exemple 1: opérateur AND au niveau du bit
// bitwise AND operator example let a = 12; let b = 25; result = a & b; console.log(result); // 8
Dans le programme ci-dessus,
- La valeur binaire de 12 est
00000000000000000000000000001100 - La valeur binaire de 25 est
00000000000000000000000000011001. - Lorsque l'opération ET au niveau du bit est effectuée, le résultat binaire sera
00000000000000000000000000001000qui se convertit en valeur décimale 8.
JavaScript au niveau du bit OU
OR au niveau du bit |renvoie 1 si l'un des bits correspondants d'un opérande est 1, sinon 0 .
| Opérande 1 | Opérande 2 | OU Fonctionnement |
|---|---|---|
| 0 | 0 | 0 | 0vaut 0 |
| 0 | 1 | 0 | 1vaut 1 |
| 1 | 0 | 1 | 0vaut 1 |
| 1 | 1 | 1 | 1vaut 1 |
Jetons un coup d'œil à l'opération OR au niveau du bit de deux entiers 12 et 25 .
En binaire, 12 = 01100 25 = 11001 // Bitwise OU Fonctionnement de 12 et 25 00001100 | 00011001 -------- 00011101 = 29 (en décimal)
Exemple 2: opérateur OR au niveau du bit
// bitwise OR operator example let a = 12; let b = 25; result = a | b; console.log(result); // 29
Lorsque l'opération OR au niveau du bit est effectuée, le résultat binaire sera 00000000000000000000000000011101qui se convertit en la valeur décimale 29.
JavaScript XOR au niveau du bit
Bitwise XOR ^renvoie 1 si les bits correspondants sont différents et renvoie 0 si les bits correspondants sont identiques.
| Opérande 1 | Opérande 2 | Fonctionnement XOR |
|---|---|---|
| 0 | 0 | 0 0vaut 0 |
| 0 | 1 | 0 1vaut 1 |
| 1 | 0 | 1 0vaut 1 |
| 1 | 1 | 1 1vaut 0 |
En binaire, 12 = 01100 25 = 11001 // XOR bit à bit Fonctionnement de 12 et 25 00001100 00011001 -------- 00010101 = 21 (en décimal)
Exemple 3: opérateur XOR au niveau du bit
// bitwise XOR operator example let a = 12; let b = 25; result = a b; console.log(result); // 21
Lorsque l'opération XOR au niveau du bit est effectuée, le résultat binaire sera 00000000000000000000000000010101qui se convertit en la valeur décimale 21.
JavaScript au niveau du bit NON
Bitwise NOT ~ inverts the bit( 0 becomes 1, 1 becomes 0).
In binary, 12 = 00000000000000000000000000001100 // Bitwise Not Operation of 12 ~ 00000000000000000000000000001100 --------------------------------- 11111111111111111111111111110011 = -13(In decimal)
While converting 11111111111111111111111111110011 to decimal, the value would be 4294967283. But when using bitwise operator, the value is computed in signed 2's complement format except for zero-fill right shift.
2's complement is computed by inverting the bits(1's complement) and then adding 1. For example,
13 in binary: 00000000000000000000000000001101 1's complement of 13: 11111111111111111111111111110010 2's complement of 13: 11111111111111111111111111110010 +1 --------------------------------- 11111111111111111111111111110011
Notice the 2's complement of 13 (i.e. -13) is 11111111111111111111111111110011. This value is equivalent to the bitwise NOT of 12.
Example 4: Bitwise NOT Operator
// bitwise NOT operator example let b = 12; result = ~b; console.log(result); // -13
When bitwise NOT operation is performed, the binary result will be 11111111111111111111111111110011 which converts into the decimal value -13.
Note: Bitwise NOT of a number x gives -(x + 1). Notice above ~2 gives -3.
JavaScript Left shift
Dans l'opérateur de décalage gauche <<, l'opérande de gauche spécifie le nombre et l'opérande de droite spécifie le nombre à décaler vers la gauche. Les bits zéro sont ajoutés à droite et les bits en excès à partir de la gauche sont rejetés.
Un peu de décalage à gauche dans JavaScript
Par exemple,
let a = 8; let b = 1; result = a << b; // 1 ( 00000000000000000000000000010000 ) console.log(result);
Décalage à droite de la propagation des signes JavaScript
Dans l'opérateur de décalage droit >>, le premier opérande spécifie le nombre et le second opérande spécifie le nombre à décaler vers la droite. Les bits excédentaires de la droite sont supprimés. Les copies du bit le plus à gauche sont décalées depuis la gauche, d'où le nom se propageant par signe.
Un peu de décalage vers la droite avec propagation de signe, remplissez JavaScript
Par exemple,
let a = 8; let b = 1; // 11111111111111111111111111111101 let c = -3; result = a>> b; result1 = c>> b; // 4 (00000000000000000000000000000100) console.log(result); // -1 (11111111111111111111111111111111) console.log(result1);
Décalage à droite JavaScript Zero-fill
Le décalage à droite de zéro-remplissage >>>décale l'opérande vers la droite en remplissant les bits de zéro vers la gauche. Les bits excédentaires de la droite sont supprimés.
Un peu de décalage à droite avec zéro remplissage dans JavaScript
Par exemple,
let a = 8; let b = 1; let c = -3; result = a>>> b; result1 = c>>> b; // 4 (00000000000000000000000000000100) console.log(result); // 1073741823 (00111111111111111111111111111111) console.log(result);
