path: root/files/ca/conflicting/web/javascript/reference/operators_94c03c413a71df1ccff4c3ede275360c/index.html

---
title: Operadors de bits
slug: Web/JavaScript/Referencia/Operadors/Bitwise_Operators
translation_of: Web/JavaScript/Reference/Operators
translation_of_original: Web/JavaScript/Reference/Operators/Bitwise_Operators
---
<div>{{jsSidebar("Operators")}}</div>

<h2 id="Summary" name="Summary">Resum</h2>

<p><strong>Els operadors de bits</strong> tracten els seus operands com una seqüència de 32 bits (uns i zeros), en comptes de operar-los com a <a href="/ca/docs/Web/JavaScript/Reference/Global_Objects/Number">nombres</a> 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.</p>

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

<table class="standard-table">
 <tbody>
  <tr>
   <th>Operador</th>
   <th>Ús</th>
   <th>Descripció</th>
  </tr>
  <tr>
   <td><a href="#Bitwise_AND">AND binari</a></td>
   <td style="white-space: nowrap;"><code>a &amp; b</code></td>
   <td>
    <p>Retorna un 1 a les posicions on el bit de <code>a</code> i el bit de <code>b</code> són 1 i un 0 en totes les altres.</p>
   </td>
  </tr>
  <tr>
   <td><a href="#Bitwise_OR">OR binari</a></td>
   <td style="white-space: nowrap;"><code>a | b</code></td>
   <td>
    <p>Retorna un 1 a les posicions on al menys la posició de <code>a</code> o la de <code>b</code> són 1.</p>
   </td>
  </tr>
  <tr>
   <td><a href="#Bitwise_XOR">XOR binari</a></td>
   <td style="white-space: nowrap;"><code>a ^ b</code></td>
   <td>
    <p>Retorna un 1 a cada posició on <code>a</code> és 1 i <code>b</code> és 0 o bé <code>a</code> és 0 i <code>b</code> és 1.</p>
   </td>
  </tr>
  <tr>
   <td><a href="#Bitwise_NOT">NOT binari</a></td>
   <td style="white-space: nowrap;"><code>~ a</code></td>
   <td>Inverteix els bits de l'operand donat.</td>
  </tr>
  <tr>
   <td><a href="#Left_shift">Desplaçament a l'esquerra</a></td>
   <td style="white-space: nowrap;"><code>a &lt;&lt; b</code></td>
   <td>Desplaça els bits de <code>a</code> <code>b</code> posicions a l'esquerra, tot omplint amb zeros les primeres b posicions.</td>
  </tr>
  <tr>
   <td><a href="#Right_shift">Desplaçament a la dreta conservant el signe</a></td>
   <td style="white-space: nowrap;"><code>a &gt;&gt; b</code></td>
   <td>Desplaça els bits de <code>a</code> <code>b</code> posicions a la dreta, descartant els bits desplaçats fora.</td>
  </tr>
  <tr>
   <td><a href="#Unsigned_right_shift">Desplaçament a la dreta omplint amb zeros</a></td>
   <td style="white-space: nowrap;"><code>a &gt;&gt;&gt; b</code></td>
   <td>Desplaça els bits de <code>a</code> <code>b</code> posicions a la dreta, descartant els bits desplaçats fora. Els primers <code>b</code> bits s'omplen amb zeros.</td>
  </tr>
 </tbody>
</table>

<h2 id="Enters_de_32_bits_amb_signe">Enters de 32 bits amb signe</h2>

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

<pre>00000000000000000000000100111010
</pre>

<p>I a continuació <code>~314</code>, és a dir, el complement de <code>314</code>:</p>

<pre>11111111111111111111111011000101
</pre>

<p>Finalment es mostra <code>-314</code>, és a dir, el complement a dos de <code>314</code>:</p>

<pre>11111111111111111111111011000110
</pre>

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

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

<pre>0 (base 10) = 00000000000000000000000000000000 (base 2)
</pre>

<p>El nombre <code>-1</code> és l'enter composats completament per 1s a tots els seus bits.</p>

<pre>-1 (base 10) = 11111111111111111111111111111111 (base 2)
</pre>

<p>El nombre <code>-2147483648</code> (representació hexadecimal: <code>-0x80000000</code>) é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.</p>

<pre>-2147483648 (base 10) = 10000000000000000000000000000000 (base 2)
</pre>

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

<pre>2147483647 (base 10) = 01111111111111111111111111111111 (base 2)
</pre>

<p>Els nombres <code>-2147483648</code> i <code>2147483647</code> 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.</p>

