Que fait l'opérateur |= en JavaScript ?

Question

J'ai trouvé le code suivant dans un projet JS :

var a = new Array();
a[0] = 0;
for (var b = 0; b < 10; b++) {
  a[0] |= b; 
}

Que fait le |= dans le corps de la boucle for ?

L'exemple de code est douteux, mais il a été présenté ici par V8 pour un exemple d'amélioration des performances.

Exemple actualisé

L'exemple ci-dessus est équivalent à var a = [15]; à toutes fins utiles. Un exemple plus réaliste pour le |= serait de configurer des drapeaux binaires dans une seule variable, par exemple sur un objet de permission :

//Set up permission masks
var PERMISSION_1_MASK = parseInt('0001',2);
var PERMISSION_2_MASK = parseInt('0010',2);
..

//Set up permissions
userPermissions = 0;
userPermissions |= hasPermissionOne && PERMISSION_1_MASK;
userPermissions |= hasPermissionTwo && PERMISSION_2_MASK;
..

//Use permissions
if(userPermissions & PERMISSION_1_MASK){
    ..//Do stuff only allowed by permission 1
}

Answer 1

a[0] |= b

est en fait

a[0] = a[0] | b

"|" est un ou opérateur binaire (au fait : Les documents du MDN sont très bien écrits et très clairs. Si le PO veut écrire et comprendre le JS, alors les docs MDN sont une excellente ressource).

Mise à jour Lorsque a[0] est attribué 0 , a[0] en binaire est 0000 . Dans la boucle,

1. b = 0

   a[0] = 0 (base 10) = 0000 (base 2)
   b    = 0 (base 10) = 0000 (base 2)
                      ---------------
   a[0] | b           = 0000 (base 2) = 0 (base 10)

2. b = 1

   a[0] = 0 (base 10) = 0000 (base 2)
   b    = 1 (base 10) = 0001 (base 2)
                      ---------------
   a[0] | b           = 0001 (base 2) = 1 (base 10)

3. b = 2

   a[0] = 1 (base 10) = 0001 (base 2)
   b    = 2 (base 10) = 0010 (base 2)
                      ---------------
   a[0] | b           = 0011 (base 2) = 3 (base 10)

4. b = 3

   a[0] = 3 (base 10) = 0011 (base 2)
   b    = 3 (base 10) = 0011 (base 2)
                      ---------------
   a[0] | b           = 0011 (base 2) = 3 (base 10)

5. b = 4

   a[0] = 3 (base 10) = 0011 (base 2)
   b    = 4 (base 10) = 0100 (base 2)
                      ---------------
   a[0] | b           = 0111 (base 2) = 7 (base 10)

6. b = 5

   a[0] = 7 (base 10) = 0111 (base 2)
   b    = 5 (base 10) = 0101 (base 2)
                      ---------------
   a[0] | b           = 0111 (base 2) = 7 (base 10)

7. b = 6

   a[0] = 7 (base 10) = 0111 (base 2)
   b    = 6 (base 10) = 0110 (base 2)
                      ---------------
   a[0] | b           = 0111 (base 2) = 7 (base 10)

8. b = 7

   a[0] = 7 (base 10) = 0111 (base 2)
   b    = 7 (base 10) = 0111 (base 2)
                      ---------------
   a[0] | b           = 0111 (base 2) = 7 (base 10)

9. b = 8

   a[0] = 7 (base 10) = 0111 (base 2)
   b    = 8 (base 10) = 1000 (base 2)
                      ---------------
   a[0] | b           = 1111 (base 2) = 15 (base 10)

10. b = 9

    a[0] = 15 (base 10) = 1111 (base 2)
    b    =  9 (base 10) = 1001 (base 2)
                        ---------------
    a[0] | b            = 1111 (base 2) = 15 (base 10)

A la fin de la boucle, la valeur de a[0] est 15

Answer 2

x |= y;

est équivalent à

x = x | y;

où | signifie OU par bit .

Answer 3

Comme pour la plupart des opérateurs d'affectation, cela revient à appliquer l'opérateur en utilisant à nouveau la valeur de gauche :

a |= b
a = a | b

Tout comme

a += b
a = a + b

Regardez Moz Dev Net pour plus.

[Edit : Brain failure, mixed up | and ||. Need more coffee. Modified below]

Depuis | est l'opérateur Bitwise OR, le résultat de a|b sera le nombre entier représentant la chaîne de bits avec tous les bits 1 de a et b . Notez que javascript n'a pas de type int ou bitstring natif, donc il va d'abord convertir le type int en type bitstring. a et b en int, puis faire un OU bit à bit sur les bits. Donc 9 | 2 en binaire est 1001 | 0010 = 1011, ce qui est 11, mais 8|2 = 8.

L'effet est d'ajouter les bits de drapeau de b en a . Donc si vous avez un drapeau WEEVILFLAG=parseInt(00001000,2) :

// a = parseInt(01100001,2)
if(isWeevilish(a))
    a |= WEEVILFLAG;
// now a = parseInt(01101001,2)

mettra ce bit à 1 dans un.

Answer 4

Cela fonctionne un peu comme ça si b est supérieure à a , b est ajouté à a .

Ce qui se passe dans la réalité est a = a | b comme pour les autres opérateurs. Cela signifie que a = a BITWISE OR b qui est expliqué ici .

Par exemple, voici le résultat de quelques opérations :

var a = 1;
a |= 2; // a = 3
a |= 2; // a = 3
a |= 4; // a = 7

J'espère que cela vous aidera.

Answer 5

Renvoie un un dans chaque position de bit pour laquelle les bits correspondants de l'un ou des deux opérandes sont des uns.

Code : résultat = a | b ;

^ est l'opérateur XOR bit à bit, qui renvoie un un pour chaque position où l'un (et non les deux) des bits correspondants de ses opérandes est un un. L'exemple suivant renvoie 4 (0100) :