Opérateurs bit à bit ECMAScript
- Page précédente Opérateurs unaires
- Page suivante Opérateurs logiques
Les opérateurs de bits opèrent au niveau inférieur des nombres (c'est-à-dire les 32 bits qui représentent le nombre).
Réviser les entiers
ECMAScript possède deux types d'entiers, à savoir les entiers signés (permettant des nombres positifs et négatifs) et les entiers unsigned (seulement des nombres positifs). Dans ECMAScript, tous les nombres entiers littéraux sont par défaut des entiers signés, ce que signifie-t-il ?
Les entiers signés utilisent 31 bits pour représenter la valeur de l'entier et le 32e bit pour représenter le signe de l'entier, 0 pour les nombres positifs et 1 pour les nombres négatifs. La plage de valeurs est de -2147483648 à 2147483647.
Il existe deux façons de stocker des entiers signés en binaire, l'une pour les nombres positifs et l'autre pour les nombres négatifs. Les nombres positifs sont stockés sous forme binaire réelle, chaque bit des 31 premiers bits représentant une puissance de 2, commençant par le premier bit (bit 0), qui représente 20Le deuxième bit (bit 1) représente 21Les chiffres non utilisés sont remplis de 0, c'est-à-dire ignorés. Par exemple, la figure suivante montre la représentation du nombre 18.
La version binaire de 18 n'utilise que les 5 premiers chiffres, qui sont les chiffres valides de ce nombre. En convertissant le nombre en chaîne binaire, vous pouvez voir les chiffres valides :
var iNum = 18; alert(iNum.toString(2)); //Sort "10010"
Ce code ne sort que "10010", pas la représentation en 32 bits de 18. Les autres chiffres ne sont pas importants, car seuls les 5 premiers chiffres suffisent pour déterminer cette valeur décimale. Voici un exemple :
Les nombres négatifs sont également stockés sous forme de code binaire, mais sous forme de complément à deux. Les étapes pour calculer le complément à deux d'un nombre sont en trois étapes :
- Déterminez la représentation binaire non signée de ce nombre (par exemple, pour calculer le complément à deux de -18, il faut d'abord déterminer la représentation binaire de 18)
- Obtenez le codage inverse binaire, ce qui consiste à remplacer les 0 par des 1 et les 1 par des 0
- Ajoutez 1 au codage inverse binaire
Pour déterminer la représentation binaire de -18, il faut d'abord obtenir la représentation binaire de 18, comme suit :
0000 0000 0000 0000 0000 0000 0001 0010
Calculons d'abord le codage inverse binaire, comme suit :
1111 1111 1111 1111 1111 1111 1110 1101
Enfin, ajoutez 1 au codage inverse binaire, comme suit :
1111 1111 1111 1111 1111 1111 1110 1101
1
---------------------------------------
1111 1111 1111 1111 1111 1111 1110 1110
Par conséquent, la représentation binaire de -18 est 1111 1111 1111 1111 1111 1111 1110 1110. Souvenez-vous que lors de la manipulation des entiers signés, les développeurs ne peuvent pas accéder au bit 31.
Curieusement, après la conversion d'un entier négatif en chaîne de caractères binaire, ECMAScript ne l'affiche pas sous forme de complément à deux, mais sous forme de valeur absolue du nombre précédée d'un signe négatif. Par exemple :
var iNum = -18; alert(iNum.toString(2)); //Affiche "-10010"
Ce code affiche "-10010", et non le complément à deux, pour éviter d'accéder au bit 31. Pour simplifier, ECMAScript traite les entiers d'une manière simple, de sorte que les développeurs n'ont pas besoin de s'inquiéter de leur utilisation.
D'autre part, les entiers unsigned traitent le dernier bit comme un autre bit de numération. Dans ce mode, le 32e bit ne représente pas le signe du nombre, mais la valeur 231En raison de ce bit supplémentaire, la plage de valeurs des entiers unsigned est de 0 à 4294967295. Pour les entiers inférieurs à 2147483647, les entiers unsigned semblent être identiques aux entiers signés, tandis que pour les entiers supérieurs à 2147483647, il faut utiliser le bit 31 (dans les entiers signés, ce bit est toujours 0).
Lors de la conversion d'un entier unsigned en chaîne de caractères, seules les positions significatives sont retournées.
Attention :Tous les littéraux numériques entiers sont stockés par défaut comme des entiers signés. Seuls les opérateurs de calcul binaire d'ECMAScript peuvent créer des entiers unsigned.
Opérateur de calcul binaire NOT
L'opérateur de calcul binaire NOT est représenté par le symbole de négation (~), c'est l'un des rares opérateurs binaires de ECMAScript liés au calcul binaire.
L'opération de calcul binaire NOT est un processus de trois étapes :
- Convertir l'opérateur en nombre de 32 bits
- Convertir un nombre binaire en son code binaire inverse
- Convertir un nombre binaire en nombre flottant
Par exemple :
var iNum1 = 25; //25 est égal à 00000000000000000000000000011001 var iNum2 = ~iNum1; //Converti en 11111111111111111111111111100110 alert(iNum2); // Affiche "-26"
L'opération de calcul binaire NOT est en réalité le négatif du nombre, puis le déduction de 1, donc 25 devient -26. On peut obtenir le même résultat avec la méthode suivante :
var iNum1 = 25; var iNum2 = -iNum1 -1; alert(iNum2); // Affiche -26
Opération de calcul binaire AND
L'opération de calcul binaire AND est représentée par le symbole (&) et opère directement sur la forme binaire des nombres. Il aligne les chiffres de chaque nombre et applique les règles suivantes pour les deux chiffres à la même position :
| Bits du premier nombre | Bits du deuxième nombre | Résultat |
|---|---|---|
| 1 | 1 | 1 |
| 1 | 0 | 0 |
| 0 | 1 | 0 |
| 0 | 0 | 0 |
Par exemple, pour effectuer une opération AND sur les nombres 25 et 3, le code est le suivant :
var iResult = 25 & 3; alert(iResult); // Affiche "1"
Le résultat de l'opération AND entre 25 et 3 est 1. Pourquoi ? L'analyse suit :
25 = 0000 0000 0000 0000 0000 0000 0001 1001 3 = 0000 0000 0000 0000 0000 0000 0000 0011 --------------------------------------------- AND = 0000 0000 0000 0000 0000 0000 0000 0001
Il est possible de voir que dans 25 et 3, seules les positions (bit 0) des deux nombres contiennent le nombre 1, donc les autres positions génèrent tous des 0, donc le résultat est 1.
Opération de calcul binaire OR
L'opération de calcul binaire OR est représentée par le symbole (|) et opère directement sur la forme binaire des nombres. Lors du calcul de chaque chiffre, l'opérateur OR suit les règles suivantes :
| Bits du premier nombre | Bits du deuxième nombre | Résultat |
|---|---|---|
| 1 | 1 | 1 |
| 1 | 0 | 1 |
| 0 | 1 | 1 |
| 0 | 0 | 0 |
Utilisons encore un exemple avec l'opérateur AND pour effectuer une opération OR entre 25 et 3, le code est le suivant :
var iResult = 25 | 3; alert(iResult); // Affiche "27"
Le résultat de l'opération OR entre 25 et 3 est 27 :
25 = 0000 0000 0000 0000 0000 0000 0001 1001 3 = 0000 0000 0000 0000 0000 0000 0000 0011 -------------------------------------------- OR = 0000 0000 0000 0000 0000 0000 0001 1011
Il est possible de voir que dans les deux nombres, il y a 4 chiffres qui contiennent le nombre 1, ces chiffres sont transmis au résultat. Le code binaire 11011 vaut 27.
Opération de calcul bit à bit XOR
L'opérateur de calcul bit à bit XOR est représenté par le symbole (^), bien sûr, il s'agit également d'une opération directe sur la forme binaire. XOR est différent de OR, il retourne 1 uniquement lorsque seul un bit contient le chiffre 1. Le tableau de vérité est le suivant :
| Bits du premier nombre | Bits du deuxième nombre | Résultat |
|---|---|---|
| 1 | 1 | 0 |
| 1 | 0 | 1 |
| 0 | 1 | 1 |
| 0 | 0 | 0 |
Pour XOR entre 25 et 3, le code est le suivant :
var iResult = 25 ^ 3; alert(iResult); //Affiche "26"
Le résultat de l'opérateur XOR entre 25 et 3 est 26 :
25 = 0000 0000 0000 0000 0000 0000 0001 1001 3 = 0000 0000 0000 0000 0000 0000 0000 0011 --------------------------------------------- XOR = 0000 0000 0000 0000 0000 0000 0001 1010
Il est visible que dans deux nombres, il y a 4 bits qui contiennent le chiffre 1, et ces bits sont passés au résultat. Le code binaire 11010 est égal à 26.
Déplacement à gauche
Le déplacement à gauche est représenté par deux guillemets de gauche (<<). Il déplace tous les bits d'un nombre d'un certain nombre de positions vers la gauche. Par exemple, si on déplace le nombre 2 (égal à 10 binaire) de 5 positions vers la gauche, le résultat est 64 (égal à 1000000 binaire) :
var iOld = 2; //Égal à 10 binaire var iNew = iOld << 5; //Égal à 1000000 binaire, 64 décimal
Attention :Lors du déplacement des bits à gauche, le nombre de bits à droite en plus est de 5. Le déplacement à gauche remplit ces bits avec des 0 pour que le résultat soit un nombre de 32 bits complet.
Attention :Le déplacement à gauche conserve le bit de signe du nombre. Par exemple, si on déplace -2 de 5 positions vers la gauche, on obtient -64, pas 64. «Le bit de signe est-il toujours stocké au 32e bit?» Oui, mais cela se fait en arrière-plan dans ECMAScript et le développeur ne peut pas accéder directement au 32e bit. Même si on affiche un nombre négatif sous forme de chaîne binaire, il est affiché avec un signe négatif (par exemple, -2 est affiché -10).
Déplacement à droite avec signe
L'opérateur de déplacement à droite avec signe est représenté par deux guillemets de droite (>>). Il déplace tous les bits d'un nombre de 32 bits vers la droite en conservant le signe du nombre (positif ou négatif). L'opérateur de déplacement à droite avec signe est l'opposé du déplacement à gauche. Par exemple, si on déplace 64 de 5 positions vers la droite, cela donne 2 :
var iOld = 64; // équivaut à 1000000 binaire var iNew = iOld >> 5; // équivaut à 10 binaire, 2 décimal
De la même manière, le déplacement des bits crée des positions vides. Cette fois, les positions vides sont à gauche du nombre, mais après le bit de signe. ECMAScript remplit ces positions vides avec la valeur du bit de signe pour créer un nombre complet, comme indiqué dans le graphique suivant :
Déplacement à droite sans signe
L'opérateur de déplacement à droite sans signe est représenté par trois Greater Than (>>>), il déplace tous les bits d'un nombre sans signe de 32 bits à droite. Pour les nombres positifs, le résultat du déplacement à droite sans signe est le même que pour le déplacement à droite avec signe.
Avec l'exemple d'un déplacement à droite avec signe, si on déplace 64 à droite de 5 positions, cela deviendra 2 :
var iOld = 64; // équivaut à 1000000 binaire var iNew = iOld >>> 5; // équivaut à 10 binaire, 2 décimal
Pour les nombres négatifs, la situation est différente.
Le déplacement à droite sans signe remplit toutes les positions vides avec zéros. Pour les nombres positifs, cela est le même que pour le déplacement à droite avec signe, tandis que pour les nombres négatifs, ils sont traités comme des nombres positifs.
Le résultat du déplacement à droite sans signe est un nombre positif de 32 bits, donc le déplacement à droite sans signe d'un nombre négatif donne toujours un nombre très grand. Par exemple, si on déplace -64 à droite de 5 positions, on obtient 134217726. Comment obtenir ce résultat ?
Pour réaliser cela, il faut convertir ce nombre en une forme équivalente sans signe (même si le nombre lui-même est signé), et on peut obtenir cette forme avec le code suivant :
var iUnsigned64 = -64 >>> 0;
Ensuite, utilisez la méthode toString() du type Number pour obtenir sa représentation binaire réelle, en utilisant une base de 2 :
alert(iUnsigned64.toString(2));
Cela génère 11111111111111111111111111000000, qui est l'représentation binaire du complément à deux de l'entier signé -64, mais cela équivaut à l'entier sans signe 4294967232.
Pour cette raison, il faut être prudent en utilisant l'opérateur de déplacement à droite sans signe.
- Page précédente Opérateurs unaires
- Page suivante Opérateurs logiques
