Introduction aux opérateurs bit à bit en JavaScript
Les opérateurs Bitwise en JavaScript agissent sur leur opérande en opérant sur eux sous leur forme de représentation de nombre binaire (Base 2) (en particulier sous forme de nombres 32 bits), plutôt que dans leur nombre décimal (Base 10), nombres octaux (Base 8), ou notation hexadécimale (Base 16). Par exemple, 1010 est la représentation binaire du nombre décimal dix. Les opérations au niveau du bit en JavaScript sont effectuées sur les opérandes des opérateurs dans leurs représentations binaires, mais la sortie est toujours renvoyée sous la forme de valeur numérique standard.
Un opérateur au niveau du bit en JavaScript convertit leurs opérandes en la forme complémentaire 2 de leur forme entière signée 32 bits. Par conséquent, chaque fois qu'un opérateur travaille sur un entier, la valeur dérivée est la forme complémentaire 2 de cet entier. Le complément à 2 d'un entier est le complément à 1 du nombre (c'est-à-dire pas au niveau du bit) plus 1.
Par exemple, ce qui suit est la représentation 32 bits du nombre 7
00000000000000000000000000000111
Ce qui suit est 1 'complément soit ~ 7
11111111111111111111111111111000
Ce qui suit est la forme du complément à 2 qui est égale à -7
11111111111111111111111111111001
| Opérateur au niveau du bit | Usage | Sens |
| ET au niveau du bit | x & y | Renvoie 1 dans chaque position de bit si les deux bits correspondants sont à 1 sinon 0. |
| OU au niveau du bit | x | y | Renvoie 1 dans chaque position de bit si l'un des bits correspondants est 1 sinon 0. |
| XOR au niveau du bit | x y | Renvoie 0 dans chaque position de bit si les deux bits correspondants sont 1 ou 0 sinon 1 chaque fois que les bits sont différents. |
| PAS au niveau du bit | ~ x | Retourne les bits de l'opérande x de 1 à 0 et vice versa. |
| Décalage à gauche | x << y | Déplace les bits vers leur gauche sur le nombre binaire x par y bits tout en poussant 0 en place à partir de la droite. |
| Signe se propageant vers la droite | x >> y | Déplacera les bits vers la droite sur le nombre binaire x par y bits tout en copiant les bits les plus à gauche vers la gauche pour compléter 32 bits. |
| Décalage vers la droite sans remplissage | x >>> y | Déplace les bits vers leur droite sur le nombre binaire x par y bits tout en poussant 0 en place à partir de la gauche. |
Opérateurs logiques bit à bit en JavaScript
Les opérateurs logiques au niveau du bit sont constitués de tous les opérateurs logiques utilisés dans la plupart des langages, mais ils sont différents dans le sens où les opérateurs logiques au niveau du bit fonctionnent bit par bit. Les opérateurs logiques au niveau du bit suivants sont utilisés en JavaScript:
1. ET au niveau du bit
Il s'agit d'un opérateur binaire désigné par le symbole de l'esperluette «&» qui effectue une opération ET sur la paire consécutive de bits correspondants de ses arguments. L'opérateur «&» ne retournerait 1 que si les deux bits 1 le sont sinon, il retournera 0. Par conséquent, nous pouvons également corréler l'opération ET avec la multiplication car les deux donneront la même réponse.
| X | Oui | X & Y |
| 0 | 0 | 0 |
| 0 | 1 | 0 |
| 1 | 0 | 0 |
| 1 | 1 | 1 |
Exemple
10 (base 10) = 000000000000000000000000000000001010
13 (base 10) = 000000000000000000000000000000111101
----------------------------
10 et 13 00000000000000000000000000001000 = 8 (base 10)
2. OU au niveau du bit
Il s'agit d'un opérateur binaire désigné par le symbole d'une barre verticale «|» qui effectue une opération OU sur la paire consécutive de bits correspondants de ses arguments. L'opérateur «|» retournerait 1 si l'un des bits est 1 ou les deux sont 1 sinon il retournera 0. L'OR au niveau du bit «|» est différent de l'OR logique «||» car il fonctionne bit par bit.
| X | Oui | X | Oui |
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 1 |
Exemple
10 (base 10) = 000000000000000000000000000000001010
13 (base 10) = 000000000000000000000000000000111101
----------------------------
10 | 13 00000000000000000000000000001111 = 15 (base 10)
3. XOR au niveau du bit
Il s'agit d'un opérateur binaire désigné par le symbole du signe insertion «^» qui effectue une opération XOR sur la paire consécutive de bits correspondants de ses arguments. L'opérateur «^» retournera 0 si les deux bits sont identiques (c'est-à-dire que les deux sont 1 ou les deux sont 0) sinon il retournera 1.
| X | Oui | X Y |
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 0 |
Exemple
10 (base 10) = 000000000000000000000000000000001010
13 (base 10) = 000000000000000000000000000000111101
----------------------------
10 13 00000000000000000000000000000111 = 7 (base 10)
4. PAS au niveau du bit
Il s'agit d'un opérateur unaire dénoté par le symbole du tilde «~» qui effectue une opération NON sur les bits correspondants de son argument. L'opérateur «~» inverserait les bits de l'opérande, c'est-à-dire convertir 0 en 1 ou 1 en 0.
| X | ~ X |
| 0 | 1 |
| 1 | 0 |
Exemple
10 (base 10) = 000000000000000000000000000000001010
----------------------------
~ 10 11111111111111111111111111110101
Opérateurs de décalage au niveau du bit en JavaScript
Dans le décalage par bits, le fonctionnement prend également deux arguments où le premier argument est le nombre binaire sur lequel l'opération de décalage sera effectuée et le deuxième argument spécifie le nombre de bits par lesquels le premier argument doit être décalé. L'opérateur utilisé spécifie la direction de l'opération de décalage dans le nombre binaire.
1. Décalage à gauche au niveau du bit
Il s'agit d'un opérateur binaire désigné par le symbole «<<». Cet opérateur décalera les bits les plus à droite du premier argument vers leur gauche de la valeur des temps du second argument. Les bits décalés de la droite sont remplacés par 0 dans la partie la plus à droite pour chaque opération de décalage effectuée.
Exemple: 8 << 3 donne 64
8 (base 10) = 00000000000000000000000000001001000
----------------------------
8 << 3 00000000000000000000000001000000 = 64 (base 10)
2. Décalage à droite au niveau du bit
Il s'agit d'un opérateur binaire désigné par le symbole «>>>». Cet opérateur décalera les bits les plus à droite du premier argument vers leur droite de la valeur des temps du second argument. Les bits décalés de la gauche sont remplacés par 0 dans la partie la plus à gauche pour chaque opération de décalage effectuée.
Exemple: 8 >>> 3 rendements 1
8 (base 10) = 00000000000000000000000000001001000
----------------------------
8 >>> 3 00000000000000000000000000000001 = 1 (base 10)
-8 (base 10) = 11111111111111111111111111111000
----------------------------
-8 >>> 3 00011111111111111111111111111111 = 536870911 (base 10)
3. Signe au niveau du bit propageant le décalage vers la droite
Il s'agit d'un opérateur binaire désigné par le symbole «>>». Cet opérateur décalera les bits les plus à droite du premier argument vers leur droite de la valeur des temps du second argument. Les bits décalés de la gauche sont remplacés par le bit le plus à gauche (c'est-à-dire le bit de signe) dans la partie la plus à gauche pour chaque opération de décalage effectuée.
Exemple: 8 >>> 3 rendements 1
8 (base 10) = 00000000000000000000000000001001000
----------------------------
8 >> 3 00000000000000000000000000000001 = 1 (base 10)
-8 (base 10) = 11111111111111111111111111111000
----------------------------
-8 >> 3 11111111111111111111111111111111 = -1 (base 10)
Conclusion
Les arguments sont convertis en nombres binaires 32 bits et exprimés sous forme de bits (c'est-à-dire 0 et 1). Les nombres dans les arguments résultant avec plus de 32 bits obtiennent leur msb (bit le plus significatif) rejeté. La même règle s'applique lorsque pendant l'opération de décalage si le décalage de bit vers la gauche puis les bits supplémentaires à msb sont rejetés et pendant le décalage de droite, le bit supplémentaire croissant dans la partie la plus à droite est rejeté.
Avant: 110011010100011101001000100000001110010010001
----------------------------
Après: 11101001000100000001110010010001
Chaque bit correspondant est apparié, c'est-à-dire le premier bit avec le premier bit d'autres arguments, le deuxième bit avec le deuxième bit et ainsi de suite.
L'opérateur est appliqué à chaque bit (pour l'opérateur binaire, il doit s'agir d'une paire de bits), donc appelés opérateurs au niveau du bit en JavaScript.
Les applications pratiques de l'opérateur au niveau du bit sont les indicateurs de bit, la communication via socket / ports, la compression, le cryptage, les machines à états finis, les graphiques, etc.
Articles recommandés
Ceci est un guide pour les opérateurs bit à bit en JavaScript. Nous discutons ici de l'introduction, des types d'opérateurs au niveau du bit en JavaScript tels que les opérateurs logiques et de décalage ainsi que ses opérations. Vous pouvez également consulter les articles suivants pour en savoir plus-
- Compilateurs JavaScript
- Inverser en JavaScript
- Pour boucle en JavaScript
- Introduction à JavaScript