Operadors de bits

This article needs an editorial review. How you can help.

Resum

Els operadors de bits tracten els seus operands com una seqüència de 32 bits (uns i zeros), en comptes de operar-los com a nombres decimals, hexadecimals o octals. Per exemple, la representació binària del és nombre decimal nou (9) 1001. Els operadors de bits treballen amb aquesta representació binària però el resultat que retorna l'operació sempre és un nombre standard de JavaScript.

La taula que trobareu a continuació és un resum dels operadors de bits que es poden trobar a JavaScript:

Operador Ús Descripció
AND binari a & b

Retorna un 1 a les posicions on el bit de a i el bit de b són 1 i un 0 en totes les altres.

OR binari a | b

Retorna un 1 a les posicions on al menys la posició de a o la de b són 1.

XOR binari a ^ b

Retorna un 1 a cada posició on a és 1 i b és 0 o bé a és 0 i b és 1.

NOT binari ~ a Inverteix els bits de l'operand donat.
Desplaçament a l'esquerra a << b Desplaça els bits de a b posicions a l'esquerra, tot omplint amb zeros les primeres b posicions.
Desplaçament a la dreta conservant el signe a >> b Desplaça els bits de a b posicions a la dreta, descartant els bits desplaçats fora.
Desplaçament a la dreta omplint amb zeros a >>> b Desplaça els bits de a b posicions a la dreta, descartant els bits desplaçats fora. Els primers b bits s'omplen amb zeros.

Enters de 32 bits amb signe

Els operands de totes les operacions de bits es converteixen a enters amb signe de 32 bits utilitzant el format de complement a 2. Això vol dir que la versió negativa d'un nombre (per exemple 5 vs -5) és exactament la mateixa representació binària però amb els bits invertits (operació de bits NOT del nombre, també coneguda com a complement del nombre) més 1. Per exemple, seguidament es mostra la representació binària de 314:

00000000000000000000000100111010

I a continuació ~314, és a dir, el complement de 314:

11111111111111111111111011000101

Finalment es mostra -314, és a dir, el complement a dos de 314:

11111111111111111111111011000110

El complement a dos garanteix que el bit de més a l'esquerra sempre serà un 0 quan el nombre és positiu i un 1 quan el nombre sigui negatiu. Aquest bit és doncs anomentat el bit de signe degut a això.

El nombre 0 es representa com a l'enter composat íntegrament de zeros a tots els seus bits.

0 (base 10) = 00000000000000000000000000000000 (base 2)

El nombre -1 és l'enter composats completament per 1s a tots els seus bits.

-1 (base 10) = 11111111111111111111111111111111 (base 2)

El nombre -2147483648 (representació hexadecimal: -0x80000000) és l'enter composat per zeros a tots els seus bits a excepciò del bit de més a l'esquerra, que és un 1.

-2147483648 (base 10) = 10000000000000000000000000000000 (base 2)

El nombre 2147483647 (representació hexadecimal: 0x7fffffff) és el sencer composat per 1 a tots els seus bits a excepció del de més a l'esquerra.

2147483647 (base 10) = 01111111111111111111111111111111 (base 2)

Els nombres -2147483648 i 2147483647 són els enters més petit i més gran respectivament que poden ser representats mitjançant un nombre de 32 bits amb signe.

Operadors lògics de bits

Conceptualment els operadors lògics de bits funcionen de la següent forma:

  • Es converteixen els operans a enters de 32 bits amb signe, expressats com una sèrie de bits (zeros i uns).
  • Cada bit del primer operand s'emparella amb el corresponent bit del segon operand: el primer bit amb el primer bit, el segon amb el segon, etcètera.
  • L'operador s'aplica per cada parella de bits, tot construint el resultat bit a bit.

& (AND binari)

Realitza l'operació AND a cada parella de bits. a AND b esdevindrà 1 només si ambdós a i b són 1. La taula de la veritat per a l'operació  AND és la següent:

a b a AND b
0 0 0
0 1 0
1 0 0
1 1 1
     9 (base 10) = 00000000000000000000000000001001 (base 2)
    14 (base 10) = 00000000000000000000000000001110 (base 2)
                   --------------------------------
