path: root/files/ca/web/javascript/guide/expressions_i_operadors/index.html

---
title: Expressions i operadors
slug: Web/JavaScript/Guide/Expressions_i_Operadors
translation_of: Web/JavaScript/Guide/Expressions_and_Operators
---
<div>{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Functions", "Web/JavaScript/Guide/Numbers_and_dates")}}</div>

<p>Aquest capítol explica les expressions i els operadors de JavaScript, incloent l'assignació, comparació, airtmètic, operadors de bits, lògics, cadenes, i operadors especials.</p>

<h2 id="Expressions">Expressions</h2>

<p>Una <em>expressió</em> és qualsevol unitat de codi vàlida que esdevé un valor.</p>

<p>Conceptualment hi ha dos tipus d'expressions: les que assignen un valor a una variable i les que simplement tenen un valor.</p>

<p>L'expressió <code>x = 7</code> és un exemple del primer tipus. Aquesta expressió fa servir l'operador<em> </em> = per a assignar el valor set a la variable <code>x</code>. L'expressió per si mateixa s'avalua com a 7.</p>

<p>El codi 3 + 4 és un exemple d'expressió del segon tipus. Aquesta expressió utilitza l'operador + per a sumar tres i quatre sense assignar el resultat, set, a una variable.<br>
 <br>
 JavaScript té les següents categories d'expressions:</p>

<ul>
 <li>Aritmètiques: s'avaluen a un nombre, per exemple 3.14159. (Generalment utilitzen {{ web.link("#Arithmetic_operators", "operadors aritmètics") }}.)</li>
 <li>String: s'avaluen a una cadena de caràcters, per exemple, "Pau" o "234". (Generalment utilitzen {{ web.link("#String_operators", "operadors d'strings") }}.)</li>
 <li>Lògiques: s'avaluen a cert o fals. (sovint inclouen {{ web.link("#Logical_operators", "operadors lògics") }}.)</li>
 <li>Objecte: s'avaluen a un objecte. (Vegeu els {{ web.link("#Special_operators", "operadors especials") }} més informació.)</li>
</ul>

<h2 id="Operadors">Operadors</h2>

<p>JavaScript disposa dels següents tipus d'operadors. Aquesta secció descriu els operadors i conté informació sobre la seva precedència.</p>

<ul>
 <li>{{ web.link("#Assignment_operators", "Operadors d'assignació") }}</li>
 <li>{{ web.link("#Comparison_operators", "Operadors de comparació") }}</li>
 <li>{{ web.link("#Arithmetic_operators", "Operadors aritmètics") }}</li>
 <li>{{ web.link("#Bitwise_operators", "Operadors de bits") }}</li>
 <li>{{ web.link("#Logical_operators", "Operadors lògics") }}</li>
 <li>{{ web.link("#String_operators", "Operadors de strings") }}</li>
 <li>{{ web.link("#Special_operators", "Operadors especials") }}</li>
</ul>

<p>JavaScript té operadors <em>binaris</em> i <em>unaris</em>, també disposa d'un operador especial ternari, l'operador condicional. Un operador binari requereix dos operands, un abans l'operador i l'altre després de l'operador:</p>

<pre><em>operand1</em> <em>operador</em> <em>operand2</em>
</pre>

<p>Per exemple, <code>3+4</code> o <code>x*y</code>.</p>

<p>Un operador unari A requereix d'un sol operand, ja sigui abans o després de l'operador:</p>

<pre><em>operador</em> <em>operand</em>
</pre>

<p>o be</p>

<pre><em>operand</em> <em>operador</em>
</pre>

<p>Per exemple, <code>x++</code> o <code>++x</code>.</p>

<h3 id="Operadors_d'assignació">Operadors d'assignació</h3>

<p>Un operador d'assignació assigna un valor a l'operand de la seva esquerra basat en l'operand de la seva dreta. L'operador d'assignació simple és l'igual (<code>=</code>), que assigna el valor de l'operand de la dreta a l'operand de l'esquerra. És a dir, <code>x = y</code> assigna el valor de <code>y</code> a <code>x</code>.</p>

<p>També hi ha operadors d'assignació compostos, que són abreviacions per als operadors llistats a la taula següent:</p>

<table class="standard-table">
 <caption>Taula 3.1 Operadors d'assignació</caption>
 <thead>
  <tr>
   <th scope="col">Operadors d'assignació compostos</th>
   <th scope="col">Significat</th>
  </tr>
 </thead>
 <tbody>
  <tr>
   <td><code>x += y</code></td>
   <td><code>x = x + y</code></td>
  </tr>
  <tr>
   <td><code>x -= y</code></td>
   <td><code>x = x - y</code></td>
  </tr>
  <tr>
   <td><code>x *= y</code></td>
   <td><code>x = x * y</code></td>
  </tr>
  <tr>
   <td><code>x /= y</code></td>
   <td><code>x = x / y</code></td>
  </tr>
  <tr>
   <td><code>x %= y</code></td>
   <td><code>x = x % y</code></td>
  </tr>
  <tr>
   <td><code>x &lt;&lt;= y</code></td>
   <td><code>x = x &lt;&lt; y</code></td>
  </tr>
  <tr>
   <td><code>x &gt;&gt;= y</code></td>
   <td><code>x = x &gt;&gt; y</code></td>
  </tr>
  <tr>
   <td><code>x &gt;&gt;&gt;= y</code></td>
   <td><code>x = x &gt;&gt;&gt; y</code></td>
  </tr>
  <tr>
   <td><code>x &amp;= y</code></td>
   <td><code>x = x &amp; y</code></td>
  </tr>
  <tr>
   <td><code>x ^= y</code></td>
   <td><code>x = x ^ y</code></td>
  </tr>
  <tr>
   <td><code>x |= y</code></td>
   <td><code>x = x | y</code></td>
  </tr>
 </tbody>
</table>

<h3 id="Operadors_de_comparació">Operadors de comparació</h3>

<p><span class="comment">This seems to me kind of poorly explained, mostly the difference betwen "==" and "==="...</span>Els operadors de comparació comparen els operands i retornen un valor lògic basat en si la comparació és certa o no. Els operands poden ser numèrics, string, lògics, o bé valors d'objectes. Els Strings es comparen basant-se en l'ordre lexicogràfic standard, utilitzant valors Unicode. Quan els dos operands no són del mateix tipus, en la majoria dels casos JavaScript intenta convertir-los a un tipus apropiat per a realitzar la comparació.<br>
  Aquest comportament generalment resulta en una comparació amb els operands transformats a nombres. La única excepció quant a la conversió de tipus és quan s'utilitzen els operands <code>===</code> i <code>!==</code>, els quals realitzen comparacións estrictes de igualtat i no-igualtat, respectivament. Aquests operadors no intenten convertir els operands a tipus compatibles abans de aplicar l'igualtat. La taula següent descriu els operadors de comparació en base a aquest exemple:</p>

<pre class="brush: js">var var1 = 3, var2 = 4;
</pre>

<table class="standard-table">
 <caption>Taula 3.2 Operadors de comparació</caption>
 <thead>
  <tr>
   <th scope="col">Operador</th>
   <th scope="col">Descripció</th>
   <th scope="col">Exemples que s'avaluen a cert</th>
  </tr>
 </thead>
 <tbody>
  <tr>
   <td>Igualtat (<code>==</code>)</td>
   <td>Retorna true si els operands són iguals.</td>
   <td><code>3 == var1</code>
    <p><code>"3" == var1</code></p>
    <code>3 == '3'</code></td>
  </tr>
  <tr>
   <td>No-igualtat (<code>!=</code>)</td>
   <td>Retorna true si els operands són diferents.</td>
   <td><code>var1 != 4<br>
    var2 != "3"</code></td>
  </tr>
  <tr>
   <td>Igualtat estricta (<code>===</code>)</td>
   <td>Retorna true si els operands són iguals i del mateix tipus. Vegeu també <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is"><code>Object.is</code></a> i <a href="/en-US/docs/Web/JavaScript/Guide/Sameness" title="/en-US/docs/Web/JavaScript/Guide/Sameness">igualtat a JS</a>.</td>
   <td><code>3 === var1</code></td>
  </tr>
  <tr>
   <td>No-igualtat estricta (<code>!==</code>)</td>
   <td>Retorna true si els operands no són iguals i/o del mateix tipus.</td>
   <td><code>var1 !== "3"<br>
    3 !== '3'</code></td>
  </tr>
  <tr>
   <td>Major que (<code>&gt;</code>)</td>
   <td>Retorna true si l'operand de l'esquerra és més gran que l'operand e la dreta.</td>
   <td><code>var2 &gt; var1<br>
    "12" &gt; 2</code></td>
  </tr>
  <tr>
   <td>Major o igual que (<code>&gt;=</code>)</td>
   <td>Retorna true si l'operand de l'esquera és major o igual que l'operand de la dreta.</td>
   <td><code>var2 &gt;= var1<br>
    var1 &gt;= 3</code></td>
  </tr>
  <tr>
   <td>Menor que (<code>&lt;</code>)</td>
   <td>Retorna true si l'operand de l'esquerra és més petit que l'operand de la dreta.</td>
   <td><code>var1 &lt; var2<br>
    "2" &lt; "12"</code></td>
  </tr>
  <tr>
   <td>Menor o igual que (<code>&lt;=</code>)</td>
   <td>Retorna true si l'operand de l'esquerra és menor o igual que l'operand de la dreta.</td>
   <td><code>var1 &lt;= var2<br>
    var2 &lt;= 5</code></td>
  </tr>
 </tbody>
</table>

<h3 id="Operadors_aritmètics">Operadors aritmètics</h3>

<p>Els operadors aritmètics prenen valors numèrics (ja siguin literals o variables) com a operands i retornen un sol valors numèric. Els operadors aritmètics standard són la suma (+), la resta (-), la multiplicació (*) i la divisió (/). Aquests operadors funcionen de la mateixa manera que a la majoria d'altres llenguatges de programació quan s'utilitzen amb nombres de coma flotant (particularment, cal destacar que la divisió entre zero produeix <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Infinity"><code>Infinity</code></a>). Per exemple:</p>

<pre class="brush: js">console.log(1 / 2); /* imprimeix 0.5 */
console.log(1 / 2 == 1.0 / 2.0); /* això també és cert */
</pre>

<p>Adicionalment, JavaScript proporciona els operadors aritmètics llistats a la taula següent:</p>

<table class="fullwidth-table">
 <caption>Taula 3.3 Operadors aritmètics</caption>
 <thead>
  <tr>
   <th scope="col">Operador</th>
   <th scope="col">Descripció</th>
   <th scope="col">Exemple</th>
  </tr>
 </thead>
 <tbody>
  <tr>
   <td><code>%</code><br>
    (Mòdul)</td>
   <td>Operador binari. Retorna el residu de dividir els dos operands.</td>
   <td>12 % 5 retorna 2.</td>
  </tr>
  <tr>
   <td><code>++</code><br>
    (Increment)</td>
   <td>
    <p>Operador unari. Afegeix un al seu operand. Si s'utilitza com a prefix (<code>++x</code>), retorna el valor del seu operand després d'afexir-li un; si s'utilitza com a sufix (<code>x++</code>), retorna el valor del seu operand abans d'afegir-li un.</p>
   </td>
   <td>Si <code>x</code> és 3, llavors <code>++x</code> assigna 4 a <code>x</code> i retorna 4, mentre que <code>x++</code> retorna 3 i, només llavors, assigna 4 a <code>x</code>.</td>
  </tr>
  <tr>
   <td><code>--</code><br>
    (Decrement)</td>
   <td>Operador uniari. Resta un al seu operand. Retorna el valor anàleg a l'operador increment.</td>
   <td>Si <code>x</code> és 3, llavors <code>--x</code> assigna 2 a <code>x</code> i retorna 2, mentre que <code>x--</code> retorna 3 i, només llavors, assigna 2 a<code> x</code>.</td>
  </tr>
  <tr>
   <td><code>-</code><br>
    (Negació unària)</td>
   <td>Operador unari. Retorna el resultat de negar el seu operand.</td>
   <td>Si <code>x</code> val 3, llavors <code>-x</code> retorna -3.</td>
  </tr>
 </tbody>
</table>

<h3 id="Operadors_de_bits">Operadors de bits</h3>

<p>Els operadors de bits tracten els seus operands com a conunts de 32 bits (zeros i uns), en comptes de com a nombres decimals, hexadecimals o octals. Per exemple, el nombre decimal 9 és representat de forma binària per 1001. Els operadors de bits realitzen operacions sobre aquestes representacions binàries, però sempre retornen valors numèrics de JavaScript.</p>

<p>La taula següent resumeix els operadors de bits disponibles a JavaScript.</p>

<table class="standard-table">
 <caption>Taula 3.4 Operadors de bits</caption>
 <thead>
  <tr>
   <th scope="col">Operador</th>
   <th scope="col">Ús</th>
   <th scope="col">Descripció</th>
  </tr>
 </thead>
 <tbody>
  <tr>
   <td>AND binari</td>
   <td><code>a &amp; b</code></td>
   <td>Retorna 1 a cada posició de bit on la posició corresponent a ambdós operadors conten uns.</td>
  </tr>
  <tr>
   <td>OR binari</td>
   <td><code>a | b</code></td>
   <td>
    <p>Retorna 1 a cada posició de bit on al menys un dels operands té un 1 a la posició corresponent.</p>
   </td>
  </tr>
  <tr>
   <td>XOR binari</td>
   <td><code>a ^ b</code></td>
   <td>
    <p>Retorna un 1 a cada posició de bit on només un dels operands té un 1 a la posicio corresponent, però no ambdós.</p>
   </td>
  </tr>
  <tr>
   <td>NOT binari</td>
   <td><code>~ a</code></td>
   <td>Inverteix els bits del seu operand.</td>
  </tr>
  <tr>
   <td>Desplaçament a l'esquerra</td>
   <td><code>a &lt;&lt; b</code></td>
   <td>Desplaça la representació binària de <code>a</code> <code>b</code> bits a l'esquerra, afegint zeros a la dreta.</td>
  </tr>
  <tr>
   <td>Desplaçament a la dreta amb propagació de signe</td>
   <td><code>a &gt;&gt; b</code></td>
   <td>Desplaça la representació binària de <code>a</code> <code>b</code> bits a la dreta, descartant els bits que no hi caben.</td>
  </tr>
  <tr>
   <td>Desplaçament a la dreta amb inserció de zeros</td>
   <td><code>a &gt;&gt;&gt; b</code></td>
   <td>Desplaça la representació binària de <code>a</code> <code>b</code> bits a la dreta, descartant els bits que no hi caben i inserint zeros a l'esquerra.</td>
  </tr>
 </tbody>
</table>

<h4 id="Bitwise_Logical_Operators" name="Bitwise_Logical_Operators">Operadors lògics de bits</h4>

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

<ul>
 <li>Es converteixen els operands a nombres sencers de 32 bits expressats per una sèrie de bits (zeros i uns).</li>
 <li>S'emparella cada bit del primer operand amb el bit corresponent del segond operand: el primer bit amb el primer bit, el segon amb el segon, etcètera.</li>
 <li>S'aplica l'operador per a cada parella de bits, i el resultat es construeix de forma binària.</li>
</ul>

<p>Per exemple, la representació binària de 9 és 1001, mentre que la representació binària de quinze és 1111. Així, quan els operadors de bits s'apliquen a aquests valors el resultat és el següent:</p>

<table class="standard-table">
 <caption>Taula 3.5 Exemples d'operadors de bits</caption>
 <thead>
  <tr>
   <th scope="col">Expressió</th>
   <th scope="col">Resultat</th>
   <th scope="col">Descripció binària</th>
  </tr>
 </thead>
 <tbody>
  <tr>
   <td><code>15 &amp; 9</code></td>
   <td><code>9</code></td>
   <td><code>1111 &amp; 1001 = 1001</code></td>
  </tr>
  <tr>
   <td><code>15 | 9</code></td>
   <td><code>15</code></td>
   <td><code>1111 | 1001 = 1111</code></td>
  </tr>
  <tr>
   <td><code>15 ^ 9</code></td>
   <td><code>6</code></td>
   <td><code>1111 ^ 1001 = 0110</code></td>
  </tr>
  <tr>
   <td><code>~15</code></td>
   <td><code>-16</code></td>
   <td><code>~</code><code>00000000...</code><code>00001111 = </code><code>1111</code><code>1111</code><code>...</code><code>11110000</code></td>
  </tr>
  <tr>
   <td><code>~9</code></td>
   <td><code>-10</code></td>
   <td><code>~</code><code>00000000</code><code>...</code><code>0000</code><code>1001 = </code><code>1111</code><code>1111</code><code>...</code><code>1111</code><code>0110</code></td>
  </tr>
 </tbody>
</table>

<p>Fixeu-vos que a l'utilitzar l'operador de bits <code>NOT</code> tots 32 bits són invertit, i que els valors amb el bit més significatiu (el de l'esquerra) amb valor 1 representen nombres negatius (representació en complement a dos).</p>

<h4 id="Bitwise_Shift_Operators" name="Bitwise_Shift_Operators">Operadors de desplaçament de bits</h4>

<p>Els operadors de desplaçament de bits requereixen de dos operands: el primer és un conjunt de bits a desplaçar. El segon operand és el nombre de posicions que es desplaçaran els bits del primer operand. La direcció des desplaçament és controlada per l'operador utilitzat.</p>

<p>Els operadors de desplaçament de bits converteixen els seus operands a nombres de 32 bits i el valor retornat és del mateix tipus que l'operand de l'esquerra. Trobareu un llistat amb els operadors de desplaçament de bits a la taula següent.</p>

<table class="fullwidth-table">
 <caption>Taula 3.6 Operadors de desplaçament de bits</caption>
 <thead>
  <tr>
   <th scope="col">Operador</th>
   <th scope="col">Descripció</th>
   <th scope="col">Exemple</th>
  </tr>
 </thead>
 <tbody>
  <tr>
   <td><code>&lt;&lt;</code><br>
    (Desplaçament a l'esquerra)</td>
   <td>
    <p>Aquest operador desplaça a l'esquerra el primer operand el nombre de bits especificat. Els bits que no hi caben es descarten. Les noves posicions de la dreta s'omplen amb zeros.</p>
   </td>
   <td><code>9&lt;&lt;2</code> retorna 36, perquè 1001 desplaçat 2 bits a l'esquerra esdevé 100100, que és la representació binaria de 36.</td>
  </tr>
  <tr>
   <td><code>&gt;&gt;</code><br>
    (Desplaçament a la dreta amb propagació de signe)</td>
   <td>
    <p>Aquest operador desplaça el primer operand el nombre de bits especificats cap a la dreta. Els nous bits de l'esquerra són copies del bit originalment més significatiu.</p>
   </td>
   <td><code>9&gt;&gt;2</code> retorna 2, perquè 1001 desplaçat 2 bits a la dreta esdevé 10, que és la representació binària de 2. De la mateixa manera, <code>-9&gt;&gt;2</code> retorna -3, perquè el signe l'operand preseva el signe.</td>
  </tr>
  <tr>
   <td><code>&gt;&gt;&gt;</code><br>
    (Desplaçament a la dreta omplint amb zeros)</td>
   <td>
    <p>Aquest operador desplaça l'operand el nombre de bits especificat a la dreta. Els bits sobrant són descartats. Els nous bits de l'esquerra s'omplen amb zeros.</p>
   </td>
   <td><code>19&gt;&gt;&gt;2</code> retorna 4, perquè 10011 desplaçat 2 bits a la dreta esdevé 100, que és la representació binària de 4. Per a nombres no negatius aquest operador retorna el mateix resultat que l'operador de desplaçament a la dreta amb propagació de signe.</td>
  </tr>
 </tbody>
</table>

<h3 id="Operadors_lògics">Operadors lògics</h3>

<p>Els operadors lògics utilitzen típicament amb valors booleans (lògics); quan ho són, retornen un valor de tipus Boolean. Els operadors &amp;&amp; i || , però, en realitat retornen el valor d'un dels operands, de tal manera que si aquests operadors s'utilitzen amb valors no booleans poden retornar un valor no booleà. A la següent taula es descriuen els operadors lògics.</p>

<table class="fullwidth-table">
 <caption>Taula 3.6 Operadors lògics</caption>
 <thead>
  <tr>
   <th scope="col">Operador</th>
   <th scope="col">Ús</th>
   <th scope="col">Descripció</th>
  </tr>
 </thead>
 <tbody>
  <tr>
   <td><code>&amp;&amp;</code></td>
   <td><code>expr1 &amp;&amp; expr2</code></td>
   <td>(AND lògic) Retorna <code>expr1</code> si pot ser convertida a fals; en qualsevol altre cas retorna <code>expr2</code>. Així, quan es proporcionen operands booleans, <code>&amp;&amp;</code> retorna true si ambdós operands són true: en qualsevol altre cas retorna fals.</td>
  </tr>
  <tr>
   <td><code>||</code></td>
   <td><code>expr1 || expr2</code></td>
   <td>(OR lògic) Retorna <code>expr1</code> si pot ser convertida a true; en qualsevol altre cas retorna <code>expr2</code>. És a dir, quan s'utilitza amb operands booleans, <code>||</code> retorna true si qualsevol dels dos operands és true; si ambdós operands són false, retorna false.</td>
  </tr>
  <tr>
   <td><code>!</code></td>
   <td><code>!expr</code></td>
   <td>(NOT lògic) Retorna false si el seu únic operand es pot convertir a true; en qualsevol altre cas retorna true.</td>
  </tr>
 </tbody>
</table>

<p>Alguns exemples d'expressions que es poden convertir a false són aquelles que s'avaluen a <code>null</code>, <code>0</code>, <code>NaN</code>, l'string buit (<code>""</code>), o <code>undefined</code>.</p>

<p>El codi següent mostra exemples de l'operador &amp;&amp; (AND lògic).</p>

<pre class="brush: js">var a1 =  true &amp;&amp; true;     // t &amp;&amp; t retorna true
var a2 =  true &amp;&amp; false;    // t &amp;&amp; f retorna false
var a3 = false &amp;&amp; true;     // f &amp;&amp; t retorna false
var a4 = false &amp;&amp; (3 == 4); // f &amp;&amp; f retorna false
var a5 = "Cat" &amp;&amp; "Dog";    // t &amp;&amp; t retorna Dog
var a6 = false &amp;&amp; "Cat";    // f &amp;&amp; t retorna false
var a7 = "Cat" &amp;&amp; false;    // t &amp;&amp; f retorna false
</pre>

<p>El codi següent mostra exemples de l'operador || (OR lògic).</p>

<pre class="brush: js">var o1 =  true || true;     // t || t retorna true
var o2 = false || true;     // f || t retorna true
var o3 =  true || false;    // t || f retorna true
var o4 = false || (3 == 4); // f || f retorna false
var o5 = "Cat" || "Dog";    // t || t retorna Cat
var o6 = false || "Cat";    // f || t retorna Cat
var o7 = "Cat" || false;    // t || f retorna Cat
</pre>

<p>El codi següent mostra exemples de l'operador ! (NOT lògic).</p>

<pre class="brush: js">var n1 = !true;  // !t retorna false
var n2 = !false; // !f retorna true
var n3 = !"Cat"; // !t retorna false
</pre>

<h4 id="Short-Circuit_Evaluation" name="Short-Circuit_Evaluation">Avaluació en curtcircuit</h4>

<p>Mentre les expressions lògiques es van avaluant una a una d'esquerra a dreta, a l'avaluar cadascuna també s'avalua si curtcirquiatar l'expressió mitjançant les regles següents:</p>

<ul>
 <li><code>false</code> &amp;&amp; <em>quelcom</em> es curtcircuita avaluant-se a false.</li>
 <li><code>true</code> || quelcom es curtcircuita avaluant-se a true.</li>
</ul>

<p>Les regles de la lògica garanteixen que aquestes avaluacions sempre són correctes. Cal remarca que la part <em>quelcom</em> no arriva a avaluar-se mai, així que cap efecte secundari provocat per la seva avaluació tindrà efecte.</p>

<h3 id="Operadors_de_Strings">Operadors de Strings</h3>

<p>A més dels operadors de comparació, que poden utilitzar-se amb valors de tipus string, l'operador de concatenació (+) concatena dos valors string, retornant un altre string format per la unió dels dos strings operands. Per exemple, <code>"la meva " + "string"</code> retorna la string <code>"la meva string"</code>.</p>

<p>L'abreviació de operador d'assignació += també pot ser emprat per a concatenar strings. Per exemple, si la variable <code>mystring</code> te el valor "alfa", llavors l'expressió <code>mystring += "bet"</code> s'avalua a "alfabet" i assigna aquest valor a <code>mystring</code>.</p>

<h3 id="Operadors_especial">Operadors especial</h3>

<p>JavaScript ofereix els següents operadors especials:</p>

<ul>
 <li>{{ web.link("#Conditional_operator", "Operador condicional") }}</li>
 <li>{{ web.link("#Comma_operator", "Operador coma") }}</li>
 <li><code>{{ web.link("#delete", "delete") }}</code></li>
 <li><code>{{ web.link("#in", "in") }}</code></li>
 <li><code>{{ web.link("#instanceof", "instanceof") }}</code></li>
 <li><code>{{ web.link("#new", "new") }}</code></li>
 <li><code>{{ web.link("#this", "this") }}</code></li>
 <li><code>{{ web.link("#typeof", "typeof") }}</code></li>
 <li><code>{{ web.link("#void", "void") }}</code></li>
</ul>

<h4 id="conditional_operator" name="conditional_operator">Operador condicional</h4>

<p>L'operador condicional és l'únic operador de JavaScript que accepta tres operands. L'operador retorna un de dos valors basant-se en una condició. La sintaxi és la següent:</p>

<pre><em>condició</em> ? <em>val1</em> : <em>val2</em>
</pre>

<p>Si <code>condició</code> és certa, l'operador retorna el valor <code>val1</code>. En qualsevol altre cas retorna el valor <code>val2</code>. Es pot emprar l'operador condicional a qualsevol lloc on es pugui utilitzar un operador standard.</p>

<p>Per exemple,</p>

<pre class="brush: js">var estat = (edat &gt;= 18) ? "adult" : "menor";
</pre>

<p>Aquesta sentència assigna el valor "adult" a la variable <code>estat</code> si edat és 18 o més. En qualsevol altre cas assigna el valor "menor" a <code>estat</code>.</p>

<h4 id="comma_operator" name="comma_operator">Operador coma</h4>

<p>L'operador coma (<code>,</code>) simplement avalua els seus dos operands i retorna el valor del segon operand. Aquest operdor s'utilitza principalment dins el bucle <code>for</code> per a permetre que múltiples variables s'actualitzin per a cada volta del bucle.</p>

<p>Per exemple, si <code>a</code> és un array de dues dimensions amb 10 elements per dimensió, el codi següent utilitza l'operador coma per a incrementar dues variables a l'hora. El codi mostra els valors dels elements de la diagonal de l'array:</p>

<pre class="brush: js">for (var i = 0, j = 9; i &lt;= j; i++, j--)
  document.writeln("a[" + i + "][" + j + "]= " + a[i][j]);
</pre>

<h4 id="delete" name="delete"><code>delete</code></h4>

<p>L'operador <code>delete</code> esborra un objecte, una propietat d'un objecte o l'element a la posició especificada d'un array. La sintaxi és:</p>

<pre class="brush: js">delete nomObjecte;
delete nomObjecte.property;
delete nomObjecte[index];
delete propietat; // Només és legal dins una sentència with
</pre>

<p>on <code>nomObjecte</code> és el nom d'un objecte, <code>propietat</code> és una propietat existent i <code>index</code> és un nombre sencer que representa la posició d'un element dins un array.</p>

<p>La quarta forma només és legal dins una sentència <code>with</code>, per a esborrar la propietat d'un objecte.</p>

<p>Es pot emprar l'operador <code>delete</code> per a esborrar variables declarades implícitament però no serveix per a variables declarades amb la sentència <code>var</code>.</p>

<p>Si l'operador delete aconsegueix el seu objectiu, assigna el valor <code>undefined</code> a la propietat o element esmentat. L'operador <code>delete</code> retorna true si l'operació és posible; retorna false si l'operació no és posible.</p>

<pre class="brush: js">x = 42;
var y = 43;
myobj = new Number();
myobj.h = 4;    // crea la propietat h
delete x;       // retorna true (pot esborrar si la variable ha estat declarada implicitament)
delete y;       // retorna false (no pot esborrar si la variable ha estat declarada amb var)
delete Math.PI; // retorna false (no pot esborrar propietats predefinides)
delete myobj.h; // retorna true (pot esborrar propietats definides per l'usuari)
delete myobj;   // retorna true (pot esborrar si l'objecte ha estat declarat implícitament)
</pre>

<h5 id="Esborrar_elements_d'un_array">Esborrar elements d'un array</h5>

<p>A l'esborrar l'element d'un array, la longitud de l'array no es veu afectada. Per exemple, si s'esborrar <code>a[3]</code>, <code>a[4]</code> roman a <code>a[4]</code> mentre que <code>a[3]</code> passa a valer <code>undefined</code>.</p>

<p>Quan l'operador delete esborra un element d'un array, aquest element ja no és a l'array. Al següent exemple, s'esborra <code>trees[3]</code> amb delete. Tot i així, <code>trees[3]</code> encara és accessible i retorna <code>undefined</code>.</p>

<pre class="brush: js">var trees = new Array("redwood", "bay", "cedar", "oak", "maple");
delete trees[3];
if (3 in trees) {
  // aquest codi no s'arriba a executar mai
}
</pre>

<p>Si es vol que un element d'un array existeixi però tingui un valor indefinit, es pot emprar la paraula clau undefined en comptes de l'operador <code>delete</code>. Al següent exemple, <code>trees[3]</code> rep el valor <code>undefined</code>, però l'elelement de l'array encara existeix:</p>

<pre class="brush: js">var trees = new Array("redwood", "bay", "cedar", "oak", "maple");
trees[3] = undefined;
if (3 in trees) {
  // aquest codi s'executa
}
</pre>

<h4 id="in" name="in"><code>in</code></h4>

<p>L'operador <code>in</code> retorna true si la propietat especificada existeix en l'objecte especificat. La sintaxi és:</p>

<pre class="brush: js">nomPropOnombre in nomObjecte
</pre>

<p>on <code>nomPropOnombre</code> és una string que representa el nom d'una propietat o bé una expressió numèrica que representa la posició d'un element dins un array, i <code>nomObjecte</code> és el nom d'un objecte.</p>

<p>Els següents exemples mostren alguns usos de l'operador <code>in</code>.</p>

<pre class="brush: js">// Arrays
var trees = new Array("redwood", "bay", "cedar", "oak", "maple");
0 in trees;        // retorna true
3 in trees;        // retorna true
6 in trees;        // retorna false
"bay" in trees;    // retorna false (s'ha de proporcionar l'índex,
                   // no el valor a aquell índex)
"length" in trees; // retorna true (length és una propietat de Array)

// Objects predefinits
"PI" in Math;          // retorna true
var myString = new String("coral");
"length" in myString;  // retorna true

// Objectes creats per l'usuari
var mycar = {make: "Honda", model: "Accord", year: 1998};
"make" in mycar;  // retorna true
"model" in mycar; // retorna true
</pre>

<h4 id="instanceof" name="instanceof"><code>instanceof</code></h4>

<p>L'operador <code>instanceof</code> retorna cert si l'objecte especificat és del tipus especificat. La sintaxi és:</p>

<pre class="brush: js">nomObjecte instanceof tipusObjecte
</pre>

<p>on <code>nomObjecte</code> és el nom de l'objecte a comprarar amb <code>tipusObjecte</code>, i tipusObjecte és un tipus d'objecte, com ara <code>Date</code> o <code>Array</code>.</p>

<p>Utilitzeu <code>instanceof</code> quan necessiteu confirmar el tipus d'un objecte en temps d'execució. Per exemple, a l'hora de capturar execepcions és posible executar diferent codi segons el tipus d'excepció llençada.</p>

<p>Per exemple, el següent codi utilitza instanceof per a determinar si <code>dia</code> és un objecte de tipus <code>Date</code>. Com que dia és un objecte de tipus <code>Date</code> les sentències dins la sentència <code>if</code> s'executaran.</p>

<pre class="brush: js">var dia = new Date(1995, 12, 17);
if (dia instanceof Date) {
  // bloc de codi que s'executarà
}
</pre>

<h4 id="new" name="new"><code>new</code></h4>

<p>L'operador <code>new</code> s'utilitza per a crear una instància d'un tipus d'objete definit per l'usuari o bé un dels tipus d'objectes predefinits <code>Array</code>, <code>Boolean</code>, <code>Date</code>, <code>Function</code>, <code>Image</code>, <code>Number</code>, <code>Object</code>, <code>Option</code>, <code>RegExp</code>, o <code>String</code>. Al servidor també es pot emprar amb <code>DbPool</code>, <code>Lock</code>, <code>File</code>, i <code>SendMail</code>. La sintaxi de <code>new</code> és la següent:</p>

<pre class="brush: js">var nomObjecte = new tipusObjecte([param1, param2, ..., paramN]);
</pre>

<p>També és posible crear objectes mitjançant inicialitzadors d'objectes, tal i com s'explica a {{ web.link("Working_with_objects#Using_object_initializers", "utilitzar inicialitzadors d'objectes") }}.</p>

<p>Vegeu la pàgina de l'<a href="/en-US/docs/Web/JavaScript/Reference/Operators/new">operador <code>new</code></a> a la Referència del nucli de JavaScript per a més informació.</p>

<h4 id="this" name="this"><code>this</code></h4>

<p>La paraula clau <code>this</code> s'utilitza per a referir-se a l'objecte actual. En general this fa referència a l'objecte que ha realitzat la crida dins un mètode. La sintaxi de <code>this</code> és la següent:</p>

<pre class="brush: js">this["nomPropietat"]
</pre>

<pre class="brush: js">this.nomPropietat
</pre>

<p><strong>Exemple 1.</strong><br>
 Suposem que una funció anomenada <code>validate</code> valida la propietat <code>value</code> d'un objecte, donat l'objecte i el rang de valors:</p>

<pre class="brush: js">function validate(obj, lowval, hival){
  if ((obj.value &lt; lowval) || (obj.value &gt; hival))
    alert("Valor no vàlid!");
}
</pre>

<p>Podríem cridar <code>validate</code> a cada manegador d'events <code>onChange</code> dels elements d'un formulari, utilitzant <code>this</code> per a passar l'element del formulari, tal i com es mostra al següent exemple:</p>

<pre class="brush: html">&lt;B&gt;Introduïu un nombre entre 18 i 99:&lt;/B&gt;
&lt;INPUT TYPE="text" NAME="edat" SIZE=3
   onChange="validate(this, 18, 99);"&gt;
</pre>

<p><strong>Exemple 2.</strong><br>
 Al combinar-lo amb la propietat del <code>form</code>, <code>this</code> fa referència al pare de l'objecte del formulari. Al següent exemple el form <code>myForm</code> conté un bojecte <code>Text</code> i un botó. Quan l'usuari fa clic al botó, el valor de l'objecte <code>Text</code> és assignat al nom del formulari. El manegador de l'event <code>onClick</code> del botó utilitza <code>this.form</code> per a fererir-se al fomulari pare, <code>myForm</code>.</p>

<pre class="brush: html">&lt;FORM NAME="myForm"&gt;
Nom del formulari:&lt;INPUT TYPE="text" NAME="text1" VALUE="Beluga"/&gt;
&lt;INPUT NAME="button1" TYPE="button" VALUE="Mostrar el nom del formulari"
   onClick="this.form.text1.value = this.form.name;"/&gt;
&lt;/FORM&gt;
</pre>

<h4 id="typeof" name="typeof"><code>typeof</code></h4>

<p>L'operador <code>typeof</code> es pot utilitzar de qualsevol de les formes següents:</p>

<ol>
 <li>
  <pre class="brush: js">typeof operand
</pre>
 </li>
 <li>
  <pre class="brush: js">typeof (operand)
</pre>
 </li>
</ol>

<p>L'operador <code>typeof</code> retorna una string indicant el tipus de l'operand, que no és avaluat. operand és una string, variable, paraula clau u objecte del qual es retornarà el tipus. Els parèntesi són opcionals.</p>

<p>Suposem que es defineixen les següents variables:</p>

<pre class="brush: js">var myFun = new Function("5 + 2");
var forma = "rodona";
var tamany = 1;
var avui = new Date();
</pre>

<p>L'operador <code>typeof</code> retornarà els següents resultats per a aquestes variables:</p>

<pre class="brush: js">typeof myFun;      // retorna "function"
typeof forma;      // retorna "string"
typeof tamany;     // retorna "number"
typeof avui;       // retorna "object"
typeof noExisteix; // retorna "undefined"
</pre>

<p>Per a les paraules clau <code>true</code> i <code>null</code>, l'operador <code>typeof</code> retorna els següents resultats:</p>

<pre class="brush: js">typeof true; // retorna "boolean"
typeof null; // retorna "object"
</pre>

<p>Per a un nombre o string, l'operador <code>typeof</code> retorna els següents resultats:</p>

<pre class="brush: js">typeof 62;            // retorna "number"
typeof 'Hola món';    // retorna "string"
</pre>

<p>Per a valors de propietats, l'operador <code>typeof</code> retorna el tipus del valor que conté la propietat:</p>

<pre class="brush: js">typeof document.lastModified; // retorna "string"
typeof window.length;         // retorna "number"
typeof Math.LN2;              // retorna "number"
</pre>

<p>Per a mètodes i funcions, l'operador <code>typeof</code> retorna els següents resultats:</p>

<pre class="brush: js">typeof blur;        // retorna "function"
typeof eval;        // retorna "function"
typeof parseInt;    // retorna "function"
typeof shape.split; // retorna "function"
</pre>

<p>Per a objectes predefinits, l'operador <code>typeof</code> retorna els resultats següents:</p>

<pre class="brush: js">typeof Date;     // retorna "function"
typeof Function; // retorna "function"
typeof Math;     // retorna "object"
typeof Option;   // retorna "function"
typeof String;   // retorna "function"
</pre>

<h4 id="void" name="void"><code>void</code></h4>

<p>L'operador <code>void</code> es pot emprar de qualsevol de les maneres següents:</p>

<ol>
 <li>
  <pre class="brush: js">void (expression)
</pre>
 </li>
 <li>
  <pre class="brush: js">void expression
</pre>
 </li>
</ol>

<p>L'operador <code>void</code> avalua una expressió però no retorna cap valor. <code>expression</code> és l'expressió JavaScript a avaluar. Els parèntesi que embocallen l'expressió són opcionals, però es considera una bona pràctica utilitzar-los.</p>

<p>És possible utilitzar l'operador <code>void</code> per a especificar una expressió com a hipervincle. L'expressió serà avaluada però el seu contingut no reemplaçarà el contingut del document actual.</p>

<p>El codi següent crea un hipervincle que no fa res quan l'usuari faci clic a l'hipervincle. Quan l'usuari fa clic al l'hipervincle, <code>void(0)</code> serà avaluada com a <code>undefined</code>, la qual cosa no té cap efecte en JavaScript.</p>

<pre class="brush: html">&lt;A HREF="javascript:void(0)"&gt;Cliqueu aquí per a no fer res&lt;/A&gt;
</pre>

<p>El codi següent crea un hipervincle que envia un formulari quan l'usuari fa clic sobre ell.</p>

<pre class="brush: html">&lt;A HREF="javascript:void(document.form.submit())"&gt;
Feu clic aquí per a enviar el formulari&lt;/A&gt;</pre>

<h3 id="Precedència_d'operadors">Precedència d'operadors</h3>

<p>La <em>precedència</em> d'operadors determina l'ordre en el qual aquests s'apliquen quan s'avalua una expressió. Es pot canviar aquest comportament mitjançant parèntesi.</p>

<p>La taula següent descriu la precedència dels operadors, del més prioritari al que ho és menys.</p>

<table class="standard-table">
 <caption>Taula 3.7 Precedència d'operadors</caption>
 <thead>
  <tr>
   <th scope="col">Tipus d'operador</th>
   <th scope="col">Operadors individuals</th>
  </tr>
 </thead>
 <tbody>
  <tr>
   <td>membre</td>
   <td><code>. []</code></td>
  </tr>
  <tr>
   <td>crida / creació d'una instància</td>
   <td><code>() new</code></td>
  </tr>
  <tr>
   <td>negació/increment</td>
   <td><code>! ~ - + ++ -- typeof void delete</code></td>
  </tr>
  <tr>
   <td>multiplicació/divisió</td>
   <td><code>* / %</code></td>
  </tr>
  <tr>
   <td>suma/resta</td>
   <td><code>+ -</code></td>
  </tr>
  <tr>
   <td>desplaçament de bits</td>
   <td><code>&lt;&lt; &gt;&gt; &gt;&gt;&gt;</code></td>
  </tr>
  <tr>
   <td>relacionals</td>
   <td><code>&lt; &lt;= &gt; &gt;= in instanceof</code></td>
  </tr>
  <tr>
   <td>igualtat</td>
   <td><code>== != === !==</code></td>
  </tr>
  <tr>
   <td>AND binari</td>
   <td><code>&amp;</code></td>
  </tr>
  <tr>
   <td>XOR binari</td>
   <td><code>^</code></td>
  </tr>
  <tr>
   <td>OR binari</td>
   <td><code>|</code></td>
  </tr>
  <tr>
   <td>AND lògic</td>
   <td><code>&amp;&amp;</code></td>
  </tr>
  <tr>
   <td>OR lògic</td>
   <td><code>||</code></td>
  </tr>
  <tr>
   <td>condicional</td>
   <td><code>?:</code></td>
  </tr>
  <tr>
   <td>assignació</td>
   <td><code>= += -= *= /= %= &lt;&lt;= &gt;&gt;= &gt;&gt;&gt;= &amp;= ^= |=</code></td>
  </tr>
  <tr>
   <td>coma</td>
   <td><code>,</code></td>
  </tr>
 </tbody>
</table>

<p>Trobareu una versió més detallada d'aqueta taula, completa amb enllaços a a detalls adicionals per a cada operador a la <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence#Table">Referència de JavaScript</a>.</p>