initial commit

12 files changed, 2809 insertions, 0 deletions

diff --git a/files/ca/web/javascript/referencia/operadors/arithmetic_operators/index.html b/files/ca/web/javascript/referencia/operadors/arithmetic_operators/index.html
new file mode 100644
index 0000000000..da169292cd
--- /dev/null
+++ b/files/ca/web/javascript/referencia/operadors/arithmetic_operators/index.html
@@ -0,0 +1,286 @@
+---
+title: Operadors aritmètics
+slug: Web/JavaScript/Referencia/Operadors/Arithmetic_Operators
+translation_of: Web/JavaScript/Reference/Operators
+---
+<div>
+<div>{{jsSidebar("Operators")}}</div>
+</div>
+
+<h2 id="Summary" name="Summary">Resum</h2>
+
+<p><strong>Els operadors aritmètics</strong> prenen valors numèrics (poden ser tant literals com ser variables) com a operands seus i retornen un valor numèric únic. Els operadors aritmètics estàndards són la suma (+), la resta (-), la multiplicació (*), i la divisió (/).</p>
+
+<h2 id="Suma_()"><a name="Addition">Suma (+)</a></h2>
+
+<p>L'operador <em>Suma</em> produeix la suma dels operands numèrics o de la concatenació de cadenes.</p>
+
+<h3 id="Sintaxi">Sintaxi</h3>
+
+<pre class="syntaxbox"><strong>Operador:</strong> x + y
+</pre>
+
+<h3 id="Exemples">Exemples</h3>
+
+<pre class="brush: js">// Nombre + Nombre -&gt; suma
+1 + 2 // 3
+
+// Booleà + Nombre -&gt; suma
+true + 1 // 2
+
+// Booleà + Booleà -&gt; suma
+false + false // 0
+
+// Nombre + String -&gt; concatenació
+5 + "foo" // "5foo"
+
+// String + Booleà -&gt; concatenació
+"foo" + false // "foofalse"
+
+// String + String -&gt; concatenació
+"foo" + "bar" // "foobar"
+</pre>
+
+<h2 id="Resta_(-)"><a name="Subtraction">Resta (-)</a></h2>
+
+<p>L'operador <em>resta</em> produeix la resta de dos operands, produint la seva diferència.</p>
+
+<h3 id="Sintaxi_2">Sintaxi</h3>
+
+<pre class="syntaxbox"><strong>Operador:</strong> x - y
+</pre>
+
+<h3 id="Exemples_2">Exemples</h3>
+
+<pre class="brush: js">5 - 3 // 2
+3 - 5 // -2
+"foo" - 3 // NaN</pre>
+
+<h2 id="Divisió_()"><a name="Division">Divisió (/)</a></h2>
+
+<p>L'operador divisió produeix el quocient dels seus operands on el operand de l'esquerra és el dividend, i l'operand de la dreta és el divisor.</p>
+
+<h3 id="Sintaxi_3">Sintaxi</h3>
+
+<pre class="syntaxbox"><strong>Operador:</strong> x / y
+</pre>
+
+<h3 id="Exemples_3">Exemples</h3>
+
+<pre class="brush: js">1 / 2      // retorna 0.5 a JavaScript
+1 / 2      // retorna 0 in Java
+// (cap dels nombres és explícitament n nombre de coma flotant)
+
+1.0 / 2.0  // retorna 0.5 a JavaScript i Java
+
+2.0 / 0    // retorna Infinity a JavaScript
+2.0 / 0.0  // també retorna Infinity
+2.0 / -0.0 // retorna -Infinity a JavaScript</pre>
+
+<h2 id="Multiplicació_(*)"><a name="Multiplication">Multiplicació (*)</a></h2>
+
+<p>L'operador <em>multiplicació</em> produeix el producte dels operands.</p>
+
+<h3 id="Sintaxi_4">Sintaxi</h3>
+
+<pre class="syntaxbox"><strong>Operador:</strong> x * y
+</pre>
+
+<h3 id="Exemples_4">Exemples</h3>
+
+<pre class="brush: js">2 * 2 // 4
+-2 * 2 // -4
+Infinity * 0 // NaN
+Infinity * Infinity // Infinity
+"foo" * 2 // NaN
+</pre>
+
+<h2 id="Mòdul_()"><a name="Remainder">Mòdul (%)</a></h2>
+
+<p>L'operador<em> mòdul </em>retorna el mòdul del primer operand amb el segon, això és, <code>var1</code> modulo <code>var2</code> en la sentència prèvia, on <code>var1</code> i <code>var2 </code>són variables. La funció mòdul és la resta entera de dividir <code>var1</code> <code>per var2</code>. <a href="http://wiki.ecmascript.org/doku.php?id=strawman:modulo_operator" title="http://wiki.ecmascript.org/doku.php?id=strawman:modulo_operator">Hi ha una proposta per a implementar un operador mòdul real en una futura versió de l'ECMAScript.</a></p>
+
+<h3 id="Sintaxi_5">Sintaxi</h3>
+
+<pre class="syntaxbox"><strong>Operador:</strong> var1 % var2
+</pre>
+
+<h3 id="Exemples_5">Exemples</h3>
+
+<pre class="brush: js">12 % 5 // 2
+-1 % 2 // -1
+NaN % 2 // NaN
+</pre>
+
+<h2 id="Increment_()"><a name="Increment">Increment (++)</a></h2>
+
+<p>L'operador <em>increment</em> incrementa (afegeix un) al seu operand i retorna un valor.</p>
+
+<ul>
+ <li>Emprat com a sufix, és a dir, amb l'operador després de l'operand (per exemple:  x++), retorna el valor de l'operand abans d'incrementar-lo.</li>
+ <li>Emprat com a prefix, és a dir, amb l'operador precedint l'operand (per exemple: ++x), retorna el valor de l'operand després d'incrementar-lo.</li>
+</ul>
+
+<h3 id="Sintaxi_6">Sintaxi</h3>
+
+<pre class="syntaxbox"><strong>Operador:</strong> x++ or ++x
+</pre>
+
+<h3 id="Exemples_6">Exemples</h3>
+
+<pre class="brush: js">// Sufix
+var x = 3;
+y = x++; // y = 3, x = 4
+
+// Prefix
+var a = 2;
+b = ++a; // a = 3, b = 3
+</pre>
+
+<h2 id="Decrement_(--)"><a name="Decrement">Decrement (--)</a></h2>
+
+<p>L'operador <em>decrement</em> decrementa (resta un) al seu operand i retorna el seu valor.</p>
+
+<ul>
+ <li>Emprat com a sufix, és a dir, amb l'operador després de l'operand (per exemple:  x--), retorna el valor de l'operand abans de decrementar-lo.</li>
+ <li>Emprat com a prefix, és a dir, amb l'operador precedint l'operand (per exemple: --x), retorna el valor de l'operand després de decrementar-lo.</li>
+</ul>
+
+<h3 id="Sintaxi_7">Sintaxi</h3>
+
+<pre class="syntaxbox"><strong>Operador:</strong> x-- or --x
+</pre>
+
+<h3 id="Exemples_7">Exemples</h3>
+
+<pre class="brush: js">// Sufix
+var x = 3;
+y = x--; // y = 3, x = 2
+
+// Prefix
+var a = 2;
+b = --a; // a = 1, b = 1
+</pre>
+
+<h2 id="Negació_unària_(-)"><a name="Unary_negation">Negació unària (-)</a></h2>
+
+<p>L'operador de negació unària precedeix el seu operand i el nega.</p>
+
+<h3 id="Sintaxi_8">Sintaxi</h3>
+
+<pre class="syntaxbox"><strong>Operator:</strong> -x
+</pre>
+
+<h3 id="Exemples_8">Exemples</h3>
+
+<pre class="brush: js">var x = 3;
+y = -x; // y = -3, x = 3
+</pre>
+
+<h2 id="Operador_unari_de_conversió_a_nombre_()"><a name="Unary_plus">Operador unari de conversió a nombre</a> (+)</h2>
+
+<p>L'operador unari de conversió a nombre precedeix el seu operand i intenta convertir-lo en un nombre si no ho és ja. Tot i que l'operand de negació unària també pot convertir no-nombres, l'operador de conversió és el mètode més ràpid i recomanat per a convertir quelcom a un nombre ja que no realitza cap altra operació al nombre. Pot convertir cadenes de caràcters representant sencers i nombres en coma flotant, així com els valors <code>true</code>, <code>false</code> i <code>null</code>. Quant a nombres sencers, tant la notació decimal com la hexadecimal (denotada amb el prefixe "0x") estàn suportades. Els nombres negatius també estàn suportats (tot i que no per a hexadecimals). Si no pot interpretar un valor determinat l'operador retornarà<a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/NaN"> NaN</a>.</p>
+
+<h3 id="Sintaxi_9">Sintaxi</h3>
+
+<pre class="syntaxbox"><strong>Operador:</strong> +x
+</pre>
+
+<h3 id="Exemples_9">Exemples</h3>
+
+<pre class="brush: js">+3     // 3
++"3"   // 3
++true  // 1
++false // 0
++null  // 0
+</pre>
+
+<h2 id="Especificacions">Especificacions</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificació</th>
+   <th scope="col">Estat</th>
+   <th scope="col">Comentaris</th>
+  </tr>
+  <tr>
+   <td>ECMAScript 1st Edition.</td>
+   <td>Standard</td>
+   <td>Initial definition.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-11.6', 'Additive operators')}}<br>
+    {{SpecName('ES5.1', '#sec-11.5', 'Multiplicative operators')}}<br>
+    {{SpecName('ES5.1', '#sec-11.3', 'Postfix expressions')}}<br>
+    {{SpecName('ES5.1', '#sec-11.4', 'Unary operators')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-additive-operators', 'Additive operators')}}<br>
+    {{SpecName('ES6', '#sec-multiplicative-operators', 'Multiplicative operators')}}<br>
+    {{SpecName('ES6', '#sec-postfix-expressions', 'Postfix expressions')}}<br>
+    {{SpecName('ES6', '#sec-unary-operators', 'Unary 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ística</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suport bàsic</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 per Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suport bàsic</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="Vegeu_també">Vegeu també</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Assignment_Operators">Operadors d'assignació</a></li>
+</ul>
diff --git a/files/ca/web/javascript/referencia/operadors/bitwise_operators/index.html b/files/ca/web/javascript/referencia/operadors/bitwise_operators/index.html
new file mode 100644
index 0000000000..048a1eddf6
--- /dev/null
+++ b/files/ca/web/javascript/referencia/operadors/bitwise_operators/index.html
@@ -0,0 +1,718 @@
+---
+title: Operadors de bits
+slug: Web/JavaScript/Referencia/Operadors/Bitwise_Operators
+translation_of: Web/JavaScript/Reference/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>
diff --git a/files/ca/web/javascript/referencia/operadors/conditional_operator/index.html b/files/ca/web/javascript/referencia/operadors/conditional_operator/index.html
new file mode 100644
index 0000000000..15265c62b3
--- /dev/null
+++ b/files/ca/web/javascript/referencia/operadors/conditional_operator/index.html
@@ -0,0 +1,170 @@
+---
+title: Operador Condicional (ternari)
+slug: Web/JavaScript/Referencia/Operadors/Conditional_Operator
+translation_of: Web/JavaScript/Reference/Operators/Conditional_Operator
+---
+<div>
+<div>{{jsSidebar("Operators")}}</div>
+</div>
+
+<h2 id="Summary" name="Summary">Resum</h2>
+
+<p>L'operador <strong>condicional (ternari)</strong> és l'únic operador de JavaScript que opera amb tres operands. Aquest operador és freqüentment usat com una simplificació de la sentència <a href="/en-US/docs/Web/JavaScript/Reference/Statements/if...else"><code>if</code></a>.</p>
+
+<h2 id="Sintaxi">Sintaxi</h2>
+
+<pre class="syntaxbox"><em>condition</em> ? <em>expr1</em> : <em>expr2</em> </pre>
+
+<h2 id="Paràmetres">Paràmetres</h2>
+
+<dl>
+ <dt><code>condition</code></dt>
+ <dd>Una expressió que avalua <code>true</code> o <code>false</code>.</dd>
+</dl>
+
+<dl>
+ <dt><code>expr1</code>, <code>expr2</code></dt>
+ <dd>Expressions amb valors de qualsevol tipus.</dd>
+</dl>
+
+<h2 id="Descripció">Descripció</h2>
+
+<p>Si <code>condition</code> és <code>true</code>, l'operador retorna el valor de <code>expr1</code>; de ser el contrari, retorna el valor de <code>expr2</code>. Per exemple, per mostrar diferents missatges basats en el valor de la variable <code>isMember</code>, es podria fer servir aquesta sentència:</p>
+
+<pre class="brush: js">"The fee is " + (isMember ? "$2.00" : "$10.00")
+</pre>
+
+<p>També es pot assignar variables depenent del resultat ternari:</p>
+
+<pre class="brush: js">var elvisLives = Math.PI &gt; 4 ? "Yep" : "Nope";</pre>
+
+<p>És possible realitzar avaluacions ternàries múltiples (nota: L'operador condicional operator s'associa per la dreta):</p>
+
+<pre class="brush: js">var firstCheck = false,
+    secondCheck = false,
+    access = firstCheck ? "Access denied" : secondCheck ? "Access denied" : "Access granted";
+
+console.log( access ); // logs "Access granted"</pre>
+
+<p>També es pot usar avaluacions ternàries en espais lliures per tal de fer diferents operacions:</p>
+
+<pre class="brush: js">var stop = false, age = 16;
+
+age &gt; 18 ? location.assign("continue.html") : stop = true;
+</pre>
+
+<p>També es pot fer més d'una sola operació per cas, separant-les amb una coma:</p>
+
+<pre class="brush: js">var stop = false, age = 23;
+
+age &gt; 18 ? (
+    alert("OK, you can go."),
+    location.assign("continue.html")
+) : (
+    stop = true,
+    alert("Sorry, you are much too young!")
+);
+</pre>
+
+<p>I per últim, també es pot fer més d'una operació durant l'assignació d'un valor. En aquest cas, <strong><em>el últim valor del parèntesis serparat per una coma</em> serà el valor assignat</strong>.</p>
+
+<pre class="brush: js">var age = 16;
+
+var url = age &gt; 18 ? (
+    alert("OK, you can go."),
+    // alert returns "undefined", but it will be ignored because
+    // isn't the last comma-separated value of the parenthesis
+    "continue.html" // the value to be assigned if age &gt; 18
+) : (
+    alert("You are much too young!"),
+    alert("Sorry :-("),
+    // etc. etc.
+    "stop.html" // the value to be assigned if !(age &gt; 18)
+);
+
+location.assign(url); // "stop.html"</pre>
+
+<h2 id="Especificacions">Especificacions</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificació</th>
+   <th scope="col">Estat</th>
+   <th scope="col">Comentaris</th>
+  </tr>
+  <tr>
+   <td>1a edició deECMAScript.</td>
+   <td>Estàndard</td>
+   <td>Definició inicial. Implementat en JavaScript 1.0</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-11.12', 'The conditional operator')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-conditional-operator', 'Conditional Operator')}}</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ística</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suport bàsic</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 per Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suport bàsic</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/Statements/if...else">if statement</a></li>
+</ul>
diff --git a/files/ca/web/javascript/referencia/operadors/function/index.html b/files/ca/web/javascript/referencia/operadors/function/index.html
new file mode 100644
index 0000000000..0908f591b6
--- /dev/null
+++ b/files/ca/web/javascript/referencia/operadors/function/index.html
@@ -0,0 +1,146 @@
+---
+title: function expression
+slug: Web/JavaScript/Referencia/Operadors/function
+translation_of: Web/JavaScript/Reference/Operators/function
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>La paraula clau <strong><code>function</code></strong> es pot utilitzar per definir una funció dins d'una expressió.</p>
+
+<h2 id="Sintaxi">Sintaxi</h2>
+
+<pre class="syntaxbox">function [<em>nom</em>]([<em>paràm1</em>[, <em>paràm2[</em>, ..., <em>paràmN</em>]]]) {
+   <em>sentències</em>
+}</pre>
+
+<h3 id="Paràmetres">Paràmetres</h3>
+
+<dl>
+ <dt><code>nom</code></dt>
+ <dd>El nom de la funció. Es pot ometre, i en aquest cas la funció seria <em>anònima</em>. El nom és només local pel cos de la funció.</dd>
+ <dt><code>paràmN</code></dt>
+ <dd>El nom d'un argument que es passa a la funció.</dd>
+ <dt><code>sentències</code></dt>
+ <dd>Les sentències que constitueixen el cos de la funció.</dd>
+</dl>
+
+<h2 id="Descripció">Descripció</h2>
+
+<p>Una expressió d'una funció és molt semblant i té gairebé la mateixa sintaxi que una sentència d'una funció (<a href="/en-US/docs/Web/JavaScript/Reference/Statements/function">function sentència d'una funció</a> per més detalls). La principal diferència entre l'expressió d'una funció i una sentèndia d'una expressió és el <em>nom de la functió,</em> el qual es pot ometre en expressions de funcions per tal de crear funcions <em>anònimes</em>. Una expressió d'una funció es pot utilitzar com a un <strong>IIFE </strong>(<em>Immediately Invoked Function Expression</em>) que s'executa un cop s'ha definit. Vegeu també el capítol sobre <a href="/en-US/docs/Web/JavaScript/Reference/Functions">funcions</a> per més informació.</p>
+
+<h2 id="Exemples">Exemples</h2>
+
+<p>L'exemple següent defineix una funció sense nom i l'assigna a <code>x</code>. La funció retorna el quadrat del seu argument:</p>
+
+<pre class="brush: js">var x = function(y) {
+   return y * y;
+};
+</pre>
+
+<h3 id="Expressió_d'una_funció_amb_nom">Expressió d'una funció amb nom</h3>
+
+<p>Si vols fer referència a la funció actual dins del cos de la funció, necessitaràs crear una expressió d'una funció amb nom. Aquest nom és llavors només local pel cos de la funció (àmbit). AIxò també evita utilitzar la propietat no estàndard <code><a href="/en-US/docs/Web/JavaScript/Reference/Functions/arguments/callee">arguments.callee.</a></code></p>
+
+<pre class="brush: js">var math = {
+  'factorial': function factorial(n) {
+    if (n &lt;= 1)
+      return 1;
+    return n * factorial(n - 1);
+  }
+};
+</pre>
+
+<h2 id="Especificacions">Especificacions</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificació</th>
+   <th scope="col">Estat</th>
+   <th scope="col">Comentaris</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-function-definitions', 'Function definitions')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-function-definitions', 'Function definitions')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-13', 'Function definition')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES3', '#sec-13', 'Function definition')}}</td>
+   <td>{{Spec2('ES3')}}</td>
+   <td>Definició inicial. Implementat en JavaScript 1.5.</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ística</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suport bàsic</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 per Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suport bàsic</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="Vegeu_també">Vegeu també</h2>
+
+<ul>
+ <li>{{jsxref("Functions_and_function_scope", "Functions and function scope")}}</li>
+ <li>{{jsxref("Function")}}</li>
+ <li>{{jsxref("Statements/function", "function statement")}}</li>
+ <li>{{jsxref("Statements/function*", "function* statement")}}</li>
+ <li>{{jsxref("Operators/function*", "function* expression")}}</li>
+ <li>{{jsxref("GeneratorFunction")}}</li>
+</ul>
diff --git a/files/ca/web/javascript/referencia/operadors/grouping/index.html b/files/ca/web/javascript/referencia/operadors/grouping/index.html
new file mode 100644
index 0000000000..45e8566806
--- /dev/null
+++ b/files/ca/web/javascript/referencia/operadors/grouping/index.html
@@ -0,0 +1,128 @@
+---
+title: Operador d'agrupament
+slug: Web/JavaScript/Referencia/Operadors/Grouping
+translation_of: Web/JavaScript/Reference/Operators/Grouping
+---
+<div>
+<div>{{jsSidebar("Operators")}}</div>
+</div>
+
+<h2 id="Resum">Resum</h2>
+
+<p>L'operador d'agrupament <code>( )</code> controla la precedència de l'avaluació en expresions.</p>
+
+<h2 id="Sintaxi">Sintaxi</h2>
+
+<pre class="syntaxbox"> ( )</pre>
+
+<h2 id="Descripció">Descripció</h2>
+
+<p>L'operador agrupament consisteix en un parell de parèntesis que embolcallen una expressió o una sub-expressió per anular la <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence">precedència d'operadors</a> normal de forma que expressions amb un nivell més baix de precedència poden ser avaluades abans d'una expressió amb més prioritat.</p>
+
+<h2 id="Exemples">Exemples</h2>
+
+<p>Primer predomina la multiplicació i la divisió, després la suma i la resta per tal d'avaluar primer la suma.</p>
+
+<pre class="brush:js">var a = 1;
+var b = 2;
+var c = 3;
+
+// default precedence
+a + b * c     // 7
+// evaluated by default like this
+a + (b * c)   // 7
+
+// now overriding precedence
+// addition before multiplication
+(a + b) * c   // 9
+
+// which is equivalent to
+a * c + b * c // 9
+</pre>
+
+<h2 id="Especificacions">Especificacions</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificació</th>
+   <th scope="col">Estat</th>
+   <th scope="col">Comentaris</th>
+  </tr>
+  <tr>
+   <td>1a edició de ECMAScript.</td>
+   <td>Estàndard</td>
+   <td>Definició inicial. Implementat en JavaScript 1.0</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-11.1.6', 'The Grouping Operator')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-grouping-operator', 'The Grouping Operator')}}</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ística</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suport bàsic</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 per Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suport bàsic</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/Operator_Precedence">Precedència d'operadors</a></li>
+ <li>{{jsxref("Operators/delete", "delete")}}</li>
+ <li>{{jsxref("Operators/typeof", "typeof")}}</li>
+</ul>
diff --git a/files/ca/web/javascript/referencia/operadors/index.html b/files/ca/web/javascript/referencia/operadors/index.html
new file mode 100644
index 0000000000..4a70edc4fb
--- /dev/null
+++ b/files/ca/web/javascript/referencia/operadors/index.html
@@ -0,0 +1,282 @@
+---
+title: Expressions and operators
+slug: Web/JavaScript/Referencia/Operadors
+tags:
+  - JavaScript
+  - NeedsTranslation
+  - Operators
+  - TopicStub
+translation_of: Web/JavaScript/Reference/Operators
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>Aquest capítol documenta totls els operadors, expressions i paraules clau del llenguatge JavaScript.</p>
+
+<h2 id="Expressions_i_operadors_per_categoria">Expressions i operadors per categoria</h2>
+
+<p>Per a un llistat en order alfabetic vegeu el menú de l'esquerra.</p>
+
+<h3 id="Expressions_primàries">Expressions primàries</h3>
+
+<p>Paraules clau bàsiques i expressions generals en JavaScript.</p>
+
+<dl>
+ <dt>{{jsxref("Operadors/this", "this")}}</dt>
+ <dd>La paraula clau <code>this</code> fa referència al contexte d'execució de la funció actual.</dd>
+ <dt>{{jsxref("Operadors/function", "function")}}</dt>
+ <dd>La paraula clau <code>function</code> defineix una expressió de funció.</dd>
+ <dt>{{experimental_inline()}} {{jsxref("Operadors/function*", "function*")}}</dt>
+ <dd>La paraula clau <code>function*</code> defineix una expressió de funció generadora.</dd>
+ <dt>{{experimental_inline()}} {{jsxref("Operadors/yield", "yield")}}</dt>
+ <dd>Pausa i resumeix una funció generadora.</dd>
+ <dt>{{experimental_inline()}} {{jsxref("Operadors/yield*", "yield*")}}</dt>
+ <dd>Delega a una altra funció generadora o objecte iterable.</dd>
+ <dt>{{jsxref("Global_Objects/Array", "[]")}}</dt>
+ <dd>Sintaxi d'inicialització o literal d'arrays.</dd>
+ <dt>{{jsxref("Operators/Object_initializer", "{}")}}</dt>
+ <dd>Sintaxi d'inicialitzador o literal d'objectes.</dd>
+ <dt>{{jsxref("Global_Objects/RegExp", "/ab+c/i")}}</dt>
+ <dd>Sintaxi de literals formats per expressions regulars.</dd>
+ <dt>{{experimental_inline()}} {{jsxref("Operadors/Array_comprehensions", "[for (x of y) x]")}}</dt>
+ <dd>Comprensió d'arrays.</dd>
+ <dt>{{experimental_inline()}} {{jsxref("Operadors/Generator_comprehensions", "(for (x of y) y)")}}</dt>
+ <dd>Comprensió de generators.</dd>
+ <dt>{{jsxref("Operadors/Grouping", "( )")}}</dt>
+ <dd>Operador d'agrupament.</dd>
+</dl>
+
+<h3 id="Expressions_de_banda_esquerra">Expressions de banda esquerra</h3>
+
+<p>Els valors de l'esquerra són la destinació d'una assignació.</p>
+
+<dl>
+ <dt>{{jsxref("Operadors/Property_accessors", "Property accessors", "", 1)}}</dt>
+ <dd>Els operadors membres proporcionen accés a una propietat o mètode d'un objecte<br>
+ (<code>object.property</code> i <code>object["property"]</code>).</dd>
+ <dt>{{jsxref("Operadors/new", "new")}}</dt>
+ <dd>L'operador <code>new</code> crea una instància d'un constructor.</dd>
+ <dt>{{experimental_inline()}} {{jsxref("Operadors/super", "super")}}</dt>
+ <dd>La paraula clau <code>super</code> crida el constructor de l'objecte pare.</dd>
+ <dt>{{experimental_inline()}} {{jsxref("Operadors/Spread_operator", "...obj")}}</dt>
+ <dd>L'operador d'extensió permet que una expressió s'expandeixi en llocs on s'esperen mútiples argurments (per a crides de funcions) o elements (per a literals d'arrays).</dd>
+</dl>
+
+<h3 id="Increment_i_decrement">Increment i decrement</h3>
+
+<p>Operadors de increment o decrement en forma de prefix/sufix.</p>
+
+<dl>
+ <dt>{{jsxref("Operadors/Arithmetic_Operators", "A++", "#Increment")}}</dt>
+ <dd>Operador sufix d'increment.</dd>
+ <dt>{{jsxref("Operadors/Arithmetic_Operators", "A--", "#Decrement")}}</dt>
+ <dd>Operador sufix de decrement.</dd>
+ <dt>{{jsxref("Operadors/Arithmetic_Operators", "++A", "#Increment")}}</dt>
+ <dd>Operador prefix d'increment.</dd>
+ <dt>{{jsxref("Operadors/Arithmetic_Operators", "--A", "#Decrement")}}</dt>
+ <dd>Operador prefix de decrement.</dd>
+</dl>
+
+<h3 id="Operadors_unaris">Operadors unaris</h3>
+
+<p>Un operador unari és un operador que només accepta un operand.</p>
+
+<dl>
+ <dt>{{jsxref("Operadors/delete", "delete")}}</dt>
+ <dd>L'operador <code>delete</code> esborra una propietat d'un objecte.</dd>
+ <dt>{{jsxref("Operadors/void", "void")}}</dt>
+ <dd>L'operador <code>void</code> evalua una expressió i descarta el que retorni.</dd>
+ <dt>{{jsxref("Operadors/typeof", "typeof")}}</dt>
+ <dd>L'operador <code>typeof</code> determina el tipus d'un objecte donat.</dd>
+ <dt>{{jsxref("Operadors/Arithmetic_Operators", "+", "#Unary_plus")}}</dt>
+ <dd>L'operador unari més converteix l'operand donat al tipus Number.</dd>
+ <dt>{{jsxref("Operadors/Arithmetic_Operators", "-", "#Unary_negation")}}</dt>
+ <dd>L'operador unari negació converteix l'operand donat al tipus Number i llavors el nega.</dd>
+ <dt>{{jsxref("Operadors/Bitwise_Operators", "~", "#Bitwise_NOT")}}</dt>
+ <dd>Operador binari NOT.</dd>
+ <dt>{{jsxref("Operadors/Logical_Operators", "!", "#Logical_NOT")}}</dt>
+ <dd>Operador lògic NOT.</dd>
+</dl>
+
+<h3 id="Operadors_aritmètics">Operadors aritmètics</h3>
+
+<p>Els operadors aritmètics accepten valors numèrics (ja siguin literals o variables) com a operands i retornen un únic valor numèric.</p>
+
+<dl>
+ <dt>{{jsxref("Operadors/Arithmetic_Operators", "+", "#Addition")}}</dt>
+ <dd>Operador de suma.</dd>
+ <dt>{{jsxref("Operadors/Arithmetic_Operators", "-", "#Subtraction")}}</dt>
+ <dd>Operador de resta.</dd>
+ <dt>{{jsxref("Operadors/Arithmetic_Operators", "/", "#Division")}}</dt>
+ <dd>Operador de divisió.</dd>
+ <dt>{{jsxref("Operadors/Arithmetic_Operators", "*", "#Multiplication")}}</dt>
+ <dd>Operador de multiplicació.</dd>
+ <dt>{{jsxref("Operadors/Arithmetic_Operators", "%", "#Remainder")}}</dt>
+ <dd>Operador de mòdul.</dd>
+</dl>
+
+<h3 id="Operadors_relacionals">Operadors relacionals</h3>
+
+<p>Els operadors relacionals compara els operands donats i retorna un valor de tipus <code>Boolean</code> value basat en si la relació és certa o no.</p>
+
+<dl>
+ <dt>{{jsxref("Operadors/in", "in")}}</dt>
+ <dd>L'operador <code>in</code> determina si un objecte té la propietat donada.</dd>
+ <dt>{{jsxref("Operadors/instanceof", "instanceof")}}</dt>
+ <dd>L'operador <code>instanceof</code> determina si un objecte és una instància d'un altre objecte.</dd>
+ <dt>{{jsxref("Operadors/Comparison_Operators", "&lt;", "#Less_than_operator")}}</dt>
+ <dd>Operador menor que.</dd>
+ <dt>{{jsxref("Operadors/Comparison_Operators", "&gt;", "#Greater_than_operator")}}</dt>
+ <dd>Operador major que.</dd>
+ <dt>{{jsxref("Operadors/Comparison_Operators", "&lt;=", "#Less_than_or_equal_operator")}}</dt>
+ <dd>Operador menor o igual que.</dd>
+ <dt>{{jsxref("Operadors/Comparison_Operators", "&gt;=", "#Greater_than_or_equal_operator")}}</dt>
+ <dd>Operador major o igual que.</dd>
+</dl>
+
+<h3 id="Operadors_d'igualtat">Operadors d'igualtat</h3>
+
+<p>El resultat d'evaluar un operador d'igualtat és sempre de tipus <code>Boolean</code> i el resultat es basa en si la comparació és certa.</p>
+
+<dl>
+ <dt>{{jsxref("Operadors/Comparison_Operators", "==", "#Equality")}}</dt>
+ <dd>Operador d'igulatat.</dd>
+ <dt>{{jsxref("Operadors/Comparison_Operators", "!=", "#Inequality")}}</dt>
+ <dd>Operador de no igualtat.</dd>
+ <dt>{{jsxref("Operadors/Comparison_Operators", "===", "#Identity")}}</dt>
+ <dd>Operador identitat.</dd>
+ <dt>{{jsxref("Operadors/Comparison_Operators", "!==", "#Nonidentity")}}</dt>
+ <dd>Operador de no identitat.</dd>
+</dl>
+
+<h3 id="Operadors_de_desplaçament_de_bits">Operadors de desplaçament de bits</h3>
+
+<p>Operacions que desplacen tots els bits d'un operand.</p>
+
+<dl>
+ <dt>{{jsxref("Operadors/Bitwise_Operators", "&lt;&lt;", "#Left_shift")}}</dt>
+ <dd>Operador de desplaçament de bits a l'esquerra.</dd>
+ <dt>{{jsxref("Operadors/Bitwise_Operators", "&gt;&gt;", "#Right_shift")}}</dt>
+ <dd>Operador de desplaçament de bits a la dreta.</dd>
+ <dt>{{jsxref("Operadors/Bitwise_Operators", "&gt;&gt;&gt;", "#Unsigned_right_shift")}}</dt>
+ <dd>Operador de desplaçament a la dreta sense signe.</dd>
+</dl>
+
+<h3 id="Operadors_binaris">Operadors binaris</h3>
+
+<p>Els operadors binaris tracten els seus operands com un conjunt de 32 bits (uns i zeros) i retornen valors numèrics standards de JavaScript.</p>
+
+<dl>
+ <dt>{{jsxref("Operadors/Bitwise_Operators", "&amp;", "#Bitwise_AND")}}</dt>
+ <dd>AND binari.</dd>
+ <dt>{{jsxref("Operadors/Bitwise_Operators", "|", "#Bitwise_OR")}}</dt>
+ <dd>OR binari.</dd>
+ <dt>{{jsxref("Operadors/Bitwise_Operators", "^", "#Bitwise_XOR")}}</dt>
+ <dd>XOR binari.</dd>
+</dl>
+
+<h3 id="Operadors_lògics">Operadors lògics</h3>
+
+<p>Els operadors lògics típicament s'utilitzen amb valors booleans (és a dir, logics) i retornen un valor booleà.</p>
+
+<dl>
+ <dt>{{jsxref("Operadors/Logical_Operators", "&amp;&amp;", "#Logical_AND")}}</dt>
+ <dd>AND lògic.</dd>
+ <dt>{{jsxref("Operadors/Logical_Operators", "||", "#Logical_OR")}}</dt>
+ <dd>OR lògic.</dd>
+</dl>
+
+<h3 id="Operador_condicional_(ternari)">Operador condicional (ternari)</h3>
+
+<dl>
+ <dt>{{jsxref("Operadors/Conditional_Operator", "(condition ? ifTrue : ifFalse)")}}</dt>
+ <dd>
+ <p>L'operador condicional retorna un dels dos valors basat en l'evaluació lògica de la condició.</p>
+ </dd>
+</dl>
+
+<h3 id="Operadors_d'assignació">Operadors d'assignació</h3>
+
+<p>Els operadors d'assignació asignen un valor a l'operand de l'esquerra basant-se en l'evaluació de l'operand de la dreta.</p>
+
+<dl>
+ <dt>{{jsxref("Operadors/Assignment_Operators", "=", "#Assignment")}}</dt>
+ <dd>Operador d'assignació.</dd>
+ <dt>{{jsxref("Operadors/Assignment_Operators", "*=", "#Multiplication_assignment")}}</dt>
+ <dd>Assignació de la multiplicació.</dd>
+ <dt>{{jsxref("Operadors/Assignment_Operators", "/=", "#Division_assignment")}}</dt>
+ <dd>Assignació de la divisó.</dd>
+ <dt>{{jsxref("Operadors/Assignment_Operators", "%=", "#Remainder_assignment")}}</dt>
+ <dd>Assignació del mòdul.</dd>
+ <dt>{{jsxref("Operadors/Assignment_Operators", "+=", "#Addition_assignment")}}</dt>
+ <dd>Assignació de la suma.</dd>
+ <dt>{{jsxref("Operadors/Assignment_Operators", "-=", "#Subtraction_assignment")}}</dt>
+ <dd>Assignació de la resta.</dd>
+ <dt>{{jsxref("Operadors/Assignment_Operators", "&lt;&lt;=", "#Left_shift_assignment")}}</dt>
+ <dd>Assignació del desplaçament a l'esquerra.</dd>
+ <dt>{{jsxref("Operadors/Assignment_Operators", "&gt;&gt;=", "#Right_shift_assignment")}}</dt>
+ <dd>Assignació del desplaçament a la dreta.</dd>
+ <dt>{{jsxref("Operadors/Assignment_Operators", "&gt;&gt;&gt;=", "#Unsigned_right_shift_assignment")}}</dt>
+ <dd>Assignació del desplaçament a la dreta sense signe.</dd>
+ <dt>{{jsxref("Operadors/Assignment_Operators", "&amp;=", "#Bitwise_AND_assignment")}}</dt>
+ <dd>Assignació de l'AND binari.</dd>
+ <dt>{{jsxref("Operadors/Assignment_Operators", "^=", "#Bitwise_XOR_assignment")}}</dt>
+ <dd>Assignació del XOR binari.</dd>
+ <dt>{{jsxref("Operadors/Assignment_Operators", "|=", "#Bitwise_OR_assignment")}}</dt>
+ <dd>Assignació de l'OR binari.</dd>
+ <dt>{{experimental_inline()}} {{jsxref("Operadors/Destructuring_assignment", "[a, b] = [1, 2]")}}<br>
+ {{experimental_inline()}} {{jsxref("Operadors/Destructuring_assignment", "{a, b} = {a:1, b:2}")}}</dt>
+ <dd>
+ <p>L'assignació de desestructuració permet assignar les propietats d'un array o objecte a variables utilitzant una sintaxi que recorda la de literals d'arrays o objectes.</p>
+ </dd>
+</dl>
+
+<h3 id="Operador_coma">Operador coma</h3>
+
+<dl>
+ <dt>{{jsxref("Operadors/Comma_Operator", ",")}}</dt>
+ <dd>L'operador coma permet que múltiples expressions siguin evaluades en una sola sentència i retorna el resultat de l'última expressió.</dd>
+</dl>
+
+<h3 id="Característiques_no_standard">Característiques no standard</h3>
+
+<dl>
+ <dt>{{non-standard_inline}} {{jsxref("Operadors/Legacy_generator_function", "Legacy generator function", "", 1)}}</dt>
+ <dd>La paraula clau <code>function</code> es pot emprar per a definir una funció generadora obsoleta dins una expressió. Per a crear una funció generadora obsoleta el cos de la funció ha de contindre al menys una expressió {{jsxref("Operators/yield", "yield")}}.</dd>
+ <dt>{{non-standard_inline}} {{jsxref("Operadors/Expression_closures", "Expression closures", "", 1)}}</dt>
+ <dd>La sintaxi d'expressions closure és una abreviació per a escriure funcions simples.</dd>
+</dl>
+
+<h2 id="Especificacions">Especificacions</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificació</th>
+   <th scope="col">Estat</th>
+   <th scope="col">Comentaris</th>
+  </tr>
+  <tr>
+   <td>ECMAScript 1a Edició.</td>
+   <td>Standard</td>
+   <td>Definició inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-11', 'Expressions')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-ecmascript-language-expressions', 'Llenguatge ECMAScript: Expressions')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>
+    <p>Nou: L'operador d'extensió, l'assignació de desestructuració, la paraula clau <code>super</code>, la comprensió d'arrays i la comprensió de generadors</p>
+   </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Vegeu_també">Vegeu també</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence">Precendència d'operadors</a></li>
+</ul>
diff --git a/files/ca/web/javascript/referencia/operadors/logical_operators/index.html b/files/ca/web/javascript/referencia/operadors/logical_operators/index.html
new file mode 100644
index 0000000000..d8ef9e99c1
--- /dev/null
+++ b/files/ca/web/javascript/referencia/operadors/logical_operators/index.html
@@ -0,0 +1,301 @@
+---
+title: Operadors Lògics
+slug: Web/JavaScript/Referencia/Operadors/Logical_Operators
+translation_of: Web/JavaScript/Reference/Operators
+---
+<div>
+<div>{{jsSidebar("Operators")}}</div>
+</div>
+
+<h2 id="Summary" name="Summary">Resum</h2>
+
+<p>Els operadors lògics s'utilitzen normalment amb valors <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean">Boolean</a></code> (lògics). En cas de serh-hi presents, retornen un valor booleà. Tot i així, els operadors <code>&amp;&amp;</code> i <code>||</code> retornen el valor d'un dels operands especificats, així que si aquests operadors es fan servir amb valors no booleans, poden retornar un valor no booleà.</p>
+
+<h2 id="Descripció">Descripció</h2>
+
+<p>Els operadors lògics es descriuren en la taula següent:</p>
+
+<table class="fullwidth-table">
+ <tbody>
+  <tr>
+   <th>Operador</th>
+   <th>Ús</th>
+   <th>Descripció</th>
+  </tr>
+  <tr>
+   <td>AND lògic (<code>&amp;&amp;</code>)</td>
+   <td><code><em>expr1</em> &amp;&amp; <em>expr2</em></code></td>
+   <td>Retorna <code>expr1 </code>si es pot convertir en false; sinó, retorna expr2. Així, quan es fa servir amb valors booleans, <code>&amp;&amp;</code> retorna true si ambdós operands són true; de ser el contrari, retorna false.</td>
+  </tr>
+  <tr>
+   <td>OR lògic(<code>||</code>)</td>
+   <td><code><em>expr1</em> || <em>expr2</em></code></td>
+   <td>Retorna <code>expr1</code> si es pot converir en true; de ser al contrari, retorna <code>expr2</code>. Així, quan s'usa amb valors Booleans, <code>||</code> retorna true si l'operand és true; si amdós són false, retorna false.</td>
+  </tr>
+  <tr>
+   <td>NOT lògic (<code>!</code>)</td>
+   <td><code>!<em>expr</em></code></td>
+   <td>Retorna false si el seu únic operand pot convertir-se a true; sinó, retorna true.</td>
+  </tr>
+ </tbody>
+</table>
+
+<p>Exemples d'expressions que es poden converir a false son aquelles que avaluen <code>null</code>, <code>0</code>, la cadena buida (""), o <code>undefined</code>.</p>
+
+<p>Tot i que els operadors <code>&amp;&amp;</code> i <code>||</code> es poden fer servir amb operands que no siguin valors Booleans, poden ser considerats operadors Booleans ja que els valors que retornen sempre es poden convertir en valors Booleans.</p>
+
+<h3 id="Short-Circuit_Evaluation" name="Short-Circuit_Evaluation">Avaluació de tipus curtcircuit</h3>
+
+<p>Com a expressions lògiques que són, s'avaluen d'esquerra a dreta, they are tested for possible "short-circuit" evaluation fent servir les regles següents:</p>
+
+<ul>
+ <li><code>false &amp;&amp; (<em>quelcom)</em></code> is short-circuit evaluated to false.</li>
+ <li><code>true || (<em>quelcom)</em></code> is short-circuit evaluated to true.</li>
+</ul>
+
+<p>Les regles de la lògica garanteixen que aquestes avaluacions són sempre correctes. Fixeu-vos que la part <code><em>quelcom</em></code> d'adalt no s'avalua, així que els efectes secundaris d'això no tindràn efecte. Fixeu-vos també que la part de l'expressió de dalt anomenada <code><em>quelcom </em></code>és una expressió lògica simple (com s'indiquen amb els parèntesis).</p>
+
+<p>Per exemple, les dues funcions següents són equivalents.</p>
+
+<pre class="brush: js">function shortCircuitEvaluation() {
+  doSomething() || doSomethingElse()
+}
+
+function equivalentEvaluation() {
+  var flag = doSomething();
+  if (!flag) {
+    doSomethingElse();
+  }
+}
+</pre>
+
+<p>Tot i així, les següents expressions no són equivalents degut a la <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence">precendència dels operadors</a>, i remarca la importància de requerir que l'operador de la dreta sigui una sola expressió (agrupada, si s'escau, per parèntesi).</p>
+
+<pre class="brush: js">false &amp;&amp; true  || true      // returns true
+false &amp;&amp; (true || true)     // returns false</pre>
+
+<h3 id="Logical_AND_.28&amp;&amp;.29" name="Logical_AND_.28&amp;&amp;.29"><a name="Logical_AND">AND lògic (<code>&amp;&amp;</code>)</a></h3>
+
+<p>El codi següent mostra exemples de l'operador <code>&amp;&amp;</code> (AND lògic).</p>
+
+<pre class="brush: js">a1 = true  &amp;&amp; true      // t &amp;&amp; t returns true
+a2 = true  &amp;&amp; false     // t &amp;&amp; f returns false
+a3 = false &amp;&amp; true      // f &amp;&amp; t returns false
+a4 = false &amp;&amp; (3 == 4)  // f &amp;&amp; f returns false
+a5 = "Cat" &amp;&amp; "Dog"     // t &amp;&amp; t returns "Dog"
+a6 = false &amp;&amp; "Cat"     // f &amp;&amp; t returns false
+a7 = "Cat" &amp;&amp; false     // t &amp;&amp; f returns false
+</pre>
+
+<h3 id="OR_lògic_()"><a name="Logical_OR">OR lògic (<code>||</code>)</a></h3>
+
+<p>El codi següent mostra exemples de l'operador <code>||</code> (OR lògic).</p>
+
+<pre class="brush: js">o1 = true  || true       // t || t returns true
+o2 = false || true       // f || t returns true
+o3 = true  || false      // t || f returns true
+o4 = false || (3 == 4)   // f || f returns false
+o5 = "Cat" || "Dog"      // t || t returns "Cat"
+o6 = false || "Cat"      // f || t returns "Cat"
+o7 = "Cat" || false      // t || f returns "Cat"
+</pre>
+
+<h3 id="Logical_NOT_.28.21.29" name="Logical_NOT_.28.21.29"><a name="Logical_NOT">NOT lògic (<code>!</code>)</a></h3>
+
+<p>El codi següent mostra exemples de l'operador <code>!</code> (NOT lògic).</p>
+
+<pre class="brush: js">n1 = !true              // !t returns false
+n2 = !false             // !f returns true
+n3 = !"Cat"             // !t returns false
+</pre>
+
+<h3 id="Regles_de_conversió">Regles de conversió</h3>
+
+<h4 id="Convertir_AND_a_OR">Convertir AND a OR</h4>
+
+<p>L'operació següent que inclou Booleans:</p>
+
+<pre class="brush: js">bCondition1 &amp;&amp; bCondition2</pre>
+
+<p>sempre és igual a:</p>
+
+<pre class="brush: js">!(!bCondition1 || !bCondition2)</pre>
+
+<h4 id="Convertir_OR_a_AND">Convertir OR a AND</h4>
+
+<p>L'operació següent que inclou Booleans:</p>
+
+<pre class="brush: js">bCondition1 || bCondition2</pre>
+
+<p>sempre és igual a:</p>
+
+<pre class="brush: js">!(!bCondition1 &amp;&amp; !bCondition2)</pre>
+
+<h3 id="Desfer-se_de_parèntesis_aniuats">Desfer-se de parèntesis aniuats</h3>
+
+<p>Com que les expressions lògiques s'avaluen d'esquerra a dreta, sempre és posible esborrar els parèntesi d'expressions complexes mitjançant les regles següents.</p>
+
+<h4 id="Desfer-se_d'un_AND_aniuat">Desfer-se d'un AND aniuat</h4>
+
+<p>L'operació següent que inclou Booleans:</p>
+
+<pre class="brush: js">bCondition1 || (bCondition2 &amp;&amp; bCondition3)</pre>
+
+<p>sempre és igual a:</p>
+
+<pre class="brush: js">bCondition1 || bCondition2 &amp;&amp; bCondition3</pre>
+
+<h4 id="Desfer-se_d'un_OR_aniuat">Desfer-se d'un OR aniuat</h4>
+
+<p>L'operació següent que inclou Booleans:</p>
+
+<pre class="brush: js">bCondition1 &amp;&amp; (bCondition2 || bCondition3)</pre>
+
+<p>sempre és igual a:</p>
+
+<pre class="brush: js">!(!bCondition1 || !bCondition2 &amp;&amp; !bCondition3)</pre>
+
+<h2 id="Especificacions">Especificacions</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>1a edició de ECMAScript.</td>
+   <td>Estàndard</td>
+   <td>Definició inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-11.4.9', 'Logical NOT Operator')}}<br>
+    {{SpecName('ES5.1', '#sec-11.11', 'Binary Logical Operators')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-logical-not-operator', 'Logical NOT operator')}}<br>
+    {{SpecName('ES6', '#sec-binary-logical-operators', 'Binary Logical 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ística</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td><a href="#Logical_AND">AND lògic (<code>&amp;&amp;</code>)</a></td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+  </tr>
+  <tr>
+   <td><a href="#Logical_OR">OR </a><a href="#Logical_AND">lògic </a><a href="#Logical_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="#Logical_NOT">NOT </a><a href="#Logical_AND">lògic</a><a href="#Logical_NOT"> (<code>!</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 per Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td><a href="#Logical_AND">AND </a><a href="#Logical_AND">lògic</a><a href="#Logical_AND"> (<code>&amp;&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="#Logical_OR">OR </a><a href="#Logical_AND">lògic </a><a href="#Logical_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="#Logical_NOT">NOT </a><a href="#Logical_AND">lògic</a><a href="#Logical_NOT"> (<code>!</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>
+
+<h3 id="JavaScript_1.0_and_1.1" name="JavaScript_1.0_and_1.1">Compatibilitat amb versions anteriors: Comportament a JavaScript 1.0 i 1.1</h3>
+
+<p>Els operadors &amp;&amp; i <code>||</code> es comporten de la forma següent:</p>
+
+<table class="fullwidth-table">
+ <tbody>
+  <tr>
+   <th>Operador</th>
+   <th>Ús</th>
+   <th>Comportament</th>
+  </tr>
+  <tr>
+   <td><code>&amp;&amp;</code></td>
+   <td><code><em>expr1</em> &amp;&amp; <em>expr2</em></code></td>
+   <td>Si el primer operand (<code>expr1</code>) es pot converitr a false, l'operador <code>&amp;&amp;</code> retorna false en comptes del valor de <code>expr1</code>.</td>
+  </tr>
+  <tr>
+   <td><code>||</code></td>
+   <td><code><em>expr1</em> || <em>expr2</em></code></td>
+   <td>Si el primer operand (<code>expr1</code>) es pot converitr a true, l'operador <code>||</code> retorna true en comptes del valor de <code>expr1</code>.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="See_also" name="See_also">Vegeu també</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators">Bitwise operators</a></li>
+</ul>
diff --git a/files/ca/web/javascript/referencia/operadors/operador_coma/index.html b/files/ca/web/javascript/referencia/operadors/operador_coma/index.html
new file mode 100644
index 0000000000..f6a62d2bc8
--- /dev/null
+++ b/files/ca/web/javascript/referencia/operadors/operador_coma/index.html
@@ -0,0 +1,129 @@
+---
+title: Operador Coma
+slug: Web/JavaScript/Referencia/Operadors/Operador_Coma
+translation_of: Web/JavaScript/Reference/Operators/Comma_Operator
+---
+<div>
+<div>{{jsSidebar("Operators")}}</div>
+</div>
+
+<h2 id="Summary" name="Summary">Resum</h2>
+
+<p><span class="seoSummary"><strong>L'operador <em>coma</em></strong> avalua cadascun dels seus operands (d'esquerra a dreta) i retorna el valor de l´últim operand.</span></p>
+
+<h2 id="Sintaxi">Sintaxi</h2>
+
+<pre class="syntaxbox"><em>expr1</em>, <em>expr2, expr3...</em></pre>
+
+<h2 id="Paràmetres">Paràmetres</h2>
+
+<dl>
+ <dt><code>expr1</code>, <code>expr2, expr3...</code></dt>
+ <dd>Qualsevol expressions.</dd>
+</dl>
+
+<h2 id="Descripció">Descripció</h2>
+
+<p>Es pot fer servir l'operador coma quan es vulgui incloure múltiples expressions en una localització que requereix una sola expressió. L'ús més freqüent que es fa d'aquest operador es per subministrar múltiples paràmetres en una <code>for</code> loop.</p>
+
+<h2 id="Exemple">Exemple</h2>
+
+<p>Si <code>a</code> és un array de 2 dimesnions amb 10 elements on a side, el codi següent usa l'operador coma per incrementar dos variables al mateix temps. Vegeu que la coma en la sentència <code>var</code> <em><strong>no </strong></em> és l'operador coma, ja que no existeix dins d'una expressió. Més aviat, és un caràcter especial en les sentències <code>var</code> que combina múltiples d'ells en un. Pràcticament, la coma es comporta quasi igual que l'operador coma. El codi imprimeix els valors dels elements de la diagonal de l'array:</p>
+
+<pre class="brush:js;highlight:[1]">for (var i = 0, j = 9; i &lt;= 9; i++, j--)
+  document.writeln("a[" + i + "][" + j + "] = " + a[i][j]);</pre>
+
+<h3 id="Processar_i_després_retornar">Processar i després retornar</h3>
+
+<p>Un altre exemple sobre l'ús que es pot fer sobre l'operador coma és processar abansd e retornar. Com s'indica, només l'últim element serà retornat, però tots els altres també seràn avaluats. Així doncs, es podria fer:</p>
+
+<pre>function myFunc () {
+  var x = 0;
+
+  return (x += 1, x); // the same of return ++x;
+}</pre>
+
+<h2 id="Especificacions">Especificacions</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 1st Edition.</td>
+   <td>Estàndard</td>
+   <td>Definició inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-11.14', 'Comma operator')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-comma-operator', 'Comma operator')}}</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ística</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suport bàsic</td>
+   <td>Sí</td>
+   <td>Sí</td>
+   <td>3.0</td>
+   <td>Sí</td>
+   <td>Sí</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Característica</th>
+   <th>Android</th>
+   <th>Chrome per Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suport bàsic</td>
+   <td>Sí</td>
+   <td>Sí</td>
+   <td>Sí</td>
+   <td>Sí</td>
+   <td>Sí</td>
+   <td>Sí</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/Statements/for">for loop</a></li>
+</ul>
diff --git a/files/ca/web/javascript/referencia/operadors/super/index.html b/files/ca/web/javascript/referencia/operadors/super/index.html
new file mode 100644
index 0000000000..c19e58cba1
--- /dev/null
+++ b/files/ca/web/javascript/referencia/operadors/super/index.html
@@ -0,0 +1,119 @@
+---
+title: super
+slug: Web/JavaScript/Referencia/Operadors/super
+translation_of: Web/JavaScript/Reference/Operators/super
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<h2 id="Resum">Resum</h2>
+
+<p>La paraula clau <strong>super</strong> s'utilitza per cridar funcions del pare de l'objecte.</p>
+
+<h2 id="Sintaxi">Sintaxi</h2>
+
+<pre class="syntaxbox">super([arguments]); // crida el constructor del pare.
+super.functionOnParent([arguments]);
+</pre>
+
+<h2 id="Descripció">Descripció</h2>
+
+<p>Quan s'utilitza en un constructor, la paraula clau <code>super</code> apareix sola i s'ha d'utilitzar abans de la paraula clau <code>this</code>. Aquesta paraula clau també es pot utilitzar per cridar funcions en un objecte pare.</p>
+
+<h2 id="Exemple">Exemple</h2>
+
+<p>Aquest fragment de codi es pren de la mostra de classes  <a href="https://github.com/GoogleChrome/samples/blob/gh-pages/classes-es6/index.html">mostra de classes</a> (<a href="https://googlechrome.github.io/samples/classes-es6/index.html">demostració en viu</a>).</p>
+
+<pre class="brush: js">class Square extends Polygon {
+  constructor(length) {
+    // Aquí es crida el constructor del pare de la classe amb les longituds
+    // proveïdes per l'alçada i l'amplada del polígon
+    super(length, length);
+    // Nota: En classes derivades, s'ha de cridar super() abans de poder
+    // utilitzar 'this'. Obviar això causarà un error de referència.
+    this.name = 'Square';
+  }
+
+  get area() {
+    return this.height * this.width;
+  }
+
+  set area(value) {
+    this.area = value;
+  }
+}</pre>
+
+<h2 id="Especificacions">Especificacions</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificació</th>
+   <th scope="col">Estat</th>
+   <th scope="col">Comentaris</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-super-keyword', 'super')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Definició inicial.</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ística</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suport bàsic</td>
+   <td>{{CompatChrome(42.0)}}</td>
+   <td>{{CompatNo}}<br>
+    {{bug(1066239)}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">Safari Mobile
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Característica</th>
+   <th>Android</th>
+   <th>Chrome per Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+  </tr>
+  <tr>
+   <td>Suport bàsic</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatChrome(42.0)}}</td>
+   <td>{{CompatNo}}<br>
+    {{bug(1066239)}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Vegeu_també">Vegeu també</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Classes">Classes</a></li>
+</ul>
diff --git a/files/ca/web/javascript/referencia/operadors/typeof/index.html b/files/ca/web/javascript/referencia/operadors/typeof/index.html
new file mode 100644
index 0000000000..a7407e79ce
--- /dev/null
+++ b/files/ca/web/javascript/referencia/operadors/typeof/index.html
@@ -0,0 +1,240 @@
+---
+title: typeof
+slug: Web/JavaScript/Referencia/Operadors/typeof
+translation_of: Web/JavaScript/Reference/Operators/typeof
+---
+<div>
+<div>{{jsSidebar("Operators")}}</div>
+</div>
+
+<h2 id="Resum">Resum</h2>
+
+<p>L'operador <code>typeof</code> retorna una cadena de caràcters que representa el tipus de l'operand, que en cap cas és evaluat.</p>
+
+<h2 id="Sintaxi">Sintaxi</h2>
+
+<p>L'operador <code>typeof</code> va seguit del seu operand:</p>
+
+<pre class="syntaxbox"><code>typeof <code><em>operand</em></code></code></pre>
+
+<h3 id="Paràmetres">Paràmetres</h3>
+
+<p><code><em>operand</em></code> és una expressió que representa l'objecte o {{Glossary("Primitive", "primitive")}} del qual es retornarà el tipus.</p>
+
+<h2 id="Descripció">Descripció</h2>
+
+<p>La taula següent resumeix els possibles valor de<code> typeof</code>. Per més informació sobre tipus i tipus primitius, vegeu també la pàgina de <a href="/en-US/docs/Web/JavaScript/Data_structures">JavaScript data structure</a>.</p>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Tipus</th>
+   <th scope="col">Resultat</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>Undefined</td>
+   <td><code>"undefined"</code></td>
+  </tr>
+  <tr>
+   <td>Null</td>
+   <td><code>"object" </code>(vegeu a sota)</td>
+  </tr>
+  <tr>
+   <td>Boolean</td>
+   <td><code>"boolean"</code></td>
+  </tr>
+  <tr>
+   <td>Number</td>
+   <td><code>"number"</code></td>
+  </tr>
+  <tr>
+   <td>String</td>
+   <td><code>"string"</code></td>
+  </tr>
+  <tr>
+   <td>Symbol (nou a l'ECMAScript 6)</td>
+   <td><code>"symbol"</code></td>
+  </tr>
+  <tr>
+   <td>Host object (proporcionat per l'entorn JS)</td>
+   <td><em>Depenent de l'implementació</em></td>
+  </tr>
+  <tr>
+   <td>Objecte Funció (implements [[Call]] in ECMA-262 terms)</td>
+   <td><code>"function"</code></td>
+  </tr>
+  <tr>
+   <td>Qualsevol altre objecte</td>
+   <td><code>"object"</code></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Exemples">Exemples</h2>
+
+<h3 id="Casos_normals">Casos normals</h3>
+
+<pre class="brush:js">// Numbers
+typeof 37 === 'number';
+typeof 3.14 === 'number';
+typeof Math.LN2 === 'number';
+typeof Infinity === 'number';
+typeof NaN === 'number'; // A pesar de ser un "Not-A-Number"
+typeof Number(1) === 'number'; // però no l'utilitzeu mai així!
+
+
+// Strings
+typeof "" === 'string';
+typeof "bla" === 'string';
+typeof (typeof 1) === 'string'; // typeof sempre retorna una string
+typeof String("abc") === 'string'; // però no l'utilitzeu mai així!
+
+
+// Booleans
+typeof true === 'boolean';
+typeof false === 'boolean';
+typeof Boolean(true) === 'boolean'; // però no l'utilitzeu mai així!
+
+
+// Symbols
+typeof Symbol() === 'symbol'
+typeof Symbol('foo') === 'symbol'
+typeof Symbol.iterator === 'symbol'
+
+
+// Undefined
+typeof undefined === 'undefined';
+typeof blabla === 'undefined'; // una variable no definida
+
+
+// Objects
+typeof {a:1} === 'object';
+
+// utilitzeu <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/isArray" title="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/isArray">Array.isArray</a> o bé Object.prototype.toString.call
+// per a diferenciar objectes normals d'arrays
+typeof [1, 2, 4] === 'object';
+
+typeof new Date() === 'object';
+
+
+// Els següents exemples són confusos, no els utilitzeu!
+typeof new Boolean(true) === 'object';
+typeof new Number(1) === 'object';
+typeof new String("abc") === 'object';
+
+
+// Funcions
+typeof function(){} === 'function';
+typeof Math.sin === 'function';
+</pre>
+
+<h3 id="null"><code>null</code></h3>
+
+<pre class="brush:js">// Això es manté així des de l'inici de JavaScript
+typeof null === 'object';
+</pre>
+
+<p>A la primera implementació de JavaScript, els valors de JavaScript es representaven com a una etiqueta de tipus i un valor. L'etiqueta de tipus per objectes era 0. <code>null</code> era representat amb el punter NULL (0x00 a la majoria de plataformes). D'aquesta manera null tenia 0 com a etiqueta de tipus, i això és el que determina que <code>typeof</code> retorni 'object' per a <code>null</code>. (<a href="http://www.2ality.com/2013/10/typeof-null.html">referència</a>)</p>
+
+<p>Es va proposar una esmena per a canviar aquest comportament per l'ECMAScript (via una <em>opt-in</em>), però aquesta <a class="external" href="http://wiki.ecmascript.org/doku.php?id=harmony:typeof_null">va ser rebutjada</a>. El resultat hagués estat <code>typeof null === 'null'</code>.</p>
+
+<h3 id="Expressions_regulars">Expressions regulars</h3>
+
+<p>Expressions regulars que poden ser cridades van ser un afegit no standard en alguns navegadors web.</p>
+
+<pre class="brush:js">typeof /s/ === 'function'; // Chrome 1-12 No cumpleix l'standard ECMAScript 5.1
+typeof /s/ === 'object';   // Firefox 5+  D'acord amb ECMAScript 5.1
+</pre>
+
+<h2 id="Especificacions">Especificacions</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>1a edició ECMAScript.</td>
+   <td>Estàndard</td>
+   <td>Definició inicial. Implementat en JavaScript 1.1</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-11.4.3', 'The typeof Operator')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-typeof-operator', 'The typeof Operator')}}</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ística</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suport bàsic</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 per Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suport bàsic</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h3 id="Els_objects_host_a_Internet_Explorer_són_objectes_en_comptes_de_funcions">Els objects host a Internet Explorer són objectes en comptes de funcions</h3>
+
+<p>A IE 6, 7, i 8 molts dels host objects són objectes i no funcions. Per exemple:</p>
+
+<pre class="brush: js">typeof alert === 'object'</pre>
+
+<h2 id="See_also" name="See_also">Vegeu també</h2>
+
+<ul>
+ <li><code><a href="/en-US/docs/Web/JavaScript/Reference/Operators/instanceof" title="/en-US/docs/JavaScript/Reference/Operators/instanceof">instanceof</a></code></li>
+</ul>
diff --git a/files/ca/web/javascript/referencia/operadors/void/index.html b/files/ca/web/javascript/referencia/operadors/void/index.html
new file mode 100644
index 0000000000..ddf98ebfd9
--- /dev/null
+++ b/files/ca/web/javascript/referencia/operadors/void/index.html
@@ -0,0 +1,138 @@
+---
+title: L'operador void
+slug: Web/JavaScript/Referencia/Operadors/void
+translation_of: Web/JavaScript/Reference/Operators/void
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<h2 id="Resum">Resum</h2>
+
+<p>L'operador <code>void</code> evalua l'<code><em>expressió</em></code> donada i retorna <code>undefined</code>.</p>
+
+<h2 id="Sintaxi">Sintaxi</h2>
+
+<pre class="syntaxbox">void <em>expressió</em></pre>
+
+<h2 id="Descripció">Descripció</h2>
+
+<p>Aquest operador permet inserir expressions que produeixen efectes secundaris en llocs on es vol una expressió que s'evalui a <code>undefined</code>.</p>
+
+<p>L'operador <code>void</code> tot sovint s'utilitza simplement per a obtenir el valor primitiu<code> undefined</code>, normalment usant "<code>void(0)</code>" (que és equivalent a "<code>void 0</code>"). En aquests casos es pot utilitzar la variable global <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined" title="/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined"><code>undefined</code></a> en comptes de l'operador <code>void</code> (asumint que no ha sigut assignada a un valor no standard).</p>
+
+<h2 id="Expressions_de_funció_invocades_de_forma_immediata">Expressions de funció invocades de forma immediata</h2>
+
+<p>A l'utilitzar una <a href="/en-US/docs/Glossary/IIFE">expressió de funció invocada de forma immediata</a>, es pot usar <code>void</code> per a forçar que la paraula clau <code>function</code> sigui tractada com a una expressió en comptes d'una declaració.</p>
+
+<pre class="brush: js">void function iife() {
+    var bar = function () {};
+    var baz = function () {};
+    var foo = function () {
+        bar();
+        baz();
+     };
+    var biz = function () {};
+
+    foo();
+    biz();
+}();
+</pre>
+
+<h2 id="URIs_de_JavaScript">URIs de JavaScript</h2>
+
+<p>Quan un navegador segueix una URI de l'estil <code>javascript:</code> , aquest evalua el codi que hi ha a la URI i llavors reemplaça el contingut de la pàgina amb el valor retornat, a no ser que el valor retornat sigui <code>undefined</code>. L'operador<code> void</code> pot ser emprat en aquest case per a retornar <code>undefined</code>. Per exemple:</p>
+
+<pre class="brush: html">&lt;a href="javascript:void(0);"&gt;
+  Cliqueu aquí per a no fer res
+&lt;/a&gt;
+
+&lt;a href="javascript:void(document.body.style.backgroundColor='green');"&gt;
+  Clique aquí per a un fons de color verd
+&lt;/a&gt;
+</pre>
+
+<p>Tingueu en compte, però, que el pseudo protocol <code>javascript:</code> no és recomanat ja que existeixen alternatives, com ara manegadors d'events no obtrusius.</p>
+
+<h2 id="Especificacions">Especificacions</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificació</th>
+   <th scope="col">Estat</th>
+   <th scope="col">Comentaris</th>
+  </tr>
+  <tr>
+   <td>ECMAScript 1a Edició.</td>
+   <td>Standard</td>
+   <td>Definició inicial. Implementat al JavaScript 1.1</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-11.4.2', 'The void Operator')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-void-operator', 'The void Operator')}}</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ística</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suport bàsic</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>Suport bàsic</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><code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined">undefined</a></code></li>
+</ul>
diff --git a/files/ca/web/javascript/referencia/operadors/yield/index.html b/files/ca/web/javascript/referencia/operadors/yield/index.html
new file mode 100644
index 0000000000..d01f641767
--- /dev/null
+++ b/files/ca/web/javascript/referencia/operadors/yield/index.html
@@ -0,0 +1,152 @@
+---
+title: yield
+slug: Web/JavaScript/Referencia/Operadors/yield
+translation_of: Web/JavaScript/Reference/Operators/yield
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<h2 id="Resum">Resum</h2>
+
+<p>La paraula clau <code>yield</code> s'utilitza per a pausar i reprendre una funció generadora ({{jsxref("Statements/function*", "function*")}} o bé una <a href="/en-US/docs/Web/JavaScript/Reference/Statements/Legacy_generator_function">funció generadora obsoleta</a>).</p>
+
+<h2 id="Syntax" name="Syntax">Sintaxi</h2>
+
+<pre class="syntaxbox language-html"> yield [[expressió]];</pre>
+
+<dl>
+ <dt><code>expressió</code></dt>
+ <dd>La expresssió a retornar. Si s'omet es retorna <code>undefined</code>.</dd>
+</dl>
+
+<h2 id="Descripció">Descripció</h2>
+
+<p>La paraula clau <code>yield</code> causa que l'execució d'una funció generadora es pausi i retorni el valor de l'expressió que la segueix. La paraula clau <code>yield</code> es pot entendre com una versió de la paraula clau <code>return</code> per a generadors.</p>
+
+<p>La paraula clau <code>yield</code> retorna en realitat un objecte de tipus <code>IteratorResult</code> amb dues propietats: <code>value</code> i <code>done</code>. La propietat <code>value</code> és el resultat d'evaluar l'expresssió que segueix <code>yield</code> mentre que la propietat <code>done</code> és de tipus booleà i indica si la funció generadora ha completat la seva execució o no.</p>
+
+<p>Un cop pausada mitjançant una expressió <code>yield</code>, l'execució de codi del generador no es reprendrà a no ser que s'invoqui externament mitjançant la crida a la funció <code>next()</code> del generador. Això permet un control directe de l'execució del generador i valors de retorn incrementals.</p>
+
+<h2 id="Exemples">Exemples</h2>
+
+<p>El següent codi és un exemple de la declaració d'una funció generadora al llarg d'una funció d'ajut.</p>
+
+<pre class="brush: js">function* foo(){
+  var index = 0;
+  while (index &lt;= 2) // quan index arriba a 3,
+                     // la propietat done del yield serà true
+                     // i el seu valor serà undefined;
+    yield index++;
+}</pre>
+
+<p>Un cop la funció generadora és definida es pot utilitzar tot construïnt un iterador tal i com es mostra a continuació:</p>
+
+<pre class="brush: js">var iterator = foo();
+console.log(iterator.next()); // { value:0, done:false }
+console.log(iterator.next()); // { value:1, done:false }
+console.log(iterator.next()); // { value:2, done:false }
+console.log(iterator.next()); // { value:undefined, done:true }</pre>
+
+<h2 id="Specifications" name="Specifications">Especificacions</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Especificació</th>
+   <th scope="col">Estat</th>
+   <th scope="col">Comentaris</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>{{SpecName('ES6', '#', 'Yield')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Definició inicial</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibility" name="Browser_compatibility">Compatibilitat amb navegadors</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Característica</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari (WebKit)</th>
+  </tr>
+  <tr>
+   <td>Suport bàsic</td>
+   <td>39</td>
+   <td>{{CompatGeckoDesktop("26.0")}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+  <tr>
+   <td>Objecte<code> IteratorResult</code> en comptes de <code>throwing</code></td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatGeckoDesktop("29.0")}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Característica</th>
+   <th>Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suport bàsic</td>
+   <td>yes (when?)</td>
+   <td>{{CompatGeckoMobile("26.0")}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{ CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+  <tr>
+   <td>Objecte<code> IteratorResult</code> en comptes de <code>throwing</code></td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatGeckoMobile("29.0")}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h3 id="Notes_específiques_per_a_Firefox">Notes específiques per a Firefox</h3>
+
+<ul>
+ <li>A partir de Gecko 29 {{geckoRelease(29)}} la funció generadora, un cop completada, no llença un {{jsxref("TypeError")}} "generator has already finished" sino que retorna un objecte de tipus <code>IteratorResult</code> com per exemple<code> { value: undefined, done: true }</code> ({{bug(958951)}}).</li>
+ <li>A partir de Gecko 33 {{geckoRelease(33)}} l'anàlisi de l'expressió que segueix al yield s'ha actualitzat per a satisfer l'especificació de ES6 ({{bug(981599)}}):
+  <ul>
+   <li>L'expressió que segueix la paraula clau yield és opcional i si s'omet ja no es llença SyntaxError: <code>function* foo() { yield; }</code></li>
+  </ul>
+ </li>
+</ul>
+
+<h2 id="See_also" name="See_also">Vegeu tambè</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Guide/The_Iterator_protocol">El protocol dels iteradors</a></li>
+ <li>{{jsxref("Statements/function*", "function*")}}</li>
+ <li>{{jsxref("Operators/function*", "function* expression")}}</li>
+ <li>{{jsxref("Operators/yield*", "yield*")}}</li>
+</ul>