Cosa fa l'operatore | = fa in JavaScript?

Question

ho trovato il seguente codice in un progetto JS:

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

Cosa significa il |= fare nel corpo del ciclo for?

L'esempio di codice è dubbio, ma è stato presentato here da V8 per un esempio di prestazioni migliorate.

aggiornato Esempio

L'esempio precedente è equivalente a var a = [15]; per la maggior parte gli effetti. Un esempio più realistico per l'operatore |= sarebbe quella di istituire bandiere binari in una singola variabile, ad esempio su un oggetto permesso:

//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 

è fondamentalmente

a[0] = a[0] | b 

"|" è un or bitwise operator (a proposito:.. La documentazione MDN sono davvero ben scritto e molto chiaro se l'OP è che vogliono scrivere e capire JS, quindi la documentazione MDN sono una grande risorsa)

Aggiornamento Quando a[0] è assegnato 0, a[0] in binario è 0000.Nel ciclo,

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

   012.351.641,061 mila

   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) 
    

Alla fine del ciclo il valore di a[0] è 15

Answer 2

x |= y; 

equivale a

x = x | y; 

dove | stand per bit a bit O.

Answer 3

Come con la maggior parte degli operatori di assegnazione, che equivale ad applicare l'operatore che utilizza ancora una volta il valore di sinistra:

a |= b 
a = a | b 

come solo

a += b 
a = a + b 

Guarda sul Moz Dev Net di più.

[Modifica: Brain fail, mixed up | e ||. Hai bisogno di più caffè. Modificate sotto]

Poiché | è l'operatore OR, il risultato di a|b sarà il numero intero che rappresenta il bitstring con tutti i bit a 1 della a e b. Nota che javascript non ha alcun tipo nativo di int o bitstring, quindi prima convertirà a e b in int, quindi eseguirà un OR bit a bit sui bit. Quindi 9 | 2 in binario è 1001 | 0010 = 1011, che è 11, ma 8 | 2 = 8.

L'effetto è di aggiungere i bit di flag di b a a. Quindi, se avete qualche bandiera WEEVILFLAG=parseInt(00001000,2):

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

imposterà che bit a 1 in una.

Answer 4

Funziona tipo di in questo modo: se b è maggiore di a, b viene aggiunto a a.

Quello che succede in realtà è a = a | b, proprio come per gli altri operatori. Questo significa a = a BITWISE OR b che viene spiegato here.

Per esempio, questo è il risultato di alcune operazioni:

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

Mi auguro che aiuta.

Answer 5

Restituisce uno in ogni posizione di bit per cui i bit corrispondenti di uno o entrambi gli operandi sono uno.

Codice: result = a | b;

^ è l'operatore XOR bit a bit, che restituisce uno per ogni posizione in cui uno (non entrambi) dei bit corrispondenti dei suoi operandi è uno. Il prossimo esempio restituisce 4 (0100):