<h2 id="Operadors_lògics_de_bits">Operadors lògics de bits</h2>

<p>Conceptualment els operadors lògics de bits funcionen de la següent forma:</p>

<ul>
 <li>Es converteixen els operans a enters de 32 bits amb signe, expressats com una sèrie de bits (zeros i uns).</li>
 <li>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.</li>
 <li>L'operador s'aplica per cada parella de bits, tot construint el resultat bit a bit.</li>
</ul>

<h3 id="(AND_binari)"><a name="Bitwise_AND">&amp; (AND binari)</a></h3>

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

<table class="standard-table">
 <tbody>
  <tr>
   <td class="header">a</td>
   <td class="header">b</td>
   <td class="header">a AND b</td>
  </tr>
  <tr>
   <td>0</td>
   <td>0</td>
   <td>0</td>
  </tr>
  <tr>
   <td>0</td>
   <td>1</td>
   <td>0</td>
  </tr>
  <tr>
   <td>1</td>
   <td>0</td>
   <td>0</td>
  </tr>
  <tr>
   <td>1</td>
   <td>1</td>
   <td>1</td>
  </tr>
 </tbody>
</table>

<pre>     9 (base 10) = 00000000000000000000000000001001 (base 2)
    14 (base 10) = 00000000000000000000000000001110 (base 2)
                   --------------------------------
14 &amp; 9 (base 10) = 00000000000000000000000000001000 (base 2) = 8 (base 10)
</pre>

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

<h3 id="(OR_binari)"><a name="Bitwise_OR">| (OR binari)</a></h3>

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

<table class="standard-table">
 <tbody>
  <tr>
   <td class="header">a</td>
   <td class="header">b</td>
   <td class="header">a OR b</td>
  </tr>
  <tr>
   <td>0</td>
   <td>0</td>
   <td>0</td>
  </tr>
  <tr>
   <td>0</td>
   <td>1</td>
   <td>1</td>
  </tr>
  <tr>
   <td>1</td>
   <td>0</td>
   <td>1</td>
  </tr>
  <tr>
   <td>1</td>
   <td>1</td>
   <td>1</td>
  </tr>
 </tbody>
</table>

<pre>     9 (base 10) = 00000000000000000000000000001001 (base 2)
    14 (base 10) = 00000000000000000000000000001110 (base 2)
                   --------------------------------
14 | 9 (base 10) = 00000000000000000000000000001111 (base 2) = 15 (base 10)
</pre>

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

<h3 id="(XOR_binari)"><a name="Bitwise_XOR">^ (XOR binari)</a></h3>

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

<table class="standard-table">
 <tbody>
  <tr>
   <td class="header">a</td>
   <td class="header">b</td>
   <td class="header">a XOR b</td>
  </tr>
  <tr>
   <td>0</td>
   <td>0</td>
   <td>0</td>
  </tr>
  <tr>
   <td>0</td>
   <td>1</td>
   <td>1</td>
  </tr>
  <tr>
   <td>1</td>
   <td>0</td>
   <td>1</td>
  </tr>
  <tr>
   <td>1</td>
   <td>1</td>
   <td>0</td>
  </tr>
 </tbody>
</table>

<pre>     9 (base 10) = 00000000000000000000000000001001 (base 2)
    14 (base 10) = 00000000000000000000000000001110 (base 2)
                   --------------------------------
14 ^ 9 (base 10) = 00000000000000000000000000000111 (base 2) = 7 (base 10)
</pre>

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

<h3 id="(NOT_binari)"><a name="Bitwise_NOT">~ (NOT binari)</a></h3>

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

<table class="standard-table">
 <tbody>
  <tr>
   <td class="header">a</td>
   <td class="header">NOT a</td>
  </tr>
  <tr>
   <td>0</td>
   <td>1</td>
  </tr>
  <tr>
   <td>1</td>
   <td>0</td>
  </tr>
 </tbody>
</table>

<pre> 9 (base 10) = 00000000000000000000000000001001 (base 2)
               --------------------------------
~9 (base 10) = 11111111111111111111111111110110 (base 2) = -10 (base 10)
</pre>

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

<p>Exemple amb indexOf:</p>

<pre class="brush: js">var str = 'rawr';
var searchFor = 'a';

// fora alternativa equivalent a if (-1*str.indexOf('a') &lt;= -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
</pre>

<h2 id="Operadors_binaris_de_desplaçament">Operadors binaris de desplaçament</h2>

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

