Ricerca…
Operatori bit a bit
Gli operatori bit a bit eseguono operazioni sui valori bit dei dati. Questi operatori convertono gli operandi in interi a 32 bit con segno nel complemento a due .
Conversione in numeri interi a 32 bit
I numeri con più di 32 bit scartano i loro bit più significativi. Ad esempio, il seguente intero con più di 32 bit viene convertito in un numero intero a 32 bit:
Before: 10100110111110100000000010000011110001000001
After: 10100000000010000011110001000001
Complemento di due
Nel binario normale troviamo il valore binario aggiungendo gli 1 base alla loro posizione come potenze di 2 - Il bit più a destra è 2^0 al bit più a sinistra essendo 2^n-1 dove n è il numero di bit. Ad esempio, utilizzando 4 bit:
// Normal Binary
// 8 4 2 1
0 1 1 0 => 0 + 4 + 2 + 0 => 6
Il formato di due complementi significa che la controparte negativa del numero (6 vs -6) è costituita da tutti i bit per un numero invertito, più uno. I bit invertiti di 6 sarebbero:
// Normal binary
0 1 1 0
// One's complement (all bits inverted)
1 0 0 1 => -8 + 0 + 0 + 1 => -7
// Two's complement (add 1 to one's complement)
1 0 1 0 => -8 + 0 + 2 + 0 => -6
Nota: l' aggiunta di più 1 alla sinistra di un numero binario non cambia il suo valore nel complimento di due. I valori 1010 e 1111111111010 sono entrambi -6 .
Bitwise AND
L'operazione AND bit a bit a & b restituisce il valore binario con un 1 cui entrambi gli operandi binari hanno 1 's in una posizione specifica e 0 in tutte le altre posizioni. Per esempio:
13 & 7 => 5
// 13: 0..01101
// 7: 0..00111
//-----------------
// 5: 0..00101 (0 + 0 + 4 + 0 + 1)
Esempio di mondo reale: controllo di parità del numero
Invece di questo "capolavoro" (purtroppo troppo spesso visto in molte parti di codice reali):
function isEven(n) {
return n % 2 == 0;
}
function isOdd(n) {
if (isEven(n)) {
return false;
} else {
return true;
}
}
Puoi controllare la parità del numero (intero) in modo molto più efficace e semplice:
if(n & 1) {
console.log("ODD!");
} else {
console.log("EVEN!");
}
Bitwise OR
L'operazione OR bit a bit a | b restituisce il valore binario con un 1 dove entrambi gli operandi o entrambi gli operandi hanno 1 's in una posizione specifica e 0 quando entrambi i valori hanno 0 in una posizione. Per esempio:
13 | 7 => 15
// 13: 0..01101
// 7: 0..00111
//-----------------
// 15: 0..01111 (0 + 8 + 4 + 2 + 1)
Bitwise NOT
L'operazione NOT bit a bit ~a ribalta i bit del valore dato a . Ciò significa che tutti gli 1 diventeranno 0 e tutti gli 0 diventeranno 1 .
~13 => -14
// 13: 0..01101
//-----------------
//-14: 1..10010 (-16 + 0 + 0 + 2 + 0)
XOR bit a bit
L'operazione di bit XOR ( esclusiva o ) a ^ b pone un 1 solo se i due bit sono diversi. Esclusivo o significa l'uno o l'altro, ma non entrambi .
13 ^ 7 => 10
// 13: 0..01101
// 7: 0..00111
//-----------------
// 10: 0..01010 (0 + 8 + 0 + 2 + 0)
Esempio di mondo reale: scambio di due valori interi senza allocazione di memoria aggiuntiva
var a = 11, b = 22;
a = a ^ b;
b = a ^ b;
a = a ^ b;
console.log("a = " + a + "; b = " + b);// a is now 22 and b is now 11
Shift Operators
Lo spostamento per bit può essere pensato come "spostare" i bit a sinistra o a destra, e quindi modificare il valore dei dati operati.
Tasto maiuscolo di sinistra
L'operatore di spostamento a sinistra (value) << (shift amount) sposterà i bit a sinistra di (shift amount) bit di (shift amount) ; i nuovi bit provenienti da destra saranno 0 :
5 << 2 => 20
// 5: 0..000101
// 20: 0..010100 <= adds two 0's to the right
Right Shift ( propagazione del segno )
L'operatore di spostamento a destra (value) >> (shift amount) è anche noto come "Spostamento a destra di propagazione del segno" perché mantiene il segno dell'operando iniziale. L'operatore di spostamento a destra sposta il value della shift amount di shift amount specificata di bit a destra. I bit in eccesso spostati da destra vengono scartati. I nuovi bit provenienti da sinistra saranno basati sul segno dell'operando iniziale. Se il bit più a sinistra era 1 i nuovi bit saranno tutti 1 e viceversa per 0 's.
20 >> 2 => 5
// 20: 0..010100
// 5: 0..000101 <= added two 0's from the left and chopped off 00 from the right
-5 >> 3 => -1
// -5: 1..111011
// -2: 1..111111 <= added three 1's from the left and chopped off 011 from the right
Maiusc destro ( riempimento zero )
L'operatore di spostamento a destra zero-fill (value) >>> (shift amount) sposta i bit a destra ei nuovi bit saranno 0 . Gli 0 vengono spostati da sinistra e i bit in eccesso a destra vengono spostati e scartati. Ciò significa che può rendere i numeri negativi in numeri positivi.
-30 >>> 2 => 1073741816
// -30: 111..1100010
//1073741816: 001..1111000
Lo spostamento a destra con riempimento zero e lo spostamento a destra con propagazione del segno producono lo stesso risultato per i numeri non negativi.