Cosa significano “>>” e “<<" in Javascript?

Ho un pezzo di codice Javascript che sto cercando di capire

// read big-endian (network byte order) 32-bit float readFloat32 = function(data, offset) { var b1 = data.charCodeAt(offset) & 0xFF, b2 = data.charCodeAt(offset+1) & 0xFF, b3 = data.charCodeAt(offset+2) & 0xFF, b4 = data.charCodeAt(offset+3) & 0xFF; var sign = 1 - (2*(b1 >> 7)); //<--- here it is and 2 lines below var exp = (((b1 <> 7)) - 127; var sig = ((b2 & 0x7f) << 16) | (b3 << 8) | b4; if (sig == 0 && exp == -127) return 0.0; return sign * (1 + sig * Math.pow(2, -23)) * Math.pow(2, exp); } 

cosa significa “>>”? È un tipo speciale di booleano (come ”)

Questi sono lo spostamento a destra (con segno) e spostare gli operatori a sinistra .

Essenzialmente, questi operatori sono usati per manipolare i valori a livello BIT .
In genere vengono utilizzati insieme a & (bit AND) e | (OR bit a bit) e in associazione con valori di masks come 0x7F e valori immediati simili trovato lo snippet della domanda.
Lo snippet in questione utilizza questi operatori per “analizzare” le tre componenti di un valore float a 32 bit (segno, esponente e frazione).

Ad esempio, nello snippet della domanda:
1 - (2*(b1 >> 7)) produce il valore intero 1 o -1 a seconda che il bit 7 (l’ottavo bit da destra) nella variabile b1 sia zero o uno rispettivamente.
Questo idioma può essere spiegato come segue.

  • all’inizio, b1, express come bit è 0000000000000000abcdefgh
    nota come tutti i bit a sinistra siano zeri, questo viene dal
    b1 = data.charCodeAt(offset) & 0xFF assignement alcune righe sopra, che essenzialmente azzerarono tutti i bit in b1 eccetto per i rightmot 8 bit (maschera 0xFF).
    a, b, c … th h rappresentano valori booleani sconosciuti 0 o 1.
    Siamo interessati a testare il valore di a.
  • b1 >> 7 sposta questo valore a destra di 7 bit, lasciando
    b1 come 00000000000000000000000a che, letto come un intero avrà valore 1 o 0
  • questo valore intero 1 o 0 viene quindi moltiplicato per 2
    è quindi o 2 o 0, rispettivamente.
  • questo valore viene quindi sottratto da 1, lasciando -1 o 1.

Sebbene sia utile per illustrare il funzionamento degli operatori di bit, l’idioma di cui sopra potrebbe essere sostituito da qualcosa che verifica il bit 7 in modo più diretto e assegna la variabile del segno in modo più esplicito. Inoltre questo approccio non richiede il mascheramento iniziale dei bit più a sinistra in b1:

 var sign if (b1 & 0x80) // test bit 7 (0x80 is [00000000]10000000) sign = -1; else sign = 1; 

Questi sono operatori bit. Dai un’occhiata a questo link: Operatori bit a bit

Puoi leggere qui gli operatori: https://developer.mozilla.org/en/JavaScript/Reference/operators/bitwise_operators

Sono bit shift e si verificano anche in lingue diverse da JS.

Esempio: 5 >> 1 = 2

binario: 0101 spostamento di una posizione = 0010

È un cambiamento aritmetico

spostare a b bit a sinistra (riempimento con zeri)

 a << b 

sposta a b bit a destra (copia del bit di segno)

 a >> b 

Da http://ecma262-5.com/ELS5_HTML.htm

11,7 Operatori di spostamento bit a bit

ShiftExpression: AdditiveExpression ShiftExpression << AdditiveExpression ShiftExpression >> AdditiveExpression ShiftExpression >>> AdditiveExpression

11.7.1 Operatore Spostamento sinistro (<<) Esegue un'operazione di spostamento a sinistra bit a bit sull'operando sinistro per la quantità specificata dall'operando destro. La produzione ShiftExpression: ShiftExpression << AdditiveExpression viene valutata come segue:

 Let lref be the result of evaluating ShiftExpression. Let lval be GetValue(lref). Let rref be the result of evaluating AdditiveExpression. Let rval be GetValue(rref). Let lnum be ToInt32(lval). Let rnum be ToUint32(rval). Let shiftCount be the result of masking out all but the least significant 5 bits of rnum, that is, compute rnum & 0x1F. Return the result of left shifting lnum by shiftCount bits. The result is a signed 32-bit integer. 

11.7.2 Operatore di spostamento a destra firmato (>>) Esegue un’operazione di spostamento a destra bit a bit per la firma sull’operando di sinistra della quantità specificata dall’operando di destra.

La produzione ShiftExpression: ShiftExpression >> AdditiveExpression viene valutata come segue:

 Let lref be the result of evaluating ShiftExpression. Let lval be GetValue(lref). Let rref be the result of evaluating AdditiveExpression. Let rval be GetValue(rref). Let lnum be ToInt32(lval). Let rnum be ToUint32(rval). Let shiftCount be the result of masking out all but the least significant 5 bits of rnum, that is, compute rnum & 0x1F. Return the result of performing a sign-extending right shift of lnum by shiftCount bits. The most significant bit is propagated. The result is a signed 32-bit integer. 

spostare a sinistra e spostare gli operatori a destra. Se hai un numero, sposta i suoi bit a sinistra oa destra.

È l’operatore bithifting. Vedi qui per maggiori dettagli.

Destra e Sinistra e operatori di turno.

Sono operatori bithift. I numeri nel computer sono rappresentati in binario. Spostarsi a sinistra equivale a moltiplicare per 2 e lo spostamento a destra equivale a dividere per 2.

Ad esempio, il numero 8 è 1000 in binario. Spostamento a sinistra << di 3 restituirebbe 1000000 che è 64. Spostando a destra di 2 si otterrà 10 che è 2.