<p>Els operadors de desplaçament converteixen els seus operands a enters de 32 bits en ordre <em>big-endian</em> 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.</p>

<h3 id="&lt;&lt;_(Desplaçament_a_l'esquerra)"><a name="Left_shift">&lt;&lt; (Desplaçament a l'esquerra)</a></h3>

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

<p>Exemple<code>: 9 &lt;&lt; 2</code> resulta en 36:</p>

<pre>     9 (base 10): 00000000000000000000000000001001 (base 2)
                  --------------------------------
9 &lt;&lt; 2 (base 10): 00000000000000000000000000100100 (base 2) = 36 (base 10)
</pre>

<p>Desplaçar a l'esquerra qualsevol nombre <strong>x</strong> <strong>y</strong> bits resulta en <strong>x * 2^y</strong>.</p>

<h3 id=">>_(Desplaçament_a_la_dreta_preservant_el_signe)"><a name="Right_shift">&gt;&gt; (Desplaçament a la dreta preservant el signe)</a></h3>

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

<p>Per exemple, <code>9 &gt;&gt; 2</code> resulta en 2:</p>

<pre>     9 (base 10): 00000000000000000000000000001001 (base 2)
                  --------------------------------
9 &gt;&gt; 2 (base 10): 00000000000000000000000000000010 (base 2) = 2 (base 10)
</pre>

<p>De la mateixa manera, <code>-9 &gt;&gt; 2</code> resulta en -3, ja que el signe es preserva:</p>

<pre>     -9 (base 10): 11111111111111111111111111110111 (base 2)
                   --------------------------------
-9 &gt;&gt; 2 (base 10): 11111111111111111111111111111101 (base 2) = -3 (base 10)
</pre>

<h3 id=">>>_(Desplaçament_a_la_dreta_omplint_amb_zeros)"><a name="Unsigned_right_shift">&gt;&gt;&gt; (Desplaçament a la dreta omplint amb zeros)</a></h3>

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

<p>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, <code>9 &gt;&gt;&gt; 2</code> resulta en 2, tal com <code>9 &gt;&gt; 2</code>:</p>

<pre>      9 (base 10): 00000000000000000000000000001001 (base 2)
                   --------------------------------
9 &gt;&gt;&gt; 2 (base 10): 00000000000000000000000000000010 (base 2) = 2 (base 10)
</pre>

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

<pre>      -9 (base 10): 11111111111111111111111111110111 (base 2)
                    --------------------------------
-9 &gt;&gt;&gt; 2 (base 10): 00111111111111111111111111111101 (base 2) = 1073741821 (base 10)
</pre>

<h2 id="Exemples">Exemples</h2>

<h3 id="Exemple_Marques_i_màscares_de_bits">Exemple: Marques i màscares de bits</h3>

<p>Els operadors lògics de bits s'empren tot sovint per a crear, manipular i llegir seqüències de <em>marques</em>, 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).</p>

<p>The bitwise logical operators are often used to create, manipulate, and read sequences of <em>flags</em>, 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).</p>

<p>Suposem 4 marques:</p>

<ul>
 <li>Marca A: tenim un problema de formigues</li>
 <li>Marca B: tenim un ratpenat</li>
 <li>Marca C: tenim un gat</li>
 <li>Marca D: tenim un ànec</li>
</ul>

<p>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 <code>flags</code> (marques en anglès) té el valor binari 0101:</p>

<pre class="brush: js">var flags = 5;   // 0101 en binari
</pre>

<p>Aquest valor indica:</p>

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

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

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

<pre class="brush: js">var FLAG_A = 1; // 0001
var FLAG_B = 2; // 0010
var FLAG_C = 4; // 0100
var FLAG_D = 8; // 1000
</pre>

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

<pre class="brush: js">var mask = FLAG_A | FLAG_B | FLAG_D; // 0001 | 0010 | 1000 =&gt; 1011
</pre>

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

<pre class="brush: js">// si tenim un gat...
if (flags &amp; FLAG_C) { // 0101 &amp; 0100 =&gt; 0100 =&gt; true
   // ... fer coses
}
</pre>

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

<pre class="brush: js">// si tenim un ratpenat o un gat...
// (0101 &amp; 0010) || (0101 &amp; 0100) =&gt; 0000 || 0100 =&gt; true
if ((flags &amp; FLAG_B) || (flags &amp; FLAG_C)) {
   // ... fer coses
}
</pre>

<pre class="brush: js">// si tenim un ratpenat o un gat...
var mask = FLAG_B | FLAG_C; // 0010 | 0100 =&gt; 0110
if (flags &amp; mask) { // 0101 &amp; 0110 =&gt; 0100 =&gt; true
   // ... fer coses
}
</pre>

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

