diff options
Diffstat (limited to 'files/ca/web/javascript/reference/global_objects/array')
25 files changed, 4796 insertions, 0 deletions
diff --git a/files/ca/web/javascript/reference/global_objects/array/entries/index.html b/files/ca/web/javascript/reference/global_objects/array/entries/index.html new file mode 100644 index 0000000000..8b67c06038 --- /dev/null +++ b/files/ca/web/javascript/reference/global_objects/array/entries/index.html @@ -0,0 +1,105 @@ +--- +title: Array.prototype.entries() +slug: Web/JavaScript/Referencia/Objectes_globals/Array/entries +translation_of: Web/JavaScript/Reference/Global_Objects/Array/entries +--- +<div>{{JSRef}}</div> + +<p>El mètode <code><strong>entries()</strong></code> retorna un nou objecte <code><strong>Array Iterator</strong></code> que conté els parells clau/valor per a cada posició de l'array.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>arr</var>.entries()</code></pre> + +<h2 id="Exemples">Exemples</h2> + +<pre class="brush:js">var arr = ['a', 'b', 'c']; +var eArr = arr.entries(); + +console.log(eArr.next().value); // [0, 'a'] +console.log(eArr.next().value); // [1, 'b'] +console.log(eArr.next().value); // [2, 'c'] +</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-array.prototype.entries', 'Array.prototype.entries')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definició inicial.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype.entries', 'Array.prototype.entries')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<div>{{CompatibilityTable}}</div> + +<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("38")}}</td> + <td>{{CompatGeckoDesktop("28")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatOpera("25")}}</td> + <td>{{CompatSafari("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>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatGeckoMobile("28")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8.0</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Array.prototype.keys()")}}</li> + <li>{{jsxref("Array.prototype.forEach()")}}</li> + <li>{{jsxref("Array.prototype.every()")}}</li> + <li>{{jsxref("Array.prototype.some()")}}</li> +</ul> diff --git a/files/ca/web/javascript/reference/global_objects/array/every/index.html b/files/ca/web/javascript/reference/global_objects/array/every/index.html new file mode 100644 index 0000000000..ad707b4990 --- /dev/null +++ b/files/ca/web/javascript/reference/global_objects/array/every/index.html @@ -0,0 +1,220 @@ +--- +title: Array.prototype.every() +slug: Web/JavaScript/Referencia/Objectes_globals/Array/every +translation_of: Web/JavaScript/Reference/Global_Objects/Array/every +--- +<div>{{JSRef}}</div> + +<p>El mètode <code><strong>every()</strong></code> comprova si tots els elements d'un array passen el test implementat per la funció proporcionada.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>arr</var>.every(<var>callback</var>[, <var>thisArg</var>])</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>callback</code></dt> + <dd>Funció utilitzada com a test per a cada element, rep tres arguments: + <dl> + <dt><code>valorActual</code></dt> + <dd>L'element de l'array que està sent avaluat.</dd> + <dt><code>posició</code></dt> + <dd>La posició que l'element passat al primer paràmetre ocupa dins l'array.</dd> + <dt><code>array</code></dt> + <dd>L'array des del que s'ha cridat el mètode <code>every()</code>.</dd> + </dl> + </dd> + <dt><code>thisArg</code></dt> + <dd>Opcional. Valor que valdrà la variable <code>this</code> quan s'estigui executant la funció <code>callback</code>.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p><code>every()</code> executa la funció <code>callback</code> un cop per a cada element present a l'array fins que troba un per al qual <code>callback</code> retorna un valor <em>falsy</em> (és a dir, un valor que esdebé fals si es realitza una conversió de tipus a <code>Boolean</code>). Si es troba aquest element, el mètode <code>every</code> retorna immediatament <code>false</code>. En cas contrari, si <code>callback</code> ha retornat un valor <code>true</code> per a tots els elements, <code>every</code> retornarà <code>true</code>. Només s'invocarà la funció <code>callback</code> en les posicions de l'array que tinguin un valor assignat, és a dir, mai es cridarà per a posicions que han estat esborrades o el valor de les quals no ha estat mai assignat.</p> + +<p>S'invoca <code>callback</code> amb tres arguments: el valor de l'element, la posició de l'element dins l'array, i l'objecte array que es recorrerà.</p> + +<p>Si es proporciona el paràmetre <code>thisArg</code> al mètode <code>every()</code>, aquest es passarà a <code>callback</code> quan s'invoqui, i serà el valor que mostrarà la variable <code>this</code>. En cas contrari, s'utilitzarà el valor <a href="https://developer.mozilla.org/ca/docs/Web/JavaScript/Referencia/Objectes_globals/undefined" title="El valor de la propietat global undefined representa el valor undefined. És un dels tipus primitius de JavaScript."><code>undefined</code></a> com a valor per a <code>this</code>. El valor de <code>this</code> observable en última instància per <code>callback</code> es determinarà d'acord a <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/this">les regles per a determinar el valor de <code>this</code> observat per una funció</a>.</p> + +<p><code>every()</code> no mutarà l'array quan sigui cridada.</p> + +<p>El rang d'elements processat per <code>every()</code> és determinat abans de la primera invocació de <code>callback</code>. Els elements que s'afegeixin a l'array després de la crida a <code>every()</code> no seran visitats per <code>callback</code>. Si el valor d'un element encara no visitat canvia, el valor que es passarà a <code>callback</code> serà el valor que tingui aquest element a l'hora de visitar-lo; els elements que s'esborrin no es visitaran.</p> + +<p><code>every</code> es comporta com un quantificador "for all" en matemàtiques. En concret, per a un array buit retornarà <code>true</code> (s'anomena <a href="http://en.wikipedia.org/wiki/Vacuous_truth#Vacuous_truths_in_mathematics">veritat per buit</a> el fet que tots els elements d'un <a href="http://en.wikipedia.org/wiki/Empty_set#Common_problems">grup buit</a> satisfacin qualsevol condició donada).</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Comprovar_el_tamany_de_tots_els_elements_d'un_array">Comprovar el tamany de tots els elements d'un array</h3> + +<p>L'exemple següent comprova si tots els elements d'un array son majors de 10.</p> + +<pre class="brush: js">function isBigEnough(element, index, array) { + return element >= 10; +} +[12, 5, 8, 130, 44].every(isBigEnough); // false +[12, 54, 18, 130, 44].every(isBigEnough); // true +</pre> + +<h3 id="Utilitzar_funcions_flexta">Utilitzar funcions flexta</h3> + +<p><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions">Les funcions fletxa</a> ofereixen una sintaxi reduïda per a realitzar el mateix test.</p> + +<pre class="brush: js">[12, 5, 8, 130, 44].every(elem => elem >= 10); // false +[12, 54, 18, 130, 44].every(elem => elem >= 10); // true</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p><code>every</code> va ser afegida al standard ECMA-262 en la cinquena edició; és per això que pot no estar disponible en certes implementacions del standard. Es pot proporcionar la seva funcionalitat inserint l'script següent a l'inici dels vostres scripts, permetent l'ús de <code>every()</code> en implementacions que no la suporten de forma nativa. Aquest algoritme és exactament l'especificat a l'ECMA-262, cinquena edició, assumint que <a class="new" href="https://developer.mozilla.org/ca/docs/Web/JavaScript/Referencia/Object" title="Aquesta pàgina encara no ha estat traduïda. Si us plau considera contribuir-hi!"><code>Object</code></a> i <a href="https://developer.mozilla.org/ca/docs/Web/JavaScript/Referencia/Objectes_globals/TypeError" title="L'objecte TypeError representa un error quan el valor no és del tipus esperat."><code>TypeError</code></a> tenen els valors originals i que <code>callbackfn.call</code> es correspon amb el valor original de {{jsxref("Function.prototype.call")}}.</p> + +<pre class="brush: js">if (!Array.prototype.every) { + Array.prototype.every = function(callbackfn, thisArg) { + 'use strict'; + var T, k; + + if (this == null) { + throw new TypeError('this is null or not defined'); + } + + // 1. Let O be the result of calling ToObject passing the this + // value as the argument. + var O = Object(this); + + // 2. Let lenValue be the result of calling the Get internal method + // of O with the argument "length". + // 3. Let len be ToUint32(lenValue). + var len = O.length >>> 0; + + // 4. If IsCallable(callbackfn) is false, throw a TypeError exception. + if (typeof callbackfn !== 'function') { + throw new TypeError(); + } + + // 5. If thisArg was supplied, let T be thisArg; else let T be undefined. + if (arguments.length > 1) { + T = thisArg; + } + + // 6. Let k be 0. + k = 0; + + // 7. Repeat, while k < len + while (k < len) { + + var kValue; + + // a. Let Pk be ToString(k). + // This is implicit for LHS operands of the in operator + // b. Let kPresent be the result of calling the HasProperty internal + // method of O with argument Pk. + // This step can be combined with c + // c. If kPresent is true, then + if (k in O) { + + // i. Let kValue be the result of calling the Get internal method + // of O with argument Pk. + kValue = O[k]; + + // ii. Let testResult be the result of calling the Call internal method + // of callbackfn with T as the this value and argument list + // containing kValue, k, and O. + var testResult = callbackfn.call(T, kValue, k, O); + + // iii. If ToBoolean(testResult) is false, return false. + if (!testResult) { + return false; + } + } + k++; + } + return true; + }; +} +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificaicó</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.4.4.16', 'Array.prototype.every')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Definició inicial. Implemnetat a JavaScript 1.6.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype.every', 'Array.prototype.every')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype.every', 'Array.prototype.every')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<div>{{CompatibilityTable}}</div> + +<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>{{CompatGeckoDesktop("1.8")}}</td> + <td>{{CompatIE("9")}}</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>{{CompatGeckoMobile("1.8")}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Array.prototype.forEach()")}}</li> + <li>{{jsxref("Array.prototype.some()")}}</li> + <li>{{jsxref("TypedArray.prototype.every()")}}</li> +</ul> diff --git a/files/ca/web/javascript/reference/global_objects/array/fill/index.html b/files/ca/web/javascript/reference/global_objects/array/fill/index.html new file mode 100644 index 0000000000..e1952a8407 --- /dev/null +++ b/files/ca/web/javascript/reference/global_objects/array/fill/index.html @@ -0,0 +1,173 @@ +--- +title: Array.prototype.fill() +slug: Web/JavaScript/Referencia/Objectes_globals/Array/fill +translation_of: Web/JavaScript/Reference/Global_Objects/Array/fill +--- +<div>{{JSRef}}</div> + +<p>El mètode <code><strong>fill()</strong></code> omple tots els elements d'un array a partir d'una posició inicial fins a una posició final amb un valor estàtic predeterminat.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>arr</var>.fill(valor[, <var>posInicial <var>= 0[, posFinal = this.length]])</var></var></code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>valor</code></dt> + <dd>Valor amb el que s'omplirà l'array.</dd> + <dt><code>posInicial</code></dt> + <dd>Opcional. Posició inicial.</dd> + <dt><code>posFinal</code></dt> + <dd>Opcional. Posició final.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>L'interval d'elements a omplir és <code>[posInicial, posFinal)</code> (inici inclusiu, final exclusiu).</p> + +<p>El mètode <strong><code>fill</code></strong> accepta fins a tres arguments: <code>valor</code>, <code>posInicial</code> i <code>posFinal.</code></p> + +<p>Els arguments <code>posInicial</code> i <code>posFinal</code> són opcionals i si no s'especifiquen prenen per defecte els valors <code>0</code> i la propietat <code>length</code> de l'objecte <code>this</code>, respectivament.</p> + +<p>Si <code>posInicial</code> és negatiu, es considera com a <code>length+start</code> on <code>length</code> és la mida de l'array. Si <code>posFinal</code> és negatiu es considera com a <code>length+end</code>.</p> + +<p>La funció <strong>fill</strong> és genèrica intencionalment i no requereix que el valor <code>this</code> sigui un objecte de tipus <code>Array</code>.</p> + +<p>El mètode <strong>fill</strong> és mutable, ja que canviarà l'objecte <code>this</code> en si mateix i després el retornarà com a resultat, en comptes de retornar una copia d'aquest.</p> + +<h2 id="Exemples">Exemples</h2> + +<pre class="brush: js">[1, 2, 3].fill(4); // [4, 4, 4] +[1, 2, 3].fill(4, 1); // [1, 4, 4] +[1, 2, 3].fill(4, 1, 2); // [1, 4, 3] +[1, 2, 3].fill(4, 1, 1); // [1, 2, 3] +[1, 2, 3].fill(4, -3, -2); // [4, 2, 3] +[1, 2, 3].fill(4, NaN, NaN); // [1, 2, 3] +Array(3).fill(4); // [4, 4, 4] +[].fill.call({ length: 3 }, 4); // {0: 4, 1: 4, 2: 4, length: 3} +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<pre class="brush: js">if (!Array.prototype.fill) { + Array.prototype.fill = function(value) { + + // Pasos 1-2. + if (this == null) { + throw new TypeError('this is null or not defined'); + } + + var O = Object(this); + + // Pasos 3-5. + var len = O.length >>> 0; + + // Pasos 6-7. + var start = arguments[1]; + var relativeStart = start >> 0; + + // Pasos 8. + var k = relativeStart < 0 ? + Math.max(len + relativeStart, 0) : + Math.min(relativeStart, len); + + // Pasos 9-10. + var end = arguments[2]; + var relativeEnd = end === undefined ? + len : end >> 0; + + // Pasos 11. + var final = relativeEnd < 0 ? + Math.max(len + relativeEnd, 0) : + Math.min(relativeEnd, len); + + // Pasos 12. + while (k < final) { + O[k] = value; + k++; + } + + // Pasos 13. + return O; + }; +} +</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-array.prototype.fill', 'Array.prototype.fill')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definició inicial.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<div>{{CompatibilityTable}}</div> + +<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("45")}} [1]</td> + <td>{{CompatGeckoDesktop("31")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatSafari("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>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatGeckoMobile("31")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8.0</td> + </tr> + </tbody> +</table> +</div> + +<p>[1] A partir del Chrome 36, està disponible a través d'una preferència. A chrome://flags, activeu l'entrada “Enable Experimental JavaScript”.</p> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Array")}}</li> + <li>{{jsxref("TypedArray.prototype.fill()")}}</li> +</ul> diff --git a/files/ca/web/javascript/reference/global_objects/array/filter/index.html b/files/ca/web/javascript/reference/global_objects/array/filter/index.html new file mode 100644 index 0000000000..c1bfec77f3 --- /dev/null +++ b/files/ca/web/javascript/reference/global_objects/array/filter/index.html @@ -0,0 +1,213 @@ +--- +title: Array.prototype.filter() +slug: Web/JavaScript/Referencia/Objectes_globals/Array/filter +translation_of: Web/JavaScript/Reference/Global_Objects/Array/filter +--- +<div>{{JSRef}}</div> + +<p>El mètode <code><strong>filter()</strong></code> crea un nou array amb tots els elements que passin el test implementat per la funció que passa com a argument.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>arr</var>.filter(<var>callback</var>[, <var>thisArg</var>])</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>callback</code></dt> + <dd>Funció que s'emprarà per a testejar cada element de l'array. Aquesta serà invocada amb els arguments <code>(element, posició, array)</code>. Ha de retornar <code>true</code> per als elements que es vulguin conservar i <code>false</code> en qualsevol altre cas.</dd> + <dt><code>element</code></dt> + <dd>El element actual que s'esta processant a l'Array.</dd> + <dt><code>thisArg</code></dt> + <dd>Opcional. Valor que rebrà <code>this</code> durant l'execució de la funció <code>callback</code>.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p><code>filter()</code> crida la funció <code>callback</code> proporcionada un cop per cada element de l'array, i construeix un nou array amb tots els elements per als quals la funció <code>callback</code> retorni el valor <code>true</code> o bé <a href="/en-US/docs/Glossary/Truthy">un valor que pugui ser interpretat com a <code>true</code></a>. Només escridarà la funció <code>callback</code> per a posicions de l'array que tinguin valors assignats; no es cridarà per a posicions que han estat esborrades o que mai hagin tingut assignat un element. Els elements que no passsin el test de <code>callback</code> seràn simplement ignorats i en cap cas seran afegits al nou array.</p> + +<p>S'invoca <code>callback</code> tot passant-li els tres arguments següents:</p> + +<ol> + <li>el valor de l'element</li> + <li>la posició de l'element</li> + <li>L'objecte array que s'està recorrent</li> +</ol> + +<p>Si es proporciona el paràmetre <code>thisArg</code> a la crida de <code>filter</code>, aquest es passarà a <code>callback</code> quan s'invoqui per a ser utilitzat com a <code>this</code> dins la funció. En qualsevol altre cas el valor que rebrà <code>this</code> dins la funció <code>callback</code> serà <code>undefined</code>. El valor de <code>this</code> que serà finalment observable dins de <code>callback</code> és determinat d'acord a <a href="/en-US/docs/Web/JavaScript/Reference/Operators/this">les regles habituals per a determinar el valor de <code>this</code> observat dins d'una funció</a>.</p> + +<p><code>filter()</code> mai modificarà l'array des del qual s'invoca.</p> + +<p>El rang dels elements processats per <code>filter()</code> es determina abans de la primera invocació de <code>callback</code>. Els elements que s'afegeixin a l'array un cop la crida a <code>filter()</code> hagi començat no seran visibles per a <code>callback</code>. Els elements que es modifiquin o s'esborrin durant aquest periode tindran el valor que els hi pertoqui al moment de cridar la funció <code>callback</code>; els elements que s'hagin eliminat no es visitaran.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Exemple_Descartar_tots_els_valors_petits">Exemple: Descartar tots els valors petits</h3> + +<p>L'exemple següent utilitza <code>filter()</code> per a crear un array filtrat que contindrà tots els elements amb valors menors de 10.</p> + +<pre class="brush: js">function esProuGran(valor) { + return valor >= 10; +} +var filtrat = [12, 5, 8, 130, 44].filter(esProuGran); +// filtrat val [12, 130, 44] +</pre> + +<h3 id="Exemple_Descartar_entrades_invàlides_de_JSON">Exemple: Descartar entrades invàlides de JSON</h3> + +<p>L'exemple següent utilitza <code>filter()</code> per a crear un array que no contingui cap entrada de JSON amb una <code>id</code> numèrica no vàlida o amb valor menor que zero.</p> + +<pre class="brush: js">var arr = [ + { id: 15 }, + { id: -1 }, + { id: 0 }, + { id: 3 }, + { id: 12.2 }, + { }, + { id: null }, + { id: NaN }, + { id: 'undefined' } +]; + +var invalidEntries = 0; + +function filterByID(obj) { + if ('id' in obj && typeof(obj.id) === 'number' && !isNaN(obj.id)) { + return true; + } else { + invalidEntries++; + return false; + } +} + +var arrByID = arr.filter(filterByID); + +console.log('Array filtrat\n', arrByID); +// [{ id: 15 }, { id: -1 }, { id: 0 }, { id: 3 }, { id: 12.2 }] + +console.log('Nombre d'entrades invàlides = ', invalidEntries); +// 4 +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p><code>filter()</code> va ser afegit al standard ECMA-262 a la cinquena edició; degut a això aquesta funció pot no ser present a totes les implementacions del standard. Es pot solucionar aquest problema inserint el codi següent al principi dels scripts, permetent l'ús de <code>filter()</code> en implementacions de l'ECMA-262 que no la incorporin per defecte. Aquest algoritme és exactament l'especificat per l'ECMA-262, 5a edició, i assumeix que <code>fn.call</code> s'evalua al valor original de {{jsxref("Function.prototype.call()")}} i que {{jsxref("Array.prototype.push()")}} te el seu valor original.</p> + +<pre class="brush: js">if (!Array.prototype.filter) { + Array.prototype.filter = function(fun/*, thisArg*/) { + 'use strict'; + + if (this === void 0 || this === null) { + throw new TypeError(); + } + + var t = Object(this); + var len = t.length >>> 0; + if (typeof fun !== 'function') { + throw new TypeError(); + } + + var res = []; + var thisArg = arguments.length >= 2 ? arguments[1] : void 0; + for (var i = 0; i < len; i++) { + if (i in t) { + var val = t[i]; + + // NOTA: Tècnicament hauria de ser Object.defineProperty + // a la posició següent ja que push pot veure's afectat per + // les propietats de Object.prototype i Array.prototype. + // Però aquest mètode és nou i només hi haurà col·lisions + // en casos excepcionals, aixíq ue utilitzem l'alternativa més compatible. + if (fun.call(thisArg, val, i, t)) { + res.push(val); + } + } + } + + return res; + }; +} +</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('ES5.1', '#sec-15.4.4.20', 'Array.prototype.filter')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Definició inicial. Implementat a JavaScript 1.6.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype.filter', 'Array.prototype.filter')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<div>{{CompatibilityTable}}</div> + +<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>{{CompatGeckoDesktop("1.8")}}</td> + <td>{{CompatIE("9")}}</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>{{CompatGeckoMobile("1.8")}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Array.prototype.forEach()")}}</li> + <li>{{jsxref("Array.prototype.every()")}}</li> + <li>{{jsxref("Array.prototype.some()")}}</li> + <li>{{jsxref("Array.prototype.reduce()")}}</li> +</ul> diff --git a/files/ca/web/javascript/reference/global_objects/array/find/index.html b/files/ca/web/javascript/reference/global_objects/array/find/index.html new file mode 100644 index 0000000000..8ee7742c09 --- /dev/null +++ b/files/ca/web/javascript/reference/global_objects/array/find/index.html @@ -0,0 +1,191 @@ +--- +title: Array.prototype.find() +slug: Web/JavaScript/Referencia/Objectes_globals/Array/find +translation_of: Web/JavaScript/Reference/Global_Objects/Array/find +--- +<div>{{JSRef}}</div> + +<p>El mètode <code><strong>find()</strong></code> retorna un valor <strong>valor</strong> pertanyent a l'array si un element de l'array satisfà la funció de testeig donada. En cas contrari retornarà {{jsxref("undefined")}}.</p> + +<p>Vegeu també el mètode {{jsxref("Array.findIndex", "findIndex()")}}, que retorna la posició a la qual s'ha trobat l'element que satisfà la funció de testeig, en comptes del seu valor.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>arr</var>.find(<var>callback</var>[, <var>thisArg</var>])</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>callback</code></dt> + <dd>Funció que s'executarà per a cada valor de l'array, rep tres arguments: + <dl> + <dt><code>element</code></dt> + <dd>L'element de l'array que s'està processant actualment.</dd> + <dt><code>posició</code></dt> + <dd>La posició de l'array que s'està processant actualment.</dd> + <dt><code>array</code></dt> + <dd>L'array des del qual s'ha cridat el mètode <code>find</code>.</dd> + </dl> + </dd> + <dt><code>thisArg</code></dt> + <dd>Opcional. L'objecte a utilitzar com a <code>this</code> mentre s'executi <code>callback</code>.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>El mètode <code>find</code> executa la funció <code>callback</code> un cop per a cada element present a l'array fins que trobi un on <code>callback</code> retorni <code>true</code>. Si es troba aquest element el mètode <code>find</code> retorna el valor de l'element trobat immediatament. En cas contrari <code>find</code> retornarà {{jsxref("undefined")}}. <code>callback</code> només serà invocada per a posicions de l'array que tinguin valors assignats; no serà invoada per a posicions que s'hagin eliminat o que mai hagin tingut assignat un valor.</p> + +<p>La invocaicó de <code>callback</code> té tres arguments: el valor de l'element, la posició de l'element i l'objecte array que està sent recorregut.</p> + +<p>Si es proporciona el paràmetre <code>thisArg</code> al cridar el mètode <code>find</code>, aquest serà utilitzat com a <code>this</code> per a cada invocació del mètode <code>callback</code>. En cas de no ser proporcionat s'utilitzarà {{jsxref("undefined")}}.</p> + +<p><code>find</code> no mutarà l'array des del que es crida.</p> + +<p>El rang d'elemnets que <code>find</code> processarà es determina abans de la primera invocació a <code>callback</code>. Els elements afegits a l'array després de la crida a <code>find</code> no seran visitats per <code>callback</code>. Si un element existent, no visitat encara, rep un altre valor, el valor percebut per <code>callback</code> serà aquell que tingui l'element al ser visitat; els elements visitats no són visitats.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Trobar_un_objecte_en_un_array_segons_el_valor_d'una_propietat">Trobar un objecte en un array segons el valor d'una propietat</h3> + +<pre class="brush: js">var inventory = [ + {name: 'apples', quantity: 2}, + {name: 'bananas', quantity: 0}, + {name: 'cherries', quantity: 5} +]; + +function findCherries(fruit) { + return fruit.name === 'cherries'; +} + +console.log(inventory.find(findCherries)); // { name: 'cherries', quantity: 5 }</pre> + +<h3 id="Trobar_un_nombre_primer_en_un_array">Trobar un nombre primer en un array</h3> + +<p>L'exemple següent troba un element dins l'array el valor del qual sigui un nombre primer (o bé retorna {{jsxref("undefined")}} si no n'hi ha cap).</p> + +<pre class="brush: js">function isPrime(element, index, array) { + var start = 2; + while (start <= Math.sqrt(element)) { + if (element % start++ < 1) { + return false; + } + } + return element > 1; +} + +console.log([4, 6, 8, 12].find(isPrime)); // undefined, no trobat +console.log([4, 5, 8, 12].find(isPrime)); // 5 +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Aquest mètode es va afegira la especificació 2015 de l'ECMAScript i pot no estar disponible encara en algunes implementacions de JavaScript. Tot i així es pot utilitzar el codi següent per a utilitzar-lo en entorns on no estigui disponible:</p> + +<pre class="brush: js">if (!Array.prototype.find) { + Array.prototype.find = function(predicate) { + if (this === null) { + throw new TypeError('Array.prototype.find called on null or undefined'); + } + if (typeof predicate !== 'function') { + throw new TypeError('predicate must be a function'); + } + var list = Object(this); + var length = list.length >>> 0; + var thisArg = arguments[1]; + var value; + + for (var i = 0; i < length; i++) { + value = list[i]; + if (predicate.call(thisArg, value, i, list)) { + return value; + } + } + return undefined; + }; +} +</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-array.prototype.find', 'Array.prototype.find')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definició inicial.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype.find', 'Array.prototype.find')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<div>{{CompatibilityTable}}</div> + +<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>Edge</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatChrome(45.0)}}</td> + <td>{{CompatGeckoDesktop("25.0")}}</td> + <td>{{CompatNo}}</td> + <td>12</td> + <td>{{CompatNo}}</td> + <td>{{CompatSafari("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>Edge</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatGeckoMobile("25.0")}}</td> + <td>{{CompatNo}}</td> + <td>12</td> + <td>{{CompatNo}}</td> + <td>8.0</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Array.prototype.findIndex()")}}</li> + <li>{{jsxref("Array.prototype.every()")}}</li> +</ul> diff --git a/files/ca/web/javascript/reference/global_objects/array/findindex/index.html b/files/ca/web/javascript/reference/global_objects/array/findindex/index.html new file mode 100644 index 0000000000..5b089bdb98 --- /dev/null +++ b/files/ca/web/javascript/reference/global_objects/array/findindex/index.html @@ -0,0 +1,173 @@ +--- +title: Array.prototype.findIndex() +slug: Web/JavaScript/Referencia/Objectes_globals/Array/findIndex +translation_of: Web/JavaScript/Reference/Global_Objects/Array/findIndex +--- +<div>{{JSRef}}</div> + +<p>El mètode <code><strong>findIndex()</strong></code> retorna una <strong>posició</strong> de l'array si un element de l'array satisfà la funció de testeig donada. En cas contrari retornarà -1.</p> + +<p>Vegeu també el mètode {{jsxref("Array.find", "find()")}}, que retorna el <strong>valor</strong> trobat dins l'array en comptes de la posició.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>arr</var>.findIndex(<var>callback</var>[, <var>thisArg</var>])</code></pre> + +<h3 id="Parameters">Parameters</h3> + +<dl> + <dt><code>callback</code></dt> + <dd>Funció que s'executarà per a cada valor de l'array, rep tres arguments: + <dl> + <dt><code>element</code></dt> + <dd>L'element de l'array que s'està processant actualment.</dd> + <dt><code>posició</code></dt> + <dd>La posició de l'array que s'està processant actualment.</dd> + <dt><code>array</code></dt> + <dd>L'array des del qual s'ha cridat el mètode <code>find</code>.</dd> + </dl> + </dd> + <dt><code>thisArg</code></dt> + <dd>Opcional. L'objecte a utilitzar com a <code>this</code> mentre s'executi <code>callback</code>.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>El mètode <code>findIndex</code> executa la funció <code>callback</code> un cop per a cada element present a l'array fins que trobi un on <code>callback</code> retorni <code>true</code>. Si es troba aquest element el mètode <code>findIndex</code> retorna la posició de l'element trobat immediatament. En cas contrari <code>findIndex</code> retornarà -1. <code>callback</code> només serà invocada per a posicions de l'array que tinguin valors assignats; no serà invoada per a posicions que s'hagin eliminat o que mai hagin tingut assignat un valor.</p> + +<p>La invocaicó de <code>callback</code> té tres arguments: el valor de l'element, la posició de l'element i l'objecte array que està sent recorregut.</p> + +<p>Si es proporciona el paràmetre <code>thisArg</code> al cridar el mètode <code>findIndex</code>, aquest serà utilitzat com a <code>this</code> per a cada invocació del mètode <code>callback</code>. En cas de no ser proporcionat s'utilitzarà {{jsxref("undefined")}}.</p> + +<p><code>findIndex</code> no mutarà l'array des del que es crida.</p> + +<p>El rang d'elemnets que <code>findIndex</code> processarà es determina abans de la primera invocació a <code>callback</code>. Els elements afegits a l'array després de la crida a <code>findIndex</code> no seran visitats per <code>callback</code>. Si un element existent, no visitat encara, rep un altre valor, el valor percebut per <code>callback</code> serà aquell que tingui l'element al ser visitat; els elements visitats no són visitats.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Trobar_la_posició_d'un_nombre_primer_dins_un_array">Trobar la posició d'un nombre primer dins un array</h3> + +<p>L'exemple següent trobarà la posició d'un element de l'array que sigui un nombre primer (o bé retornarà -1 si no n'hi ha cap).</p> + +<pre class="brush: js">function isPrime(element, index, array) { + var start = 2; + while (start <= Math.sqrt(element)) { + if (element % start++ < 1) { + return false; + } + } + return element > 1; +} + +console.log([4, 6, 8, 12].findIndex(isPrime)); // -1, not found +console.log([4, 6, 7, 12].findIndex(isPrime)); // 2 +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Aquest mètode es va afegir a la especificació 6 de l'ECMAScript i pot no estar disponible encara en algunes implementacions de JavaScript. Tot i així es pot utilitzar el codi següent per a utilitzar-lo en entorns on no estigui disponible:</p> + +<pre class="brush: js">if (!Array.prototype.findIndex) { + Array.prototype.findIndex = function(predicate) { + if (this === null) { + throw new TypeError('Array.prototype.findIndex called on null or undefined'); + } + if (typeof predicate !== 'function') { + throw new TypeError('predicate must be a function'); + } + var list = Object(this); + var length = list.length >>> 0; + var thisArg = arguments[1]; + var value; + + for (var i = 0; i < length; i++) { + value = list[i]; + if (predicate.call(thisArg, value, i, list)) { + return i; + } + } + return -1; + }; +} +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype.findIndex', 'Array.prototype.findIndex')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definició inicial.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype.findIndex', 'Array.prototype.findIndex')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<div>{{CompatibilityTable}}</div> + +<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(45.0)}}</td> + <td>{{CompatGeckoDesktop("25.0")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatSafari("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>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatGeckoMobile("25.0")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8.0</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Array.prototype.find()")}}</li> + <li>{{jsxref("Array.prototype.indexOf()")}}</li> +</ul> diff --git a/files/ca/web/javascript/reference/global_objects/array/foreach/index.html b/files/ca/web/javascript/reference/global_objects/array/foreach/index.html new file mode 100644 index 0000000000..4d391346eb --- /dev/null +++ b/files/ca/web/javascript/reference/global_objects/array/foreach/index.html @@ -0,0 +1,238 @@ +--- +title: Array.prototype.forEach() +slug: Web/JavaScript/Referencia/Objectes_globals/Array/forEach +translation_of: Web/JavaScript/Reference/Global_Objects/Array/forEach +--- +<div>{{JSRef}}</div> + +<p>El mètode <code><strong>forEach()</strong></code> executa la funció rebuda un cop per cada element de l'array.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>arr</var>.forEach(<var>callback</var>[, <var>thisArg</var>])</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>callback</code></dt> + <dd>Funció a executar per a cada element. Aquesta funció rebrà tres paràmetres: + <dl> + <dt><code>valor</code></dt> + <dd>L'element que s'està processant ara mateix a l'array.</dd> + <dt><code>posició</code></dt> + <dd>La posició que l'element actual ocupa dins l'array.</dd> + <dt><code>array</code></dt> + <dd>L'array al qual el mètode <code>forEach</code> s'aplica.</dd> + </dl> + </dd> + <dt><code>thisArg</code></dt> + <dd>Opcional. Valor que s'utilitzarà com a <code>this</code> a l'hora d'executar la funció <code>callback</code>.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p><code>forEach()</code> executa la funció <code>callback</code> rebuda com a argument un cop per cada element present a l'array, en ordre ascendent. No es cridarà la funció per a elements que s'hagin eliminat o que no hagin rebut cap valor (és a dir, arrays disperses).</p> + +<p>S'invocarà <code>callback</code> amb els <strong>tres arguments</strong> següents:</p> + +<ul> + <li>el <strong>valor de l'element</strong></li> + <li>la <strong>posició de l'element</strong></li> + <li>L'<strong>array que s'està recorrent</strong></li> +</ul> + +<p>Si es proporciona el paràmetre <code>thisArg</code> a <code>forEach()</code>, aquest es passarà a <code>callback</code> quan es cridi, i es podrà accedir a ell mitjançant la paraula clau <code>this</code>. En el cas que no es proporcioni el paràmetre <code>this</code> rebrà el valor {{jsxref("undefined")}}. El valor de <code>this</code> que serà observable per <code>callback</code> es determina d'acord a les <a href="/en-US/docs/Web/JavaScript/Reference/Operators/this">regles usuals per a determinar el valor de <code>this</code> que una funció veu</a>.</p> + +<p>El rang dels elements processats per <code>forEach()</code> és determinat abans de la primera invocació de <code>callback</code>. Els elements que s'afegeixin a l'array després de la crida a <code>forEach()</code> no seran visitats per la funció <code>callback</code>. En el cas que es canviï el valor dels elements de l'array el valor que es passarà a <code>callback</code> serà el valor que tingui l'element en el moment que es visita. Els elements que s'han eliminat abans de ser visitats no es visitaran.</p> + +<p><code>forEach()</code> executa la funció <code>callback</code> un cop per cada element de l'array; a diferència de {{jsxref("Array.prototype.map()", "map()")}} i {{jsxref("Array.prototype.reduce()", "reduce()")}}, sempre retorna el valor {{jsxref("undefined")}} i no es pot encadenar. El cas d'ús típic és per executar efectes secundaris al final de la cadena.</p> + +<div class="note"> +<p><strong>Nota:</strong> L'única forma d'aturar un bucle <code>forEach()</code> és llençar una excepció. Si es requereix aquesta funcionalitat llavors el mètode <code>.forEach()</code> és l'eina incorrecta i es recomana utilitzar un bucle normal. Si el que es pretén és validar els elements d'un array contra un predicat i es requereix retornar un valor booleà, es recomana utilitzar la funció {{jsxref("Array.prototype.every()", "every()")}} o bé {{jsxref("Array.prototype.some()", "some()")}}.</p> +</div> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Imprimir_el_contingut_d'un_array">Imprimir el contingut d'un array</h3> + +<p>El codi següent mostra una línia per a cada element de l'array:</p> + +<pre class="brush:js">function logArrayElements(element, index, array) { + console.log('a[' + index + '] = ' + element); +} + +// Cal destacar l'omissió, no hi ha cap element a la posició 2 així que aquesta no es visita +[2, 5, , 9].forEach(logArrayElements); +// Mostra: +// a[0] = 2 +// a[1] = 5 +// a[3] = 9 +</pre> + +<h3 id="Una_funció_per_a_copiar_objectes">Una funció per a copiar objectes</h3> + +<p>El codi següent crea una copia de l'objecte donat. Hi ha diverses formes de crear una copia d'un objecte, la forma següent és simplement una d'elles i es presenta per a explicar com funciona <code>Array.prototype.forEach()</code> tot utilitzant les funcions de meta-propietats de l'ECMAScript 5 a <code>Object.*</code></p> + +<pre class="brush: js">function copy(obj) { + var copy = Object.create(Object.getPrototypeOf(obj)); + var propNames = Object.getOwnPropertyNames(obj); + + propNames.forEach(function(name) { + var desc = Object.getOwnPropertyDescriptor(obj, name); + Object.defineProperty(copy, name, desc); + }); + + return copy; +} + +var obj1 = { a: 1, b: 2 }; +var obj2 = copy(obj1); // obj2 looks like o1 now +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p><code>forEach()</code> va ser afegida l'standard ECMA-262 en la cinquena edició; per aquest motiu aquesta funció pot no estar present en altres implementacions de l'standard. Es pot solventar aquest problema inserint el codi següent a l'inici dels vostres scripts. Això permetrà l'ús de <code>forEach()</code> en implementacions que no el suportin de forma nativa. Aquest algoritme és el mateix que l'especificat a l'ECMA-262, cinquena edició, si assumim que {{jsxref("Object")}} i {{jsxref("TypeError")}} tenen els seus valors originals i que <code>callback.call</code> es resol com al valor original de {{jsxref("Function.prototype.call()")}}.</p> + +<pre class="brush: js">// Production steps of ECMA-262, Edition 5, 15.4.4.18 +// Reference: http://es5.github.io/#x15.4.4.18 +if (!Array.prototype.forEach) { + + Array.prototype.forEach = function(callback, thisArg) { + + var T, k; + + if (this == null) { + throw new TypeError(' this is null or not defined'); + } + + // 1. Assignem a O el resultat de cridar ToObject tot passant-li el valor de |this| com a argument. + var O = Object(this); + + // 2. lenValue representa el resultat de cridar el mètode intern Get de O amb l'argument "length". + // 3. Assignem a len el valor ToUint32(lenValue). + var len = O.length >>> 0; + + // 4. Si IsCallable(callback) és false, llençem una excepció TypeError. + // Vegeu: http://es5.github.com/#x9.11 + if (typeof callback !== "function") { + throw new TypeError(callback + ' no és una funció'); + } + + // 5. Si s'ha passat thisArg com a aragument, assignem el seu valor a la variable T, en qualsevol altre cas deixem T com a undefined. + if (arguments.length > 1) { + T = thisArg; + } + + // 6. Assignem 0 a la variable k + k = 0; + + // 7. Repetir, mentre k < len + while (k < len) { + + var kValue; + + // a. Assignem ToString(k) a Pk. + // Aquest comportament és implícit per a operands al cantó esquerra (de l'anglés LHS o Left-Hand-Side) de l'operador "in"This is implicit for LHS operands of the in operator + // b. Assignem el resultat de cridar el mètode intern HasProperty de O amb l'argument Pk a la variable kPresent + // Podem combinar aquest pas amb c + // c. Si kPresent és true, llavors... + if (k in O) { + + // i. Assignem a kValue el resultat de cridar el mètode intern Get de l'objecte O amb l'argument Pk. + kValue = O[k]; + + // ii. Cridem el mètode intern "call" del callback tot passant-li T com a valor de "this" + // així com una llista d'arguments que conté kValue, k i 0 + callback.call(T, kValue, k, O); + } + // d. Incrementem el valor de k en 1. + k++; + } + // 8. retornem undefined + }; +} +</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('ES5.1', '#sec-15.4.4.18', 'Array.prototype.forEach')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Definició inicial. Implementat a JavaScript 1.6.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype.foreach', 'Array.prototype.forEach')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<div>{{CompatibilityTable}}</div> + +<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>{{CompatGeckoDesktop("1.8")}}</td> + <td>{{CompatIE("9")}}</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>{{CompatGeckoMobile("1.8")}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Map.prototype.forEach()")}}</li> + <li>{{jsxref("Set.prototype.forEach()")}}</li> + <li>{{jsxref("Array.prototype.map()")}}</li> + <li>{{jsxref("Array.prototype.every()")}}</li> + <li>{{jsxref("Array.prototype.some()")}}</li> +</ul> diff --git a/files/ca/web/javascript/reference/global_objects/array/includes/index.html b/files/ca/web/javascript/reference/global_objects/array/includes/index.html new file mode 100644 index 0000000000..9f64b0e117 --- /dev/null +++ b/files/ca/web/javascript/reference/global_objects/array/includes/index.html @@ -0,0 +1,158 @@ +--- +title: Array.prototype.includes() +slug: Web/JavaScript/Referencia/Objectes_globals/Array/includes +translation_of: Web/JavaScript/Reference/Global_Objects/Array/includes +--- +<div>{{JSRef}}</div> + +<p>El mètode <code><strong>includes()</strong></code> determina si un array inclou un element concret, retornant <code>true</code> o <code>false</code> segons s'escaigui. </p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox">var <var>boolean</var> = <var>array</var>.includes(elementCercat[, desdePosicio])</pre> + +<h3 id="Parameters">Parameters</h3> + +<dl> + <dt>elementCercat</dt> + <dd>L'element a cercar.</dd> + <dt>desdePosicio</dt> + <dd>Opcional. La posició de l'array a partir de la qual començar la cerca de <code>elementCercat</code>. Un valor negatiu cercarà el nombre absolut donat de posicions contant des del final de l'array. El seu valor per defecte és 0.</dd> +</dl> + +<h3 id="Valor_retornat">Valor retornat</h3> + +<p>Un {{jsxref("Boolean")}}.</p> + +<h2 id="Exemples">Exemples</h2> + +<pre class="brush: js">[1, 2, 3].includes(2); // true +[1, 2, 3].includes(4); // false +[1, 2, 3].includes(3, 3); // false +[1, 2, 3].includes(3, -1); // true +[1, 2, NaN].includes(NaN); // true +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<pre class="brush: js">if (!Array.prototype.includes) { + Array.prototype.includes = function(searchElement /*, fromIndex*/ ) { + 'use strict'; + var O = Object(this); + var len = parseInt(O.length) || 0; + if (len === 0) { + return false; + } + var n = parseInt(arguments[1]) || 0; + var k; + if (n >= 0) { + k = n; + } else { + k = len + n; + if (k < 0) {k = 0;} + } + var currentElement; + while (k < len) { + currentElement = O[k]; + if (searchElement === currentElement || + (searchElement !== searchElement && currentElement !== currentElement)) { // NaN !== NaN + return true; + } + k++; + } + return false; + }; +} +</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('ES7', '#sec-array.prototype.includes', 'Array.prototype.includes')}}</td> + <td>{{Spec2('ES7')}}</td> + <td>Definició inicial.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype.includes', 'Array.prototype.includes')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<div>{{CompatibilityTable}}</div> + +<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>Edge</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td> + <p>{{CompatChrome(47)}}</p> + </td> + <td>43</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>34</td> + <td>9</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Android Webview</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + <th>Chrome for Android</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatNo}}</td> + <td> + <p>{{CompatChrome(47)}}</p> + </td> + <td>43</td> + <td>{{CompatNo}}</td> + <td>34</td> + <td>9</td> + <td> + <p>{{CompatChrome(47)}}</p> + </td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("TypedArray.prototype.includes()")}}</li> + <li>{{jsxref("String.prototype.includes()")}}</li> + <li>{{jsxref("Array.prototype.indexOf()")}}</li> +</ul> diff --git a/files/ca/web/javascript/reference/global_objects/array/index.html b/files/ca/web/javascript/reference/global_objects/array/index.html new file mode 100644 index 0000000000..da7c400799 --- /dev/null +++ b/files/ca/web/javascript/reference/global_objects/array/index.html @@ -0,0 +1,482 @@ +--- +title: Array +slug: Web/JavaScript/Referencia/Objectes_globals/Array +translation_of: Web/JavaScript/Reference/Global_Objects/Array +--- +<div>{{JSRef}}</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>L'objecte de JavaScript <strong><code>Array</code></strong> és un objecte global que s'utilitza per a construir arrays; que són objectes d'al nivell que representen llistes.</p> + +<p><strong>Crear un Array</strong></p> + +<pre class="brush: js">var fruites = ["Poma", "Pera"]; + +console.log(fruites.length); +// 2 +</pre> + +<p><strong>Accedir (mitjançant la posició) a un element d'un Array</strong></p> + +<pre class="brush: js">var primer = fruites[0]; +// Poma + +var ultim = fruites[fruites.length - 1]; +// Pera +</pre> + +<p><strong>Recòrrer un Array</strong></p> + +<pre class="brush: js">fruites.forEach(function (element, index, array) { + console.log(element, index); +}); +// Poma 0 +// Pera 1 +</pre> + +<p><strong>Afegir elements al final d'un Array</strong></p> + +<pre class="brush: js">var nouTamany = fruites.push("Taronja"); +// ["Poma", "Pera", "Taronja"] +</pre> + +<p><strong>Eliminar l'element del final d'un Array</strong></p> + +<pre class="brush: js">var ultim = fruites.pop(); // Elimina Taronja (del final) +// ["Poma", "Pera"]; +</pre> + +<p><strong>Eliminar l'element de l'inici d'un Array</strong></p> + +<pre class="brush: js">var primer = fruites.shift(); // elimina Poma del principi del Array +// ["Pera"]; +</pre> + +<p><strong>Afegir un element a l'inici d'un Array</strong></p> + +<pre class="brush: js">var nouTamany = fruites.unshift("Maduixa") // Afegir al principi +// ["Maduixa", "Pera"]; +</pre> + +<p><strong>Trobar la posició d'un element del Array</strong></p> + +<pre class="brush: js">fruites.push("Mango"); +// ["Maduixa", "Pera", "Mango"] + +var pos = fruites.indexOf("Pera"); +// 1 +</pre> + +<p><strong>Eliminar un element segons la seva posició</strong></p> + +<pre class="brush: js">var elementEliminat = fruites.splice(pos, 1); // així és com s'elimina un element +// ["Maduixa", "Mango"] +</pre> + +<p><strong>Copiar un Array</strong></p> + +<pre class="brush: js">var shallowCopy = fruits.slice(); // així és com es copia +// ["Maduixa", "Mango"] +</pre> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code>[<var>element0</var>, <var>element1</var>, ..., <var>elementN</var>] +new Array(<var>element0</var>, <var>element1</var>[, ...[, <var>elementN</var>]]) +new Array(longitudArray)</code></pre> + +<dl> + <dt><code>element<em>N</em></code></dt> + <dd>S'inicialitza un array de JavaScript amb els elements donats, excepte si només es proporciona un sol argument al constructor <code>Array</code> i aquest argument és un nombre. (Vegeu a sota). Cal destacar que aquest cas especial només s'aplica a arrays de JavaScript creats mitjançant el constructor <code>Array</code> i no a literals array creats a partir de ls sintaxi de claus.</dd> + <dt><code>longitudArray</code></dt> + <dd>Si només es passa un sol argument al constructor <code>Array</code> i aquest argument és un nombre entre 0 2<sup>32</sup>-1 (inclòs), aquest retorna un nou array de JavaScript amb la longitud especificada pel nombre passat com a argument. Si l'argument és qualsevol altre nombre es llença l'excepció {{jsxref("Global_Objects/RangeError", "RangeError")}}.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Els arrays són objectes semblants a lliste el prototipus dels quals té mètodes que permeten realitzar operacions de travessa i mutació. Ni a longitud ni el tipus dels elements són fixos en els arrays de JavaScript. Com que el tamany d'un array pot canviar en qualsevol moment no es pot garantir la seva densitat. En general aquestes característiques són convenients; però si en algun cas aquestes característiques no fossin convenients es recomana considerar l'ús de arrays amb tipus.</p> + +<p>Algunes persones creuen que <a class="external" href="http://www.andrewdupont.net/2006/05/18/javascript-associative-arrays-considered-harmful/">no s'hauria de fer ús de arrays com amb finalitats associatives</a>. En qualsevol cas sempre es pot utilitzar senzillament un {{jsxref("Global_Objects/Object", "objects")}} per a tal fet instead, tot i que fer-ho també té els seus inconvenients. Vegeu el post <a class="external" href="http://www.less-broken.com/blog/2010/12/lightweight-javascript-dictionaries.html">Diccionaris de JavaScript lleugers amb claus arbitràries</a> per a exemple.</p> + +<h3 id="Accedir_als_elements_d'un_array">Accedir als elements d'un array</h3> + +<p>Els arrays de JavaScript comencen el compte de posició (índex) amb el zero: és a dir, el primer element d'un array ocupa la posició <code>0</code> i l'últim element d'un array es troba a l'índex amb valor del {{jsxref("Array.length", "tamany")}} de l'array menys 1.</p> + +<pre class="brush: js">var arr = ['aquest és el primer element', 'aquest és el segon element']; +console.log(arr[0]); // mostra 'aquest és el primer element' +console.log(arr[1]); // mostra 'aquest és el segon element' +console.log(arr[arr.length - 1]); // mostra 'aquest és el segon element' +</pre> + +<p>Els elements d'un array són propietats de l'objecte de la mateixa que <code>toString</code> és una propietat, però intentar accedir un element d'un array de la manera que es mostra a continuació llença un error de sintaxi, ja que el nom de la propietat no és vàlid:</p> + +<pre class="brush: js">console.log(arr.0); // error de sintaxi +</pre> + +<p>No hi ha res d'especial sobre els arrays de JavaScript i les propietats que causen aquest comportament. A JavaScript, les propietats que comencen amb un dígit no es poden referenciar amb la notació de punt; per a accedir-hi és necesari utilitzar la notació de claus. Per exemple, per a accedir a la propietat anomenada <code>'3d'</code> d'un objecte, l'única forma d'accedir-hi és mitjançant la notació de claus tal i com es mostra a continuació:</p> + +<pre class="brush: js">var anys = [1950, 1960, 1970, 1980, 1990, 2000, 2010]; +console.log(anys.0); // error de sintaxi +console.log(anys[0]); // funciona +</pre> + +<pre class="brush: js">renderer.3d.setTexture(model, 'character.png'); // error de sintaxi +renderer['3d'].setTexture(model, 'character.png'); // funciona +</pre> + +<p>Fixeu-vos que a l'exemple de <code>3d</code>, <code>'3d'</code> necessita cometes. És possible utilitzar cometes amb les posicions d'un array (per exemple, <code>anys['2']</code> en comptes de <code>anys[2]</code>), tot i que no és necesari. El 2 a <code>anys[2]</code> és transformat en un string pel motor de JavaScript implícitament mitjançant el mètode <code>toString</code>. Per aquesta raó <code>'2'</code> i <code>'02'</code> es referirien a dues propietats diferents de l'objecte <code>anys</code> i l'exemple següent podría retornar <code>true</code>:</p> + +<pre class="brush: js">console.log(anys['2'] != anys['02']); +</pre> + +<p>De la mateixa manera, les propietats d'objectes que utilitzin paraules clau com a nom(!) només es poden accedir mitjançant literals string en notació de claus (però poden accedir-se mitjançant notació de punt com a mínim al firefox 40.0a2):</p> + +<pre class="brush: js">var promise = { + 'var' : 'text', + 'array': [1, 2, 3, 4] +}; + +console.log(promise['array']); +</pre> + +<h3 id="Relació_entre_length_i_propietats_numèriques">Relació entre <code>length</code> i propietats numèriques</h3> + +<p>La propietat {{jsxref("Array.length", "length")}} dels arrays de JavaScript està relacionada amb les propietats numèriques. Diversos mètodes pertanyent de forma nativa a l'objecte array (com ara {{jsxref("Array.join", "join")}}, {{jsxref("Array.slice", "slice")}}, {{jsxref("Array.indexOf", "indexOf")}}, etcètera.) tenen en compte el valor de la propietat {{jsxref("Array.length", "length")}} quan són cridats. Altres mètodes, com ara {{jsxref("Array.push", "push")}} o {{jsxref("Array.splice", "splice")}}, també actualitzen el valor de la propietat {{jsxref("Array.length", "length")}}.</p> + +<pre class="brush: js">var fruites = []; +fruites.push('banana', 'poma', 'prèssec'); + +console.log(fruites.length); // 3 +</pre> + +<p>A l'hora d'assignar una propietat a un array de JavaScript, quan la propietat és una posició vàlida i aquesta posició cau fora dels límits que l'array té en aquell moment, el motor ha d'actualitzar la propietat {{jsxref("Array.length", "length")}} de l'array apropiadament:</p> + +<pre class="brush: js">fruites[5] = 'mango'; +console.log(fruites[5]); // 'mango' +console.log(Object.keys(fruites)); // ['0', '1', '2', '5'] +console.log(fruites.length); // 6 +</pre> + +<p>Incrementant la longitud amb {{jsxref("Array.length", "length")}}.</p> + +<pre class="brush: js">fruites.length = 10; +console.log(Object.keys(fruites)); // ['0', '1', '2', '5'] +console.log(fruites.length); // 10 +</pre> + +<p>Decrementar la propietat {{jsxref("Array.length", "length")}}, per contra, elimina elements.</p> + +<pre class="brush: js">fruites.length = 2; +console.log(Object.keys(fruites)); // ['0', '1'] +console.log(fruites.length); // 2 +</pre> + +<p>Aquest comportament s'explica amb més detall a la pàgina de {{jsxref("Array.length")}}.</p> + +<h3 id="Crear_un_array_utilitzant_el_resultat_d'una_expressió_regular">Crear un array utilitzant el resultat d'una expressió regular</h3> + +<p>El resultats obtinguts a l'aplicar una expressió regular sobre un string poden crear un array de JavaScript. Aquest array tindrà propietats i elements que ofereixen informació sobre les coincidències. Aquest tipus d'arrays és retornat pels mètodes {{jsxref("RegExp.exec")}}, {{jsxref("String.match")}}, i {{jsxref("String.replace")}}. Per a ajudar a entendre aquestes propietats i elements, vegeu l'exemple següent i la taula a continuació:</p> + +<pre class="brush: js">// Cerca una d seguida d'una o més b's seguides d'una d +// Desa les coincidències de b's amb una d a continuació +// No distingeix entre majúscules i minúscules + +var myRe = /d(b+)(d)/i; +var myArray = myRe.exec('cdbBdbsbz'); +</pre> + +<p>Les propietats i elements retornats d'aplicar aquesta expressió regular al string són les següents:</p> + +<table class="fullwidth-table"> + <tbody> + <tr> + <td class="header">Propietat/Element</td> + <td class="header">Descripció</td> + <td class="header">Exemple</td> + </tr> + <tr> + <td><code>input</code></td> + <td>Propietat només de lectura que representa el string original contra el que s'ha aplicat la expressió regular.</td> + <td>cdbBdbsbz</td> + </tr> + <tr> + <td><code>index</code></td> + <td>Propietat només de lectura que representa la posició on s'ha trobat coincidència (considerant zero la primera posició)</td> + <td>1</td> + </tr> + <tr> + <td><code>[0]</code></td> + <td>element només de lectura que especifica els últims caràcters que han coincidit.</td> + <td>dbBd</td> + </tr> + <tr> + <td><code>[1], ...[n]</code></td> + <td>Elements només de lectura que especifiquen coincidències parcials en parèntesi, si aquests s'inclouen a l'expressió regular. El nombre de possibles coincidències parcials en parèntesi és il·limitat.</td> + <td>[1]: bB<br> + [2]: d</td> + </tr> + </tbody> +</table> + +<h2 id="Propietats">Propietats</h2> + +<dl> + <dt><code>Array.length</code></dt> + <dd>La propietat de longitud del constructor de <code>Array</code>. El seu valor és 1.</dd> + <dt>{{jsxref("Array.prototype")}}</dt> + <dd>Permet l'adició de propietats a tots els objectes array.</dd> +</dl> + +<h2 id="Mètodes">Mètodes</h2> + +<dl> + <dt>{{jsxref("Array.from()")}} {{experimental_inline}}</dt> + <dd>Crea una nova instància de <code>Array</code> a partir d'un objecte iterable o un objecte similar a un array.</dd> + <dt>{{jsxref("Array.isArray()")}}</dt> + <dd>Retorna <code>true</code> si una variable és un array. En cas contrari retorna <code>false</code>.</dd> + <dt>{{jsxref("Array.observe()")}} {{experimental_inline}}</dt> + <dd>Observa de forma asíncrona canvis en Arrays, de manera similar al mètode {{jsxref("Object.observe()")}} per a objectes. Proporciona una sequència de canvis ordenats per ordre d'ocurrència.</dd> + <dt>{{jsxref("Array.of()")}} {{experimental_inline}}</dt> + <dd>Crea una nova instància de <code>Array</code> amb un nombre variable d'arguments, sense importar el nombre o tipus d'arguments.</dd> +</dl> + +<h2 id="Instàncies_de_Array">Instàncies de <code>Array</code></h2> + +<p>Totes les instàncies de <code>Array</code> hereten de {{jsxref("Array.prototype")}}. L'objecte prototipus del constructor de <code>Array</code> es pot modificar per a afectar a totes les instàncies de <code>Array</code> a l'hora.</p> + +<h3 id="Propietats_2">Propietats</h3> + +<div>{{page('/ca/docs/Web/JavaScript/Reference/Global_Objects/Array/prototype', 'Properties')}}</div> + +<h3 id="Mètodes_2">Mètodes</h3> + +<h4 id="Mètodes_de_mutació">Mètodes de mutació</h4> + +<div>{{page('ca/docs/Web/JavaScript/Reference/Global_Objects/Array/prototype', 'Mutator_methods')}}</div> + +<h4 id="Mètodes_d'accés">Mètodes d'accés</h4> + +<div>{{page('ca/docs/Web/JavaScript/Reference/Global_Objects/Array/prototype', 'Accessor_methods')}}</div> + +<h4 id="Mètodes_d'iteració">Mètodes d'iteració</h4> + +<div>{{page('ca/docs/Web/JavaScript/Reference/Global_Objects/Array/prototype', 'Iteration_methods')}}</div> + +<h2 id="Mètodes_genèrics_de_Array">Mètodes genèrics de <code>Array</code></h2> + +<div class="note"> +<p><strong>Els genèrics de Array no formen part de cap standard, estan en desús i poden ser esborrats en el futur</strong>. Noteu que no funcionen a tots els navegadors, tot i que hi ha una <a href="https://github.com/plusdude/array-generics">correcció de compatibilitat disponible a GitHub</a>.</p> +</div> + +<p>De vegades hom voldria aplicar mètodes de array a strings o altres objectes semblants a arrays (com ara la funció {{jsxref("Functions/arguments", "arguments", "", 1)}}). Per a aconseguir això, es tractaria un string com un array de caràcters (o en tot cas tractar un objecte que no sigui un array com a array). Per exemple, per a comprovar que tots els caràcters d'una variable <em>str</em> són lletres, es faria de la forma següent:</p> + +<pre class="brush: js">function isLetter(character) { + return character >= 'a' && character <= 'z'; +} + +if (Array.prototype.every.call(str, isLetter)) { + console.log("El string '" + str + "' només conté lletres!"); +} +</pre> + +<p>Aquesta notació és força molesta i JavaScript 1.6 va introduïr una abreviació genèrica:</p> + +<pre class="brush: js">if (Array.every(str, isLetter)) { + console.log("El string '" + str + "' només conté lletres!"); +} +</pre> + +<p>{{jsxref("Global_Objects/String", "Generics", "#String_generic_methods", 1)}} també estan disponibles a {{jsxref("Global_Objects/String", "String")}}.</p> + +<p>Aquests no formen actualment part de cap standard ECMAScript (tot i que es pot utilitzar el mètode {{jsxref("Array.from()")}} de l'ECMAScript 6 per a aconseguir el mateix resultat). A continuació es presenta una correcció de compatibilitat per a permetre el seu ús a qualsevol navegador:</p> + +<pre class="brush: js">// Asumeix que els extres de Array són presents (també es poden utilitzar funcions Polifyll per a suplir això) +(function() { + 'use strict'; + + var i, + // També es podria construïr l'array de mètodes de la forma següent, però + // el mètode getOwnPropertyNames() no té cap corrector de compatibilitat: + // Object.getOwnPropertyNames(Array).filter(function(methodName) { + // return typeof Array[methodName] === 'function' + // }); + methods = [ + 'join', 'reverse', 'sort', 'push', 'pop', 'shift', 'unshift', + 'splice', 'concat', 'slice', 'indexOf', 'lastIndexOf', + 'forEach', 'map', 'reduce', 'reduceRight', 'filter', + 'some', 'every', 'find', 'findIndex', 'entries', 'keys', + 'values', 'copyWithin', 'includes' + ], + methodCount = methods.length, + assignArrayGeneric = function(methodName) { + if (!Array[methodName]) { + var method = Array.prototype[methodName]; + if (typeof method === 'function') { + Array[methodName] = function() { + return method.call.apply(method, arguments); + }; + } + } + }; + + for (i = 0; i < methodCount; i++) { + assignArrayGeneric(methods[i]); + } +}()); +</pre> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Crear_un_array">Crear un array</h3> + +<p>L'exemple següent crea un array, <code>msgArray</code>, amb un tamany de 0, després assigna valors a les posicions <code>msgArray[0]</code> i <code>msgArray[99]</code>, canviant automàticament el tamany de l'array a 100.</p> + +<pre class="brush: js">var msgArray = []; +msgArray[0] = 'Hello'; +msgArray[99] = 'world'; + +if (msgArray.length === 100) { + console.log('The length is 100.'); +} +</pre> + +<h3 id="Crear_un_array_de_dues_dimensions_(bidimensional)">Crear un array de dues dimensions (bidimensional)</h3> + +<p>L'exemple següent crea un tauler d'escacs com a array bidimensional de strings. El primer moviement es realitza tot copiant la 'p' de la posició (6,4) a (4,4). La posició anterior esdevé buïda.</p> + +<pre class="brush: js">var board = [ + ['R','N','B','Q','K','B','N','R'], + ['P','P','P','P','P','P','P','P'], + [' ',' ',' ',' ',' ',' ',' ',' '], + [' ',' ',' ',' ',' ',' ',' ',' '], + [' ',' ',' ',' ',' ',' ',' ',' '], + [' ',' ',' ',' ',' ',' ',' ',' '], + ['p','p','p','p','p','p','p','p'], + ['r','n','b','q','k','b','n','r'] ]; + +console.log(board.join('\n') + '\n\n'); + +// Movem el peó del Rei endevant dues caselles +board[4][4] = board[6][4]; +board[6][4] = ' '; +console.log(board.join('\n')); +</pre> + +<p>Aquesta seria la sortida:</p> + +<pre class="eval">R,N,B,Q,K,B,N,R +P,P,P,P,P,P,P,P + , , , , , , , + , , , , , , , + , , , , , , , + , , , , , , , +p,p,p,p,p,p,p,p +r,n,b,q,k,b,n,r + +R,N,B,Q,K,B,N,R +P,P,P,P,P,P,P,P + , , , , , , , + , , , , , , , + , , , ,p, , , + , , , , , , , +p,p,p,p, ,p,p,p +r,n,b,q,k,b,n,r +</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.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.4', 'Array')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>S'afegeixen més mètodes: {{jsxref("Array.isArray")}}, {{jsxref("Array.prototype.indexOf", "indexOf")}}, {{jsxref("Array.prototype.lastIndexOf", "lastIndexOf")}}, {{jsxref("Array.prototype.every", "every")}}, {{jsxref("Array.prototype.some", "some")}}, {{jsxref("Array.prototype.forEach", "forEach")}}, {{jsxref("Array.prototype.map", "map")}}, {{jsxref("Array.prototype.filter", "filter")}}, {{jsxref("Array.prototype.reduce", "reduce")}}, {{jsxref("Array.prototype.reduceRight", "reduceRight")}}</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array-objects', 'Array')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>S'afegeixen més mètodes: {{jsxref("Array.from")}}, {{jsxref("Array.of")}}, {{jsxref("Array.prototype.find", "find")}}, {{jsxref("Array.prototype.findIndex", "findIndex")}}, {{jsxref("Array.prototype.fill", "fill")}}, {{jsxref("Array.prototype.copyWithin", "copyWithin")}}</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<div>{{CompatibilityTable}}</div> + +<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> + <table class="compat-table"> + <tbody> + <tr> + <td>Suport bàsic</td> + </tr> + </tbody> + </table> + </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/Guide/Working_with_Objects#Indexing_object_properties">Guia de JavaScript: “Indexar propietats d'objectes”</a></li> + <li><a href="/en-US/docs/Web/JavaScript/Guide/Predefined_Core_Objects#Array_Object">Guia de JavaScript: “Objectes bàsics predefinits: L'objecte <code>Array</code>”</a></li> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Array_comprehensions">Array comprehensions</a></li> + <li><a href="https://github.com/plusdude/array-generics">Polyfill per a Genèrics d'Array a JavaScript 1.8.5 i Array Extras a l'ECMAScript 5 </a></li> + <li><a href="/en-US/docs/JavaScript_typed_arrays">Arrays amb tipus</a></li> +</ul> diff --git a/files/ca/web/javascript/reference/global_objects/array/indexof/index.html b/files/ca/web/javascript/reference/global_objects/array/indexof/index.html new file mode 100644 index 0000000000..939571a0c8 --- /dev/null +++ b/files/ca/web/javascript/reference/global_objects/array/indexof/index.html @@ -0,0 +1,235 @@ +--- +title: Array.prototype.indexOf() +slug: Web/JavaScript/Referencia/Objectes_globals/Array/indexOf +translation_of: Web/JavaScript/Reference/Global_Objects/Array/indexOf +--- +<div>{{JSRef}}</div> + +<p>El mètode <code><strong>indexOf()</strong></code> retorna la primera posició a la qual es troba l'element proporcionat, o bé -1 si l'element no es troba dins l'array.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><var>arr</var>.indexOf(elementAcercar[, posicioInicial = 0])</pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt>elementAcercar</dt> + <dd>L'element que es cercarà.</dd> + <dt>posicioInicial</dt> + <dd>La posició a la qual començar la cerca. Si la posició és major o igual a la longitud de l'array, es retornarà -1, això implica que no es realitzarà cap cerca a l'array. Si es proporciona un onmbre negatiu, es calcularà la posició des de la qual cercar des del final de l'array. Nota: l'array sempre es cercarà accedint a les posicions en ordre ascendent encara que la <code>posicioInicial</code> sigui negatiu. Si la posició proporcionada és 0 es cercarà en tot l'array. El valor per defecte és 0 (cerca a tot l'array).</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p><code>indexOf()</code> compara <strong>elementAcercar</strong> amb els elements de l'array mitjançant la <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators#Using_the_Equality_Operators">igualtat estricta</a> (el mateix mètode utilitzat per l'operador <code>===</code>, també anomenat triple-equals).</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_indexOf()">Utilitzar <code>indexOf()</code></h3> + +<p>L'exemple següent utilitza <code>indexOf()</code> per a localitzar valors dins un array.</p> + +<pre class="brush: js">var array = [2, 9, 9]; +array.indexOf(2); // 0 +array.indexOf(7); // -1 +array.indexOf(9, 2); // 2 +array.indexOf(2, -1); // -1 +array.indexOf(2, -3); // 0 +</pre> + +<h3 id="Trobar_totes_les_ocurrències_d'un_element">Trobar totes les ocurrències d'un element</h3> + +<pre class="brush: js">var indices = []; +var array = ['a', 'b', 'a', 'c', 'a', 'd']; +var element = 'a'; +var idx = array.indexOf(element); +while (idx != -1) { + indices.push(idx); + idx = array.indexOf(element, idx + 1); +} +console.log(indices); +// [0, 2, 4] +</pre> + +<h3 id="Determinar_si_un_element_existeix_o_no_a_l'array_i_actualitzar-lo">Determinar si un element existeix o no a l'array i actualitzar-lo</h3> + +<pre class="brush: js">function updateVegetablesCollection (veggies, veggie) { + if (veggies.indexOf(veggie) === -1) { + veggies.push(veggie); + console.log('La nova col·lecció de verdures és : ' + veggies); + } else if (veggies.indexOf(veggie) > -1) { + console.log(veggie + ' ja existeix a la col·lecció de verdures.'); + } +} + +var veggies = ['potato', 'tomato', 'chillies', 'green-pepper']; + +updateVegetablesCollection(veggies, 'spinach'); +// La nova col·lecció de verdures és : potato,tomato,chillies,green-papper,spinach +updateVegetablesCollection(veggies, 'spinach'); +// spinach ja existeix a la col·lecció de verdures. +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p><code>indexOf()</code> va ser afegit al standard ECMA-262 a la cinquena versió; degut a això pot no estar present en tots els navegadors. Afegir el següent codi al principi dels vostres escripts us permetrà utilitzar aquesta funció en navegadors on <code>indexOf</code> no sigui suportada de forma nativa. Aquest algoritme és el mateix que l'especificat a la cinquena versió de l'ECMA-262, donat que {{jsxref("Global_Objects/TypeError", "TypeError")}} i {{jsxref("Math.abs()")}} no han estat modificats.</p> + +<pre class="brush: js">// Production steps of ECMA-262, Edition 5, 15.4.4.14 +// Reference: http://es5.github.io/#x15.4.4.14 +if (!Array.prototype.indexOf) { + Array.prototype.indexOf = function(searchElement, fromIndex) { + + var k; + + // 1. Sigui o el resultat de cridar ToObject passant + // el valor de this com a argument. + if (this == null) { + throw new TypeError('"this" is null or not defined'); + } + + var o = Object(this); + + // 2. Sigui lenValue el resultat de cridar el mètode intern Get + // de o amb l'argument "length". + // 3. Sigui len ToUint32(lenValue). + var len = o.length >>> 0; + + // 4. Si len és 0, retornem -1. + if (len === 0) { + return -1; + } + + // 5. Si s'ha passat l'argument fromIndex n valdrà + // ToInteger(fromIndex); si no n valdrà 0. + var n = +fromIndex || 0; + + if (Math.abs(n) === Infinity) { + n = 0; + } + + // 6. Si n >= len, retornem -1. + if (n >= len) { + return -1; + } + + // 7. Si n >= 0, k valdrà n. + // 8. Si no, si n<0, k valdrà len - abs(n). + // Si k és menor que 0, llavors k valdrà 0. + k = Math.max(n >= 0 ? n : len - Math.abs(n), 0); + + // 9. Repetir mentre k < len + while (k < len) { + // a. Sigui Pk ToString(k). + // Això és implícit per a operands a l'esquerra de l'operador in + // b. Sigui kPresent el resultat de cridar el mètode intern + // HasProperty de o amb l'argument Pk. + // Aquest pas es pot combinar amb c + // c. Si kPresent és cert, llavors + // i. Sigui elementK el resultat de cridar el mètode intern Get + // de o amb l'argument ToString(k). + // ii. Sigui same el resultat d'aplicar l'algoritme del + // comparador d'igualtat estricta a + // searchElement i elementK. + // iii. Si same és cert retornem k. + if (k in o && o[k] === searchElement) { + return k; + } + k++; + } + return -1; + }; +} +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.4.4.14', 'Array.prototype.indexOf')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Definició inicial. Implementat a JavaScript 1.6.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype.indexof', 'Array.prototype.indexOf')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype.indexof', 'Array.prototype.indexOf')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<div>{{CompatibilityTable}}</div> + +<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>{{CompatGeckoDesktop("1.8")}}</td> + <td>{{CompatIE("9")}}</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>{{CompatGeckoMobile("1.8")}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Notes_de_compatibilitat">Notes de compatibilitat</h2> + +<ul> + <li>Començant amb el Firefox 47 {{geckoRelease(47)}}, aquest mètode no retornarà <code>-0</code>. Per exemple, <code>[0].indexOf(0, -0)</code> ara sempre retornarà <code>+0</code> ({{bug(1242043)}}).</li> +</ul> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Array.prototype.lastIndexOf()")}}</li> + <li>{{jsxref("TypedArray.prototype.indexOf()")}}</li> +</ul> diff --git a/files/ca/web/javascript/reference/global_objects/array/isarray/index.html b/files/ca/web/javascript/reference/global_objects/array/isarray/index.html new file mode 100644 index 0000000000..6393dde86f --- /dev/null +++ b/files/ca/web/javascript/reference/global_objects/array/isarray/index.html @@ -0,0 +1,135 @@ +--- +title: Array.isArray() +slug: Web/JavaScript/Referencia/Objectes_globals/Array/isArray +translation_of: Web/JavaScript/Reference/Global_Objects/Array/isArray +--- +<div>{{JSRef}}</div> + +<p>El mètode <code><strong>Array.isArray()</strong></code>retorna <code>true</code> si un objecte és un array, o <code>false</code> en cas que no ho sigui.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code>Array.isArray(<var>obj</var>)</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>obj</code></dt> + <dd>L'objecte que s'ha de comprovar.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Vegeu l'article <a href="http://web.mit.edu/jwalden/www/isArray.html">“Determinar amb absoluta precisió si un objecte JavaScript és un array o no”</a> per més detalls.</p> + +<h2 id="Exemples">Exemples</h2> + +<pre class="brush: js">// totes les crides següents retornen true +Array.isArray([]); +Array.isArray([1]); +Array.isArray(new Array()); +// Fet poc conegut: Array.prototype és un array per si mateix: +Array.isArray(Array.prototype); + +// totes les crides següents retornen false +Array.isArray(); +Array.isArray({}); +Array.isArray(null); +Array.isArray(undefined); +Array.isArray(17); +Array.isArray('Array'); +Array.isArray(true); +Array.isArray(false); +Array.isArray({ __proto__: Array.prototype }); +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Executar el codi següent abans de cap altre codi crearà <code>Array.isArray()</code> si no es troba disponible de forma nativa.</p> + +<pre class="brush: js">if (!Array.isArray) { + Array.isArray = function(arg) { + return Object.prototype.toString.call(arg) === '[object Array]'; + }; +} +</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('ES5.1', '#sec-15.4.3.2', 'Array.isArray')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Definició inicial. Implementat en JavaScript 1.8.5.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.isarray', 'Array.isArray')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<div>{{CompatibilityTable}}</div> + +<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("5")}}</td> + <td>{{CompatGeckoDesktop("2.0")}}</td> + <td>{{CompatIE("9")}}</td> + <td>{{CompatOpera("10.5")}}</td> + <td>{{CompatSafari("5")}}</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>{{CompatGeckoMobile("2.0")}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Array")}}</li> +</ul> diff --git a/files/ca/web/javascript/reference/global_objects/array/join/index.html b/files/ca/web/javascript/reference/global_objects/array/join/index.html new file mode 100644 index 0000000000..8d76b4474a --- /dev/null +++ b/files/ca/web/javascript/reference/global_objects/array/join/index.html @@ -0,0 +1,123 @@ +--- +title: Array.prototype.join() +slug: Web/JavaScript/Referencia/Objectes_globals/Array/join +translation_of: Web/JavaScript/Reference/Global_Objects/Array/join +--- +<div>{{JSRef}}</div> + +<p>El mètode <code><strong>join()</strong></code> ajunta tots els elements d'un array en un string.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>str</var> = <var>arr</var>.join([<var>separador</var> = ','])</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>separador</code></dt> + <dd>Opcional. Expecifica un string que s'utilitzarà per a serparar cada element de l'array. El separador es converteix a string automàticament en cas necesari. Si s'omet, els elements de l'array seran separats per una coma. Si <code>separador</code> és un string buit, s'ajuntaran tots els elements de l'array sense cap caràcter entre ells.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Ajunta les conversions a string de tots els elements de l'array en un sol string. Si un element és <code>undefined</code> o bé <code>null</code> aquest es converteix en una cadena buida.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Quatre_formes_diferents_d'ajuntar_un_array">Quatre formes diferents d'ajuntar un array</h3> + +<p>L'exemple següent crea un array, <code>a</code>, amb tres elements, l'ajunta quatre cops: utilitzant el separador per defect, utilitzant coma i espai, utiltizant el signe més i utilitzant un string buit.</p> + +<pre class="brush: js">var a = ['Wind', 'Rain', 'Fire']; +var myVar1 = a.join(); // assigna 'Wind,Rain,Fire' a myVar1 +var myVar2 = a.join(', '); // assigna 'Wind, Rain, Fire' a myVar2 +var myVar3 = a.join(' + '); // assigna 'Wind + Rain + Fire' a myVar3 +var myVar4 = a.join(''); // assigna 'WindRainFire' a myVar4 +</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. Implementat a JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.4.4.5', 'Array.prototype.join')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype.join', 'Array.prototype.join')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<div>{{CompatibilityTable}}</div> + +<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("1.0")}}</td> + <td>{{CompatGeckoDesktop("1.7")}}</td> + <td>{{CompatIE("5.5")}}</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="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("String.prototype.split()")}}</li> + <li>{{jsxref("Array.prototype.toString()")}}</li> + <li>{{jsxref("TypedArray.prototype.join()")}}</li> +</ul> diff --git a/files/ca/web/javascript/reference/global_objects/array/keys/index.html b/files/ca/web/javascript/reference/global_objects/array/keys/index.html new file mode 100644 index 0000000000..7d9df8e1f5 --- /dev/null +++ b/files/ca/web/javascript/reference/global_objects/array/keys/index.html @@ -0,0 +1,115 @@ +--- +title: Array.prototype.keys() +slug: Web/JavaScript/Referencia/Objectes_globals/Array/keys +translation_of: Web/JavaScript/Reference/Global_Objects/Array/keys +--- +<div>{{JSRef}}</div> + +<p>El mètode <code><strong>keys()</strong></code> retorna un nou <code><strong>Array Iterator</strong></code> que conté la clau de cada posició d'un array.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>arr</var>.keys()</code></pre> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Ús_bàsic">Ús bàsic</h3> + +<pre class="brush: js">var arr = ["a", "b", "c"]; +var iterator = arr.keys(); + +console.log(iterator.next()); // { value: 0, done: false } +console.log(iterator.next()); // { value: 1, done: false } +console.log(iterator.next()); // { value: 2, done: false } +console.log(iterator.next()); // { value: undefined, done: true } +</pre> + +<h3 id="L'iterador_de_claus_no_ignora_els_forats">L'iterador de claus no ignora els forats</h3> + +<pre class="brush: js">var arr = ["a", , "c"]; +var sparseKeys = Object.keys(arr); +var denseKeys = [...arr.keys()]; +console.log(sparseKeys); // ['0', '2'] +console.log(denseKeys); // [0, 1, 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('ES6', '#sec-array.prototype.keys', 'Array.prototype.keys')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definició inicial.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype.keys', 'Array.prototype.keys')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<div>{{CompatibilityTable}}</div> + +<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("38")}}</td> + <td>{{CompatGeckoDesktop("28")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatOpera("25")}}</td> + <td>{{CompatSafari("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>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatGeckoMobile("28")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8.0</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Array.prototype.values()")}}</li> + <li>{{jsxref("Array.prototype.entries()")}}</li> +</ul> diff --git a/files/ca/web/javascript/reference/global_objects/array/lastindexof/index.html b/files/ca/web/javascript/reference/global_objects/array/lastindexof/index.html new file mode 100644 index 0000000000..038aa614e5 --- /dev/null +++ b/files/ca/web/javascript/reference/global_objects/array/lastindexof/index.html @@ -0,0 +1,197 @@ +--- +title: Array.prototype.lastIndexOf() +slug: Web/JavaScript/Referencia/Objectes_globals/Array/lastIndexOf +translation_of: Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf +--- +<div>{{JSRef}}</div> + +<p> </p> + +<p>El mètode <code><strong>lastIndexOf</strong></code> <code><strong>()</strong></code> retorna l'última posició a la qual es troba l'element proporcionat, o bé -1 si l'element no es troba dins l'array. L'array es recorrerà en ordre invers a partir de la posició <strong>pocicioInicial</strong>.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>arr</var>.lastIndexOf(elementAcercar[, posicioInicial = arr.length - 1])</code></pre> + +<h2 id="Paràmetres">Paràmetres</h2> + +<dl> + <dt><code>elementAcercar</code></dt> + <dd>L'element que es cercarà.</dd> + <dt><code>posicioInicial</code></dt> + <dd>Opcional. La posició a partir de la qual es començarà a cercar cap enrera. El valor per defecte és el tamany de l'array menys un, és a dir, tota l'array serà cercada. Si la posició proporcionada es major o igual que la longitud de l'array tot l'array serà cercat. Si és negatiu s'utilitzarà com a desplaçament respecte el final de l'array. Nota: l'array sempre es cercarà accedint a les posicions en ordre descendent encara que la <code>posicioInicial</code> sigui negatiu. Si la posició calculada és menor que zero, es retornarà -1, és a dir, l'array no serà cercat.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p><code>lastIndexOf</code> compara <strong>elementAcercar</strong> amb els elements de l'array mitjançant la <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators#Using_the_Equality_Operators">igualtat estricta</a> (el mateix mètode utilitzat per l'operador <code>===</code>, també anomenat triple-equals).</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_lastIndexOf">Utilitzar <code>lastIndexOf</code></h3> + +<p>L'exemple següent utilitza <code>lastIndexOf</code> per a localitzar valors dins un array.</p> + +<pre class="brush: js">var array = [2, 5, 9, 2]; +array.lastIndexOf(2); // 3 +array.lastIndexOf(7); // -1 +array.lastIndexOf(2, 3); // 3 +array.lastIndexOf(2, 2); // 0 +array.lastIndexOf(2, -2); // 0 +array.lastIndexOf(2, -1); // 3 +</pre> + +<h3 id="Trobar_totes_les_ocurrències_d'un_element">Trobar totes les ocurrències d'un element</h3> + +<p>L'exemple segïuent utilitza <code>lastIndexOf</code> per a trobar totes les posicions d'un element en un array donat, utilitzant {{jsxref("Array.prototype.push", "push")}} per a afegir-los a u altre array un cop trobats.</p> + +<pre class="brush: js">var indices = []; +var array = ['a', 'b', 'a', 'c', 'a', 'd']; +var element = 'a'; +var idx = array.lastIndexOf(element); +while (idx != -1) { + indices.push(idx); + idx = (idx > 0 ? array.lastIndexOf(element, idx - 1) : -1); +} + +console.log(indices); +// [4, 2, 0] +</pre> + +<p>Cal destacar que el cas <code>idx == 0</code> s'ha de tractar de forma separada ja que l'element sempre serà trobat sense importar el valor del paràmetre <code>posicioInicial</code> si és el primer element de l'array. Aquest comportament és diferent del del mètode {{jsxref("Array.prototype.indexOf", "indexOf")}}.</p> + +<h2 id="Polyfill">Polyfill</h2> + +<p><code>lastIndexOf</code> va ser afegit al standard ECMA-262 a la cinquena versió; degut a això pot no estar present en tots els navegadors. Afegir el següent codi al principi dels vostres escripts us permetrà utilitzar aquesta funció en navegadors on <code>indexOf</code> no sigui suportada de forma nativa. Aquest algoritme és el mateix que l'especificat a la cinquena versió de l'ECMA-262, donat que {{jsxref("Object")}}, {{jsxref("TypeError")}}, {{jsxref("Number")}}, {{jsxref("Math.floor")}}, {{jsxref("Math.abs")}}, i{{jsxref("Math.min")}} no han estat modificats.</p> + +<pre class="brush: js">// Production steps of ECMA-262, Edition 5, 15.4.4.15 +// Reference: http://es5.github.io/#x15.4.4.15 +if (!Array.prototype.lastIndexOf) { + Array.prototype.lastIndexOf = function(searchElement /*, fromIndex*/) { + 'use strict'; + + if (this === void 0 || this === null) { + throw new TypeError(); + } + + var n, k, + t = Object(this), + len = t.length >>> 0; + if (len === 0) { + return -1; + } + + n = len - 1; + if (arguments.length > 1) { + n = Number(arguments[1]); + if (n != n) { + n = 0; + } + else if (n != 0 && n != (1 / 0) && n != -(1 / 0)) { + n = (n > 0 || -1) * Math.floor(Math.abs(n)); + } + } + + for (k = n >= 0 ? Math.min(n, len - 1) : len - Math.abs(n); k >= 0; k--) { + if (k in t && t[k] === searchElement) { + return k; + } + } + return -1; + }; +} +</pre> + +<p>Cal destacar que l'implementació aspira una compatibilitat ambsoluta amb els mètodes <code>lastIndexOf</code> trobats al Firefox i el motor JavaScript SpiderMonkey, incloent diversos casos que són excepcionals. Si es pretén utilitzar-lo en aplicacions quotidianes, és posible calcular <code>from</code> amb codi més senzill si s'ignoren aquests casos.</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('ES5.1', '#sec-15.4.4.15', 'Array.prototype.lastIndexOf')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Definició inicial. Implementat a JavaScript 1.6.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype.lastindexof', 'Array.prototype.lastIndexOf')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype.lastindexof', 'Array.prototype.lastIndexOf')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<div>{{CompatibilityTable}}</div> + +<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>{{CompatIE("9")}}</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="Notes_de_compatibilitat">Notes de compatibilitat</h2> + +<ul> + <li>Començant amb el Firefox 47 {{geckoRelease(47)}}, aquest mètode no retornarà <code>-0</code>. Per exemple, <code>[0].lastIndexOf(0, -0)</code> ara sempre retornarà <code>+0</code> ({{bug(1242043)}}).</li> +</ul> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Array.prototype.indexOf()")}}</li> + <li>{{jsxref("TypedArray.prototype.lastIndexOf()")}}</li> +</ul> diff --git a/files/ca/web/javascript/reference/global_objects/array/length/index.html b/files/ca/web/javascript/reference/global_objects/array/length/index.html new file mode 100644 index 0000000000..a4954565ff --- /dev/null +++ b/files/ca/web/javascript/reference/global_objects/array/length/index.html @@ -0,0 +1,128 @@ +--- +title: Array.prototype.length +slug: Web/JavaScript/Referencia/Objectes_globals/Array/length +translation_of: Web/JavaScript/Reference/Global_Objects/Array/length +--- +<div>{{JSRef}}</div> + +<p>La propietat <code><strong>length</strong></code> representa un nombre sencer sense signe de 32 bits que és sempre numèricament major que la última posició de l'array.</p> + +<div>{{js_property_attributes(1, 0, 0)}}</div> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>arr</var>.length</code></pre> + +<h2 id="Descripció">Descripció</h2> + +<p>El valor de la propietat <code>length</code> és un sencer amb un signe positiu un valor menor de 2 elevat a 32 (2<sup>32</sup>).</p> + +<p>Es pot establir la propietat <code>length</code> per truncar un array en qualsevol moment. Quan s'exten un array per mitjà de canviar la seva propietat <code>length,</code> el nombre actual d'elements no s'incrementa; per exemple, si s'estableix <code>length</code> a 3 quan en aquell moment és 2, l'array encara conté només 2 elements. Així, la propietat <code>length</code> no necessàriament indica el nombre de valors definits en l'array. Vegeu també <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array#Relationship_between_length_and_numerical_properties" title="Relationship between length and numerical properties">Relació entre <code>length</code> i propietats numèriques.</a></p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Recorrer_un_array">Recorrer un array</h3> + +<p>En l'exemple següent, es recorre l'array <code>numbers</code> comprovant la propietat <code>length.</code> Es duplica el valor de cada element.</p> + +<pre class="brush: js">var numbers = [1, 2, 3, 4, 5]; + +for (var i = 0; i < numbers.length; i++) { + numbers[i] *= 2; +} +// <em>numbers </em>és ara [2, 4, 6, 8, 10] +</pre> + +<h3 id="Escurçar_una_array">Escurçar una array</h3> + +<p>L'exemple següent escurça l'array <code>statesUS</code> a una llargària de 50 en cas que la llargària actual sigui major de 50.</p> + +<pre class="brush: js">if (statesUS.length > 50) { + statesUS.length = 50; +} +</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.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.4.5.2', 'Array.length')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-properties-of-array-instances-length', 'Array.length')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<div>{{CompatibilityTable}}</div> + +<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("Array")}}</li> +</ul> diff --git a/files/ca/web/javascript/reference/global_objects/array/map/index.html b/files/ca/web/javascript/reference/global_objects/array/map/index.html new file mode 100644 index 0000000000..6f0dc1a0d4 --- /dev/null +++ b/files/ca/web/javascript/reference/global_objects/array/map/index.html @@ -0,0 +1,317 @@ +--- +title: Array.prototype.map() +slug: Web/JavaScript/Referencia/Objectes_globals/Array/map +translation_of: Web/JavaScript/Reference/Global_Objects/Array/map +--- +<div>{{JSRef("Global_Objects", "Array")}}</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>El mètode <code><strong>map() </strong></code>crea una nova array amb els resultats de la crida a la funció proporcionada un cop per cada element.</p> + +<h2 id="Syntax" name="Syntax">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>arr</var>.map(<var>callback</var>[, <var>thisArg</var>])</code></pre> + +<h3 id="Parameters" name="Parameters">Paràmetres</h3> + +<dl> + <dt><code>callback</code></dt> + <dd>Funció que produeix un element de la nova array, agafant tres arguments:</dd> + <dd> + <dl> + <dt><code>currentValue</code></dt> + <dd>El valor actual que és processat en l'array.</dd> + <dt><code>index</code></dt> + <dd>L'índex de l'element actual que és processat en l'array.</dd> + <dt><code>array</code></dt> + <dd>L'array sobre la qual es crida <code>map.</code></dd> + </dl> + </dd> + <dt><code>thisArg</code></dt> + <dd>Opcional. Valor a usar com a <code>this</code> quan s'executa la funció.</dd> +</dl> + +<h2 id="Description" name="Description">Descripció</h2> + +<p><code>map</code> crida a la funció passada <code>callback</code> <strong>un cop per cada element</strong> de l'array, en ordre, i construeix un nou array a partir dels resultats. Només s'invoca <code>callback</code> per a posicions de l'array que tinguin valors assignats, incloent <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined">undefined</a>. No es crida per a elements no trobats (és a dir, elements que no han rebut mai un valor o bé elements que s'han eliminat).</p> + +<p>S'invoca <code>callback</code> amb tres arguments: el valor de l'element, la posició de l'element a l'array, i l'array que s'està recorrent.</p> + +<p>Si s'ha proporcionat el paràmetre <code>thisArg</code> a l'hora de cridar <code>map</code>, aquest es passarà a la funció <code>callback</code> com a valor per a <code>this</code> dins la funció. En qualsevol altre cas el valor utilitzat com a <code>this</code> serà {{jsxref("Global_Objects/undefined", "undefined")}}. El valor finalment observable des de <code>callback</code> es determinarà d'acord a <a href="/en-US/docs/Web/JavaScript/Reference/Operators/this">les regles usuals per a determinar el valor de <code>this</code> dins una funció</a>.</p> + +<p><code>map</code> no canvia l'array des del que es crida (tot i que <code>callback</code>, si s'invoca, pot fer-ho).</p> + +<p>El rang d'elements processat per <code>map</code> s'estableix abans de la primera invocació de <code>callback</code>. Els elements que s'hagin afegit a l'array després d'haver cridat <code>map</code> no seran visitats per <code>callback</code>. Si es canvient els elements existents, o s'eliminen, el valor passat a <code>callback</code> serà el valor que tinguessin quan es va invocar <code>map</code>; els elements que s'han eliminat no es visitaran.</p> + +<h2 id="Examples" name="Examples">Exemples</h2> + +<h3 id="Example:_Mapping_an_array_of_numbers_to_an_array_of_square_roots" name="Example:_Mapping_an_array_of_numbers_to_an_array_of_square_roots">Exemple: Generar un array de rels quadrades a partir d'un array de nombres</h3> + +<p>El codi següent agafa un array de nombres i crea un nou array que contindrà les rels quadrades dels nombres del primer array.</p> + +<pre class="brush: js">var nombres = [1, 4, 9]; +var rels = nombres.map(Math.sqrt); +// rels ara val [1, 2, 3], nombres encara val [1, 4, 9] +</pre> + +<h3 id="Example:_Mapping_an_array_of_numbers_to_an_array_of_square_roots" name="Example:_Mapping_an_array_of_numbers_to_an_array_of_square_roots">Exemple: Utilitzar map per a canviar el format dels objectes d'un array</h3> + +<p>El codi següent agafa un array d'objectes i crea un nou array que conté els nous objectes, que tenen un format diferent.</p> + +<pre class="brush: js">var kvArray = [{key:1, value:10}, {key:2, value:20}, {key:3, value: 30}]; +var reformattedArray = kvArray.map(function(obj){ + var rObj = {}; + rObj[obj.key] = obj.value; + return rObj; +}); +// reformattedArray ara val [{1:10}, {2:20}, {3:30}], +// kvArray encara val [{key:1, value:10}, {key:2, value:20}, {key:3, value: 30}] +</pre> + +<h3 id="Example:_Mapping_an_array_of_numbers_using_a_function_containing_an_argument" name="Example:_Mapping_an_array_of_numbers_using_a_function_containing_an_argument">Exemple: Assignar els nombres d'un array al resultat d'una funció que espera un argument</h3> + +<p>El codi següent mostra com funciona <code>map</code> quan s'utilitza una funció que espera un argument. L'argument rebrà automàticament el valor de cada element de l'array mentre <code>map</code> recorre tot l'array original.</p> + +<pre class="brush: js">var nombres = [1, 4, 9]; +var dobles = nombres.map(function(num) { + return num * 2; +}); +// dobles ara val [2, 8, 18]. nombres encara val [1, 4, 9] +</pre> + +<h3 id="Example:_using_map_generically" name="Example:_using_map_generically">Exemple: utilitzar <code>map</code> de forma genèrica</h3> + +<p>Aquest exemple mostra com utilitzar <code>map</code> en un {{jsxref("Global_Objects/String", "String")}} per a obtindre un array de bytes que representin el valor dels caràcters codificats amb ASCII:</p> + +<pre class="brush: js">var map = Array.prototype.map; +var a = map.call('Hello World', function(x) { return x.charCodeAt(0); }); +// a ara val [72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100] +</pre> + +<h3 id="Example:_using_map_generically_querySelectorAll" name="Example:_using_map_generically_querySelectorAll">Exemple: Utilitzar <code>map</code> de forma genèrica amb <code>querySelectorAll</code></h3> + +<p>Aquest exemple mostra com iterar sobre una col·lecció d'objectes obtinguts mitjançant <code>querySelectorAll</code>. En aquest cas obtenim totes les opcions seleccionades de la web:</p> + +<pre class="brush: js">var elems = document.querySelectorAll('select option:checked'); +var values = Array.prototype.map.call(elems, function(obj) { + return obj.value; +}); +</pre> + +<h3 id="Exemple_Utilitzar_map_per_a_invertir_un_string">Exemple: Utilitzar <code>map</code> per a invertir un string</h3> + +<pre class="brush: js">var str = '12345'; +Array.prototype.map.call(str, function(x) { + return x; +}).reverse().join(''); + +// Sortida: '54321' +// Bonus: utilitzeu '===' per a comprovar si l'string original era un palindrom +</pre> + +<h3 id="Example:_Tricky_use_case" name="Example:_Tricky_use_case">Exemple: Un cas d'ús delicat</h3> + +<p><a href="http://www.wirfs-brock.com/allen/posts/166">(inspirat per aquesta entrada de blog)</a></p> + +<p>És comú utilitzar la funció <em>callback</em> amb un sol argument (l'element corresponent a la volta del bucle de l'array que s'està recorrent). Algunes funcions també solen requerir un sol argument, tot i que també poden acceptar arguements adicionals de forma opcional. Això pot produïr comportaments confussos.</p> + +<pre class="brush: js">// Considerem: +['1', '2', '3'].map(parseInt); +// Quan hom esperaria [1, 2, 3] +// El resultat real serà [1, NaN, NaN] + +// parseInt s'utilitza normalment amb un argument, però admet dos. +// El primer és una expressió mentre que el segon és el mòdul. +// Array.prototype.map passa 3 arguments a la funció callback: +// l'element, la posició de l'element i l'array +// parseInt ignorarà el tercer argument, però no el segon, +// provocant la confussió. Vegeu l'entrada del blog per a més detalls + +function returnInt(element) { + return parseInt(element, 10); +} + +['1', '2', '3'].map(returnInt); // [1, 2, 3] +// Actual result is an array of numbers (as expected) + +// A simpler way to achieve the above, while avoiding the "gotcha": +['1', '2', '3'].map(Number); // [1, 2, 3] +</pre> + +<h2 id="Polyfill" name="Polyfill">Polyfill</h2> + +<p><code>map</code> va ser afegit a l'standard ECMA-262 a la cinquena edició; degut a això aquest pot no estar present en algunes implementacions de l'standard. Es pot solventar aquest problema insertant el codi següent al principi dels scripts que el requereixin, permetent que implementacions on <code>map</code> no està disponible de forma nativa en puguin fer ús. Aquest algoritme és exactament l'especificat per l'ECMA-262, 5a edició, assument que {{jsxref("Global_Objects/Object", "Object")}}, {{jsxref("Global_Objects/TypeError", "TypeError")}}, i {{jsxref("Global_Objects/Array", "Array")}} tenen els seus valors originals i que <code>callback.call</code> s'evalua al valor original de <code>{{jsxref("Function.prototype.call")}}</code>.</p> + +<pre class="brush: js">// Production steps of ECMA-262, Edition 5, 15.4.4.19 +// Reference: http://es5.github.io/#x15.4.4.19 +if (!Array.prototype.map) { + + Array.prototype.map = function(callback, thisArg) { + + var T, A, k; + + if (this == null) { + throw new TypeError(' this is null or not defined'); + } + + // 1. Assignem a O el resultat de cridar a ToObject passant-li el valor de |this| + // com a argument. + var O = Object(this); + + // 2. lenValue és el resultat de cridar el mètode intern + // Get de O amb l'argument "length". + // 3. Assignem a len el valor d'executar ToUint32(lenValue). + var len = O.length >>> 0; + + // 4. Si IsCallable(callback) és false, llencem l'excepció TypeError. + // Vegeu: http://es5.github.com/#x9.11 + if (typeof callback !== 'function') { + throw new TypeError(callback + ' is not a function'); + } + + // 5. Si s'ha passat l'argument thisArg, l'assigment a T; en cas contrari T valdrà undefined. + if (arguments.length > 1) { + T = thisArg; + } + + // 6. Assignem a A el nou array creat per l'expressió new Array(len) + // on Array és el constructor standard de JavaScript amb aquest nom i + // len és el valor de len. + A = new Array(len); + + // 7. Assignem 0 a k + k = 0; + + // 8. Repetim mentre k < len + while (k < len) { + + var kValue, mappedValue; + + // a. Assignem ToString(k) a Pk. + // Això és implicit per a operands al cantó esquerra de l'operador <code>in</code> + // b. Assignem a kPresent el resultat de cridar el mètode intern HasProperty + // de O amb l'argument Pk. + // Es pot combinar aquest pas amb c + // c. Si kPresent és true, llavors + if (k in O) { + + // i. Assignem a kValue el resultat de cridar el mètode intern + // Get de O amb l'argument Pk. + kValue = O[k]; + + // ii. Assignem a mappedValue el resultat de cridar el mètode intern Call + // de callback amb T com a valor de this i una llista d'arguments + // que conté kValue, k, i O. + mappedValue = callback.call(T, kValue, k, O); + + // iii. Cridem el mètode intern DefineOwnProperty de A amb els arguments + // Pk, Property Descriptor + // { Value: mappedValue, + // Writable: true, + // Enumerable: true, + // Configurable: true }, + // i false. + + // En navegadors que suportin Object.defineProperty, utilitzeu el següent: + // Object.defineProperty(A, k, { + // value: mappedValue, + // writable: true, + // enumerable: true, + // configurable: true + // }); + + // Per a un millor suport de navegadors, utilitzeu el següent: + A[k] = mappedValue; + } + // d. incrementem k en 1. + k++; + } + + // 9. retornem A + return A; + }; +} +</pre> + +<h2 id="Specifications" name="Specifications">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('ES5.1', '#sec-15.4.4.19', 'Array.prototype.map')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Definició inicial. Implementat a JavaScript 1.6.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype.map', 'Array.prototype.map')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility" name="Browser_compatibility">Compatibilitat amb navegadors</h2> + +<div>{{CompatibilityTable}}</div> + +<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>{{CompatGeckoDesktop("1.8")}}</td> + <td>{{CompatIE("9")}}</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>{{CompatGeckoMobile("1.8")}}</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("Array.prototype.forEach()")}}</li> + <li>{{jsxref("Map")}} object</li> + <li>{{jsxref("Array.from()")}}</li> +</ul> diff --git a/files/ca/web/javascript/reference/global_objects/array/of/index.html b/files/ca/web/javascript/reference/global_objects/array/of/index.html new file mode 100644 index 0000000000..efe2d96abd --- /dev/null +++ b/files/ca/web/javascript/reference/global_objects/array/of/index.html @@ -0,0 +1,120 @@ +--- +title: Array.of() +slug: Web/JavaScript/Referencia/Objectes_globals/Array/of +translation_of: Web/JavaScript/Reference/Global_Objects/Array/of +--- +<div>{{JSRef}}</div> + +<p>El mètode <code><strong>Array.of()</strong></code> crea una nova instància <code>Array</code> amb un nombre variable d'arguments, sense tenir en compte el nombre o el tipus d'arguments.</p> + +<p>La diferència entre <code><strong>Array.of()</strong></code> i el constructor <code><strong>Array</strong></code> es troba en el maneig dels arguments sencers: <code><strong>Array.of(42)</strong></code> crea un array amb un sol element, <code>42</code>, mentre que <code><strong>Array(42)</strong></code> crea un array amb 42 elements, Cadascun dels quals és <code>undefined</code>.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code>Array.of(<var>element0</var>[, <var>element1</var>[, ...[, <var>elementN</var>]]])</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>element<em>N</em></code></dt> + <dd>Elements a partir dels quals es crea l'array.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Aquesta funció forma part del ECMAScript 6 estàndard. Per més informació vegeu <a href="https://gist.github.com/rwaldron/1074126">proposta de l'<code>Array.of</code> i <code>Array.from</code> </a> i <a href="https://gist.github.com/rwaldron/3186576"><code>Array.of</code> polyfill</a>.</p> + +<h2 id="Exemples">Exemples</h2> + +<pre class="brush: js">Array.of(1); // [1] +Array.of(1, 2, 3); // [1, 2, 3] +Array.of(undefined); // [undefined] +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Executar el codi següent abans que cap altre codi crearà <code>Array.of()</code> en cas que no es trobi disponible de forma nativa.</p> + +<pre class="brush: js">if (!Array.of) { + Array.of = function() { + return Array.prototype.slice.call(arguments); + }; +} +</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-array.of', 'Array.of')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definició inicial.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<div>{{CompatibilityTable}}</div> + +<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(45)}}</td> + <td>{{CompatGeckoDesktop("25")}}</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>{{CompatChrome(39)}}</td> + <td>{{CompatGeckoMobile("25")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Array")}}</li> + <li>{{jsxref("Array.from()")}}</li> + <li>{{jsxref("TypedArray.of()")}}</li> +</ul> diff --git a/files/ca/web/javascript/reference/global_objects/array/pop/index.html b/files/ca/web/javascript/reference/global_objects/array/pop/index.html new file mode 100644 index 0000000000..7d2ee3189f --- /dev/null +++ b/files/ca/web/javascript/reference/global_objects/array/pop/index.html @@ -0,0 +1,123 @@ +--- +title: Array.prototype.pop() +slug: Web/JavaScript/Referencia/Objectes_globals/Array/pop +translation_of: Web/JavaScript/Reference/Global_Objects/Array/pop +--- +<div>{{JSRef}}</div> + +<p>El mètode <code><strong>pop()</strong></code> elimina l'<strong>últim</strong> element d'un array i retorna l'element eliminat.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>arr</var>.pop()</code></pre> + +<h2 id="Descripció">Descripció</h2> + +<p>El mètode <code>pop</code> elimina l'últim element d'un array i retorna el seu valor.</p> + +<p><code>pop</code> és genèric de forma intencionada; aquest mètode pot ser {{jsxref("Function.call", "cridat", "", 1)}} i {{jsxref("Function.apply", "aplicat", "", 1)}} des de/a objectes que semblin arrays. Els objectes que no continguin la propietat <code>length</code> que reflecteixi l'última propietat d'una sèrie de propietats numèriques consecutives, on el nom de la primera propietat sigui el zero, poden comportar-se de forma imprevista.</p> + +<p>Si es crida <code>pop()</code> en un array buit, es retornarà {{jsxref("undefined")}}.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Esborrar_l'últim_element_d'un_array">Esborrar l'últim element d'un array</h3> + +<p>El codi següent crea un array anomenat <code>myFish</code> que conté quatre elements, després elimina l'últim element.</p> + +<pre class="brush: js">var myFish = ['angel', 'clown', 'mandarin', 'sturgeon']; + +console.log(myFish); // ['angel', 'clown', 'mandarin', 'sturgeon'] + +var popped = myFish.pop(); + +console.log(myFish); // ['angel', 'clown', 'mandarin' ] + +console.log(popped); // 'sturgeon'</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 a JavaScript 1.2.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.4.4.6', 'Array.prototype.pop')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype.pop', 'Array.prototype.pop')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<div>{{CompatibilityTable}}</div> + +<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("1.0")}}</td> + <td>{{CompatGeckoDesktop("1.7")}}</td> + <td>{{CompatIE("5.5")}}</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="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Array.prototype.push()")}}</li> + <li>{{jsxref("Array.prototype.shift()")}}</li> + <li>{{jsxref("Array.prototype.unshift()")}}</li> +</ul> diff --git a/files/ca/web/javascript/reference/global_objects/array/push/index.html b/files/ca/web/javascript/reference/global_objects/array/push/index.html new file mode 100644 index 0000000000..5770e5a10c --- /dev/null +++ b/files/ca/web/javascript/reference/global_objects/array/push/index.html @@ -0,0 +1,146 @@ +--- +title: Array.prototype.push() +slug: Web/JavaScript/Referencia/Objectes_globals/Array/push +translation_of: Web/JavaScript/Reference/Global_Objects/Array/push +--- +<div>{{JSRef}}</div> + +<p>El mètode <code><strong>push()</strong></code> afegeix un o més elements al final d'un array i retorna el nou tamany de l'array.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>arr</var>.push(<var>element1</var>, ..., <var>elementN</var>)</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>element<em>N</em></code></dt> + <dd>Els elements que seran afegits al final de l'array.</dd> +</dl> + +<h3 id="Valor_retornat">Valor retornat</h3> + +<p>El nou valor de la propietat {{jsxref("Array.length", "length")}} de l'objecte del qual s'ha executat el mètode.</p> + +<h2 id="Descripció">Descripció</h2> + +<p>El mètode <code>push</code> afegeix valors a un array.</p> + +<p><code>push</code> és genèric de manera intencionada. Es pot utilitzar aquest mètode amb {{jsxref("Function.call", "call()")}} i {{jsxref("Function.apply", "apply()")}} en objectes semblants a arrays. El mètode <code>push</code> depèn de la propietat <code>length</code> per a determinar on insertar els nous valors. Si la propietat <code>length</code> no es pot convertir en un nombre, la posició utilitzada serà la 0. Això inclou la posibilitat que no existeixi la propietat <code>length</code>, en aquest case es crearà automàticament la propietat <code>length</code>.</p> + +<p>Els únics objectes semblants a arrays que inclou el nucli de JavaScript són els {{jsxref("Global_Objects/String", "strings", "", 1)}}, tot i que no admeten la aplicació d'aquest mètode ja que els strings són immutables.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Afegir_elements_a_un_array">Afegir elements a un array</h3> + +<p>El codi següent crea un array anomenat <code>esports</code> que conté dos elements, llavors l'hi afegeix dos elements més. La variable <code>total</code> acaba revent el valor del nou tamany d e l'array.</p> + +<pre class="brush: js">var esports = ['futbol', 'basket']; +var total = esports.push('badminton', 'natació'); + +console.log(esports); // ['futbol', 'basket', 'badminton', 'natació'] +console.log(total); // 4 +</pre> + +<h3 id="Unir_dos_arrays">Unir dos arrays</h3> + +<p>Aquest exemple utilitza {{jsxref("Function.apply", "apply()")}} per a afegir tots els elements d'un segon array.</p> + +<pre class="brush: js">var verdures = ['ceba', 'patata']; +var mesVerdures = ['pastanaga', 'rabe']; + +// Uneix el segon array al primer +// Equivalent a verdures.push('pastanaga', 'rabe'); +Array.prototype.push.apply(verdures , mesVerdures); + +console.log(verdures); // ['ceba', 'patata', 'pastanaga', 'rabe'] +</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 a JavaScript 1.2.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.4.4.7', 'Array.prototype.push')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype.push', 'Array.prototype.push')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<div>{{CompatibilityTable}}</div> + +<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("1.0")}}</td> + <td>{{CompatGeckoDesktop("1.7")}}</td> + <td>{{CompatIE("5.5")}}</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="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Array.prototype.pop()")}}</li> + <li>{{jsxref("Array.prototype.shift()")}}</li> + <li>{{jsxref("Array.prototype.unshift()")}}</li> + <li>{{jsxref("Array.prototype.concat()")}}</li> +</ul> diff --git a/files/ca/web/javascript/reference/global_objects/array/reduce/index.html b/files/ca/web/javascript/reference/global_objects/array/reduce/index.html new file mode 100644 index 0000000000..fa6253fd0c --- /dev/null +++ b/files/ca/web/javascript/reference/global_objects/array/reduce/index.html @@ -0,0 +1,304 @@ +--- +title: Array.prototype.reduce() +slug: Web/JavaScript/Referencia/Objectes_globals/Array/Reduce +translation_of: Web/JavaScript/Reference/Global_Objects/Array/Reduce +--- +<div>{{JSRef}}</div> + +<p>El mètode <code><strong>reduce()</strong></code> aplica una funció sobre un acumulador i cada valor de l'array (de esquerra a dreta) perr a reduir-lo a un sol valor.</p> + +<h2 id="sintaxi">sintaxi</h2> + +<pre class="syntaxbox"><code><var>arr</var>.reduce(<var>callback</var>[, valorInicial])</code></pre> + +<h3 id="Parameters">Parameters</h3> + +<dl> + <dt><code>callback</code></dt> + <dd>Funció a executar per a cada valor de l'array. Rep quatre arguments: + <dl> + <dt><code>valorPrevi</code></dt> + <dd>El valor retornat prèviament en l'última invocació de la funció <code>callback</code>, o bé <code>valorInicial</code>, si s'ha proporcionat (vegeu més abaix).</dd> + <dt><code>valorActual</code></dt> + <dd>L'element essent processat actualment a l'array.</dd> + <dt><code>index</code></dt> + <dd>La posició de l'element essent processat actualment a l'array.</dd> + <dt><code>array</code></dt> + <dd>L'array al qual s'ha cridat el mètode <code>reduce</code>.</dd> + </dl> + </dd> + <dt><code>valorInicial</code></dt> + <dd>Opcional. Valor a utilitzar com a primer argument a la primera crida de la funció <code>callback</code>.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p><code>reduce</code> executa la funció <code>callback</code> un cop per cada element present a l'array, excloent forats a l'array, i rep quatre arguments:</p> + +<ul> + <li><code>valorPrevi</code></li> + <li><code>valorActual</code></li> + <li><code>index</code></li> + <li><code>array</code></li> +</ul> + +<p>El primer cop que es crida <code>callback</code>, <code>valorAnterior</code> i <code>valorActual</code> reben el valor de la forma descrita a continuació. Si es proporciona <code>valorInicial</code> a la crida de <code>reduce</code>, <code>valorAnterior</code> rebrà el valor de <code>valorInicial</code> i <code>valorActual</code> serà igual al primer valor de l'array. Si no es proporciona <code>valorInicial</code>, <code>valorAnterior</code> serà igual al primer valor de l'array i <code>valorActual</code> serà igual al segon.</p> + +<p>Si l'array és buit i no s'ha proporcionat <code>valorInicial</code>, es llençarà {{jsxref("Global_Objects/TypeError", "TypeError")}}. Si l'array només té un element (sense importar la seva posició) i no s'ha proporcionat <code>valorInicial</code>, o si <code>valorInicial</code> s'ha proporcionat però l'array és buit, es retornarà aquest únic valor sense realitzar cap crida a <code>callback</code>.</p> + +<p>Suposem que s'ha utilitzar <code>reduce</code> de la forma següent:</p> + +<pre class="brush: js">[0, 1, 2, 3, 4].reduce(function(previousValue, currentValue, index, array) { + return previousValue + currentValue; +}); +</pre> + +<p>La funció <code>callback</code> es cridarà quatre cops, on els arguments i els valors a retornar es mostren a continuació:</p> + +<table> + <thead> + <tr> + <th scope="col"> </th> + <th scope="col"><code>valorAnterior</code></th> + <th scope="col"><code>valorActual</code></th> + <th scope="col"><code>index</code></th> + <th scope="col"><code>array</code></th> + <th scope="col">valor retornat</th> + </tr> + </thead> + <tbody> + <tr> + <th scope="row">primera crida</th> + <td><code>0</code></td> + <td><code>1</code></td> + <td><code>1</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>1</code></td> + </tr> + <tr> + <th scope="row">segons crida</th> + <td><code>1</code></td> + <td><code>2</code></td> + <td><code>2</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>3</code></td> + </tr> + <tr> + <th scope="row">tercera crida</th> + <td><code>3</code></td> + <td><code>3</code></td> + <td><code>3</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>6</code></td> + </tr> + <tr> + <th scope="row">quarta crida</th> + <td><code>6</code></td> + <td><code>4</code></td> + <td><code>4</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>10</code></td> + </tr> + </tbody> +</table> + +<p>El valor retornat per <code>reduce</code> serà el de l'última invocació a <code>callback</code> (<code>10</code>).</p> + +<p>Si es proporcionés el valor inicial com a segon argument de <code>reduce</code>, el resultat seria el següent:</p> + +<pre class="brush: js">[0, 1, 2, 3, 4].reduce(function(valorAnterior, valorActual, index, array) { + return valorAnterior + valorActual; +}, 10); +</pre> + +<table> + <thead> + <tr> + <th scope="col"> </th> + <th scope="col"><code>valorAnterior</code></th> + <th scope="col"><code>valorActual</code></th> + <th scope="col"><code>index</code></th> + <th scope="col"><code>array</code></th> + <th scope="col">valor retornat</th> + </tr> + </thead> + <tbody> + <tr> + <th scope="row">primera crida</th> + <td><code>10</code></td> + <td><code>0</code></td> + <td><code>0</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>10</code></td> + </tr> + <tr> + <th scope="row">segona crida</th> + <td><code>10</code></td> + <td><code>1</code></td> + <td><code>1</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>11</code></td> + </tr> + <tr> + <th scope="row">tercera crida</th> + <td><code>11</code></td> + <td><code>2</code></td> + <td><code>2</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>13</code></td> + </tr> + <tr> + <th scope="row">quarta crida</th> + <td><code>13</code></td> + <td><code>3</code></td> + <td><code>3</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>16</code></td> + </tr> + <tr> + <th scope="row">cinquena crida</th> + <td><code>16</code></td> + <td><code>4</code></td> + <td><code>4</code></td> + <td><code>[0, 1, 2, 3, 4]</code></td> + <td><code>20</code></td> + </tr> + </tbody> +</table> + +<p>El valor de la crida final (<code>20</code>) és el retornat per la funció <code>reduce</code>.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Sumar_tots_els_valors_d'un_array">Sumar tots els valors d'un array</h3> + +<pre class="brush: js">var total = [0, 1, 2, 3].reduce(function(a, b) { + return a + b; +}); +// total == 6 +</pre> + +<h3 id="Aplanar_un_array_d'arrays"><em>Aplanar</em> un array d'arrays</h3> + +<pre class="brush: js">var flattened = [[0, 1], [2, 3], [4, 5]].reduce(function(a, b) { + return a.concat(b); +}, []); +// flattened is [0, 1, 2, 3, 4, 5] +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p><code>Array.prototype.reduce</code> va ser afegida a l'standard ECMA-262 a la cinquena edició; degut a això aquesta no estar present a totes les implementacions de l'standard. És possible simular-la en aquests casos mitjançant l'inserció del codi que trobareu a continuació a l'inici dels vostres scripts, tot permetent-vos utilitzar <code>reduce</code> en implementacions que no la suportin de forma nativa.</p> + +<pre class="brush: js">// Production steps of ECMA-262, Edition 5, 15.4.4.21 +// Reference: http://es5.github.io/#x15.4.4.21 +if (!Array.prototype.reduce) { + Array.prototype.reduce = function(callback /*, initialValue*/) { + 'use strict'; + if (this == null) { + throw new TypeError('Array.prototype.reduce called on null or undefined'); + } + if (typeof callback !== 'function') { + throw new TypeError(callback + ' is not a function'); + } + var t = Object(this), len = t.length >>> 0, k = 0, value; + if (arguments.length == 2) { + value = arguments[1]; + } else { + while (k < len && !(k in t)) { + k++; + } + if (k >= len) { + throw new TypeError('Reduce of empty array with no initial value'); + } + value = t[k++]; + } + for (; k < len; k++) { + if (k in t) { + value = callback(value, t[k], k, t); + } + } + return value; + }; +} +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.4.4.21', 'Array.prototype.reduce')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Definició inicial. Implementat a JavaScript 1.8.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype.reduce', 'Array.prototype.reduce')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<div>{{CompatibilityTable}}</div> + +<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>{{CompatGeckoDesktop("1.9")}}</td> + <td>{{CompatIE("9")}}</td> + <td>{{CompatOpera("10.5")}}</td> + <td>{{CompatSafari("4.0")}}</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="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Array.prototype.reduceRight()")}}</li> +</ul> diff --git a/files/ca/web/javascript/reference/global_objects/array/reverse/index.html b/files/ca/web/javascript/reference/global_objects/array/reverse/index.html new file mode 100644 index 0000000000..2528cabdc5 --- /dev/null +++ b/files/ca/web/javascript/reference/global_objects/array/reverse/index.html @@ -0,0 +1,119 @@ +--- +title: Array.prototype.reverse() +slug: Web/JavaScript/Referencia/Objectes_globals/Array/reverse +translation_of: Web/JavaScript/Reference/Global_Objects/Array/reverse +--- +<div>{{JSRef}}</div> + +<p>El mètode <code><strong>reverse()</strong></code> inverteix un array. El primer element de l'array es converteix en l'últim element i l'últim element de l'array passa a ésser el primer.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>arr</var>.reverse()</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<p>Cap.</p> + +<h2 id="Descripció">Descripció</h2> + +<p>El mètode <code>reverse</code> method transposa els elements de l'objecte array cridat en un lloc, mutant l'array, i retorna una referència de l'array.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Revertir_els_elements_d'un_array">Revertir els elements d'un array</h3> + +<p>L'exemple següent crea un array <code>myArray</code>, que conté tres elements, després inverteix l'array.</p> + +<pre class="brush: js">var myArray = ['one', 'two', 'three']; +myArray.reverse(); + +console.log(myArray) // ['three', 'two', 'one'] +</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. Implementat en JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.4.4.8', 'Array.prototype.reverse')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype.reverse', 'Array.prototype.reverse')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<div>{{CompatibilityTable}}</div> + +<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("1.0")}}</td> + <td>{{CompatGeckoDesktop("1.7")}}</td> + <td>{{CompatIE("5.5")}}</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("Array.prototype.join()")}}</li> + <li>{{jsxref("Array.prototype.sort()")}}</li> + <li>{{jsxref("TypedArray.prototype.reverse()")}}</li> +</ul> diff --git a/files/ca/web/javascript/reference/global_objects/array/shift/index.html b/files/ca/web/javascript/reference/global_objects/array/shift/index.html new file mode 100644 index 0000000000..7b5fa1b330 --- /dev/null +++ b/files/ca/web/javascript/reference/global_objects/array/shift/index.html @@ -0,0 +1,129 @@ +--- +title: Array.prototype.shift() +slug: Web/JavaScript/Referencia/Objectes_globals/Array/shift +translation_of: Web/JavaScript/Reference/Global_Objects/Array/shift +--- +<div>{{JSRef}}</div> + +<p>El mètode <code><strong>shift()</strong></code> elimina el <strong>primer</strong> element d'un array i retorna l'element eliminat. Aquest mètode canvia el tamany de l'array.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>arr</var>.shift()</code></pre> + +<h2 id="Descripció">Descripció</h2> + +<p>El mètode <code>shift</code> elimina l'element de l'array situat a la posició zero i mou la resta d'elements a la posició immediatament menor, tot seguit retorna el valor de l'element eliminat. Si la propietat {{jsxref("Array.length", "length")}} de l'array és 0, aquest mètode retornarà {{jsxref("undefined")}}.</p> + +<p><code>shift</code> és generic de forma intencionada; aquest mètode pot ser {{jsxref("Function.call", "cridat", "", 1)}} o bé {{jsxref("Function.apply", "aplicat", "", 1)}} a objectes que es comportin com a arrays. Els objectes que no continguin una propietat <code>length</code> que reflecteixi l'última propietat numèrica poden tenir un comportament erràtic.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Eliminar_un_element_d'un_array">Eliminar un element d'un array</h3> + +<p>El codi següent mostra l'array <code>myFish</code> abans i després d'eliminar el seu primer element. També mostra l'element eliminat:</p> + +<pre class="brush: js">var myFish = ['angel', 'clown', 'mandarin', 'surgeon']; + +console.log('myFish abans: ' + myFish); +// "myFish abans: angel,clown,mandarin,surgeon" + +var shifted = myFish.shift(); + +console.log('myFish després: ' + myFish); +// "myFish després: clown,mandarin,surgeon" + +console.log('Element eliminat: ' + shifted); +// "Element eliminat: angel"</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 a JavaScript 1.2.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.4.4.9', 'Array.prototype.shift')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype.shift', 'Array.prototype.shift')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype.shift', 'Array.prototype.shift')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<div>{{CompatibilityTable}}</div> + +<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("1.0")}}</td> + <td>{{CompatGeckoDesktop("1.7")}}</td> + <td>{{CompatIE("5.5")}}</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="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Array.prototype.push()")}}</li> + <li>{{jsxref("Array.prototype.pop()")}}</li> + <li>{{jsxref("Array.prototype.unshift()")}}</li> +</ul> diff --git a/files/ca/web/javascript/reference/global_objects/array/slice/index.html b/files/ca/web/javascript/reference/global_objects/array/slice/index.html new file mode 100644 index 0000000000..d181f94a65 --- /dev/null +++ b/files/ca/web/javascript/reference/global_objects/array/slice/index.html @@ -0,0 +1,268 @@ +--- +title: Array.prototype.slice() +slug: Web/JavaScript/Referencia/Objectes_globals/Array/slice +translation_of: Web/JavaScript/Reference/Global_Objects/Array/slice +--- +<div>{{JSRef}}</div> + +<p>El mètode <code><strong>slice()</strong></code> retorna una còpia feble d'una porció d'un array en forma d'un nou objecte array.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>arr</var>.slice([<var>inici</var>[, <var>fi</var>]])</code></pre> + +<h2 id="Paràmetres">Paràmetres</h2> + +<dl> + <dt><code>inici</code></dt> + <dd>La posició (tenint en compte que zero correspon a la primera posició) a partir de la qual començarà l'extracció.</dd> + <dd>Si <code>inici</code> és negatiu, la posició correspondrà a la posicó final de la seqüència menys el valor proporcionat. <code>slice(-2)</code> extreu els últims dos elements de la seqüència.</dd> + <dd>Si <code>inici</code> és <code>undefined</code>, <code>slice</code> començarà a la posició <code>0</code>.</dd> + <dt><code>fi</code></dt> + <dd>La posició (contant des de zero) en la qual finalitzarà l'extracció. <code>slice</code> extraurà fins a aquesta posicó, sense incloure-la.</dd> + <dd><code>slice(1,4)</code> extrau des del segon element fins al quart element (és a dir, els elements pertanyents a les posicions 1, 2 i 3).</dd> + <dd>Si <code>fi</code> és negatiu, la posició correspondrà a la posicó final de la seqüència menys el valor proporcionat. <code>slice(2,-1)</code> extrau des del tercer element fins al penúltim element de la seqüència.</dd> + <dd>Si s'omet el paràmetre <code>fi</code>, <code>slice</code> extreurà fins al final de la seqüència (<code>arr.length</code>)<code>.</code></dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p><code>slice</code> no altera l'array original. Retorna una copia feble dels elements de l'array original. Els elements de l'array original són copiats a l'array resultat de la forma següent:</p> + +<ul> + <li>Per a referències a objectes (no l'objecte en si), <code>slice</code> copia la referència dins el nou array. Tant l'array original com el resultat referenciaran el mateix objecte. Si l'objecte referenciat canvia, aquests canvis seran visibles a ambdos arrays.</li> + <li>Per a strings i nombres (no els objectes {{jsxref("String")}} i {{jsxref("Number")}}), <code>slice</code> copia els strings i nombres a l'array resultant. Els canvis al string o nombre en un dels arrays no afectaran a l'altre array.</li> +</ul> + +<p>Si s'afegeix un nou element a un dels dos arrays, l'altre array no es veu afectat.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Retornar_una_part_d'un_array_existent">Retornar una part d'un array existent</h3> + +<pre class="brush: js">var fruits = ['Banana', 'Orange', 'Lemon', 'Apple', 'Mango']; +var citrus = fruits.slice(1, 3); + +// citrus conté ['Orange','Lemon'] +</pre> + +<h3 id="Utilitzar_slice">Utilitzar <code>slice</code></h3> + +<p>A l'exemple següent <code>slice</code> crea un ou array <code>newCar</code>, a partir de <code>myCar</code>. Ambdos inclouen una referència a l'objecte <code>myHonda</code>. Quan el color de <code>myHonda</code> canvia a lila, ambdos arrays reflecteixen aquest canvi.</p> + +<pre class="brush: js">// Ús de slice, creem newCar a partir de myCar. +var myHonda = { color: 'red', wheels: 4, engine: { cylinders: 4, size: 2.2 } }; +var myCar = [myHonda, 2, 'cherry condition', 'purchased 1997']; +var newCar = myCar.slice(0, 2); + +// Mostrem els valors de myCar, newCar, i el color de myHonda +// referenciat a ambdos arrays. +console.log('myCar = ' + myCar.toSource()); +console.log('newCar = ' + newCar.toSource()); +console.log('myCar[0].color = ' + myCar[0].color); +console.log('newCar[0].color = ' + newCar[0].color); + +// Canviem el color de myHonda. +myHonda.color = 'purple'; +console.log('The new color of my Honda is ' + myHonda.color); + +// Mostrem el color de myHonda referenciat a ambdos arrays. +console.log('myCar[0].color = ' + myCar[0].color); +console.log('newCar[0].color = ' + newCar[0].color); +</pre> + +<p>Aquest script mostra:</p> + +<pre class="brush: js">myCar = [{color:'red', wheels:4, engine:{cylinders:4, size:2.2}}, 2, + 'cherry condition', 'purchased 1997'] +newCar = [{color:'red', wheels:4, engine:{cylinders:4, size:2.2}}, 2] +myCar[0].color = red +newCar[0].color = red +The new color of my Honda is purple +myCar[0].color = purple +newCar[0].color = purple +</pre> + +<h2 id="Objectes_compatibles_amb_arrays">Objectes compatibles amb arrays</h2> + +<p>El mètode <code>slice</code> també es pot utilitzar per a convertir objectes compatibles amb arrays / col·leccions a un nou Array. Simplement hem de vincular el mètode a l'objecte. L'objecte {{jsxref("Functions/arguments", "arguments")}} dins una funció és un exemple d'objecte 'compatible amb arrays'.</p> + +<pre class="brush: js">function list() { + return Array.prototype.slice.call(arguments); +} + +var list1 = list(1, 2, 3); // [1, 2, 3] +</pre> + +<p>Podem vincular el mètode a l'objecte mitjançant la funció .<code>call</code> proporcionada per {{jsxref("Function.prototype")}}, també podem reduir-la a <code>[].slice.call(arguments)</code> en comptes de <code>Array.prototype.slice.call</code>. També podem simplificar-ho utilitzant la funció {{jsxref("Function.prototype.bind", "bind")}}.</p> + +<pre class="brush: js">var unboundSlice = Array.prototype.slice; +var slice = Function.prototype.call.bind(unboundSlice); + +function list() { + return slice(arguments); +} + +var list1 = list(1, 2, 3); // [1, 2, 3] +</pre> + +<h2 id="Oferint_un_comportament_similar_entre_navegadors">Oferint un comportament similar entre navegadors</h2> + +<p>Tot i que segons la especificació els objectes de l'hoste (com ara els objectes DOM) no requereixen seguir el comportament de Mozilla al ser convertits mitjançant <code>Array.prototype.slice</code> i, de fet les versions de Internet Explorer anteriors a la 9 no ho fan, les versions a partir de la 9 si que suporten l'ús d'aquesta funció de compatibilitat, permetent un comportament fiable entre navegadors. Mentre els altres navegadors moderns continuin oferint aquesta habilitat, tal i com ara fan IE, Mozilla, Chrome, Safari i Opera, els desenvolupadors que llegeixin codi sobre slice (suportat pel DOM) que es recolzi en aquesta funció de compatibilitat no tenen que patir per la semàntica; poden fiar-se de la semàntica descrita per a proporcionar el comportament que ara sembla standard <em>de facto</em> (La funció de compatibilitat també permet que el IE funcioni quan es passa com a segon argument de <code>slice()</code> un valor explícit de {{jsxref("null")}}/{{jsxref("undefined")}} ja que versions anteriors de IE no ho permetien però tots els nous navegadors, incloent IE >= 9, si que ho permeten.)</p> + +<pre class="brush: js">/** + * Shim for "fixing" IE's lack of support (IE < 9) for applying slice + * on host objects like NamedNodeMap, NodeList, and HTMLCollection + * (technically, since host objects have been implementation-dependent, + * at least before ES6, IE hasn't needed to work this way). + * Also works on strings, fixes IE < 9 to allow an explicit undefined + * for the 2nd argument (as in Firefox), and prevents errors when + * called on other DOM objects. + */ +(function () { + 'use strict'; + var _slice = Array.prototype.slice; + + try { + // Can't be used with DOM elements in IE < 9 + _slice.call(document.documentElement); + } catch (e) { // Fails in IE < 9 + // This will work for genuine arrays, array-like objects, + // NamedNodeMap (attributes, entities, notations), + // NodeList (e.g., getElementsByTagName), HTMLCollection (e.g., childNodes), + // and will not fail on other DOM objects (as do DOM elements in IE < 9) + Array.prototype.slice = function(begin, end) { + // IE < 9 gets unhappy with an undefined end argument + end = (typeof end !== 'undefined') ? end : this.length; + + // For native Array objects, we use the native slice function + if (Object.prototype.toString.call(this) === '[object Array]'){ + return _slice.call(this, begin, end); + } + + // For array like object we handle it ourselves. + var i, cloned = [], + size, len = this.length; + + // Handle negative value for "begin" + var start = begin || 0; + start = (start >= 0) ? start : Math.max(0, len + start); + + // Handle negative value for "end" + var upTo = (typeof end == 'number') ? Math.min(end, len) : len; + if (end < 0) { + upTo = len + end; + } + + // Actual expected size of the slice + size = upTo - start; + + if (size > 0) { + cloned = new Array(size); + if (this.charAt) { + for (i = 0; i < size; i++) { + cloned[i] = this.charAt(start + i); + } + } else { + for (i = 0; i < size; i++) { + cloned[i] = this[start + i]; + } + } + } + + return cloned; + }; + } +}()); +</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 a JavaScript 1.2.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.4.4.10', 'Array.prototype.slice')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype.slice', 'Array.prototype.slice')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype.slice', 'Array.prototype.slice')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<div>{{CompatibilityTable}}</div> + +<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("1.0")}}</td> + <td>{{CompatGeckoDesktop("1.7")}}</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="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Function.prototype.call()")}}</li> + <li>{{jsxref("Function.prototype.bind()")}}</li> +</ul> diff --git a/files/ca/web/javascript/reference/global_objects/array/some/index.html b/files/ca/web/javascript/reference/global_objects/array/some/index.html new file mode 100644 index 0000000000..7abc1ed76d --- /dev/null +++ b/files/ca/web/javascript/reference/global_objects/array/some/index.html @@ -0,0 +1,213 @@ +--- +title: Array.prototype.some() +slug: Web/JavaScript/Referencia/Objectes_globals/Array/some +translation_of: Web/JavaScript/Reference/Global_Objects/Array/some +--- +<div>{{JSRef}}</div> + +<p>El mètode <code><strong>some()</strong></code> comprova si un algun element de l'array passa el test implementat per la funció proporcionada com a argument.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox notranslate"><code><var>arr</var>.some(<var>callback</var>[, <var>thisArg</var>])</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>callback</code></dt> + <dd>Funció utilitzada com a test per a cada element, rep tres arguments: + <dl> + <dt><code>valorActual</code></dt> + <dd>L'element de l'array que està sent avaluat.</dd> + <dt><code>posició</code></dt> + <dd>La posició que l'element passat al primer paràmetre ocupa dins l'array.</dd> + <dt><code>array</code></dt> + <dd>L'array des del que s'ha cridat el mètode <code>some()</code>.</dd> + </dl> + </dd> + <dt><code>thisArg</code></dt> + <dd>Opcional. Valor que valdrà la variable <code>this</code> quan s'estigui executant la funció <code>callback</code>.</dd> +</dl> + +<h3 id="Valor_retornat">Valor retornat</h3> + +<p>Aquesta funció retorna <code><strong>true</strong></code> si la funció <code>callback</code> retorna <code><strong>true</strong></code> per a almenys un element de l'array; en qualsevol altre cas retorna <code><strong>false</strong></code>.</p> + +<h2 id="Descripció">Descripció</h2> + +<p><code>some()</code> executa la funció <code>callback</code> un cop per a cada element present a l'array fins que troba un per al qual <code>callback</code> retorna <code>true</code>. Si es troba aquest element, <code>some()</code> retorna <code>true</code> immediatament. En cas contrari <code>some()</code> retornarà <code>false</code>. Només s'invocarà la funció <code>callback</code> en les posicions de l'array que tinguin un valor assignat, és a dir, mai es cridarà per a posicions que han estat esborrades o el valor de les quals no ha estat mai assignat.</p> + +<p>S'invoca <code>callback</code> amb tres arguments: el valor de l'element, la posició de l'element dins l'array, i l'objecte array que es recorrerà.</p> + +<p>Si es proporciona el paràmetre <code>thisArg</code> al mètode <code>some()</code>, aquest es passarà a <code>callback</code> quan s'invoqui, i serà el valor que mostrarà la variable <code>this</code>. En cas contrari, s'utilitzarà el valor {{jsxref("undefined")}} com a valor per a <code>this</code>. El valor de <code>this</code> observable en última instància per <code>callback</code> es determinarà d'acord a <a href="/en-US/docs/Web/JavaScript/Reference/Operators/this">les regles per a determinar el valor de <code>this</code> observat per una funció</a>.</p> + +<p><code>some()</code> no mutarà l'array quan sigui cridada.</p> + +<p>El rang d'elements processat per <code>some()</code> és determinat abans de la primera invocació de <code>callback</code>. Els elements que s'afegeixin a l'array després de la crida a <code>some()</code> no seran visitats per <code>callback</code>. Si el valor d'un element encara no visitat canvia, el valor que es passarà a <code>callback</code> serà el valor que tingui aquest element a l'hora de visitar-lo; els elements que s'esborrin no es visitaran.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Comprovar_el_valor_dels_elements_dun_array">Comprovar el valor dels elements d'un array</h3> + +<p>L'exemple següent comprova si el valor d'algun element de l'array es major que 10.</p> + +<pre class="brush: js notranslate">function isBiggerThan10(element, posicio, array) { + return element > 10; +} +[2, 5, 8, 1, 4].some(isBiggerThan10); // false +[12, 5, 8, 1, 4].some(isBiggerThan10); // true +</pre> + +<h3 id="Comprovar_els_elements_dun_array_utilitzant_funcions_fletxa">Comprovar els elements d'un array utilitzant funcions fletxa</h3> + +<p><a href="/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions">Les funcions fletxa</a> ofereixen una sintaxi reduïda per a realitzar el mateix test.</p> + +<pre class="brush: js notranslate">[2, 5, 8, 1, 4].some(elem => elem > 10); // false +[12, 5, 8, 1, 4].some(elem => elem > 10); // true +</pre> + +<h3 id="Comprovar_si_existeix_un_valor_en_un_array">Comprovar si existeix un valor en un array</h3> + +<p>L'exemple següent retorna cert si existeix un elmeent donat dins un array</p> + +<pre class="brush: js notranslate">var fruits = ['poma', 'platan', 'mango', 'guava']; + +function checkAvailability(arr, val) { + return arr.some(function(arrVal) { + return val === arrVal; + }); +} + +checkAvailability(fruits, 'kela'); //false +checkAvailability(fruits, 'platan'); //true</pre> + +<h3 id="Comprovar_si_existeix_un_valor_amb_funcions_fletxa">Comprovar si existeix un valor amb funcions fletxa</h3> + +<pre class="brush: js notranslate">var fruits = ['poma', 'platan', 'mango', 'guava']; + +function checkAvailability(arr, val) { + return arr.some(arrVal => val === arrVal); +} + +checkAvailability(fruits, 'kela'); //false +checkAvailability(fruits, 'platan'); //true</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p><code>some()</code> va ser afegida al standard ECMA-262 en la cinquena edició; és per això que pot no estar disponible en certes implementacions del standard. Es pot proporcionar la seva funcionalitat inserint l'script següent a l'inici dels vostres scripts, permetent l'ús de <code>some()</code> en implementacions que no la suporten de forma nativa. Aquest algoritme és exactament l'especificat a l'ECMA-262, cinquena edició, assumint que {{jsxref("Object")}} i {{jsxref("TypeError")}} tenen els valors originals i que <code>fun.call</code> es correspon amb el valor original de {{jsxref("Function.prototype.call()")}}.</p> + +<pre class="brush: js notranslate">// Production steps of ECMA-262, Edition 5, 15.4.4.17 +// Reference: http://es5.github.io/#x15.4.4.17 +if (!Array.prototype.some) { + Array.prototype.some = function(fun/*, thisArg*/) { + 'use strict'; + + if (this == null) { + throw new TypeError('Array.prototype.some called on null or undefined'); + } + + if (typeof fun !== 'function') { + throw new TypeError(); + } + + var t = Object(this); + var len = t.length >>> 0; + + var thisArg = arguments.length >= 2 ? arguments[1] : void 0; + for (var i = 0; i < len; i++) { + if (i in t && fun.call(thisArg, t[i], i, t)) { + return true; + } + } + + return false; + }; +} +</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('ES5.1', '#sec-15.4.4.17', 'Array.prototype.some')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Definició inicial. Implementat a JavaScript 1.6.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype.some', 'Array.prototype.some')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype.some', 'Array.prototype.some')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<div>{{CompatibilityTable}}</div> + +<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>{{CompatGeckoDesktop("1.8")}}</td> + <td>{{CompatIE("9")}}</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>{{CompatGeckoMobile("1.8")}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Array.prototype.forEach()")}}</li> + <li>{{jsxref("Array.prototype.every()")}}</li> + <li>{{jsxref("TypedArray.prototype.some()")}}</li> +</ul> diff --git a/files/ca/web/javascript/reference/global_objects/array/splice/index.html b/files/ca/web/javascript/reference/global_objects/array/splice/index.html new file mode 100644 index 0000000000..c1abada8d9 --- /dev/null +++ b/files/ca/web/javascript/reference/global_objects/array/splice/index.html @@ -0,0 +1,171 @@ +--- +title: Array.prototype.splice() +slug: Web/JavaScript/Referencia/Objectes_globals/Array/splice +translation_of: Web/JavaScript/Reference/Global_Objects/Array/splice +--- +<div>{{JSRef}}</div> + +<p>El mètode <code><strong>splice()</strong></code> modifica el contingut d'un array eliminant elements ja existents i/o afegint-ne de nous.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>array</var>.splice(<em>inici</em>, <em>comptadorEliminar</em>[, <var>item1</var>[, <var>item2</var>[, ...]]]) +</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>inici</code></dt> + <dd>La posició a partir de la qual es començarà a modificar l'array (considerant 0 com a primera posició). Si s'especifca un nombre major que la longitud de l'array, la posició d'inici real esdevindrà la longitud de l'array. Si s'especifica un nombre negatiu, la posició d'inici serà el valor absolut del nombre especificat contant des del final de l'array.</dd> + <dt><code>comptadorEliminar</code></dt> + <dd>Un nombre sencer que indica el nombre d'elements que s'eliminaran. Si <code>comptadorEliminar</code> és 0 no s'eliminarà cap element. En aquest cas s'hauria d'especificar al menys un nou element. Si <code>comptadorEliminar</code> és major que el nombre d'elements de l'array des de la posició<strong> </strong><code>inici</code> fins el final de l'array tots els elements des d'<code>inici</code> fins al final de l'array seran eliminats.</dd> + <dd>Si s'omet <code>comptadorEliminar</code> aquest rebrà un valor per defecte igual a (<code>arr.length - inici</code>)<code>.</code></dd> + <dt><code>item1, item2, <em>...</em></code></dt> + <dd>Els elements que s'afegiran a l'array, començant a la posició <code>inici</code>. Si no s'especifcia cap element, <code>splice()</code> només eliminarà elements de l'array.</dd> +</dl> + +<h3 id="Valor_retornat">Valor retornat</h3> + +<p>Un array que conté els elements eliminats. Si només s'ha eliminat un element es retornarà un array amb un sol element. Si no s'ha eliminat cap element retornarà un array buit.</p> + +<h2 id="Descripció">Descripció</h2> + +<p>Si s'especifica un nombre diferent d'elements a eliminar del nombre d'elements a inserir la longitud de l'array canviarà al final de la crida.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_splice()">Utilitzar <code>splice()</code></h3> + +<p>L'script seguent ilustra l'ús de <code>splice()</code>:</p> + +<pre class="brush: js">var myFish = ['angel', 'clown', 'mandarin', 'surgeon']; + +// eliminem 0 elements a partir de la posició 2, i inserim 'drum' +var eliminats = myFish.splice(2, 0, 'drum'); +// myFish is ['angel', 'clown', 'drum', 'mandarin', 'surgeon'] +// eliminats va [], no s'han eliminat elements + +// myFish val ['angel', 'clown', 'drum', 'mandarin', 'surgeon'] +// eliminem 1 element a la posició 3 +eliminats = myFish.splice(3, 1); +// myFish val ['angel', 'clown', 'drum', 'surgeon'] +// eliminats val ['mandarin'] + +// myFish val ['angel', 'clown', 'drum', 'surgeon'] +// Eliminem 1 element a la posició 2, i inserim 'trumpet' +eliminats = myFish.splice(2, 1, 'trumpet'); +// myFish val ['angel', 'clown', 'trumpet', 'surgeon'] +// eliminats val ['drum'] + +// myFish val ['angel', 'clown', 'trumpet', 'surgeon'] +// eliminem 2 elements de la posició 0, i inserim 'parrot', 'anemone' i 'blue' +eliminats = myFish.splice(0, 2, 'parrot', 'anemone', 'blue'); +// myFish val ['parrot', 'anemone', 'blue', 'trumpet', 'surgeon'] +// eliminats val ['angel', 'clown'] + +// myFish val ['parrot', 'anemone', 'blue', 'trumpet', 'surgeon'] +// eliminem 2 elements de la posició 3 +eliminats = myFish.splice(myFish.length -3, 2); +// myFish val ['parrot', 'anemone', 'surgeon'] +// eliminats val ['blue', 'trumpet'] +</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 a JavaScript 1.2.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.4.4.12', 'Array.prototype.splice')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype.splice', 'Array.prototype.splice')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-array.prototype.splice', 'Array.prototype.splice')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<div>{{CompatibilityTable}}</div> + +<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("1.0")}}</td> + <td>{{CompatGeckoDesktop("1.7")}}</td> + <td>{{CompatIE("5.5")}}</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="Compatibilitat_amb_versions_anteriors">Compatibilitat amb versions anteriors</h2> + +<p>A JavaScript 1.2 el mètode <code>splice()</code> retornava l'element eliminat si només s'havia eliminat un sol element (és a dir, si el valor del paràmetre <code>comptadorEliminar</code> era 1); en qualsevol altre cas retornava un array contenit els elements eliminats.</p> + +<div class="note"> +<p><strong>Nota:</strong> L'últim navegador en utilitzar JavaScript 1.2 va ser el Netscape Navigator 4, així que podeu asumir que <code>splice()</code> sempre retornarà un array. Aquest és el cas quan un objecte JavaScript disposa de la propietat <code>length</code> i un mètode <code>splice()</code>,{{domxref("console.log()")}} el tracta com si fós un objecte array. Comprovar-ho amb <code>instanceof Array</code> retornarà <code>false.</code></p> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Array.prototype.push()", "push()")}} / {{jsxref("Array.prototype.pop()", "pop()")}} — afegir/eliminar elements del final d'un array</li> + <li>{{jsxref("Array.prototype.unshift()", "unshift()")}} / {{jsxref("Array.prototype.shift()", "shift()")}} — afegir/eliminar elements de l'inici d'un array</li> + <li>{{jsxref("Array.prototype.concat()", "concat()")}} — retorna un nou array format a partir d'aquest array i d'altres array(s) i/o valor(s)</li> +</ul> |