Explication détaillée de '&' et '|' en Javascript

1. Avant-propos :

Avant de commencer l'article, permettez-moi de vous poser quelques questions à examiner :

var num1 = 1 & 0;
console.log(num1); // 0
var num2 = 'string' & 1;
console.log(num2); // 0
var num3 = true & 1;
console.log(num3); // 1
var num4 = undefined | false;
console.log(num4); // 0
var num5 = undefined | true;
console.log(num5); // 1
var num6 = 23 & 5;
console.log(num6); // 5
var num7 = 23 | 5;
console.log(num7); // 23

Tout le monde a-t-il répondu correctement aux questions ci-dessus ? Nous avons précédemment résumé "Un bref exposé sur "&&" et "||" en JavaScript". "&&" et "||" sont des opérateurs dans des expressions d'opérations logiques. Alors, que signifie un « & » ou un « | » ? Quelles sont les caractéristiques ? Ensuite, nous révélerons les secrets un par un.

Tout d’abord, nous devons comprendre que « & » et « | » sont des opérateurs au niveau du bit.

Les opérateurs au niveau du bit sont utilisés pour opérer sur les valeurs au niveau le plus élémentaire, en fonction des bits qui représentent la valeur en mémoire. Toutes les valeurs dans ECMAScript sont stockées au format IEEE-754 64 bits, mais les opérateurs de bits n'opèrent pas directement sur les valeurs 64 bits. Au lieu de cela, il convertit d'abord la valeur 64 bits en un entier 32 bits, puis effectue l'opération et enfin convertit le résultat en 64 bits. Pour les développeurs, étant donné que le format de stockage 64 bits est transparent, l'ensemble du processus apparaît comme s'il n'existait que des entiers de 32 bits.

Pour les entiers signés, les 31 premiers des 32 bits sont utilisés pour représenter la valeur de l'entier. Le bit 32 représente le signe de la valeur : 0 représente un nombre positif, 1 représente un nombre négatif. Ce bit représentant le signe est appelé bit de signe, et la valeur du bit de signe détermine le format des autres bits. Lorsque les nombres positifs sont stockés au format binaire pur, chacun des 31 bits représente une puissance de 2. Le premier bit (appelé bit 0) représente 20, le deuxième bit représente 21, et ainsi de suite. Les bits inutilisés sont représentés par 0 et sont ignorés. Par exemple, la représentation binaire de la valeur 18 est 0000 0000 0000 0000 0000 0000 0001 0010, ou plus précisément 10010. Ce sont 5 bits significatifs, et ces 5 bits déterminent à eux seuls la valeur réelle.

Les nombres négatifs sont également stockés en code binaire, mais le format utilisé est le complément à deux. Pour calculer le complément à deux d'une valeur, vous devez suivre les trois étapes suivantes :