<pre class="brush: js">// si, tenim un gat i un ànec
var mask = FLAG_C | FLAG_D; // 0100 | 1000 =&gt; 1100
flags |= mask;   // 0101 | 1100 =&gt; 1101
</pre>

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

<pre class="brush: js">// no, no tenim un problema amb formigues ni tenim un gat
var mask = ~(FLAG_A | FLAG_C); // ~0101 =&gt; 1010
flags &amp;= mask;   // 1101 &amp; 1010 =&gt; 1000
</pre>

<p>També es podría haver creat la màscara amb <code>~FLAG_A &amp; ~FLAG_C</code> (Llei de De Morgan):</p>

<pre class="brush: js">// no, no tenim un problema amb formigues ni tenim un gat
var mask = ~FLAG_A &amp; ~FLAG_C;
flags &amp;= mask;   // 1101 &amp; 1010 =&gt; 1000
</pre>

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

<pre class="brush: js">// 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 =&gt; 1010
</pre>

<p>Finalment, les marques poden ser invertides mitjançant l'operador NOT:</p>

<pre class="brush: js">// entrant a l'univers paral·lel
flags = ~flags;    // ~1010 =&gt; 0101
</pre>

<h3 id="Xuletes_per_conversions">Xuletes per conversions</h3>

<p>Converteix un <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/String" title="/en-US/docs/JavaScript/Reference/Global_Objects/String">String</a></code> binari a un <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number" title="/en-US/docs/JavaScript/Reference/Global_Objects/Number">Number</a></code> decimal:</p>

<pre class="brush: js">var sBinString = "1011";
var nMyNumber = parseInt(sBinString, 2);
alert(nMyNumber); // prints 11, i.e. 1011
</pre>

<p>Converteix un <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number" title="/en-US/docs/JavaScript/Reference/Global_Objects/Number">Number</a></code> decimal en un <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/String" title="/en-US/docs/JavaScript/Reference/Global_Objects/String">String</a></code> binari:</p>

<pre class="brush: js">var nMyNumber = 11;
var sBinString = nMyNumber.toString(2);
alert(sBinString); // prints 1011, i.e. 11
</pre>

<h3 id="Automatització_de_la_creació_de_màscares">Automatització de la creació de màscares</h3>

<p>El procés de creació de màscares per a valors <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean" title="/en-US/docs/JavaScript/Reference/Global_Objects/Boolean">Booleans</a></code> pot ser automatitzat:</p>

