Opérateurs JavaScript Bitwise
La raison fondamentale d'utiliser ces opérateurs est que ces opérateurs sont beaucoup plus rapides en mathématiques et en équivalents par Parseint. Dans ce tutoriel, nous découvrirons les opérateurs de bitwise en JavaScript et en découvrirons le besoin et l'utilisation de ces opérateurs. Dans cet article, nous décrivons les types d'opérateurs bit avec des exemples.
Types d'opérateurs bit
Tous les opérateurs bitwise traitent de leurs opérandes dans un ensemble de 32 bits; ces bits sont sous la forme de chiffres binaires. Cependant, le résultat de ces bits est indiqué sous forme décimale. Dans le tableau suivant, nous définissons plusieurs opérateurs de bit en javascript avec des exemples de code.
Représentation des opérateurs
| Nom des opérateurs | Symbole de l'opérateur | Exemple |
| Et opérateur | & | un B |
| Ou opérateur | | | un | b |
| Pas opérateur | ~ | un ~ b |
| Opérateur XOR | ^ | un ^ b |
Note: Les gammes entières maximales et minimales représentables sont définies dans des opérateurs de bit
- Plage entier représentable minimum = -2147483648,
- Plage entier représentable maximale = 2147483647.
Parlons de chaque opérateur un par un avec quelques exemples.
Et opérateur en javascript
Il y a deux opérandes sous forme binaire (0,1) dans l'opérateur et. Sa sortie est 0, si l'un des opérandes est 0 et renvoie 1 si les deux opérandes sont 1. Les sorties et les tableaux sont indiqués dans le tableau donné.
Opérations et opérateurs
| Opérande 1 | Opérande 2 | Et opération |
| 1 | 1 | 1 et 1 = 1 |
| 1 | 0 | 1 & 0 = 0 |
| 0 | 1 | 0 & 1 = 0 |
| 0 | 0 | 0 & 0 = 0 |
Jetons un coup d'œil à un exemple pour une explication et un opérateur plus approfondis.
Exemple
Il y a deux entiers 12 et 25 pour la mise en œuvre et l'opérateur.
À la première étape, les deux entiers sont convertis en bits. La conversion de bit de 12 et 25 est:
12 = 0000000000000000000000000000001100,25 = 0000000000000000000000000000011001.
Après la conversion des entiers, l'opérateur et l'opérateur est appliqué.
// Convertir d'abord les deux entiers sous forme binaire,12 = 01100
25 = 011001
00001100
& 00011001
--------
00001000 = 8 // (en décimal)
Les zéros précédents sont retirés pour des raisons de simplicité. Après la mise en œuvre et l'opérateur, la réponse est de 00001000, ce qui est égal à 8 dans les entiers.
Programme de bitwise et opérateur en javascript
Soit a = 12;Soit b = 25;
résultat = a & b;
console.log (résultat); // 8
Ou opérateur en javascript:
Il y a deux opérandes sous forme binaire (0,1) dans l'opérateur OR. La sortie est 0, si les deux opérandes sont 0s et que la sortie est 1 si l'un d'un seul opérande est 1. Dans le tableau donné, toutes les sorties possibles de l'opérateur OR sont données:
Opérations ou opérateur
| Opérande 1 | Opérande 2 | Et opération |
| 1 | 1 | 1 | 1 = 1 |
| 1 | 0 | 1 | 0 = 1 |
| 0 | 1 | 0 | 1 = 1 |
| 0 | 0 | 0 | 0 = 0 |
Jetons un coup d'œil à un exemple pour une explication plus approfondie de l'opérateur.
Exemple
Il y a deux entiers 12 et 25 pour la mise en œuvre de l'opérateur OR.
Tout d'abord, nous convertissons les deux entiers en bits.La conversion de bit de 12 et 25 est:
12 = 01100,25 = 11001.
Les zéros précédents sont retirés pour des raisons de simplicité.
// Convertir d'abord les deux entiers sous forme binaire,12 = 01100
25 = 11001
// Bitwise ou opération de 12 et 25
00001100
| 00011001
--------
00011101 = 29 // (en décimal)
Après la conversion des entiers, l'opérateur OR est appliqué, la réponse est 11101, ce qui est égal à 29.
Programme de bitwise ou opérateur en javascript
// Exemple de bitwise ou opérateurSoit a = 12;
Soit b = 25;
Résultat = A | B;
console.log (résultat); // 29
Opérateur XOR en JavaScript
Il y a deux opérandes sous forme binaire (0,1) dans l'opérateur XOR. Il renvoie 0 en tant que sortie si les deux opérandes sont les mêmes et renvoie 1 en tant que sortie si les deux opérandes sont différents. Dans le tableau donné, toutes les sorties possibles de l'opérateur XOR sont données:
Opérations de l'opérateur XOR
| Opérande 1 | Opérande 2 | Et opération |
| 1 | 1 | 1 ^ 1 = 0 |
| 1 | 0 | 1 ^ 0 = 1 |
| 0 | 1 | 0 ^ 1 = 1 |
| 0 | 0 | 0 ^ 0 = 0 |
Jetons un coup d'œil à un exemple pour une explication plus approfondie de l'opérateur XOR.
Exemple
Il y a deux entiers 12 et 25 pour la mise en œuvre de l'opérateur XOR.
Tout d'abord, nous convertissons les deux entiers en bits.La conversion de bit de 12 et 25 est:
12 = 01100,25 = 11001. // Convertir d'abord les deux entiers sous forme binaire,
12 = 01100
25 = 11001
// Opération XOR bitwise de 12 et 25
01100
^ 11001
-----
10101 = 21 // (en décimal)
Après la conversion des entiers, l'opérateur XOR est appliqué, la réponse est 11101, ce qui est égal à 21.
Programme de l'opérateur XOR Bitwise en JavaScript
// Exemple de l'opérateur XOR sur bitwiseSoit a = 12;
Soit b = 25;
résultat = a ^ b;
console.log (résultat); // 21
Pas opérateur en javascript
Pas l'opérateur est appelé opérateur de négation. Il convertit les bits 1 à 0 et 0 à 1. C'est un opérateur unaire parmi tous les opérateurs de bit.
Opérations de non opérateur
| Opérande 1 | Pas opération |
| 1 | (~ 1) = 0 |
| 0 | (~ 0) = 1 |
Jetons un coup d'œil à un exemple pour une explication plus approfondie du non opérateur.
Exemple
Puisque non l'opérateur est un opérateur unaire; Par conséquent, ici, nous n'avons pris qu'un seul opérande (12) et et nous avons appliqué l'opération.
Tout d'abord, convertissez le 12 en forme binaire:
12 = 0000000000000000000000000000001100.L'opérateur non convertira tous les 0 en 1 et change tous les 1 en 0.
// Convertir d'abord l'entier sous forme binaire,12 = 0000000000000000000000000000001100
// Bitwise pas opération de 12
~ 0000000000000000000000000000001100
---------------------------------
1111111111111111111111110011 = -13 // (en décimal)
La réponse deviendra 1111111111111111111111110011, ce qui est égal à -13 sous forme entier.
Programme de Bitwise Not Operator en JavaScript
// Bitwise pas Exemple d'opérateurSoit b = 12;
résultat = ~ b;
console.log (résultat); // -13
Conclusion
Les opérateurs bitwise sont ceux qui travaillent sur des entiers au niveau binaire. Il y a total quatre opérateurs de bitwise en javascript: et, ou, xor, et non. Cet article explique les quatre types d'opérateurs de bitwise et leur travail en JavaScript. Nous avons décrit tous les opérateurs avec leurs sorties possibles sous forme de tables. Toutes les opérations sont bien expliquées par des exemples et des codes.