diff options
Diffstat (limited to 'files/ca/web/javascript/referencia/sentencies')
15 files changed, 2443 insertions, 0 deletions
diff --git a/files/ca/web/javascript/referencia/sentencies/block/index.html b/files/ca/web/javascript/referencia/sentencies/block/index.html new file mode 100644 index 0000000000..cfa5d7fd20 --- /dev/null +++ b/files/ca/web/javascript/referencia/sentencies/block/index.html @@ -0,0 +1,138 @@ +--- +title: block +slug: Web/JavaScript/Referencia/Sentencies/block +translation_of: Web/JavaScript/Reference/Statements/block +--- +<div> +<div>{{jsSidebar("Statements")}}</div> +</div> + +<h2 id="Resum">Resum</h2> + +<p>Una<strong> sentència bloc</strong> (o <strong>sentència composta</strong> en altres llengües) s'usa per agrupar zero o més sentències. El bloc està delimitat per un parell de claus.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox">{ + <var>sentència_1</var>; + <var>sentència_2;</var> + ... + <var>sentència_n;</var> +} +</pre> + +<dl> + <dt><code>statement_1</code>, <code>statement_2</code>, <code>statement_n</code></dt> + <dd>Sentències agrupades dins la sentència block.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Aquesta sentència s'utilitza normalment amb les sentències de control de flux (p.ex. <code>if</code>, <code>for</code>, <code>while</code>). Per exemple:</p> + +<pre class="brush: js">while (x < 10) { + x++; +} +</pre> + +<p>Tingueu en compte que la sentència block no acaba amb un punt i coma.</p> + +<p>La sentència bloc sovint s'anomena <strong>sentència composta</strong> en altres llengües. Aquesta sentència permet usar múltiples sentències allà on JavaScript espera només una única sentència. Combinar sentències en blocs és una pràctica comuna en JavaScript. El comportament oposat és possible fent servir una <a href="/en-US/docs/Web/JavaScript/Reference/Statements/Empty">sentència buida</a>, on no es proporciona cap declaració, encara que es requereixi una.</p> + +<h3 id="Fora_de_l'àmbit_del_bloc">Fora de l'àmbit del bloc</h3> + +<p><strong>Important</strong>: Les variables declarades amb <code>var</code> no tenen àmbit de bloc. Les variables introduïdes amb un bloc estàn en l'àmbit de la funció o l'script que els conté, i els efectes d'establir-los persisteixen més enllà del mateix bloc. En altres paraules, les sentències de bloc no introdueixen un àmbit. Encara que els blocs "independents" són sintàcticament vàlids, no és desitjable usar-los en JavaScript, ja que no fan el que pensem que fan, en el cas que penseu que fan alguna cosa semblant als blocs en C o Java. Per exemple:</p> + +<pre class="brush: js">var x = 1; +{ + var x = 2; +} +console.log(x); // logs 2 +</pre> + +<p>Això registra 2 ja que la sentència <code>var x</code> dins el bloc es troba en el mateix àmbit que la sentència <code>var x</code> anterior al bloc. En C o Java, el codi equivalent hauria emès 1.</p> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificacions</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>1a edició d'ECMAScript.</td> + <td>Estàndard</td> + <td>Definició inicial. Implementat en JavaScript 1.0</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-12.1', 'Block statement')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-block', 'Block statement')}}</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>{{jsxref("Statements/while", "while")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/sentencies/break/index.html b/files/ca/web/javascript/referencia/sentencies/break/index.html new file mode 100644 index 0000000000..d71eff620d --- /dev/null +++ b/files/ca/web/javascript/referencia/sentencies/break/index.html @@ -0,0 +1,154 @@ +--- +title: break +slug: Web/JavaScript/Referencia/Sentencies/break +translation_of: Web/JavaScript/Reference/Statements/break +--- +<div>{{jsSidebar("Statements")}}</div> + +<p>La <strong> sentència</strong> <strong>break</strong> acaba el bucle actual, {{jsxref("Statements/switch", "switch")}}, o una sentència {{jsxref("Statements/label", "label")}} i transfereix el control de programa a la sentència següent de la sentència acabada.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code>break [<em>etiqueta</em>];</code></pre> + +<dl> + <dt><code>Etiqueta</code></dt> + <dd>Opcional. És l'identificador associat amb l'etiqueta de la sentència. Si la sentència no és un bucle o un {{jsxref("Statements/switch", "switch")}}, això és necessari.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>La sentència <code>break</code> inclou una etiqueta opcional que permet al programa sortir de la sentència etiquetada. La sentència <code>break</code> necessita ser imbricada dins l'etiqueta de referència. La sentència etiquetada pot ser qualsevol sentència {{jsxref("Statements/block", "block")}}, no ha de ser precedida per una sentència de bucle.</p> + +<h2 id="Exemples">Exemples</h2> + +<p>La funció següent té una sentència <code>break</code> que acaba amb el bucle{{jsxref("Statements/while", "while")}} quan <code>i</code> és 3, per després retornar el valor 3 * <code>x</code>.</p> + +<pre class="brush:js;highlight:[6];">function testBreak(x) { + var i = 0; + + while (i < 6) { + if (i == 3) { + break; + } + i += 1; + } + + return i * x; +}</pre> + +<p>El codi següent utilitza sentències<code> break</code> amb blocs etiquetats. Una sentència <code>break</code> ha de ser imbricada dins de qualsevol etiqueta que fa referència. Vegeu que <code>inner_block</code> és troba imbricada dins <code>outer_block</code>.</p> + +<pre class="brush:js;highlight:[1,2,4];">outer_block: { + inner_block: { + console.log('1'); + break outer_block; // surt tan de inner_block com de outer_block + console.log(':-('); // es salta + } + console.log('2'); // es salta +} +</pre> + +<p>El codi següent també utilitza sentències <code>break</code> amb blocs etiquetats però cenera un Syntax Error perquè la sentència <code>break</code> es troba dins de <code>block_1</code> però fa referència a <code>block_2</code>. Una sentència <code>break</code> ha d'estar sempre imbricada dins de l'eitqueta a la que fa referència.</p> + +<pre class="brush:js;highlight:[1,3,6];">block_1: { + console.log('1'); + break block_2; // SyntaxError: etiqueta no trobada +} + +block_2: { + console.log('2'); +} +</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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definició inicial. Versió no etiquetada.</td> + </tr> + <tr> + <td>{{SpecName('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>versió etiquetada afegida.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-12.8', 'Break statement')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-break-statement', 'Break statement')}}</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>{{jsxref("Statements/continue", "continue")}}</li> + <li>{{jsxref("Statements/label", "label")}}</li> + <li>{{jsxref("Statements/switch", "switch")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/sentencies/buida/index.html b/files/ca/web/javascript/referencia/sentencies/buida/index.html new file mode 100644 index 0000000000..6800d476f8 --- /dev/null +++ b/files/ca/web/javascript/referencia/sentencies/buida/index.html @@ -0,0 +1,138 @@ +--- +title: Buida +slug: Web/JavaScript/Referencia/Sentencies/Buida +translation_of: Web/JavaScript/Reference/Statements/Empty +--- +<div> +<div>{{jsSidebar("Statements")}}</div> +</div> + +<h2 id="Resum">Resum</h2> + +<p>Una sentència <strong>buida</strong> es fa servir per no proveïr cap sentència, encara que la sintaxi de JavaScript n'esperaria una.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox">; +</pre> + +<h2 id="Descripció">Descripció</h2> + +<p>La sentència buida és un punt i coma (;) que indica que cap sentència s'executarà, encara que la sintaxi de JavaScript en requereixi una. Pel contrari, quan es vol realitzar múltiples sentències, però JavaScript només en permet un, és possible realitzar-ho mitjançant l'ús d'una <a href="/en-US/docs/Web/JavaScript/Reference/Statements/block">sentència de block</a>; que combina diverses sentències en una única sentència.</p> + +<h2 id="Exemples">Exemples</h2> + +<p>La sentència buida sovint s'utilitza amb sentències de bucles. Vegeu l'exemple segúent amb el cos del bucle buit:</p> + +<pre class="brush: js">var arr = [1, 2, 3]; + +// Assign all array values to 0 +for (i = 0; i < arr.length; arr[i++] = 0) /* empty statement */ ; + +console.log(arr) +// [0, 0, 0] +</pre> + +<p><strong>Nota:</strong> És una bona idea comentar l'ús intencional de la sentència buida, ja que no és fa molt obvi diferenciar-lo d'un punt i coma normal. En el següent exemple l'ús probablement no és intencional:</p> + +<pre class="brush: js">if (condition); // Caution, this "if" does nothing! + killTheUniverse() // So this gets always executed!!! +</pre> + +<p>Un altre exemple: Una sentència <a href="/en-US/docs/Web/JavaScript/Reference/Statements/if...else"><code>if...else</code></a> sense claus (<code>{}</code>). Si <code>tres</code> és cert, no passarà res, <u><code>four</code> does not matter, </u>ni tampoc s'executarà la funció <code>launchRocket()</code> en el cas <code>else</code>.</p> + +<pre class="brush: js">if (one) + doOne(); +else if (two) + doTwo(); +else if (three) + ; // nothing here +else if (four) + doFour(); +else + launchRocket();</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.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-12.3', 'Empty statement')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-empty-statement', 'Empty statement')}}</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>{{jsxref("Statements/block", "Block statement")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/sentencies/continue/index.html b/files/ca/web/javascript/referencia/sentencies/continue/index.html new file mode 100644 index 0000000000..a6928d15b7 --- /dev/null +++ b/files/ca/web/javascript/referencia/sentencies/continue/index.html @@ -0,0 +1,199 @@ +--- +title: continue +slug: Web/JavaScript/Referencia/Sentencies/continue +translation_of: Web/JavaScript/Reference/Statements/continue +--- +<div>{{jsSidebar("Statements")}}</div> + +<p>La <strong> sentència continue</strong> acaba l'execució de les sentències en la iteració actual del bucle actual o etiquetat, i continua l'execució del bucle amb la següent iteració.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox">continue [<em>etiqueta</em>];</pre> + +<dl> + <dt><code>Etiqueta</code></dt> + <dd>Identificador associat amb l'etiqueta de la sentència.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>En contrast amb la sentència {{jsxref("Statements/break", "break")}} , <code>continue</code> no acaba l'execució del bucle: En comptes d'això,</p> + +<ul> + <li>En un bucle {{jsxref("Statements/while", "while")}}, salta un altre cop a la condició.</li> +</ul> + +<ul> + <li>En un bucle {{jsxref("Statements/for", "for")}}, Salta a l'actualització de l'expressió.</li> +</ul> + +<p>La sentència <code>continue</code> pot incloure una etiqueta opcional que permet al programa saltar a la següent iteració d'una sentència d'un bucle etiquetat en comptes del bucle actual. En aquest cas, la sentència <code>continue</code> necessita trobar-se imbricada dins de la sentència etiquetada.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_continue_amb_while">Utilitzar <code>continue</code> amb <code>while</code></h3> + +<p>L'exemple següent mostra un bucle{{jsxref("Statements/while", "while")}} que contè una sentència <code>continue</code> que s'executa quan el valor de <code>i</code> és 3. Així doncs, <code>n</code> pren els valors 1, 3, 7, i 12.</p> + +<pre class="brush: js">var i = 0; +var n = 0; + +while (i < 5) { + i++; + + if (i === 3) { + continue; + } + + n += i; +} +</pre> + +<h3 id="Utilitzar_continue_amb_una_etiqueta">Utilitzar <code>continue</code> amb una etiqueta</h3> + +<p>En l'exemple següent, una sentència etiquetada <code>checkiandj</code> contè una sentència etiquetada <code>checkj</code>. si es troba un <code>continue</code>, el programa continua al començament de la sentència <code>checkj</code>. Cada cop que es troba <code>continue</code>, <code>checkj</code> reitera fins que la condició retorna falç. Quan es retorna falç, es completa la resta de la sentència <code>checkiandj</code>.</p> + +<p>Si <code>continue</code> té una etiqueta de <code>checkiandj</code>, el programa continuarà al començament de la sentència <code>checkiandj</code>.</p> + +<p>Vegeu també {{jsxref("Statements/label", "label")}}.</p> + +<pre class="brush: js">var i = 0; +var j = 8; + +checkiandj: while (i < 4) { + console.log("i: " + i); + i += 1; + + checkj: while (j > 4) { + console.log("j: "+ j); + j -= 1; + + if ((j % 2) == 0) + continue checkj; + console.log(j + " is odd."); + } + console.log("i = " + i); + console.log("j = " + j); +} +</pre> + +<p>Resultat:</p> + +<pre class="brush: js">"i: 0" + +// start checkj +"j: 8" +"7 is odd." +"j: 7" +"j: 6" +"5 is odd." +"j: 5" +// end checkj + +"i = 1" +"j = 4" + +"i: 1" +"i = 2" +"j = 4" + +"i: 2" +"i = 3" +"j = 4" + +"i: 3" +"i = 4" +"j = 4" +</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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definició inicial. Versió sense etiqueta.</td> + </tr> + <tr> + <td>{{SpecName('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Versió amb etiqueta afegida.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-12.7', 'Continue statement')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-continue-statement', 'Continue statement')}}</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>{{jsxref("Statements/break", "break")}}</li> + <li>{{jsxref("Statements/label", "label")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/sentencies/debugger/index.html b/files/ca/web/javascript/referencia/sentencies/debugger/index.html new file mode 100644 index 0000000000..54d8d02e3d --- /dev/null +++ b/files/ca/web/javascript/referencia/sentencies/debugger/index.html @@ -0,0 +1,116 @@ +--- +title: debugger +slug: Web/JavaScript/Referencia/Sentencies/debugger +translation_of: Web/JavaScript/Reference/Statements/debugger +--- +<div>{{jsSidebar("Statements")}}</div> + +<p>La <strong>sentència</strong> <strong>debugger </strong>invoca qualsevol funcionalitat de depuració disponible, com l'establiment d'un breakpoint (punt de ruptura). Si no hi ha cap funcionalitat de depuració disponible, aquesta sentència queda sense efecte.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code>debugger;</code></pre> + +<h2 id="Exemples">Exemples</h2> + +<p>L'exemple següent mostra un codi on s'ha insertat una sentència de depuració, de forma que es crida un debugger (si existeix) quan es crida la funció.</p> + +<pre class="brush:js">function potentiallyBuggyCode() { + debugger; + // codi potencialment erroni a examinar, executar pas a pas, etc. +}</pre> + +<p>Quan es crida el debugger, s'atura l'execució a la sentència del debugger. Es com un breakpoint en la font de l'script.</p> + +<p><a href="https://mdn.mozillademos.org/files/6963/Screen Shot 2014-02-07 at 9.14.35 AM.png"><img alt="Paused at a debugger statement." src="https://mdn.mozillademos.org/files/6963/Screen%20Shot%202014-02-07%20at%209.14.35%20AM.png" style="height: 371px; width: 700px;"></a></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>{{SpecName('ES6', '#sec-debugger-statement', 'Debugger statement')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-12.15', 'Debugger statement')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Definició inicial</td> + </tr> + <tr> + <td>{{SpecName('ES3', '#sec-7.5.3', 'Debugger statement')}}</td> + <td>{{Spec2('ES3')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES1', '#sec-7.4.3', 'Debugger statement')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Només mencionat com a paraula reservada.</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/Debugging_JavaScript">Debugging JavaScript</a></li> + <li><a href="/en-US/docs/Tools/Debugger">El depurador en eines de desenvoupador de Firefox</a></li> +</ul> diff --git a/files/ca/web/javascript/referencia/sentencies/do...while/index.html b/files/ca/web/javascript/referencia/sentencies/do...while/index.html new file mode 100644 index 0000000000..88f221f83d --- /dev/null +++ b/files/ca/web/javascript/referencia/sentencies/do...while/index.html @@ -0,0 +1,124 @@ +--- +title: do...while +slug: Web/JavaScript/Referencia/Sentencies/do...while +translation_of: Web/JavaScript/Reference/Statements/do...while +--- +<div>{{jsSidebar("Statements")}}</div> + +<p>La <strong>sentència</strong> <strong><code>do...while</code> </strong> crea un bucle que executa una sentència especificada fins que la condició avalui a fals. La condició s'avalua després de la sentència, donant lloc a l'execució de la sentència especificada almenys un cop.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox">do + <em>sentència</em> +while (<em>condició</em>); +</pre> + +<dl> + <dt><code>sentència</code></dt> + <dd>Una sentència que s'executa almenys un cop i que es torna a executar cada cop que la condició avalui a certa. Per executar múltiples sentències dins d'un bucle, utilitzeu una sentència {{jsxref("Statements/block", "block")}} (<code>{ ... }</code>) per agrupar aquestes sentències.</dd> +</dl> + +<dl> + <dt><code>condició</code></dt> + <dd>Una expressió que s'avalua després de cada volta del bucle. si <code>condició</code> avalua a certa, la <code>sentència</code> es torna a executar. Quan la <code>condició</code> avalua a falç, control passa a la següent sentència que segueix el <code>do...while</code>.</dd> +</dl> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_el_do...while">Utilitzar el <code>do...while</code></h3> + +<p>En l'exemple següent, el bucle <code>do...while</code> itera almenys un cop i torna a iterar fins que <code>i</code> deixa de ser més petit que 5.</p> + +<pre class="brush: js">var i = 0; +do { + i += 1; + console.log(i); +} while (i < 5); +</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('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Definició inicial. Implementat en JavaScript 1.2</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-12.6.1', 'do-while statement')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-do-while-statement', 'do-while statement')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Trailing ; ara és opcional.</td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</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>6</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("Statements/while", "while")}}</li> + <li>{{jsxref("Statements/for", "for")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/sentencies/export/index.html b/files/ca/web/javascript/referencia/sentencies/export/index.html new file mode 100644 index 0000000000..c1d92ab504 --- /dev/null +++ b/files/ca/web/javascript/referencia/sentencies/export/index.html @@ -0,0 +1,158 @@ +--- +title: export +slug: Web/JavaScript/Referencia/Sentencies/export +translation_of: Web/JavaScript/Reference/Statements/export +--- +<div>{{jsSidebar("Statements")}}</div> + +<p>La<strong> </strong>sentència <strong>export</strong> s'utilitza per exportar funcions, objectes o valors primitius d'un fitxer donat (o <em>mòdul</em>) per a que els puguin fer servir altres programes amb la sentència {{jsxref("Statements/import", "import")}}.</p> + +<p>Els mòduls exportats estan sempre {{jsxref("Strict_mode","strict mode", "", 1)}} tan si es declaren així com si no. La sentència export no es pot fer servir en mòduls incrustats (embedded).</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox notranslate">export <em>nom1</em>, <em>nom2</em>, ..., <em>nomN</em>; +export default <em>nom1</em> </pre> + +<dl> + <dt><code>nomN</code></dt> + <dd>Propietat, funció, o objecte que s'ha d'exportar (de manera que es pot importar a través de <code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/import">import</a></code> en un altre script).</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Hi ha dos tipus diferents d'export:</p> + +<ul> + <li>Exportacions nominals (una o més per mòdul): + <pre class="brush: js notranslate">export myFunction; // exporta una funció declarada anteriorment +export const foo = Math.sqrt(2); // exporta una constant +export let <var>name1</var>, <var>name2</var>, …, <var>nameN</var>; +export let <var>name1</var> = …, <var>name2</var> = …, …, <var>nameN</var>; +export function functionName(){...} +export class ClassName {...}</pre> + </li> + <li>Exportacions per defecte (una per mòdul): + <pre class="notranslate">export default <em>expression</em>; +export default function (…) { … } // també class, function* +export default function name1(…) { … } // també class, function* +export { <var>name1</var> as default, … };</pre> + </li> +</ul> + +<p>Les exportacions amb nom són útils per exportar diversos valors. Durant la importació, un serà capaç d'utilitzar el mateix nom per referir-se al valor corresponent.</p> + +<p>Sobre la exportació per defecte, només pot haver-n'hi una per mòdul. Una exportació per defecte pot ser una funció, una classe un objecte o qualsevol altra cosa. Aquest valor es considerarà el principal valor exportat, ja que serà el més fàcil d'importar.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Usant_les_exportacions_nominals">Usant les exportacions nominals</h3> + +<p>En el mòdul podem fer servir el codi següent:</p> + +<pre class="brush: js notranslate">// "modul.js" +export function cub(x) { + return x * x * x; +} +const foo = Math.PI + Math.SQRT2; +export foo; +</pre> + +<p>Així, en un altre mòdul podem tenir:</p> + +<pre class="brush: js notranslate">import { cub, foo } from 'modul.js'; +console.log(cub(3)); // 9 +console.log(foo); // 4.555806215962888</pre> + +<h3 id="Usant_lexportació_per_defecte">Usant l'exportació per defecte</h3> + +<p>Si volem exportar un únic valor o tenir un valor per defecte per al nostre mòdul podem fer::</p> + +<pre class="brush: js notranslate">// "modul.js" +var function cub(x) { + return x * x * x; +} +export default cub;</pre> + +<p>Així, en un altre mòdul podem importar directament:</p> + +<pre class="brush: js notranslate">import laFuncio from 'modul'; +console.log(laFuncio(3)); // 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>{{SpecName('ES6', '#sec-imports', 'Imports')}}</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>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</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>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Statements/import", "import")}}</li> + <li><a href="https://hacks.mozilla.org/2015/08/es6-in-depth-modules/">ES6 in Depth: Modules</a>, Hacks blog post per Jason Orendorff</li> + <li><a href="http://exploringjs.com/es6/ch_modules.html">Axel Rauschmayer's book: "Exploring JS: Modules"</a></li> +</ul> diff --git a/files/ca/web/javascript/referencia/sentencies/for...of/index.html b/files/ca/web/javascript/referencia/sentencies/for...of/index.html new file mode 100644 index 0000000000..5cc16f52f8 --- /dev/null +++ b/files/ca/web/javascript/referencia/sentencies/for...of/index.html @@ -0,0 +1,181 @@ +--- +title: for...of +slug: Web/JavaScript/Referencia/Sentencies/for...of +translation_of: Web/JavaScript/Reference/Statements/for...of +--- +<div> +<div>{{jsSidebar("Statements")}}</div> +</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>La instrucció <code>for...of</code> crea un bucle que itera sobre <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/iterable">objectes iterables</a> (incloent {{jsxref("Array")}}, {{jsxref("Map")}}, {{jsxref("Set")}}, l'objecte <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions_and_function_scope/arguments">arguments</a>, etcètera), tot invocant un bloc de codi amb les instruccions a executar per a cada valor de la propietat.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox">for (<em>variable</em> of <em>objecte</em>) + codi +</pre> + +<dl> + <dt><code>variable</code></dt> + <dd>A cada iteració el valor d'una propietat diferent és asignat a <em>variable</em>.</dd> + <dt><code>object</code>e</dt> + <dd>L'objecte del qual s'iteren les propietats, que són iterables.</dd> +</dl> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Diferència_entre_for...of_i_for...in">Diferència entre <code>for...of</code> i <code>for...in</code></h3> + +<p>El següent exemple mostra la diferència entre el bucle <code>for...of</code> i el bucle <code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...in" title="en-US/docs/JavaScript/Reference/Statements/for...in">for...in</a></code>. Mentre <code>for...in</code> itera sobre noms de propietats, <code>for...of</code> itera sobre els valors de les propietats:</p> + +<pre class="brush:js">let arr = [3, 5, 7]; +arr.foo = "hola"; + +for (let i in arr) { + console.log(i); // mostra "0", "1", "2", "foo" +} + +for (let i of arr) { + console.log(i); // mostra "3", "5", "7" +} +</pre> + +<h3 id="Ús_de_Array.prototype.forEach()">Ús de <code>Array.prototype.forEach()</code></h3> + +<p>Per a aconseguir els mateixos valors que s'obtenen amb <code>for...of</code> també es pot utilitzar el mètode {{jsxref("Array.prototype.forEach()")}}:</p> + +<pre class="brush: js">let arr = [3, 5, 7]; +arr.foo = "hola"; + +arr.forEach(function (element, index) { + console.log(element); // mostra "3", "5", "7" + console.log(index); // mostra "0", "1", "2" +}); + +// or with Object.keys() + +Object.keys(arr).forEach(function (element, index) { + console.log(arr[element]); // mostra "3", "5", "7", "hello" + console.log(arr[index]); // mostra "3", "5", "7" +});</pre> + +<h3 id="Iteració_de_coleccions_del_DOM">Iteració de coleccions del DOM</h3> + +<p>Iterant sobre coleccions del DOM com {{domxref("NodeList")}}: el següent exemple afegeix la classe <code>read</code> als paràgrafs que són descendens directes d'un article:</p> + +<pre class="brush:js">// Nota: Això només funcionarà en plataformes que +// implementen NodeList.prototype[Symbol.iterator] +let articleParagraphs = document.querySelectorAll("article > p"); + +for (let paragraph of articleParagraphs) { + paragraph.classList.add("read"); +} +</pre> + +<h3 id="Iteració_de_generadors">Iteració de generadors:</h3> + +<p>Els <a href="/en-US/docs/Web/JavaScript/Reference/Statements/function*">generadors</a> també són iterables:</p> + +<pre class="brush:js">function* fibonacci() { // una funció generadora + let [prev, curr] = [0, 1]; + for (;;) { + [prev, curr] = [curr, prev + curr]; + yield curr; + } +} + +for (let n of fibonacci()) { + // trunca la seqüència als 1000 + if (n > 1000) + break; + print(n); +} +</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>{{SpecName('ES6', '#sec-for-in-and-for-of-statements', 'for...of statement')}}</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(29)}}<a href="#chrome-note-1">[1]</a><br> + {{CompatChrome(38)}}</td> + <td>{{CompatGeckoDesktop("13")}}<br> + {{CompatGeckoDesktop("17")}} (.iterator)<br> + {{CompatGeckoDesktop("27")}} ("@@iterator")<br> + {{CompatGeckoDesktop("36")}} (Symbol.iterator)</td> + <td>{{CompatNo}}</td> + <td>25</td> + <td>7.1</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>{{CompatUnknown}}</td> + <td>{{CompatChrome(29)}}<a href="#chrome-note-1">[1]</a><br> + {{CompatChrome(38)}}</td> + <td>{{CompatGeckoMobile("13")}}<br> + {{CompatGeckoMobile("17")}} (.iterator)<br> + {{CompatGeckoMobile("27")}} ("@@iterator")<br> + {{CompatGeckoMobile("36")}} (Symbol.iterator)</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>iOS 8</td> + </tr> + </tbody> +</table> +</div> + +<p><a name="chrome-note-1"></a>[1] La característica està disponible sota una preferència. A chrome://flags/#enable-javascript-harmony, activar la entrada “Enable Experimental JavaScript”.</p> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for_each...in">for each...in</a> - una instrucció similar, però itera els valors de les propietats d'un objecte en comptes de les propietats mateixes de l'objecte (en desús).</li> + <li>{{jsxref("Array.prototype.forEach()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/sentencies/for/index.html b/files/ca/web/javascript/referencia/sentencies/for/index.html new file mode 100644 index 0000000000..00a16b62df --- /dev/null +++ b/files/ca/web/javascript/referencia/sentencies/for/index.html @@ -0,0 +1,190 @@ +--- +title: for +slug: Web/JavaScript/Referencia/Sentencies/for +translation_of: Web/JavaScript/Reference/Statements/for +--- +<div> +<div>{{jsSidebar("Statements")}}</div> +</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>La<strong> sentència</strong> <strong>for</strong> crea un bucle que consta de tres expressions opcionals, embolcallades entre paràntesis i separades per punts i comes, seguits d'una sentència o un grup de sentències executades en el bucle.</p> + +<h2 id="Syntax" name="Syntax">Sintaxi</h2> + +<pre class="syntaxbox">for ([<em>inicialització</em>]; [<em>condició</em>]; [<em>expressió final</em>]) + <em>sentència</em> +</pre> + +<dl> + <dt><code>inicialització</code></dt> + <dd>Una expressió (incloent expressions d'assignació) o declaració de variables. Normalment s'usa per inicialitzar una variable al contador. Opcionalment aquesta expressió pot declarar noves variables amb la paraula clau <code>var</code>. Aquestes variables no sóc locals pel bucle, és a dir, es troben en el mateix àmbit en que es troba el bucle <code>for</code>. El resultat d'aquesta expressió es descarta.</dd> + <dt><code>condició</code></dt> + <dd>Una expressió que s'avalua abans de cada iteració del bucle. Si aquesta expressió s'avalua<strong> true,</strong> s'executa la <code>sentència</code>. Aquesta prova condicional és opcional. Si s'omet, la condició sempre avalua<strong> true.</strong> Si l'expressió avalua a false, l'execució salta a la primera expressió que es trobi després del constructe <code>for</code>.</dd> + <dt><code>Expressió final</code></dt> + <dd>Una expressió per ser avaluada al final de cada iteració del bucle. Això passa abans de la següent avaluació de <code>condició</code>. Generalment s'usa per actualitzar o incrementar la variable contador.</dd> + <dt><code>sentència</code></dt> + <dd>Una sentència que s'executa mentre la condició avalui a true. Per executar múltiples sentències dins el bucle, utilitzeu una sentència <a href="/en-US/docs/JavaScript/Reference/Statements/block" title="JavaScript/Reference/Statements/block">block</a> (<code>{ ... }</code>) per agrupar aquestes sentències. Per no executar cap sentència dins el bucle, utilitzeu una sentència <a href="/en-US/docs/Web/JavaScript/Reference/Statements/Empty">buida</a> (<code>;</code>).</dd> +</dl> + +<h2 id="Examples" name="Examples">Exemples</h2> + +<h3 id="Example.3A_Using_for" name="Example.3A_Using_for">Exemple: Fer servir <code>for</code></h3> + +<p>La següent sentència <code>for</code> comença declarant la variable <code>i</code> i l'inicialitza a <code>0</code>. Comprova que <code>i</code> és menor que nou, realitza les dues sentències següents<u>, i incrementa <code>i</code> per 1 després de cada pas pel bucle.</u></p> + +<pre class="brush: js">for (var i = 0; i < 9; i++) { + console.log(i); + // more statements +} +</pre> + +<h3 id="Exemple_Expressions_for_opcionals"><u>Exemple: Expressions <code>for</code> opcionals</u></h3> + +<p>Les tres expressions en la capçalera del bucle <code>for</code> són opcionals.</p> + +<p>Per exemple, enel bloc d'<em>inicialització</em> no es requereix inicialitzar les variablesblock it is not required to initialize variables:</p> + +<pre class="brush: js">var i = 0; +for (; i < 9; i++) { + console.log(i); + // more statements +} +</pre> + +<p><u>Com el bloc d'<em>inicialització</em>, el bloc de <em>condició</em> també és opcional. Si s'omet aquesta expressió, s'ha de d'assegurar de trencar el bucle en el cos per evitar crear un bucle infinit.</u></p> + +<pre class="brush: js">for (var i = 0;; i++) { + console.log(i); + if (i > 3) break; + // more statements +}</pre> + +<p>També es pot ometre els tres blocs. Un alre cop, assegureu-vos de fer servir la sentència <code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/break">break</a></code> per finalitzar el bucle i també modificar (incrementar) una variable, de forma que la condició per la sentència break esdevé certa en algun moment determinat.</p> + +<pre class="brush: js">var i = 0; + +for (;;) { + if (i > 3) break; + console.log(i); + i++; +} +</pre> + +<h3 id="Example.3A_Using_for_without_the_statement_section" name="Example.3A_Using_for_without_the_statement_section"><u>Exemple: Fer servir <code>for</code> amb una sentència buida</u></h3> + +<p><u>El cicle <code>for</code> següent callcula la possició de desplaçament d'un node en la secció <em>[expressió final]</em>, i per tant no requereix l'ús d'una <code>sentència</code> o secció de sentències <code><a href="/en-US/docs/JavaScript/Reference/Statements/block" title="JavaScript/Reference/Statements/block">block</a></code>, es fa servir una sentència <a href="/en-US/docs/Web/JavaScript/Reference/Statements/Empty">buida</a> en el seu lloc</u>.</p> + +<pre class="brush: js">function showOffsetPos (sId) { + var nLeft = 0, nTop = 0; + + for (var oItNode = document.getElementById(sId); // initialization + oItNode; // condition + nLeft += oItNode.offsetLeft, nTop += oItNode.offsetTop, oItNode = oItNode.offsetParent) // final-expression + /* empty statement */ ; + + console.log("Offset position of \"" + sId + "\" element:\n left: " + nLeft + "px;\n top: " + nTop + "px;"); +} + +// Example call: + +showOffsetPos("content"); + +// Output: +// "Offset position of "content" element: +// left: 0px; +// top: 153px;"</pre> + +<div class="note"><strong>Nota:</strong> En aquest cas, quan no es fa servir la secció <code>sentència</code>, <strong>es fica un punt i coma immediatament despres de la declaració del cicle</strong>.</div> + +<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.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-12.6.3', 'for statement')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-for-statement', 'for statement')}}</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>{{jsxref("Statements/break", "break")}}</li> + <li>{{jsxref("Statements/continue", "continue")}}</li> + <li>{{jsxref("Statements/empty", "empty")}}</li> + <li>{{jsxref("Statements/while", "while")}}</li> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Statements/do...while"><code>do...while</code></a></li> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...in"><code>for...in</code></a></li> + <li><code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...of"><code>for...of</code></a></code></li> +</ul> diff --git a/files/ca/web/javascript/referencia/sentencies/function/index.html b/files/ca/web/javascript/referencia/sentencies/function/index.html new file mode 100644 index 0000000000..37deff748f --- /dev/null +++ b/files/ca/web/javascript/referencia/sentencies/function/index.html @@ -0,0 +1,171 @@ +--- +title: function +slug: Web/JavaScript/Referencia/Sentencies/function +translation_of: Web/JavaScript/Reference/Statements/function +--- +<div> +<div>{{jsSidebar("Statements")}}</div> +</div> + +<h2 id="Resum">Resum</h2> + +<p>La <strong>declaració d'una funció</strong> defineix una funció amb uns paràmetres especificats.</p> + +<div class="noinclude"> +<p>També podeu definir funcions fent servir el constructor {{jsxref("Function")}} i un {{jsxref("Operators/function", "function expression")}}.</p> +</div> + +<h2 id="Syntax" name="Syntax">Sintaxi</h2> + +<pre class="syntaxbox">function <em>nom</em>([<em>paràm</em>,[, <em>paràm</em>,[..., <em>paràm</em>]]]) { + [<em>sentències</em>] +} +</pre> + +<dl> + <dt><code>nom</code></dt> + <dd>El nom de la funció.</dd> +</dl> + +<dl> + <dt><code>paràm</code></dt> + <dd>El nom d'un argument que se li passarà a la funció. Una funció pot arribar a tenir fins a 255 arguments.</dd> +</dl> + +<dl> + <dt><code>sentències</code></dt> + <dd>Les sentències que comprenen el cos de la funció.</dd> +</dl> + +<h2 id="Description" name="Description">Descripció</h2> + +<p>Una funció creada amb una declaració d'una funció és un objecte <code>Function</code> i té totes les propietats, mètodes i comportament dels objectes <code>Function</code>. Vegeu {{jsxref("Function")}} per informació detallada sobre funcions.</p> + +<p>Una funció també es pot crear fent servir una expressió (vegeu {{jsxref("Operators/function", "function expression")}}).</p> + +<p>Per defecte, les funcions retornen <code>undefined</code>. Per tal de retornar qualsevol altre valor, la funció ha de tenir una sentència {{jsxref("Statements/return", "return")}} que especifiqui el valor que retorna.</p> + +<h3 id="Funcions_creades_de_forma_condicional">Funcions creades de forma condicional</h3> + +<p>Les funcions poden ser declarades de forma condicional, és a dir, una sentència d'una funció pot estar aniuada dins d'una sentència <code>if</code>. La majoria de navegadors que no siguin Mozilla tractaran aquestes declaracions condicionals com a declaracions incondicionals i crearàn la funció tant si la condició és vertadera o falsa, vegeu <a href="http://kangax.github.io/nfe/#function-statements">aquest article</a> per una visió general. Per tant, no s'haurien de fer servir, per creacions condicionals feu servir expressions de funcions.</p> + +<h3 id="Declarar_les_funcions_abans_de_definir-les_(hosting)">Declarar les funcions abans de definir-les <em>(hosting)</em></h3> + +<p><u>Function declarations in JavaScript are hoisting the function definition</u>. En Javascript es pot ser cridar una funció abans de declarar-la. En anglès existeix un ver:</p> + +<pre class="brush: js">hoisted(); // logs "foo" + +function hoisted() { + console.log("foo"); +} +</pre> + +<p>Vegeu que {{jsxref("Operators/function", "function expressions")}} no estan hoisted:</p> + +<pre class="brush: js">notHoisted(); // TypeError: notHoisted is not a function + +var notHoisted = function() { + console.log("bar"); +}; +</pre> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Exemple_Fer_servir_function">Exemple: Fer servir <code>function</code></h3> + +<p>El codi següent declara una funció que retorna la quantitat total de vendes, quan se li dóna el nombre d'unitat venudes d' <code>a</code>, <code>b</code>, i <code>c</code>.</p> + +<pre class="brush: js">function calc_sales(units_a, units_b, units_c) { + return units_a*79 + units_b * 129 + units_c * 699; +} +</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ó iniciañ. Implementat en JavaScript 1.0</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-13', 'Function definition')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-function-definitions', 'Function definitions')}}</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>{{jsxref("Functions_and_function_scope", "Functions and function scope")}}</li> + <li>{{jsxref("Function")}}</li> + <li>{{jsxref("Operators/function", "function expression")}}</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/sentencies/if...else/index.html b/files/ca/web/javascript/referencia/sentencies/if...else/index.html new file mode 100644 index 0000000000..b45e9bea3c --- /dev/null +++ b/files/ca/web/javascript/referencia/sentencies/if...else/index.html @@ -0,0 +1,203 @@ +--- +title: if...else +slug: Web/JavaScript/Referencia/Sentencies/if...else +translation_of: Web/JavaScript/Reference/Statements/if...else +--- +<div> +<div>{{jsSidebar("Statements")}}</div> +</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>La <strong><a href="/en-US/docs/Web/JavaScript/Guide/Statements">sentència </a>if </strong>executa una sentència si una condició especificada és certa. Si la condició és falsa, opcionalment s'executa una declaració diferent.</p> + +<h2 id="Syntax" name="Syntax">Sintaxi</h2> + +<pre class="syntaxbox">if (<em>condició</em>) + <em>sentència1</em> +[else + <em>sentència2</em>] +</pre> + +<dl> + <dt><code>condició</code></dt> + <dd><u>Una <a href="/en-US/docs/Web/JavaScript/Guide/Expressions_and_Operators#Expressions">expressió</a> que esdevé o certa o falsa.</u></dd> +</dl> + +<dl> + <dt><code>sentència1</code></dt> + <dd><u>És la sentència que s'executa si la <code>condició</code> esdevé certa. Pot ser qualsevol declaració, incloent més sentències <code>if</code> aniuades.</u> Per executar múltimples sentències, es fa servir una sentència <a href="/en-US/docs/Web/JavaScript/Reference/Statements/block" title="en/JavaScript/Reference/Statements/block">block</a> ({ ... }) per agrupar aquestes sentències, si no es vol executar cap sentència, es fa servir una sentència <a href="/en-US/docs/Web/JavaScript/Reference/Statements/Empty">buida</a>.</dd> +</dl> + +<dl> + <dt><code>sentència2</code></dt> + <dd>La sentència que s'executa si la <code>condition</code> esdevé falsa i hi ha la clàusula <code>else</code>. Pot ser qualsevol sentència, incloent sentències en<u> block </u>i més sentències <code>if</code> aniuades.</dd> +</dl> + +<h2 id="Description" name="Description">Descripció</h2> + +<p>Múltiples sentències <code>if...else</code> poden aniuar-se per crear una clàusula <code>else if</code>. Fixeu-vos que no hi ha la paraula clau <code>elseif</code> (en una paraula) en JavaScript.</p> + +<pre class="eval">if (<em>condició1</em>) + <em>sentència1</em> +else if (<em>condició2</em>) + <em>sentència2</em> +else if (<em>condició3</em>) + <em>sentència3</em> +... +else + <em>sentènciaN</em> +</pre> + +<p>Per veure com funciona, així es com es veuria amb l'aniuament degudament indentat.</p> + +<pre class="eval">if (<em>condició1</em>) + <em>sentència1</em> +else + if (<em>condició2</em>) + <em>sentència2</em> + else + if (<em>condició3</em>) +... +</pre> + +<p>Per executar múltiples sentències dins una clàusula, utilitzeu una sentència block (<code>{ ... }</code>) per agrupar aquestes sentències. En general, és una bona pràctica utilitzar sempre sentències de <u>block</u>, especialment en codi que inclogui sentències <code>if</code> aniuades:</p> + +<pre class="eval">if (<em>condició</em>) { + <em>sentència1</em> +} else { + <em>sentència2</em> +} +</pre> + +<p>No confongueu els valors booleans primitius <code>true</code> i <code>false</code> amb els valors cert i fals de l'objecte <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean" title="en/JavaScript/Reference/Global_Objects/Boolean">Boolean</a>. Qualsevol valor que no sigui <code>undefined</code>, <code>null</code>, <code>0</code>, <code>NaN</code>, o una cadena buida (<code>""</code>), i qualsevol objecte, incloent un objecte Boolean que tingui el valor fals, esdevé cert quan es passa a una sentència condicional. Per exemple:</p> + +<pre class="brush: js">var b = new Boolean(false); +if (b) // this condition evaluates to true +</pre> + +<h2 id="Examples" name="Examples">Exemples</h2> + +<h3 id="Example:_Using_if...else" name="Example:_Using_if...else">Exemple: Fer servir <code>if...else</code></h3> + +<pre class="brush: js">if (cipher_char === from_char) { + result = result + to_char; + x++; +} else { + result = result + clear_char; +} +</pre> + +<h3 id="Exemple_Fer_servir_else_if">Exemple: Fer servir <code>else if</code></h3> + +<p>Vegeu que no hi ha cap sintaxi <code>elseif</code> en JavaScript. Tanmateix, es pot escriure amb un espai entre <code>else</code> i <code>if</code>:</p> + +<pre class="brush: js">if (x > 5) { + +} else if (x > 50) { + +} else { + +}</pre> + +<h3 id="Example:_Assignment_within_the_conditional_expression" name="Example:_Assignment_within_the_conditional_expression">Exemple: Assignació dins l'expressió condicional</h3> + +<p>És recomanable no utilitzar assignacions simples en una expressió condicional, atès que l'assignació es pot confondre amb l'igualtat quan es mira per sobre el codi. Per exemple, no utilitzeu el codi següent:</p> + +<pre class="brush: js">if (x = y) { + /* do the right thing */ +} +</pre> + +<p>Si necessiteu usar una assignació dins d'una expressió condicional, una pràctica comuna és ficar parèntesis addicionals embolcallant l'assignació. Per exemple:</p> + +<pre class="brush: js">if ((x = y)) { + /* do the right thing */ +} +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificacó</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>1a edició de ECMAScript.</td> + <td>Estàndard</td> + <td>Definció inicial.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-12.5', 'if statement')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-if-statement', 'if statement')}}</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>{{jsxref("Statements/block", "block")}}</li> + <li>{{jsxref("Statements/switch", "switch")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/sentencies/index.html b/files/ca/web/javascript/referencia/sentencies/index.html new file mode 100644 index 0000000000..e91e446cbf --- /dev/null +++ b/files/ca/web/javascript/referencia/sentencies/index.html @@ -0,0 +1,129 @@ +--- +title: Statements and declarations +slug: Web/JavaScript/Referencia/Sentencies +tags: + - JavaScript + - NeedsTranslation + - Reference + - TopicStub + - statements +translation_of: Web/JavaScript/Reference/Statements +--- +<div>{{jsSidebar("Statements")}}</div> + +<p>Les aplicacions de JavaScript consisteixen en sentències amb una sintaxi adequada. Una sola sentència pot ocupar múltiples línies. Múltiples sentències poden donar-se en una sola línia si cada sentència és separada per un punt i coma. Això no és una paraula clau sino un grup de paraules claus.</p> + +<h2 id="Sentències_i_declaracions_per_categoria">Sentències i declaracions per categoria</h2> + +<p>Per a un llistat alfabetic vegeu el menú de l'esquerra.</p> + +<h3 id="Control_de_fluxe">Control de fluxe</h3> + +<dl> + <dt>{{jsxref("Sentencies/block", "Block")}}</dt> + <dd>Una sentència bloc s'utilitza per a agrupar zero o més sentències. El bloc és delimitat per un parell de claus {}.</dd> + <dt>{{jsxref("Sentencies/break", "break")}}</dt> + <dd>Acaba la sentència bucle, switch o label actual i transfereix el control del programa a la sentència que segueix la sentència que tot just s'ha acabat.</dd> + <dt>{{jsxref("Sentencies/continue", "continue")}}</dt> + <dd>Acaba l'execució de les sentències de la iteració del bucle actual o bé del bucle especificat, i continua l'execució del bucle amb la següent iteració.</dd> + <dt>{{jsxref("Sentencies/Empty", "Empty")}}</dt> + <dd>Una sentència buida s'utilitza per a proporcionar una sentència que no fa res quan JavaScript espera una sentència però no se'n necesita executar cap.</dd> + <dt>{{jsxref("Sentencies/if...else", "if...else")}}</dt> + <dd>Executa una sentència si la condició especificada és certa. Si la condició és falsa una altra sentència pot ser executada.</dd> + <dt>{{jsxref("Sentencies/switch", "switch")}}</dt> + <dd>Evalua una expressió, compara el resultat de l'evaluació amb una clàusula de tipus <em>case </em>i executa la sentència pertanyent a la clàusula case que és igual a l'evaluació de l'expressió.</dd> + <dt>{{jsxref("Sentencies/throw", "throw")}}</dt> + <dd>Llença una excepció definida per l'usuari.</dd> + <dt>{{jsxref("Sentencies/try...catch", "try...catch")}}</dt> + <dd>Executa un bloc de sentències i, en cas que alguna sentència del bloc llenci una excepció, executa una sentència alternativa.</dd> +</dl> + +<h3 id="Declaracions">Declaracions</h3> + +<dl> + <dt>{{jsxref("Sentencies/var", "var")}}</dt> + <dd>Declara una variable, opcionalment li assigna un valor.</dd> + <dt>{{experimental_inline()}} {{jsxref("Sentencies/let", "let")}}</dt> + <dd>Declara un bloc de variables d'àmbit local, opcionalment li assigna un valor.</dd> + <dt>{{experimental_inline()}} {{jsxref("Sentencies/const", "const")}}</dt> + <dd>Declara una constant de només lectura.</dd> +</dl> + +<h3 id="Funcions">Funcions</h3> + +<dl> + <dt>{{jsxref("Sentencies/function", "function")}}</dt> + <dd>Declara una funció amb els paràmetres especificats.</dd> + <dt>{{experimental_inline()}} {{jsxref("Sentencies/function*", "function*")}}</dt> + <dd>Funcions generadores que permeten escriure <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/The_Iterator_protocol">iteradors</a> de forma més senzilla.</dd> + <dt>{{jsxref("Sentencies/return", "return")}}</dt> + <dd>Especifica el valor que retornarà una funció.</dd> +</dl> + +<h3 id="Iteracions">Iteracions</h3> + +<dl> + <dt>{{jsxref("Sentencies/do...while", "do...while")}}</dt> + <dd>Crea un bucle que executa una sentència especificada fins que la condició de test s'evalua a fals. La condició s'evalua després d'executar la sentència, resultant en que la sentència especificada s'executa al menys un cop.</dd> + <dt>{{jsxref("Sentencies/for", "for")}}</dt> + <dd>Crea un bucle que sonsisteix en tres expressions opcionals embolcallades per parèntesi i separades per punts i coma, seguides d'una sentència que s'executarà en el bucle.</dd> + <dt>{{deprecated_inline()}} {{non-standard_inline()}} {{jsxref("Sentencies/for_each...in", "for each...in")}}</dt> + <dd>Itera sobre tots els valors de les propietats d'un objecte, assignant a una variable determinada el seu valor. Per a cada propietat distinta s'executa una sentència.</dd> + <dt>{{jsxref("Sentencies/for...in", "for...in")}}</dt> + <dd>Itera sobre les propietats enumerables d'un objecte en un ordre arbitrari. Per a cada propietat distinta s'executa una sentència.</dd> + <dt>{{experimental_inline()}} {{jsxref("Sentencies/for...of", "for...of")}}</dt> + <dd>Itera sobre objectes iterables (incloent <a href="https://developer.mozilla.org/en-US/docs/Core_JavaScript_1.5_Reference/Global_Objects/Array" title="Array">arrays</a>, objectes similar a arrays, <a href="https://developer.mozilla.org/en-US/docs/JavaScript/Guide/Iterators_and_Generators" title="Iterators and generators">iteradors i generadors</a>), executant una sentència per al valor de cada propietat distinta.</dd> + <dt>{{jsxref("Sentencies/while", "while")}}</dt> + <dd>Crea un bucle que executa la sentència donada mentre una condició sigui certa. La condició s'evalua abans d'executar la sentència.</dd> +</dl> + +<h3 id="Altres">Altres</h3> + +<dl> + <dt>{{jsxref("Sentencies/debugger", "debugger")}}</dt> + <dd>Invoca qualsevol funcionalitat de depuració que estigui disponible. Si no hi ha cap funcionalitat de depuració disponible aquesta sentència no te cap efecte.</dd> + <dt>{{experimental_inline()}} {{jsxref("Sentencies/export", "export")}}</dt> + <dd>Utilitzada per a exportar funcions per a que aquestes estiguin disponibles per a imports a mòduls externs, en altres scripts.</dd> + <dt>{{experimental_inline()}} {{jsxref("Sentencies/import", "import")}}</dt> + <dd>Utilitzada per a importar funcions exportades d'un mòdul extern, un altre script.</dd> + <dt>{{jsxref("Sentencies/label", "label")}}</dt> + <dd>Asigna un identificador a una sentència. Aquest identificador pot ser emprat en sentències <code>break</code> o <code>continue</code>.</dd> +</dl> + +<dl> + <dt>{{deprecated_inline()}} {{jsxref("Sentencies/with", "with")}}</dt> + <dd>Extèn la cadena d'àmbit per a una sentència.</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">Comentari</th> + </tr> + <tr> + <td>ECMAScript 1a Edició</td> + <td>Standard</td> + <td>Definició inicial.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-12', 'Statements')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-ecmascript-language-statements-and-declarations', 'Llenguatge ECMAScript: Sentències i declaracions')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Nou: function*, let, for...of, yield</td> + </tr> + </tbody> +</table> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators">Operadors</a></li> +</ul> diff --git a/files/ca/web/javascript/referencia/sentencies/return/index.html b/files/ca/web/javascript/referencia/sentencies/return/index.html new file mode 100644 index 0000000000..5b3c3e902a --- /dev/null +++ b/files/ca/web/javascript/referencia/sentencies/return/index.html @@ -0,0 +1,183 @@ +--- +title: return +slug: Web/JavaScript/Referencia/Sentencies/return +translation_of: Web/JavaScript/Reference/Statements/return +--- +<div> +<div>{{jsSidebar("Statements")}}</div> +</div> + +<h2 id="Resum">Resum</h2> + +<p><u>La <strong>sentència</strong> <strong><code>return</code> </strong>finalitza l'execució de la funció i especifica un valor que retornarà a la funció que l'ha cridat.</u></p> + +<h2 id="Syntax" name="Syntax">Sintaxi</h2> + +<pre class="syntaxbox">return [[expressió]]; </pre> + +<dl> + <dt><code>expressió</code></dt> + <dd>L'expressió que retorna. En cas d'ometre-s, es retorna <code>undefined</code>.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Quan una sentència <code>return</code> és cridada dins una funció, l'execució d'aquesta funció s'atura. En cas d'especificar-se, un valor donat és retornat a la funció que l'ha cridat. Si s'omet l'expressió, es retornarà <code>undefined</code>. En les següents sentències return totes aturen l'execució de la funció:</p> + +<pre class="brush: js">return; +return true; +return false; +return x; +return x + y / 3; +</pre> + +<h3 id="Insersió_automàtica_de_punt_i_coma">Insersió automàtica de punt i coma</h3> + +<p><u>La sentència <code>return</code> es veu afectada per la <a href="/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#Automatic_semicolon_insertion">insersió automàtica de punt i coma ()</a>. No hi ha cap final de línia entre la paraula clau <code>return</code> i l'expressió permesa.</u></p> + +<pre class="brush: js">return +a + b; + +// is transformed by ASI into + +return; +a + b; +</pre> + +<h2 id="Examples" name="Examples">Exemples</h2> + +<h3 id="Example:_Using_return" name="Example:_Using_return">Exemple: Fer servir <code>return</code></h3> + +<p>La següent funció retorna el quadrat del seu argument, <code>x</code>, on <code>x</code> és un nombre.</p> + +<pre class="brush: js">function square(x) { + return x * x; +} +</pre> + +<h3 id="Example:_Interrupt_a_function" name="Example:_Interrupt_a_function">Exemple: Interrompre una funció</h3> + +<p>Una funció s'atura immediatament en el moment en que es crida <code>return</code>.</p> + +<pre class="brush: js">function counter() { + for (var count = 1; ; count++) { // infinite loop + console.log(count + "A"); // until 5 + if (count === 5) { + return; + } + console.log(count + "B"); // until 4 + } + console.log(count + "C"); // never appears +} + +counter(); + +// Output: +// 1A +// 1B +// 2A +// 2B +// 3A +// 3B +// 4A +// 4B +// 5A +</pre> + +<h3 id="Exemple_Returning_a_function">Exemple: Returning a function</h3> + +<p>Per més informació sobre closures, llegiu la <a href="/en-US/docs/Web/JavaScript/Guide/Closures">Guia de JavaScript</a>.</p> + +<pre class="brush: js">function magic(x) { + return function calc(x) { return x * 42}; +} + +var answer = magic(); +answer(1337); // 56154 +</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.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-12.9', 'Return statement')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-return-statement', 'Return statement')}}</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/Functions_and_function_scope" title="En/Core_JavaScript_1.5_Reference/Functions">Funcions</a></li> + <li><a href="/en-US/docs/Web/JavaScript/Guide/Closures">Closures</a></li> +</ul> diff --git a/files/ca/web/javascript/referencia/sentencies/throw/index.html b/files/ca/web/javascript/referencia/sentencies/throw/index.html new file mode 100644 index 0000000000..37d13b964b --- /dev/null +++ b/files/ca/web/javascript/referencia/sentencies/throw/index.html @@ -0,0 +1,228 @@ +--- +title: throw +slug: Web/JavaScript/Referencia/Sentencies/throw +translation_of: Web/JavaScript/Reference/Statements/throw +--- +<div>{{jsSidebar("Statements")}}</div> + +<p>La <strong>sentència <code>throw</code> </strong>llença una excepció definida per l'usuari. L'execució de la funció actual s'aturarà (les sentències de després de <code>throw</code> no s'executaran) i es passarà el control al primer bloc <a href="/en-US/docs/Web/JavaScript/Reference/Statements/try...catch"><code>catch</code></a> en la pila de crides. Si no existeix cap bloc <code>catch</code> en les funcions de crides, el programa s'acabarà.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox">throw <em>expressió</em>; </pre> + +<dl> + <dt><code>expressió</code></dt> + <dd>L'expressió que es llença.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Utilitzeu una sentència <code>throw</code> per llençar una excepció. Quan es llença l'excepció, <code>expression</code> especifica el valor de l'excepció. Cadascun dels exemples següents llença una excepció:</p> + +<pre class="brush: js">throw "Error2"; // genera una excepció amb un valor tipus cadena +throw 42; // genera una excepció amb el valor 42 +throw true; // genera una excepció amb el valor true</pre> + +<p>Tingueu en compte que la sentència <code>throw</code> queda afectada per <a href="/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#Automatic_semicolon_insertion">insersió automàtica de punts i comes (ASI)</a> ja que no es permet cap final de línia<u> </u>entre la paraula clau <code>throw</code> i l'expressió.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Llença_un_objecte">Llença un objecte</h3> + +<p>Es pot especificar un objecte quan es llença una excepció. Es pot fer referència a les propietats de l'objecte en el bloc <code>catch</code>. L'exemple següent crea un objecte <code>myUserException</code> de tipus <code>UserException</code> i l'utilitza en una sentència <code>throw</code>.</p> + +<pre class="brush: js">function UserException(message) { + this.message = message; + this.name = "UserException"; +} +function getMonthName(mo) { + mo = mo-1; // Adjustar el número de mes per un índex d'array (1=Jan, 12=Dec) + var months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", + "Aug", "Sep", "Oct", "Nov", "Dec"]; + if (months[mo] !== undefined) { + return months[mo]; + } else { + throw new UserException("InvalidMonthNo"); + } +} + +try { + // sentències que s'intentarà exxecutar + var myMonth = 15; // 15 està fora del rang i llençarà l'excepció + monthName = getMonthName(myMonth); +} catch (e) { + monthName = "unknown"; + logMyErrors(e.message, e.name); // es pasa l'objecte excepció al manegador d'errors +} +</pre> + +<h3 id="Un_altre_exemple_de_llençar_un_objecte">Un altre exemple de llençar un objecte</h3> + +<p>L'exemple següent comprova si una cadena donada és un codi postal per EE.UT. SI el codi postal utilitza un format invàlid, la sentència throw llença una excepció creant un objecte de tipus <code>ZipCodeFormatException</code>.</p> + +<pre class="brush: js">/* + * Crea un objecte ZipCode. + * + * Els formats acceptats per a un codi postal són: + * 12345 + * 12345-6789 + * 123456789 + * 12345 6789 + * + * Si l'argument passat al constructor ZipCode no s'adjusta a + * un d'aquests patrons, es llença una excepció. + */ + +function ZipCode(zip) { + zip = new String(zip); + pattern = /[0-9]{5}([- ]?[0-9]{4})?/; + if (pattern.test(zip)) { + // el valor del codi postal serà el primer trobat dins la cadena + this.value = zip.match(pattern)[0]; + this.valueOf = function() { + return this.value + }; + this.toString = function() { + return String(this.value) + }; + } else { + throw new ZipCodeFormatException(zip); + } +} + +function ZipCodeFormatException(value) { + this.value = value; + this.message = "no s'adjusta al format esperat per a un codi postal"; + this.toString = function() { + return this.value + this.message; + }; +} + +/* + * Això podria trobar-se en un script que valida adresses d'EE.UU. + */ + +const ZIPCODE_INVALID = -1; +const ZIPCODE_UNKNOWN_ERROR = -2; + +function verifyZipCode(z) { + try { + z = new ZipCode(z); + } catch (e) { + if (e instanceof ZipCodeFormatException) { + return ZIPCODE_INVALID; + } else { + return ZIPCODE_UNKNOWN_ERROR; + } + } + return z; +} + +a = verifyZipCode(95060); // retorna 95060 +b = verifyZipCode(9560); // retorna -1 +c = verifyZipCode("a"); // retorna -1 +d = verifyZipCode("95060"); // retorna 95060 +e = verifyZipCode("95060 1234"); // retorna 95060 1234 +</pre> + +<h3 id="Rellençar_una_excepció">Rellençar una excepció</h3> + +<p>Es pot utilitzar <code>throw</code> per rellençar una excepció després de caputrar-la. L'exemple següent captura una excepció amb un valor numèric i el rellença si el valor és major de 50. L'excepció rellençada es propaga fins a la funció que l'envolcalla o al nivell superior de forma que l'usuari ho vegi.</p> + +<pre class="brush: js">try { + throw n; // llença una excepció amb un valor numèric +} catch (e) { + if (e <= 50) { + // sentències per manejar excepcions 1-50 + } else { + // no es pot manejar aquesta excepció, per tant es rellença + throw e; + } +} +</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('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Definició inicial. Implementat en JavaScript 1.4</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-12.13', 'throw statement')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-throw-statement', 'throw statement')}}</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/Statements/try...catch"><code>try...catch</code></a></li> +</ul> diff --git a/files/ca/web/javascript/referencia/sentencies/while/index.html b/files/ca/web/javascript/referencia/sentencies/while/index.html new file mode 100644 index 0000000000..d3997dbefd --- /dev/null +++ b/files/ca/web/javascript/referencia/sentencies/while/index.html @@ -0,0 +1,131 @@ +--- +title: while +slug: Web/JavaScript/Referencia/Sentencies/while +translation_of: Web/JavaScript/Reference/Statements/while +--- +<div>{{jsSidebar("Statements")}}</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>la <strong>sentència while</strong> crea un bucle que executa una sentència especificada sempre que la condició s'avalui certa. La condició s'avalua abans d'executar la sentència..</p> + +<h2 id="Syntax" name="Syntax">Sintaxi</h2> + +<pre class="syntaxbox">while (<em>condició</em>) { + <em>sentència</em> +}</pre> + +<dl> + <dt><code>condició</code></dt> + <dd>Una expressió que s'avalua abans de cada passada del bucle. Si aquesta condició esdevé certa, s'executa la <code>sentència</code>. Quan la condició esdevé falsa, l'execució continua amb la sentència posterior al bucle <code>while</code>.</dd> + <dt><code>sentència</code></dt> + <dd>Una sentència que s'executa sempre que la condició esdevingui certa. Per executar múltiples sentències dins un bucle, podeu fer ús de la sentència <a href="/en-US/docs/JavaScript/Reference/Statements/block" title="JavaScript/Reference/Statements/block">block</a> (<code>{ ... }</code>) per agrupar aquestes sentències.</dd> +</dl> + +<h2 id="Examples" name="Examples">Exemples</h2> + +<p>El següent bucle <code>while</code> itera sempre que <code>n</code> sigui menor que tres.</p> + +<pre class="brush:js">var n = 0; +var x = 0; + +while (n < 3) { + n++; + x += n; +}</pre> + +<p>En cada iteració, el bucle incrementa <code>n</code> i ho suma a <code>x</code>. Per tant, <code>x</code> i <code>n</code> prenen els següents valors:</p> + +<ul> + <li>Després de la primera volta: <code>n</code> = 1 i <code>x</code> = 1</li> + <li>Després de la segona volta: <code>n</code> = 2 i <code>x</code> = 3</li> + <li>Després de la tercera volta: <code>n</code> = 3 i <code>x</code> = 6</li> +</ul> + +<p>Després de completar la tercera volta, la condició <code>n</code> < 3 ja no esdevé més certa, i per tant finalitza el bucle.</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>1a edició de ECMAScript.</td> + <td>Estàndard</td> + <td>Definició inicial.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-12.6.2', 'while statement')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-while-statement', 'while statement')}}</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/do...while"><code>do...while</code></a></li> + <li>{{jsxref("Statements/for", "for")}}</li> +</ul> |