(1) Trouver le code binaire de la valeur absolue de cette valeur (par exemple, si vous avez besoin du complément à deux de -18, trouvez d'abord le code binaire de 18) ;

(2) Trouvez le complément binaire, c'est-à-dire remplacez 0 par 1, et remplacez 1 par 0

(3) Ajoutez ; 1 au complément binaire obtenu.

De cette façon, on obtient la représentation binaire de -18, soit 1111 1111 1111 1111 1111 1111 1110 1110.

......Dans ECMAScript, lorsque des opérateurs de bits sont appliqués à des valeurs, le processus de conversion suivant se produit en arrière-plan : la valeur 64 bits est convertie en valeur 32 bits, puis l'opération sur bits est effectué, et enfin reconvertissez le résultat 32 bits en une valeur 64 bits. De cette façon, à première vue, il semble que vous opérez sur une valeur de 32 bits, tout comme les opérations binaires sont effectuées de la même manière dans d'autres langages. Mais ce processus de conversion entraîne également un effet secondaire sérieux, c'est-à-dire que lors de l'application d'opérations sur bits aux valeurs spéciales NaN et Infinity, ces deux valeurs seront traitées comme 0.

Si des opérateurs de bits sont appliqués à des valeurs non numériques, la fonction Number() sera utilisée pour convertir la valeur en valeur numérique (terminée automatiquement), puis les opérations sur les bits seront appliquées. Le résultat sera une valeur numérique. ...... (Intercepté depuis "Javascript Advanced Programming")

2. "&" (AND au niveau du bit) :

L'opérateur AND au niveau du bit se compose d'une esperluette (&) signifie qu'il dispose de deux numéros d'opérateur. Essentiellement, l'opération ET au niveau du bit consiste à aligner chaque bit de deux valeurs et à effectuer une opération ET sur deux nombres à la même position.

Règles d'opération ET au niveau du bit : 1 est renvoyé uniquement lorsque les bits correspondants des deux valeurs sont 1. Si un bit est 0, le résultat est 0.

J'ai déjà parlé de trop de choses théoriques, mais je pense que la théorie est très nécessaire. Ensuite, analysons directement les exemples !

Regardons d'abord num1, num2, num3 et num6 dans la question ci-dessus. Nous essayons de combiner la théorie ci-dessus pour analyser pourquoi le résultat final est généré.

// num1是1和0进行“按位与”操作后的返回值。1的二进制码简写为1，0的二进制码简写为0，根据上面的规则，第二个操作符数为0，结果是0
var num1 = 1 & 0;
console.log(num1); // 0
// 第一个操作符数是字符串，按照前言里面的理论，对于非数值的操作符数，先使用Number()函数处理，结果返回NaN，NaN又会被当成0来处理。所以最终结果也是0
var num2 = 'string' & 1;
console.log(num2); // 0
// true是布尔类型值，同样使用Number()函数处理，处理后得到数值1，于是表达式就相当于“1 & 1” 进行位运算，当两个数值都为1的时候，结果返回1
var num3 = true & 1;
console.log(num3); // 1
// 23的二进制码是：...10111，5的二进制码是：...00101。然后每一位进行对齐处理，结合上面的规则，可以得出10111&00101的结果是：00101。00101就是5
var num6 = 23 & 5;
console.log(num6); // 5
// 再加个例子：24的二进制码为...11000，7的二进制码为...00111，相同位置的两个数执行AND操作，结果发现结果是...00000。所以最终结果是0，你算对了吗？
var add1 = 24 & 7;
console.log(add1); // 0

3. "|" (OU au niveau du bit) :

L'opérateur OU au niveau du bit est représenté par un symbole de barre verticale (|) et comporte également deux opérandes. Essentiellement, l'opération OU au niveau du bit aligne également chaque bit des deux valeurs et effectue une opération OU sur les deux nombres à la même position.

Règles de fonctionnement OU au niveau du bit : Tant que l'un des bits correspondants des deux valeurs est 1, 1 est renvoyé, et 0 n'est renvoyé que lorsque les deux bits sont 0.

Prenons le meilleur exemple et regardons-le !

// 第一个操作符数为undefined，第二个操作符数是false，均不是数值，所以都要先使用Number()函数处理，处理结果都是返回NaN，NaN又会被当成0处理，于是最终结果是0
var num4 = undefined | false;
console.log(num4); // 0
// 第一个操作符数相当于0，第二个操作符数相当于1，结合按位或的规则，最终结果是1
var num5 = undefined | true;
console.log(num5); // 1
// 23的二进制码是：...10111，5的二进制码是：...00101。然后每一位进行对齐处理，结合上面的规则，可以得出10111|00101的结果是：10111。10111就是23
var num7 = 23 | 5;
console.log(num7); // 23
// 再加个例子：24的二进制码为...11000，7的二进制码为...00111，相同位置的两个数执行AND操作，结果发现结果是...11111。所以最终结果是31，你算对了吗？
var add2 = 24 | 7;
console.log(add2); // 31

4. Autres :

Je crois qu'il y aura des amis qui ne sauront pas comment convertir la valeur numérique en un binaire standard. code. Existe-t-il un moyen rapide de convertir la valeur en un code binaire standard ? La réponse est oui.

J'ai trouvé par hasard l'adresse d'un outil de conversion en ligne sur Internet : conversion numérique en décimal (cliquez sur moi pour voir). (Bien sûr, vous pouvez également utiliser d'autres outils que vous trouvez. Dans tous les cas, obtenir l'effet est notre objectif ultime)

Enfin, je joins le tableau régulier que j'ai résumé dans le processus de conversion binaire par écriture manuscrite, toujours Vous pouvez rapidement convertir des valeurs numériques en codes binaires, ce qui est très puissant !

Pour des explications plus détaillées sur « & » et « | » en Javascript, veuillez faire attention au site Web PHP chinois !