14 & 9 (base 10) = 00000000000000000000000000001000 (base 2) = 8 (base 10)

Realitzar l'operació AND binària de qualsevol nombre amb el zero retornarà zero. Realitzar l'operació AND binària de qualsevol nombre amb -1 retornarà el mateix nombre.

| (OR binari)

Realitza la operació OR a cada parella de bits. a OR b retornarà 1 si qualsevol de a o b és 1. La taula de la veritat per a l'operació OR és:

a b a OR b
0 0 0
0 1 1
1 0 1
1 1 1
     9 (base 10) = 00000000000000000000000000001001 (base 2)
    14 (base 10) = 00000000000000000000000000001110 (base 2)
                   --------------------------------
14 | 9 (base 10) = 00000000000000000000000000001111 (base 2) = 15 (base 10)

Realitzar l'operació OR binària de qualsevol nombre x amb 0 retornarà x. Realitzar l'operació OR binària de qualsevol nombre x amb -1 retornarà ~x

^ (XOR binari)

Realitza la operació XOR a cada parella de bits. a XOR b retorna 1 si a i b són diferents. La taula de la veritat per a l'operació XOR és la següent:

a b a XOR b
0 0 0
0 1 1
1 0 1
1 1 0
     9 (base 10) = 00000000000000000000000000001001 (base 2)
    14 (base 10) = 00000000000000000000000000001110 (base 2)
                   --------------------------------
14 ^ 9 (base 10) = 00000000000000000000000000000111 (base 2) = 7 (base 10)

Realitzar l'operació XOR binària de qualsevol nombre x amb 0 retornarà x. Realitzar l'operació OR binària de qualsevol nombre x amb -1 retornarà ~x.

~ (NOT binari)

Realitza una operació NOT a cada bit. NOT a retorna el valor invers (també conegut com el complement a 1) de a. La taula de la veritat per a la operació NOT és:

a NOT a
0 1
1 0
 9 (base 10) = 00000000000000000000000000001001 (base 2)
               --------------------------------
~9 (base 10) = 11111111111111111111111111110110 (base 2) = -10 (base 10)

Realitzar la operació NOT binària a un nombre x qualsevol retorna -(x + 1). Per exemple, ~5 resulta en -6.

Exemple amb indexOf:

var str = 'rawr';
var searchFor = 'a';

// fora alternativa equivalent a if (-1*str.indexOf('a') <= -1)
if (~str.indexOf(searchFor)) {
  // searchFor és dins l'string
} else {
  // searchFor no està dins l'string
}

// valors retornats per (~str.indexOf(searchFor))
// r == -1
// a == -2
// w == -3

Operadors binaris de desplaçament

Els operadors binaris de desplaçament accepten dos operands: el primer és el valor que serà transformat a enter de 32 bits i al que se li aplicarà el desplaçament. El segon determina el nombre de posicions que es desplaçarà cada bit. La direcció en la que els bits es desplaçaran es determina per l'operador usat.

Els operadors de desplaçament converteixen els seus operands a enters de 32 bits en ordre big-endian i retornen un valor amb el mateix tipus que l'operand de l'esquerra. L'operand de la dreta hauria de ser menor de 32, però de no ser així només s'utilitzen els primers 5 bits.