<pre class="brush: js">function createMask () {
  var nMask = 0, nFlag = 0, nLen = arguments.length &gt; 32 ? 32 : arguments.length;
  for (nFlag; nFlag &lt; nLen; nMask |= arguments[nFlag] &lt;&lt; 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
</pre>

<h3 id="Algorisme_invers_un_array_de_booleans_a_partir_d'una_màscara">Algorisme invers: un array de booleans a partir d'una màscara</h3>

<p>El codi següent crea un <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array" title="/en-US/docs/JavaScript/Reference/Global_Objects/Array">Array</a></code> de <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean" title="/en-US/docs/JavaScript/Reference/Global_Objects/Boolean">Booleans</a></code> a partir d'una màscara:</p>

<pre class="brush: js">function arrayFromMask (nMask) {
  // nMask must be between -2147483648 and 2147483647
  if (nMask &gt; 0x7fffffff || nMask &lt; -0x80000000) {
    throw new TypeError("arrayFromMask - out of range");
  }
  for (var nShifted = nMask, aFromMask = []; nShifted;
       aFromMask.push(Boolean(nShifted &amp; 1)), nShifted &gt;&gt;&gt;= 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
</pre>

<p>Ambdós algorismes poden ser testejats a l'hora...</p>

<pre class="brush: js">var nTest = 19; // la nostra màscara personal
var nResult = createMask.apply(this, arrayFromMask(nTest));

alert(nResult); // 19
</pre>

<p>Només amb finalitat didàctica (ja que disposem del mètode<code> <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toString" title="/en-US/docs/JavaScript/Reference/Global_Objects/Number/toString">Number.toString(2)</a></code>), es mostra com és posible modficiar l'algorisme <code>arrayFromMask</code> per a crear un <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/String" title="/en-US/docs/JavaScript/Reference/Global_Objects/String">String</a></code> que contingui la representació d'un <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number" title="/en-US/docs/JavaScript/Reference/Global_Objects/Number">Number</a></code> en comptes d'un <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array" title="/en-US/docs/JavaScript/Reference/Global_Objects/Array">Array</a></code> de <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean" title="/en-US/docs/JavaScript/Reference/Global_Objects/Boolean">Booleans</a></code>:</p>

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

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

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

<h2 id="Specifications">Specifications</h2>

<table class="standard-table">
 <tbody>
  <tr>
   <th scope="col">Especificació</th>
   <th scope="col">Estat</th>
   <th scope="col">Comentari</th>
  </tr>
  <tr>
   <td>ECMAScript 1a Edició.</td>
   <td>Standard</td>
   <td>Definició inicial</td>
  </tr>
  <tr>
   <td>{{SpecName('ES5.1', '#sec-11.4.8', 'Bitwise NOT operator')}}<br>
    {{SpecName('ES5.1', '#sec-11.7', 'Bitwise shift operators')}}<br>
    {{SpecName('ES5.1', '#sec-11.10', 'Binary bitwise operators')}}</td>
   <td>{{Spec2('ES5.1')}}</td>
   <td> </td>
  </tr>
  <tr>
   <td>{{SpecName('ES6', '#sec-bitwise-not-operator', 'Bitwise NOT operator')}}<br>
    {{SpecName('ES6', '#sec-bitwise-shift-operators', 'Bitwise shift operators')}}<br>
    {{SpecName('ES6', '#sec-binary-bitwise-operators', 'Binary bitwise operators')}}</td>
   <td>{{Spec2('ES6')}}</td>
   <td> </td>
  </tr>
 </tbody>
</table>

<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2>

<p>{{ CompatibilityTable() }}</p>

<div id="compat-desktop">
<table class="compat-table">
 <tbody>
  <tr>
   <th>Característiques</th>
   <th>Chrome</th>
   <th>Firefox (Gecko)</th>
   <th>Internet Explorer</th>
   <th>Opera</th>
   <th>Safari</th>
  </tr>
  <tr>
   <td><a href="#Bitwise_NOT">Bitwise NOT (<code>~</code>)</a></td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
  </tr>
  <tr>
   <td><a href="#Bitwise_AND">Bitwise AND (<code>&amp;</code>)</a></td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
  </tr>
  <tr>
   <td><a href="#Bitwise_OR">Bitwise OR (<code>|</code>)</a></td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
  </tr>
  <tr>
   <td><a href="#Bitwise_XOR">Bitwise XOR (<code>^</code>)</a></td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
  </tr>
  <tr>
   <td><a href="#Left_shift">Left shift (<code>&lt;&lt;</code>)</a></td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
  </tr>
  <tr>
   <td><a href="#Right_shift">Right shift (<code>&gt;&gt;</code>)</a></td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
  </tr>
  <tr>
   <td><a href="#Unsigned_right_shift">Unsigned right shift (<code>&gt;&gt;&gt;</code>)</a></td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
  </tr>
 </tbody>
</table>
</div>

<div id="compat-mobile">
<table class="compat-table">
 <tbody>
  <tr>
   <th>Característica</th>
   <th>Android</th>
   <th>Chrome for Android</th>
   <th>Firefox Mobile (Gecko)</th>
   <th>IE Mobile</th>
   <th>Opera Mobile</th>
   <th>Safari Mobile</th>
  </tr>
  <tr>
   <td><a href="#Bitwise_NOT">Bitwise NOT (<code>~</code>)</a></td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
  </tr>
  <tr>
   <td><a href="#Bitwise_AND">Bitwise AND (<code>&amp;</code>)</a></td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
  </tr>
  <tr>
   <td><a href="#Bitwise_OR">Bitwise OR (<code>|</code>)</a></td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
  </tr>
  <tr>
   <td><a href="#Bitwise_XOR">Bitwise XOR (<code>^</code>)</a></td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
  </tr>
  <tr>
   <td><a href="#Left_shift">Left shift (<code>&lt;&lt;</code>)</a></td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
  </tr>
  <tr>
   <td><a href="#Right_shift">Right shift (<code>&gt;&gt;</code>)</a></td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
  </tr>
  <tr>
   <td><a href="#Unsigned_right_shift">Unsigned right shift (<code>&gt;&gt;&gt;</code>)</a></td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
   <td>{{ CompatVersionUnknown() }}</td>
  </tr>
 </tbody>
</table>
</div>

<h2 id="See_also" name="See_also">Vegeu també</h2>

<ul>
 <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Logical_Operators">Operadors lògics</a></li>
</ul>