<< (Desplaçament a l'esquerra)

Aquest operador desplaça el primer operand un nombre específic de bits cap a l'esquerra. Els bits de l'esquerra sobrants són descartats. Per a omplir les primeres posicions de la dreta s'utilitzen zeros.

Exemple: 9 << 2 resulta en 36:

     9 (base 10): 00000000000000000000000000001001 (base 2)
                  --------------------------------
9 << 2 (base 10): 00000000000000000000000000100100 (base 2) = 36 (base 10)

Desplaçar a l'esquerra qualsevol nombre x y bits resulta en x * 2^y.

>> (Desplaçament a la dreta preservant el signe)

Aquest operador desplaça el primer operand un nombre específic de bits a la dreta. Els bits sobrants es descarten. Els bits de l'esquerra s'inicialitzen amb el valor inicial del primer bit de l'esquerra. Degut a que el bit de més a l'esquerra tindrà el mateix valor que el bit de més a l'esquerra abans de realitzar el desplaçament, el bit de signe no canvia. És degut a aquesta propietat que es diu que aquest operand preserva el signe.

Per exemple, 9 >> 2 resulta en 2:

     9 (base 10): 00000000000000000000000000001001 (base 2)
                  --------------------------------
9 >> 2 (base 10): 00000000000000000000000000000010 (base 2) = 2 (base 10)

De la mateixa manera, -9 >> 2 resulta en -3, ja que el signe es preserva:

     -9 (base 10): 11111111111111111111111111110111 (base 2)
                   --------------------------------
-9 >> 2 (base 10): 11111111111111111111111111111101 (base 2) = -3 (base 10)

>>> (Desplaçament a la dreta omplint amb zeros)

Aquest operador desplaça el primer operand un nombre específic de bits cap a la dreta. Els bits sobrants degut al desplaçament són descartats. Els bits de l'esquerra són omplerts utilitzant zeros. Com que el bit de signe sempre acaba sent un zero el resultat sempre és no negatiu.

Per a nombres no negatius, els operadors de desplaçament a la dreta preservant el signe i omplint amb zeros retornen el mateix resultat. Per exemple, 9 >>> 2 resulta en 2, tal com 9 >> 2:

      9 (base 10): 00000000000000000000000000001001 (base 2)
                   --------------------------------
9 >>> 2 (base 10): 00000000000000000000000000000010 (base 2) = 2 (base 10)

El resultat varia, però, per a nombres negatius. Per exemple, -9 >>> 2 resulta en 1073741821, el qual es diferent de -9 >> 2 (que retorna -3):

      -9 (base 10): 11111111111111111111111111110111 (base 2)
                    --------------------------------
-9 >>> 2 (base 10): 00111111111111111111111111111101 (base 2) = 1073741821 (base 10)

Exemples

Exemple: Marques i màscares de bits

Els operadors lògics de bits s'empren tot sovint per a crear, manipular i llegir seqüències de marques, les quals realitzen uns funció similar a les variables booleanes. El seu avantatge davant les variables booleanes és que les seqüències de marques utilitzen molta menys memòria (per un factor de 32).

The bitwise logical operators are often used to create, manipulate, and read sequences of flags, which are like binary variables. Variables could be used instead of these sequences, but binary flags take much less memory (by a factor of 32).

Suposem 4 marques:

  • Marca A: tenim un problema de formigues
  • Marca B: tenim un ratpenat
  • Marca C: tenim un gat
  • Marca D: tenim un ànec

Aquestes marques són representades per una seqüència de bits: DCBA. Quan una marca està activada, té un valor de 1. Quan una marca no està activa rep un valor de 0. Suposem que una variable anomenada flags (marques en anglès) té el valor binari 0101:

var flags = 5;   // 0101 en binari

Aquest valor indica:

  • La marca A està activa, és a dir, és certa (tenim un problema de formigues)
  • La marca B és falsa (no tenim un murisec)
  • La marca C és certa (tenim un gat)
  • La marca D és falsa (no tenim un ànec)

Com que les operacions be bits utilitzen nombres de 32 bits, 0101 és en realitat 00000000000000000000000000000101, però els zeros a l'esquerra es poden obviar ja que no contenen informació útil.

Una màscara de bits és una seqüència que pot manipular i/o llegir marques. És molt comú definir màscares "primitives" per a cada marca:

var FLAG_A = 1; // 0001
var FLAG_B = 2; // 0010
var FLAG_C = 4; // 0100
var FLAG_D = 8; // 1000

Es fàcil crear noves màscares mitjançant operacions de bits lògiques sobre les màscares primitives. Per exemple, la màscara de bits 1011 es pot crear mitjançant operacions OR sobre FLAG_A, FLAG_B i FLAG_D:

var mask = FLAG_A | FLAG_B | FLAG_D; // 0001 | 0010 | 1000 => 1011

Els valors individuals d'una marca es poden obtindre mitjançant una operació AND de la seqüència de marques amb la màscara primitiva corresponent. La màscara de bits descarta els bits de les marques que no s'escauen. Per exemple, la màscara de bits 0100 es pot emprar per veure si la marca C està activa:

// si tenim un gat...
if (flags & FLAG_C) { // 0101 & 0100 => 0100 => true
   // ... fer coses
}

Una màscara de bits amb múltiples marques activades funciona com un "or". Per exemple els següents dos blocs de codi són equivalents:

// si tenim un ratpenat o un gat...
// (0101 & 0010) || (0101 & 0100) => 0000 || 0100 => true
if ((flags & FLAG_B) || (flags & FLAG_C)) {
   // ... fer coses
}
// si tenim un ratpenat o un gat...
var mask = FLAG_B | FLAG_C; // 0010 | 0100 => 0110
if (flags & mask) { // 0101 & 0110 => 0100 => true
   // ... fer coses
}

Les marques es poden activar mitjançant una operació OR amb la màscara, on cada bit amb el valor 1 activarà la marca corresponent si no està ja activada. Per exemple, la màscara de bits 1100 pot ser emprada per a activar les marques C i D:

// si, tenim un gat i un ànec
var mask = FLAG_C | FLAG_D; // 0100 | 1000 => 1100
flags |= mask;   // 0101 | 1100 => 1101

Les marques es poden desactivar mitjançant una operació AND amb una màscara de bits, on cada bit amb el valor de zero desactivarà la marca corresponent si no està ja desactivada. Aquestes màscares poden generar-se fàcilment mitjançant una operació NOT sobre la màscara primitiva adient. Per exemple, la màscara 1010 pot ser emprada per a desactivar les marques A i C:

// no, no tenim un problema amb formigues ni tenim un gat
var mask = ~(FLAG_A | FLAG_C); // ~0101 => 1010
flags &= mask;   // 1101 & 1010 => 1000

També es podría haver creat la màscara amb ~FLAG_A & ~FLAG_C (Llei de De Morgan):

// no, no tenim un problema amb formigues ni tenim un gat
var mask = ~FLAG_A & ~FLAG_C;
flags &= mask;   // 1101 & 1010 => 1000

Es pot invertir una màscara (entenem per invertir activar-la si està desactivada i desactivar-la si està activada. És a dir, invertir el seu valor) mitjançant una operació XOR amb una màscara de bits, on cada bit amb el valor 1 invertirà el valor de la marca corresponent. Per exemple, la màscara de bits 0110 pot ser emprada per invertir les marques B i C:

// Si no teniem un ratpenat, ara en tenim un
// i si en teniem un, adéu ratpenat
// El mateix amb els gats
var mask = FLAG_B | FLAG_C;
flags = flags ^ mask;   // 1100 ^ 0110 => 1010

Finalment, les marques poden ser invertides mitjançant l'operador NOT:

// entrant a l'univers paral·lel
flags = ~flags;    // ~1010 => 0101

Xuletes per conversions

Converteix un String binari a un Number decimal:

var sBinString = "1011";
var nMyNumber = parseInt(sBinString, 2);
alert(nMyNumber); // prints 11, i.e. 1011

Converteix un Number decimal en un String binari:

var nMyNumber = 11;
var sBinString = nMyNumber.toString(2);
alert(sBinString); // prints 1011, i.e. 11

Automatització de la creació de màscares

El procés de creació de màscares per a valors Booleans pot ser automatitzat:

function createMask () {
  var nMask = 0, nFlag = 0, nLen = arguments.length > 32 ? 32 : arguments.length;
  for (nFlag; nFlag < nLen; nMask |= arguments[nFlag] << nFlag++);
  return nMask;
}
var mask1 = createMask(true, true, false, true); // 11, i.e.: 1011
var mask2 = createMask(false, false, true); // 4, i.e.: 0100
var mask3 = createMask(true); // 1, i.e.: 0001
// etc.

alert(mask1); // prints 11, i.e.: 1011

Algorisme invers: un array de booleans a partir d'una màscara

El codi següent crea un Array de Booleans a partir d'una màscara:

function arrayFromMask (nMask) {
  // nMask must be between -2147483648 and 2147483647
  if (nMask > 0x7fffffff || nMask < -0x80000000) { 
    throw new TypeError("arrayFromMask - out of range"); 
  }
  for (var nShifted = nMask, aFromMask = []; nShifted; 
       aFromMask.push(Boolean(nShifted & 1)), nShifted >>>= 1);
  return aFromMask;
}

var array1 = arrayFromMask(11);
var array2 = arrayFromMask(4);
var array3 = arrayFromMask(1);

alert("[" + array1.join(", ") + "]");
// prints "[true, true, false, true]", i.e.: 11, i.e.: 1011

Ambdós algorismes poden ser testejats a l'hora...

var nTest = 19; // la nostra màscara personal
var nResult = createMask.apply(this, arrayFromMask(nTest));

alert(nResult); // 19

Només amb finalitat didàctica (ja que disposem del mètode Number.toString(2)), es mostra com és posible modficiar l'algorisme arrayFromMask per a crear un String que contingui la representació d'un Number en comptes d'un Array de Booleans:

function createBinaryString (nMask) {
  // nMask ha d'estar entre -2147483648 i 2147483647
  for (var nFlag = 0, nShifted = nMask, sMask = ""; nFlag < 32;
       nFlag++, sMask += String(nShifted >>> 31), nShifted <<= 1);
  return sMask;
}

var string1 = createBinaryString(11);
var string2 = createBinaryString(4);
var string3 = createBinaryString(1);

alert(string1);
// prints 00000000000000000000000000001011, i.e. 11

Specifications

Especificació Estat Comentari
ECMAScript 1a Edició. Standard Definició inicial
ECMAScript 5.1 (ECMA-262)
The definition of 'Bitwise NOT operator' in that specification.

ECMAScript 5.1 (ECMA-262)
The definition of 'Bitwise shift operators' in that specification.

ECMAScript 5.1 (ECMA-262)
The definition of 'Binary bitwise operators' in that specification.
Standard  
ECMAScript 6 (ECMA-262)
The definition of 'Bitwise NOT operator' in that specification.

ECMAScript 6 (ECMA-262)
The definition of 'Bitwise shift operators' in that specification.

ECMAScript 6 (ECMA-262)
The definition of 'Binary bitwise operators' in that specification.
Release Candidate  

Compatibilitat amb navegadors

Característiques Chrome Firefox (Gecko) Internet Explorer Opera Safari
Bitwise NOT (~) (Yes) (Yes) (Yes) (Yes) (Yes)
Bitwise AND (&) (Yes) (Yes) (Yes) (Yes) (Yes)
Bitwise OR (|) (Yes) (Yes) (Yes) (Yes) (Yes)
Bitwise XOR (^) (Yes) (Yes) (Yes) (Yes) (Yes)
Left shift (<<) (Yes) (Yes) (Yes) (Yes) (Yes)
Right shift (>>) (Yes) (Yes) (Yes) (Yes) (Yes)
Unsigned right shift (>>>) (Yes) (Yes) (Yes) (Yes) (Yes)
Característica Android Chrome for Android Firefox Mobile (Gecko) IE Mobile Opera Mobile Safari Mobile
Bitwise NOT (~) (Yes) (Yes) (Yes) (Yes) (Yes) (Yes)
Bitwise AND (&) (Yes) (Yes) (Yes) (Yes) (Yes) (Yes)
Bitwise OR (|) (Yes) (Yes) (Yes) (Yes) (Yes) (Yes)
Bitwise XOR (^) (Yes) (Yes) (Yes) (Yes) (Yes) (Yes)
Left shift (<<) (Yes) (Yes) (Yes) (Yes) (Yes) (Yes)
Right shift (>>) (Yes) (Yes) (Yes) (Yes) (Yes) (Yes)
Unsigned right shift (>>>) (Yes) (Yes) (Yes) (Yes) (Yes) (Yes)

Vegeu també

Document Tags and Contributors

 Contributors to this page: teoli, enTropy
 Last updated by: teoli,