diff options
Diffstat (limited to 'files/ca/web/javascript')
304 files changed, 47457 insertions, 0 deletions
diff --git a/files/ca/web/javascript/a_re-introduction_to_javascript/index.html b/files/ca/web/javascript/a_re-introduction_to_javascript/index.html new file mode 100644 index 0000000000..171c31bf1b --- /dev/null +++ b/files/ca/web/javascript/a_re-introduction_to_javascript/index.html @@ -0,0 +1,930 @@ +--- +title: Una re-introducció a JavaScript (tutorial JS) +slug: Web/JavaScript/A_re-introduction_to_JavaScript +translation_of: Web/JavaScript/A_re-introduction_to_JavaScript +--- +<div>{{jsSidebar}}</div> + +<p id="Introducció">Per què una reintroducció? Perquè {{Glossary("JavaScript")}} és conegut per ser <a class="external" href="http://javascript.crockford.com/javascript.html">el llenguatge de programació més incomprès del món</a>. És ridiculitzat sovint categoritzant-lo de joguina, però darrera de la seva simplicitat enganyosa s'amaguen característiques molt potents. JavaScript s'utilitza per a un nombre increïble d'aplicacions d'alt perfil, fet que mostra que un coneixement profund d'aquesta tecnologia és una habilitat important per a qualsevol desenvolupador web o mòbil.</p> + +<p>És útil començar amb una visió general de la història del llenguatge. JavaScript va ser creat el 1995 per Brendan Eich, enginyer de Netscape, i la primera versió va sortir amb Netscape 2 a principis de 1996. (Originalment s'anava a dir LiveScript, però en una decisió pot encertada de marqueting se li va canviar pel de JavaScript en un intent de capitalitzar la popularitat del llenguatge Java de Sun Microsystem -. tot i que els dos llenguatges tenen molt poc en comú. Això ha sigut, des de llavors, una font de confusió).</p> + +<p>Alguns mesos més tard, Microsoft va llançar JScript, un llenguatge compatible amb Internet Explorer 3 semblant a JavaScript. Uns mesos més tard Netscape el va portar a <a class="external" href="http://www.ecma-international.org/">Ecma International</a>, una organització d'estandarització europea, i d'aquí en va sortir la primera edició de l'estandard {{Glossary("ECMAScript")}} d'aquell any. L'estandard va patir una important actualització a la <a class="external" href="http://www.ecma-international.org/publications/standards/Ecma-262.htm">tercera edició de l'ECMAScript </a>el 1999, i s'ha mantingut estable des de llavors. La quarta edició es va abandonar, degut a diferència sobre la complexitat del llenguatge. Moltes parts de la quarta edició van servir de base per a la 5ena edició de l'ECMAScript , publicada el Desembre de 2009, i per la 6ena i més gran versió de l'estandard, que es publicarà el 2015.</p> + +<p>D'ara en endavant, per familiaritat, em referiré a l'ECMAScript com a "JavaScript".</p> + +<p>Al contrari que la majoria de llenguatges de programació, JavaScript no té el concepte de "input" ( entrada) o "output" sortida. Està pensat per a ser executat com un llenguatge d'"script" sobre un entorn extern que l'acull i li proporciona els mecanismes per a la comunicació amb el món exterior. L'entorn més comú és el navegador, però l'intèrpret de JavaScript es pot trobar en una extensa llista d'altres llocs, incloent Adobe Acrobat, Abobe Photoshop, imatge SVG , Yahoo's Widget engine, entorns de la banda del servidor com <a href="http://nodejs.org/" title="nodejs.org">Node.js</a>, bases de dades NoSQL com <a href="http://couchdb.apache.org/">Apache CouchDB</a>, que es de codi obert, ordinadors integrats<span style="background-color: #ffffff; color: #4d4e53; font-family: open sans,arial,sans-serif; font-size: 14px; line-height: 21px;">, entorns d'escriptori sencers com </span><a href="http://www.gnome.org/" style="margin: 0px; padding: 0px; border: 0px; color: rgb(0, 149, 221); text-decoration: none; font-family: 'Open Sans', Arial, sans-serif; font-size: 14px; line-height: 21px; background-color: rgb(255, 255, 255);">GNOME</a><span style="background-color: #ffffff; color: #4d4e53; font-family: open sans,arial,sans-serif; font-size: 14px; line-height: 21px;"> (una de les GUIs pel sistema operatiu GNU/Linux més populars), i la llista segueix</span>.</p> + +<h2 id="Visió_General">Visió General</h2> + +<p>JavaScript és un llenguatge orientat a objectes dinàmic amb tipus i operadors, amb contructor estàndard d'objectes i mètodes. La seva sintaxi ve de llenguatges com ara Java i C, de manera que moltes de les estructures d'aquests llenguatges s'apliquen també a JavaScript. Una de les principals diferències és que JavaScript no té classes; En el seu lloc, la funcionalitat de classe s'aconsegueix mitjançant prototips d'objectes. L'altra diferència principal és que les funcions són objectes, donant a les funcions la capacitat de tenir codi executable i ser passat a una altre funció com qualsevol altre objecte.</p> + +<p>Comencem per mirar el component bàsic de qualsevol idioma: els tipus. Els programes de JavaScript manipulen valors, i tots aquests valors pertanyen a un tipus. Els tipus de JavaScript són:</p> + +<ul> + <li>{{jsxref("Number")}}</li> + <li>{{jsxref("String")}}</li> + <li>{{jsxref("Boolean")}}</li> + <li>{{jsxref("Function")}}</li> + <li>{{jsxref("Object")}}</li> + <li>{{jsxref("Symbol")}} (nou a la 6ena edició)</li> +</ul> + +<p>... ah, i {{jsxref ("undefined")}} i {{jsxref ("nul")}}, que són ... una mica estranys. I les matrius {{jsxref ("arrays")}}, que són un tipus especial d'objecte. I {{jsxref ("Data")}} i {{jsxref ("RegExp")}}, que són objectes que tens de forma gratuïta. I per ser tècnicament precisos, les funcions són només un tipus especial d'objecte. Així que el diagrama tipus s'assembla més a això:</p> + +<ul> + <li>{{jsxref("Number")}}</li> + <li>{{jsxref("String")}}</li> + <li>{{jsxref("Boolean")}}</li> + <li>{{jsxref("Symbol")}} (nou a l'edició 6)</li> + <li>{{jsxref("Object")}} + <ul> + <li>{{jsxref("Function")}}</li> + <li>{{jsxref("Array")}}</li> + <li>{{jsxref("Date")}}</li> + <li>{{jsxref("RegExp")}}</li> + </ul> + </li> + <li>{{jsxref("null")}}</li> + <li>{{jsxref("undefined")}}</li> +</ul> + +<p>I també hi ha alguns tipus interns com aquest {{jsxref("Error")}} . Crec que ésmés senzill si ens quedem amb el primer diagrama.</p> + +<h2 id="Nombres">Nombres</h2> + +<p>Els nombres a JavaScript són "valors de 64-bit de doble precisió en format IEEE 754", d'acord amb l'especificació. Això té conseqüències interessants. No hi ha. No hi ha coses com "integer" (nombre enter) a JavaScript, així que et cal ser una mica curós amb la seva aritmètica si estàs acostumat a les operacions de C o Java. Compte amb coses com:</p> + +<pre class="brush: js">0.1 + 0.2 == 0.30000000000000004 +</pre> + +<p>A la pràctica, els valors enters són tractats com sencers de 32 bits (i s'emmagatzemen d'aquesta manera en algunes implementacions de navegador), fet que pot ser important per a operacions bit a bit.</p> + +<p>Els operadors aritmètics estàndard hi són implantats, inclou la suma, la resta, el mòdul (o el residu) i molts altres. També hi ha un objecte incorporat que em vaig oblidar d'esmentar anteriorment que s'anomena {{jsxref ("Math")}} per si vols realitzar funcions matemàtiques més avançades i valors de constants:.</p> + +<pre class="brush: js">Math.sin(3.5); +var circumfrence = Math.PI * (r + r); +</pre> + +<p>Pot convertir una cadena a un enter utilitzant la funció incorporada {{jsxref ("Global_Objects / parseInt", "parseInt ()")}}. Això pren com a base ( decimal, hexadecimal, ...) per a la conversió un segon argument opcional , que sempre s'ha de proporcionar</p> + +<pre class="brush: js">parseInt("123", 10); // 123 +parseInt("010", 10); // 10 +</pre> + +<p>Si no el proporciones, pots obtenir resultats sorprenents en els navegadors més antics (anteriors a 2013):</p> + +<pre class="brush: js">parseInt("010"); // 8 +</pre> + +<p>Això passa perquè la funció {{jsxref ("Global_Objects / parseInt", "parseInt ()")}} tracta per defecte la cadena com un nombre octal degut al 0 inicial.</p> + +<p>Si voleu convertir un nombre binari a un sencer, només cal canviar la base:</p> + +<pre class="brush: js">parseInt("11", 2); // 3 +</pre> + +<p>De la mateixa manera, pot analitzar els nombres de coma flotant utilitzant la funció incorporada {{jsxref ("Global_Objects / parseFloat", "parseFloat ()")}} que fa servir sempre la base 10 a diferència del seu cosí {{jsxref ("Global_Objects / parseInt", "parseInt () ")}}.</p> + +<p>També pot utilitzar l'operador unari + per convertir les cadenes amb nombre als seus valors :</p> + +<pre class="brush: js">+ "42"; // 42 +</pre> + +<p>Un valor especial anomenat {{jsxref ("NaN")}} (abreviatura de "Not a Number") es retorna si la cadena no és un nombre:</p> + +<pre class="brush: js">parseInt("hello", 10); // NaN +</pre> + +<p><code>NaN</code> és toxic: si es proporciona com una entrada a qualsevol operació matemàtica el resultat també serà sempre NaN:</p> + +<pre class="brush: js">NaN + 5; // NaN +</pre> + +<p>Podeu provar NaN utilitzant al funció incorporada {{jsxref ("Global_Objects / isNaN", "isNaN ()")}}:</p> + +<pre class="brush: js">isNaN(NaN); // true +</pre> + +<p>JavaScript també té els valors especials com l'infinit {{jsxref ("Infinity")}} i també -infinity:</p> + +<pre class="brush: js"> 1 / 0; // Infinity +-1 / 0; // -Infinity +</pre> + +<p>Podeu provar Infinity, -Infinity i el valor NaN utilitzant la funció incorporada {{jsxref ("Global_Objects / isFinite", "isFinite ()")}} :</p> + +<pre class="brush: js">isFinite(1/0); // false +isFinite(-Infinity); // false +isFinite(NaN); // false +</pre> + +<div class="note"><strong>Nota:</strong> Les funcions {{jsxref ("Global_Objects / parseInt", "parseInt ()")}} i {{jsxref ("Global_Objects / parseFloat", "parseFloat ()")}} analitzen una cadena fins que arriben a un caràcter que no és nombre vàlid pel format especificat, i torna el resultat de l'anàlisis fins a aquest moment. No obstant això, l'operador "+" senzillament converteix la cadena a NaN si hi ha algun caràcter no vàlid en ella. Només cal que intenti analitzar la cadena "10.2abc" amb cada mètode a la consola i entredrà millor les diferències.</div> + +<h2 id="Cadenes">Cadenes</h2> + +<p>Les cadenes a JavaScript són seqüències de caràcters. Més exactament, són seqüències de caràcters Unicode, amb cada caràcter representat per un nombre de 16 bits. Això hauria de ser una bona notícia per a qualsevol persona que ha hagut de lidiar amb la internacionalització.</p> + +<p>Si vol representar un sol caràcter, només ha d'utilitzar una cadena de longitud 1.</p> + +<p>Per trobar la longitud d'una cadena, pot accedir a la seva propietat ( atribut) length:</p> + +<pre class="brush: js">"hello".length; // 5 +</pre> + +<p>Aquí tenim la nostra primera topoda amb objectes JavaScript! He esmentat que pot fer servir cadenes com {{jsxref ("objecte", "objectes", "", 1)}} Tenen {{jsxref ("String", "mètodes", "#Methods", 1)}}, que li permeten manipular la informació de la cadena i l'accés a la cadena:</p> + +<pre class="brush: js">"hello".charAt(0); // "h" +"hello, world".replace("hello", "goodbye"); // "goodbye, world" +"hello".toUpperCase(); // "HELLO" +</pre> + +<h2 id="Altres_Tipus">Altres Tipus</h2> + +<p>JavaScript distingeix entre {{jsxref ("nul")}}, que és un valor que indica un no-valor deliberat (i només és accessible a través de la paraula clau null), i {{jsxref ("indefinit")}}, que és un valor de tipus 'indefinit' que indica un valor no inicialitzat - és a dir, un valor que ni tan sols s'ha assignat encara. Parlarem de les variables més tard, però a JavaScript, és possible declarar una variable sense assignar un valor a la mateixa. Si fa això, el tipus de la variable no està definida. indefinit és en realitat una constant.</p> + +<p>JavaScript té un tipus booleà, amb possibles valors vertaders i falsos (que són paraules clau). Qualsevol valor pot ser convertit a un valor booleà d'acord amb les següents regles:</p> + +<ol> + <li><code>false</code>, <code>0</code>, cadena buida (<code>""</code>), <code>NaN</code>, <code>null</code>, i <code>undefined</code> tots donant com a resultat <code>false.</code></li> + <li>Tots els altres valors es considern <code>true.</code></li> +</ol> + +<p>Pot dur a terme aquesta conversió utilitzant de manera explícita la funció Boolean ():</p> + +<pre class="brush: js">Boolean(""); // false +Boolean(234); // true +</pre> + +<p>De totes maneres, no sol ser necessari, Javascript fa aquesta conversió automàticament quan s'espera un booleà, com en una sentència if (veure més avall). Per aquesta raó, de vegades parlem senzillamentt de "valors vertaders" i "valors falsos", és a dir els valors que esdevenen vertaders i falsos, respectivament, quan es converteixen en booleans. Aquests valors poden es poden dir "Truthy" i "Falsy", respectivament.</p> + +<p>Operacions booleanes com && (AND lògic), || (o lògica), i! (Lògic no) també estan incorporats; Skip. Veure més avall.</p> + +<h2 id="Variables">Variables</h2> + +<p>Les noves variables a JavaScript es declaren fent servir la paraula clau var:</p> + +<pre class="brush: js">var a; +var name = "simon"; +</pre> + +<p>Si es declara una variable sense assignar un valor a la mateixa, el seu tipus no està definit.</p> + +<p>Una diferència important amb altres llenguatges com ara Java és que a JavaScript els blocs no tenen un "scope" (àmbit a on tenen un valor assignat) ( ; només les funcions tenen àmbit d'aplicació. Així que si una variable es defineix fent servir var en una sentència composta (per exemple, dins d'una estructura de control "if"), serà visible a tota la funció. No obstant això, a partir de ECMAScript Edition 6, es permeten les declaracions const que permetrar crear variables amb ambit d'assignació.</p> + +<h2 id="Operadors">Operadors</h2> + +<p>Els Operadors numèrics de JavaScript són +, -, *, / i% - que és l'operador del reste de la divisió. Els valors s'assignen utilitzant =, i també hi ha instruccions d'assignació compostos com += i -=. Aquests últims equivalen a x = x operador i.</p> + +<pre class="brush: js">x += 5 +x = x + 5 //equival a l'operador anterior +</pre> + +<p>Podeu utilitzar ++ i - per augmentar i decrèixer, respectivament. Poden ser usats com a operadors de prefix o sufix.</p> + +<p>L'operador + també serveix per a la concatenació de cadenes:</p> + +<pre class="brush: js">"hello" + " world"; // "hello world" +</pre> + +<p>Si s'agrega una cadena a un nombre (o un altre valor) tot es converteix a cadena su el primer valor és la cadena . Si no, primer s'operen el nombre i després es converteix a cadena:</p> + +<pre class="brush: js">"3" + 4 + 5; // "345" + 3 + 4 + "5"; // "75" +</pre> + +<p>Afegir una cadena buida a alguna cosa és una forma útil per a la seva conversió.</p> + +<p>Les comparacions a JavaScript es poden fer usant <, >, <= i >= . Aquests funcionen tant per cadenes com per nombres. L' "igual a" és una mica més complicatl. El doble igual fa la conversió al mateix tipus si són diferents i després compara els valors . Això, de vegades, suposa resultats interessants:</p> + +<pre class="brush: js">"dog" == "dog"; // true +1 == true; // true +</pre> + +<p>Per tenir em compte el tipus en la comparació , utilitza l'operador triple igual:</p> + +<pre class="brush: js">1 === true; // false +true === true; // true +</pre> + +<p>Hi ha tamble l'operador contrari <code>!=</code> i contrari estricte <code>!==</code> .</p> + +<p>JavaScript té també operacions bit a bit. Si voleu utilitzar-les, allà estan.</p> + +<h2 id="Estructures_de_control">Estructures de control</h2> + +<p>JavaScript té un conjunt similar d'estructures de control a altres idiomes de la família C. Les sentències condicionals es fan a partir d' "if", i "else" ; ès poden encadenar si et convé:</p> + +<pre class="brush: js">var name = "kittens"; +if (name == "puppies") { + name += "!"; +} else if (name == "kittens") { + name += "!!"; +} else { + name = "!" + name; +} +name == "kittens!!" +</pre> + +<p>JavaScript té bucles while i do-while. El primer d'ells és bo per bucles bàsics; el segon pels bucles que vol que s'executin com a mínim una vegada:</p> + +<pre class="brush: js">while (true) { + // an infinite loop! +} + +var input; +do { + input = get_input(); +} while (inputIsNotValid(input)) +</pre> + +<p>El bucle "for" és el mateix que a C i Java: se li permet proporcionar la informació de control del bucle en una sola línia.</p> + +<pre class="brush: js">for (var i = 0; i < 5; i++) { + // Will execute 5 times +} +</pre> + +<p>Els operadors && i || fan servir la lògica de curtcircuit, això significa que el segon operant depèn de la primer. Això és útil per exemple per comprovar que els objectes no siguin nuls abans d'accedir als seus atributs:</p> + +<pre class="brush: js">var name = o && o.getName(); +</pre> + +<p>O per donar valors per defecte:</p> + +<pre class="brush: js">var name = otherName || "default"; +</pre> + +<p>JavaScript té un operador ternari per expressions condicionals:</p> + +<pre class="brush: js">var allowed = (age > 18) ? "yes" : "no"; +</pre> + +<p>La declaració switch pot ser utilitzat per comparar amb múltiples branques basades en nombres o cadenes:</p> + +<pre class="brush: js">switch(action) { + case 'draw': + drawIt(); + break; + case 'eat': + eatIt(); + break; + default: + doNothing(); +} +</pre> + +<p>Si no afegeix una sentència break, l'execució "cauen al" següent nivell. Això rares vegades serà el que voldrà - de fet val la pena etiquetar específicament aquest "fallthrough" deliberat si és el cas amb un comentari per ajudar a la depuració:</p> + +<pre class="brush: js">switch(a) { + case 1: // fallthrough + case 2: + eatIt(); + break; + default: + doNothing(); +} +</pre> + +<p>La clàusula d'incompliment és opcional. Pot tenir expressions, tant en la part del "switch" com la dels casos si vol; les comparacions es realitzen entre els dos fent servir l'operador ===:</p> + +<pre class="brush: js">switch(1 + 3) { + case 2 + 2: + yay(); + break; + default: + neverhappens(); +} +</pre> + +<h2 id="Objectes">Objectes</h2> + +<p>Els objectes de JavaScript poden ser considerats com a simples col·leccions de parells nom-valor. Com a tals, són similars a:</p> + +<ul> + <li>Dicdionaris a Python</li> + <li>Hashes in Perl and Ruby</li> + <li>Taules Hash a C i C++</li> + <li>HashMaps a Java</li> + <li>Matrius associades a PHP</li> +</ul> + +<p>En realitat aquesta estructura de dades és fa ser tant que és una prova de la seva enorme versatilitat. Ja que tot (fins i tots els tipus bàsics) a JavaScript són objectes, qualsevol programa en JavaScript implica, naturalment, una gran quantitat d'operacions de recerca a taules hash. Éstà molt bé que siguin tan ràpids.</p> + +<p>La part del "nom" és una cadena JavaScript, mentre que la part del " valor" pot ser qualsevol valor de Javascript - incloent altres objectes. Això li permet construir estructures de dades de la complexitat que es necessiti.</p> + +<p>Hi ha dues formes bàsiques per crear un objecte buit:</p> + +<pre class="brush: js">var obj = new Object(); +</pre> + +<p>I:</p> + +<pre class="brush: js">var obj = {}; +</pre> + +<p>I....</p> + +<pre class="brush: js">function Person(name, age) { + this.name = name; + this.age = age; +} + +// Defineix un objecte +var You = new Person("You", 24); +// Estem creant una nova persona amb el nom "You" +// (que serà el primer paràmetre, i l'edat..) +</pre> + +<p>Aquestes formes són semànticament equivalents; la segona es diu sintaxi literal d'objecte, i és la més convenient. Aquesta sintaxi és també el nucli de format JSON i s'ha de preferir en tot moment.</p> + +<p>Un cop creat un objecte , és pot accedir a les seves propietats de nou d'una d'aquestes dues maneres:</p> + +<pre class="brush: js">obj.name = "Simon"; +var name = obj.name; +</pre> + +<p>I...</p> + +<pre class="brush: js">obj["name"] = "Simon"; +var name = obj["name"]; +</pre> + +<p>Aquestes dues, també són semànticament equivalents. El segon mètode té l'avantatge que el nom de la propietat s'ofereix com una cadena, el que significa que es pot calcular en temps d'execució, encara que l'ús d'aquest mètode evita que algunes optimitzacions de motor JavaScript i Minifier s'apliquin. També es pot utilitzar per definir i obtenir propietats amb noms que són paraules reservades o que tenen espais:</p> + +<pre class="brush: js">obj.for = "Simon"; // Syntax error, perque 'for' es una paraula reservada +obj["for"] = "Simon"; // funciona +</pre> + +<div class="note"> +<p><span style="color: #222222; font-family: verdana,arial,sans-serif; font-size: 12px; line-height: 18px;"><strong>Nota:</strong></span>A partir d'EcmaScript 5, les paraules reservades es poden usar com a noms de propietats d'objecte "en l'aficionat". Això significa que no necessiten ser posades "entre cometes" a l'hora de definir objectes literals. Veure ES5 Spec.</p> +</div> + +<p>La sintaxi d'objecte literal es pot fer servir per inicialitzar un objecte totalment:</p> + +<pre class="brush: js">var obj = { + name: "Carrot", + "for": "Max", + details: { + color: "orange", + size: 12 + } +} +</pre> + +<p>L'accès als atributs pot ser encadenat:</p> + +<pre class="brush: js">obj.details.color; // orange +obj["details"]["size"]; // 12 +</pre> + +<h2 id="Matrius">Matrius</h2> + +<p>Les matrius a Javascript són en realitat un tipus especial d'objecte. Treballen de manera molt semblant als objectes normals ( naturalment a les seves propietats només es pot accedir mitjançant la sintaxi de claudàtors []) però tenen una propietat màgica anomenada "length" (llargada) , que sempre és un nombre més que l'índex més alt de la matriu.</p> + +<p>Una forma de creació de matrius és la següent:</p> + +<pre class="brush: js">var a = new Array(); +a[0] = "dog"; +a[1] = "cat"; +a[2] = "hen"; +a.length; // 3 +</pre> + +<p>Una notació més convenient és utilitzar una matriu literal:</p> + +<pre class="brush: js">var a = ["dog", "cat", "hen"]; +a.length; // 3 +</pre> + +<p>Recordeu que array.length no és necessàriament el nombre d'elements de la matriu. Considera el següent:</p> + +<pre class="brush: js">var a = ["dog", "cat", "hen"]; +a[100] = "fox"; +a.length; // 101 +</pre> + +<p>Recordi - la longitud de la matriu és un nombre més que l'índex més alt.</p> + +<p>Si es consulta un índex de matriu que no existeix, s'obté indefinit:</p> + +<pre class="brush: js">typeof a[90]; // indefinit +</pre> + +<p>Si es té en compte l'anterior, es pot iterar sobre una matriu mitjançant el següent:</p> + +<pre class="brush: js">for (var i = 0; i < a.length; i++) { + // Fer alguna cosa amb a[i] +} +</pre> + +<p>Això és una mica ineficient si cada passada del bucle ha de calcular la "length". És pot millorar fent:</p> + +<pre class="brush: js">for (var i = 0, len = a.length; i < len; i++) { + // Do something with a[i] +} +</pre> + +<p>Una forma més maca, tot i que amb limitacions, seria:</p> + +<pre class="brush: js">for (var i = 0, item; item = a[i++];) { + // Do something with item +} +</pre> + +<p>Aquí estem creant dues variables. L'assignació a la part del mig del bucle també és comprova si es "true" - si això és així, el bucle continua. Després i es va incrementant, els elements de la matriu seran assignats a "item" en ordre seqüencial. El bucle es deté quan es troba que "item" és un element "Falsy"( per tant no definit).</p> + +<p>Aquest truc només s'ha d'utilitzar per a les matrius que sap que no contenen valors "Falsy" (arrays d'objectes o {{Glossary("DOM")}} nodes, per exemple). Si està iterant sobre dades numèriques que podria incloure una dada 0 o una cadena que podria incloure la cadena buida s'ha d'utilitzar l'i, amb "len".</p> + +<p>Pot iterar sobre una matriu usant un bucle for ... in. Recordeu que si algú afegeix noves propietats a Array.prototype, també es repetiran al llarg d'aquest bucle. Per tant "no" es recomana aquest mètode.</p> + +<p>Una altra forma d'iterar sobre una matriu que s'ha afegit amb ECMAScript 5 és foreach ():</p> + +<pre class="brush: js" style="font-size: 14px;">["dog", "cat", "hen"].forEach(function(currentValue, index, array) { + // Fer alguan cosa amb el valoractual o matriu[index] +}); +</pre> + +<p>Si vol afegir un element a una matriu simplement pot fer-ho d'aquesta manera:</p> + +<pre class="brush: js">a.push(item);</pre> + +<p>Les matrius vénen amb una sèrie de mètodes. Mira també la documentació completa pels mètodes de matriu.</p> + +<table> + <thead> + <tr> + <th scope="col">Method name</th> + <th scope="col">Description</th> + </tr> + </thead> + <tbody> + <tr> + <td><code>a.toString()</code></td> + <td>Retorna una cadena amb el mètode toString () a on cada element esta separat per comes.</td> + </tr> + <tr> + <td><code>a.toLocaleString()</code></td> + <td>Retorna una cadena amb el toLocaleString () a on cada element està separat per comes.</td> + </tr> + <tr> + <td><code>a.concat(item1[, item2[, ...[, itemN]]])</code></td> + <td>Retorna una nova matriu amb els elements agregats a ella.</td> + </tr> + <tr> + <td><code>a.join(sep)</code></td> + <td>Converteix la matriu en una matriu amb valord de cadena separats entre ells pel paràmetre sep</td> + </tr> + <tr> + <td><code>a.pop()</code></td> + <td>Elimina i retorna l'últim element.</td> + </tr> + <tr> + <td><code>a.push(item1, ..., itemN)</code></td> + <td><code>Push</code> afegeix un o més elements al final.</td> + </tr> + <tr> + <td><code>a.reverse()</code></td> + <td>Inverteix la matriu.</td> + </tr> + <tr> + <td><code>a.shift()</code></td> + <td>Elimina i retorna el primer element.</td> + </tr> + <tr> + <td><code>a.slice(start, end)</code></td> + <td>Retorna una sub-matriu.</td> + </tr> + <tr> + <td><code>a.sort([cmpfn])</code></td> + <td>Pren una funció de comparació opcional.</td> + </tr> + <tr> + <td><code>a.splice(start, delcount[, item1[, ...[, itemN]]])</code></td> + <td>Li permet modificar una matriu mitjançant la supressió d'una secció i reemplaçar-la amb més elements.</td> + </tr> + <tr> + <td><code>a.unshift([item])</code></td> + <td>Afegeix items a l'inici de la matriu.</td> + </tr> + </tbody> +</table> + +<h2 id="Funcions">Funcions</h2> + +<p>Juntament amb els objectes, les funcions són el component central en la comprensió de JavaScript. La funció més bàsica no podria ser molt més simple:</p> + +<pre class="brush: js">function add(x, y) { + var total = x + y; + return total; +} +</pre> + +<p>Això demostra tot el que cal saber sobre les funcions bàsiques. Una funció de JavaScript pot tenir 0 o més paràmetres. El cos de la funció pot contenir tantes declaracions com es vulgui, i pot declarar les seves pròpies variables que són locals per a aquesta funció. La sentència return es pot utilitzar per tornar un valor en qualsevol moment i acabar la funció. Si no s'utilitza cap sentència return (o una declaració buida sense valor), JavaScript retorna undefined.</p> + +<p>Els paràmetres amb nom resulten ser més com directrius que res mes. Pot cridar ("call") una funció sense passar els paràmetres que espera, en aquest cas és passaran com indefinits.</p> + +<pre class="brush: js">add(); // NaN +//No pots fer una suma amb un valor indefinit +</pre> + +<p>També és pot passar més arguments dels que la funció espera:</p> + +<pre class="brush: js">add(2, 3, 4); // 5 +// ha sumat els dos primers; el 4 ha sigut ignorat +</pre> + +<p>Això pot semblar una mica ximple, però les funcions tenen accés a variables addicional dins del seu cos que s'anomenen arguments, que és com una matriu amb tots els valors passats a la funció. Tornem a escriure la funció add perque accepti tants valors com es vulgui:</p> + +<pre class="brush: js">function add() { + var sum = 0; + for (var i = 0, j = arguments.length; i < j; i++) { + sum += arguments[i]; + } + return sum; +} + +add(2, 3, 4, 5); // 14 +</pre> + +<p>Penso que això no és més eficaç que escriure <code>2 + 3 + 4 + 5</code>. Creem una funció més útil, calcular el promig:</p> + +<pre class="brush: js">function avg() { + var sum = 0; + for (var i = 0, j = arguments.length; i < j; i++) { + sum += arguments[i]; + } + return sum / arguments.length; +} + +avg(2, 3, 4, 5); // 3.5 +</pre> + +<p>Això és molt més útil, peró introdueix un nou problema. La funció avg () pren una llista d'argument separada per comes - però que passa si vol trobar la mitjana d'una matriu? Podria reescriure la funció de la següent manera:</p> + +<pre class="brush: js">function avgArray(arr) { + var sum = 0; + for (var i = 0, j = arr.length; i < j; i++) { + sum += arr[i]; + } + return sum / arr.length; +} + +avgArray([2, 3, 4, 5]); // 3.5 +</pre> + +<p>Però seria bo poder tornar a utilitzar la funció que ja hem creat. Per sort, JavaScript li permet cridar a una funció i cridar-la amb una sèrie arbitrària d'arguments, utilitzant el mètode {{jsxref ("Function.apply", "apply ()")}} de qualsevol objecte de funció.</p> + +<pre class="brush: js">avg.apply(null, [2, 3, 4, 5]); // 3.5 +</pre> + +<p>El segon argument per apply () és la matriu que fem servir com a argument; el primer es discutirà més endavant. Això posa en relleu el fet que les funcions són objectes també.</p> + +<p>JavaScript li deixa creas funcions anònimes.</p> + +<pre class="brush: js">var avg = function() { + var sum = 0; + for (var i = 0, j = arguments.length; i < j; i++) { + sum += arguments[i]; + } + return sum / arguments.length; +}; +</pre> + +<p>Aquesta és semànticament equivalent a la forma funció avg (). És molt potent, ja que li permet posar una definició de funció completa en qualsevol lloc, fins i tot on normalment si posa una expressió. Això permet tot tipus de trucs enginyosos. Aquí té una manera d '"amagar" algunes variables locals - àmbit de bloc com en C:</p> + +<pre class="brush: js">var a = 1; +var b = 2; + +(function() { + var b = 3; + a += b; +})(); + +a; // 4 +b; // 2 +</pre> + +<p>JavaScript li permet cridar a funcions de forma recursiva. Això és particularment útil per fer front a les estructures d'arbre, com la que s'obté en el navegador DOM.</p> + +<pre class="brush: js">function countChars(elm) { + if (elm.nodeType == 3) { // TEXT_NODE + return elm.nodeValue.length; + } + var count = 0; + for (var i = 0, child; child = elm.childNodes[i]; i++) { + count += countChars(child); + } + return count; +} +</pre> + +<p>Això posa en relleu un problema potencial amb funcions anònimes: com cridar-les de forma recursiva si no tenen un nom? JavaScript permet gravar en una expressió el nom de la funció . Podeu utilitzar noms IIFEs (Expressions de funció Immediatament invocats) com a continuació:</p> + +<pre class="brush: js">var charsInBody = (function counter(elm) { + if (elm.nodeType == 3) { // TEXT_NODE + return elm.nodeValue.length; + } + var count = 0; + for (var i = 0, child; child = elm.childNodes[i]; i++) { + count += counter(child); + } + return count; +})(document.body); +</pre> + +<p>El nom proporcionat a una expressió de funció com l'anterior només està disponible pel propi àmbit de la funció. Això permet tant que el motor pugui optimitzar més l'execució un codi més llegible. El nom també apareix en el depurador i en alguns seguiments de pila poden estalviar-li temps.</p> + +<p>Recordeu que les funcions de JavaScript són en si mateixes objectes i se les hi pot afegir o canviar les propietats igual que en els objectes que hem vist a la secció Objectes</p> + +<h2 id="Custom_objects">Custom objects</h2> + +<div class="note"><strong>Note:</strong> For a more detailed discussion of object-oriented programming in JavaScript, see <a href="/en-US/docs/Web/JavaScript/Introduction_to_Object-Oriented_JavaScript" title="https://developer.mozilla.org/en/Introduction_to_Object-Oriented_JavaScript">Introduction to Object Oriented JavaScript</a>.</div> + +<p>In classic Object Oriented Programming, objects are collections of data and methods that operate on that data. JavaScript is a prototype-based language which contains no class statement, such as is found in C++ or Java. (This is sometimes confusing for programmers accustomed to languages with a class statement.) Instead, JavaScript uses functions as classes. Let's consider a person object with first and last name fields. There are two ways in which the name might be displayed: as "first last" or as "last, first". Using the functions and objects that we've discussed previously, here's one way of doing it:</p> + +<pre class="example-bad brush: js">function makePerson(first, last) { + return { + first: first, + last: last + }; +} +function personFullName(person) { + return person.first + ' ' + person.last; +} +function personFullNameReversed(person) { + return person.last + ', ' + person.first; +} + +s = makePerson("Simon", "Willison"); +personFullName(s); // "Simon Willison" +personFullNameReversed(s); "Willison, Simon" +</pre> + +<p>This works, but it's pretty ugly. You end up with dozens of functions in your global namespace. What we really need is a way to attach a function to an object. Since functions are objects, this is easy:</p> + +<pre class="brush: js">function makePerson(first, last) { + return { + first: first, + last: last, + fullName: function() { + return this.first + ' ' + this.last; + }, + fullNameReversed: function() { + return this.last + ', ' + this.first; + } + }; +} + +s = makePerson("Simon", "Willison") +s.fullName(); // "Simon Willison" +s.fullNameReversed(); // "Willison, Simon" +</pre> + +<p>There's something here we haven't seen before: the <code><a href="/en-US/docs/Web/JavaScript/Reference/Operators/this" title="/en/JavaScript/Reference/Operators/this">this</a></code> keyword. Used inside a function, <code>this</code> refers to the current object. What that actually means is specified by the way in which you called that function. If you called it using <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Object_initializer#Accessing_properties" title="/en/JavaScript/Reference/Operators/Member_Operators">dot notation or bracket notation</a> on an object, that object becomes <code>this</code>. If dot notation wasn't used for the call, <code>this</code> refers to the global object.</p> + +<p>Note that <code>this</code> is a frequent cause of mistakes. For example:</p> + +<pre class="brush: js">s = makePerson("Simon", "Willison"); +var fullName = s.fullName; +fullName(); // undefined undefined +</pre> + +<p>When we call <code>fullName()</code> alone, without using <code>s.fullName()</code>, <code>this</code> is bound to the global object. Since there are no global variables called <code>first</code> or <code>last</code> we get <code>undefined</code> for each one.</p> + +<p>We can take advantage of the <code>this</code> keyword to improve our <code>makePerson</code> function:</p> + +<pre class="brush: js">function Person(first, last) { + this.first = first; + this.last = last; + this.fullName = function() { + return this.first + ' ' + this.last; + }; + this.fullNameReversed = function() { + return this.last + ', ' + this.first; + }; +} +var s = new Person("Simon", "Willison"); +</pre> + +<p>We have introduced another keyword: <code><a href="/en-US/docs/Web/JavaScript/Reference/Operators/new" title="/en/JavaScript/Reference/Operators/new">new</a></code>. <code>new</code> is strongly related to <code>this</code>. What it does is it creates a brand new empty object, and then calls the function specified, with <code>this</code> set to that new object. Notice though that the function specified with <code>this</code> does not return a value but merely modifies the <code>this</code> object. It's <code><code> </code>new</code> that returns the <code>this</code> object to the calling site. Functions that are designed to be called by <code>new</code> are called constructor functions. Common practice is to capitalize these functions as a reminder to call them with <code>new</code>.</p> + +<p>The improved function still has the same pitfall with calling <code>fullName()</code> alone.</p> + +<p>Our person objects are getting better, but there are still some ugly edges to them. Every time we create a person object we are creating two brand new function objects within it — wouldn't it be better if this code was shared?</p> + +<pre class="brush: js">function personFullName() { + return this.first + ' ' + this.last; +} +function personFullNameReversed() { + return this.last + ', ' + this.first; +} +function Person(first, last) { + this.first = first; + this.last = last; + this.fullName = personFullName; + this.fullNameReversed = personFullNameReversed; +} +</pre> + +<p>That's better: we are creating the method functions only once, and assigning references to them inside the constructor. Can we do any better than that? The answer is yes:</p> + +<pre class="brush: js">function Person(first, last) { + this.first = first; + this.last = last; +} +Person.prototype.fullName = function() { + return this.first + ' ' + this.last; +}; +Person.prototype.fullNameReversed = function() { + return this.last + ', ' + this.first; +}; +</pre> + +<p><code>Person.prototype</code> is an object shared by all instances of <code>Person</code>. It forms part of a lookup chain (that has a special name, "prototype chain"): any time you attempt to access a property of <code>Person</code> that isn't set, JavaScript will check <code>Person.prototype</code> to see if that property exists there instead. As a result, anything assigned to <code>Person.prototype</code> becomes available to all instances of that constructor via the <code>this</code> object.</p> + +<p>This is an incredibly powerful tool. JavaScript lets you modify something's prototype at any time in your program, which means you can add extra methods to existing objects at runtime:</p> + +<pre class="brush: js">s = new Person("Simon", "Willison"); +s.firstNameCaps(); // TypeError on line 1: s.firstNameCaps is not a function + +Person.prototype.firstNameCaps = function() { + return this.first.toUpperCase() +}; +s.firstNameCaps(); // "SIMON" +</pre> + +<p>Interestingly, you can also add things to the prototype of built-in JavaScript objects. Let's add a method to <code>String</code> that returns that string in reverse:</p> + +<pre class="brush: js">var s = "Simon"; +s.reversed(); // TypeError on line 1: s.reversed is not a function + +String.prototype.reversed = function() { + var r = ""; + for (var i = this.length - 1; i >= 0; i--) { + r += this[i]; + } + return r; +}; + +s.reversed(); // nomiS +</pre> + +<p>Our new method even works on string literals!</p> + +<pre class="brush: js">"This can now be reversed".reversed(); // desrever eb won nac sihT +</pre> + +<p>As I mentioned before, the prototype forms part of a chain. The root of that chain is <code>Object.prototype</code>, whose methods include <code>toString()</code> — it is this method that is called when you try to represent an object as a string. This is useful for debugging our <code>Person</code> objects:</p> + +<pre class="brush: js">var s = new Person("Simon", "Willison"); +s; // [object Object] + +Person.prototype.toString = function() { + return '<Person: ' + this.fullName() + '>'; +} + +s.toString(); // "<Person: Simon Willison>" +</pre> + +<p>Remember how <code>avg.apply()</code> had a null first argument? We can revisit that now. The first argument to <code>apply()</code> is the object that should be treated as '<code>this</code>'. For example, here's a trivial implementation of <code>new</code>:</p> + +<pre class="brush: js">function trivialNew(constructor, ...args) { + var o = {}; // Create an object + constructor.apply(o, args); + return o; +} +</pre> + +<p>This isn't an exact replica of <code>new</code> as it doesn't set up the prototype chain (it would be difficult to illustrate). This is not something you use very often, but it's useful to know about. In this snippet, <code>...args</code> (including the ellipsis) is called the "<a href="/en-US/docs/Web/JavaScript/Reference/Functions/rest_parameters">rest arguments</a>" – as the name implies, this contains the rest of the arguments.</p> + +<p>Calling</p> + +<pre class="brush: js">var bill = trivialNew(Person, "William", "Orange");</pre> + +<p>is therefore almost equivalent to</p> + +<pre class="brush: js">var bill = new Person("William", "Orange");</pre> + +<p><code>apply()</code> has a sister function named <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/call" title="/en/JavaScript/Reference/Global_Objects/Function/call"><code>call</code></a>, which again lets you set <code>this</code> but takes an expanded argument list as opposed to an array.</p> + +<pre class="brush: js">function lastNameCaps() { + return this.last.toUpperCase(); +} +var s = new Person("Simon", "Willison"); +lastNameCaps.call(s); +// Is the same as: +s.lastNameCaps = lastNameCaps; +s.lastNameCaps(); +</pre> + +<h3 id="Inner_functions">Inner functions</h3> + +<p>JavaScript function declarations are allowed inside other functions. We've seen this once before, with an earlier <code>makePerson()</code> function. An important detail of nested functions in JavaScript is that they can access variables in their parent function's scope:</p> + +<pre class="brush: js">function betterExampleNeeded() { + var a = 1; + function oneMoreThanA() { + return a + 1; + } + return oneMoreThanA(); +} +</pre> + +<p>This provides a great deal of utility in writing more maintainable code. If a function relies on one or two other functions that are not useful to any other part of your code, you can nest those utility functions inside the function that will be called from elsewhere. This keeps the number of functions that are in the global scope down, which is always a good thing.</p> + +<p>This is also a great counter to the lure of global variables. When writing complex code it is often tempting to use global variables to share values between multiple functions — which leads to code that is hard to maintain. Nested functions can share variables in their parent, so you can use that mechanism to couple functions together when it makes sense without polluting your global namespace — 'local globals' if you like. This technique should be used with caution, but it's a useful ability to have.</p> + +<h2 id="Closures">Closures</h2> + +<p>This leads us to one of the most powerful abstractions that JavaScript has to offer — but also the most potentially confusing. What does this do?</p> + +<pre class="brush: js">function makeAdder(a) { + return function(b) { + return a + b; + }; +} +var x = makeAdder(5); +var y = makeAdder(20); +x(6); // ? +y(7); // ? +</pre> + +<p>The name of the <code>makeAdder</code> function should give it away: it creates new 'adder' functions, which when called with one argument add it to the argument that they were created with.</p> + +<p>What's happening here is pretty much the same as was happening with the inner functions earlier on: a function defined inside another function has access to the outer function's variables. The only difference here is that the outer function has returned, and hence common sense would seem to dictate that its local variables no longer exist. But they <em>do</em> still exist — otherwise the adder functions would be unable to work. What's more, there are two different "copies" of <code>makeAdder</code>'s local variables — one in which <code>a</code> is 5 and one in which <code>a</code> is 20. So the result of those function calls is as follows:</p> + +<pre class="brush: js">x(6); // returns 11 +y(7); // returns 27 +</pre> + +<p>Here's what's actually happening. Whenever JavaScript executes a function, a 'scope' object is created to hold the local variables created within that function. It is initialised with any variables passed in as function parameters. This is similar to the global object that all global variables and functions live in, but with a couple of important differences: firstly, a brand new scope object is created every time a function starts executing, and secondly, unlike the global object (which is accessible as <code>this</code> and in browsers is accessible as <code>window</code>) these scope objects cannot be directly accessed from your JavaScript code. There is no mechanism for iterating over the properties of the current scope object, for example.</p> + +<p>So when <code>makeAdder</code> is called, a scope object is created with one property: <code>a</code>, which is the argument passed to the <code>makeAdder</code> function. <code>makeAdder</code> then returns a newly created function. Normally JavaScript's garbage collector would clean up the scope object created for <code>makeAdder</code> at this point, but the returned function maintains a reference back to that scope object. As a result, the scope object will not be garbage collected until there are no more references to the function object that <code>makeAdder</code> returned.</p> + +<p>Scope objects form a chain called the scope chain, similar to the prototype chain used by JavaScript's object system.</p> + +<p>A closure is the combination of a function and the scope object in which it was created.</p> + +<p>Closures let you save state — as such, they can often be used in place of objects. Several excellent introductions to closures can be found <a href="http://stackoverflow.com/questions/111102/how-do-javascript-closures-work">here</a>.</p> + +<h3 id="Memory_leaks">Memory leaks</h3> + +<p>An unfortunate side effect of closures is that they make it trivially easy to leak memory in Internet Explorer. JavaScript is a garbage collected language — objects are allocated memory upon their creation and that memory is reclaimed by the browser when no references to an object remain. Objects provided by the host environment are handled by that environment.</p> + +<p>Browser hosts need to manage a large number of objects representing the HTML page being presented — the objects of the DOM. It is up to the browser to manage the allocation and recovery of these.</p> + +<p>Internet Explorer uses its own garbage collection scheme for this, separate from the mechanism used for JavaScript. It is the interaction between the two that can cause memory leaks.</p> + +<p>A memory leak in IE occurs any time a circular reference is formed between a JavaScript object and a native object. Consider the following:</p> + +<pre class="example-bad brush: js">function leakMemory() { + var el = document.getElementById('el'); + var o = { 'el': el }; + el.o = o; +} +</pre> + +<p>The circular reference formed above creates a memory leak; IE will not free the memory used by <code>el</code> and <code>o</code> until the browser is completely restarted.</p> + +<p>The above case is likely to go unnoticed; memory leaks only become a real concern in long running applications or applications that leak large amounts of memory due to large data structures or leak patterns within loops.</p> + +<p>Leaks are rarely this obvious — often the leaked data structure can have many layers of references, obscuring the circular reference.</p> + +<p>Closures make it easy to create a memory leak without meaning to. Consider this:</p> + +<pre class="example-bad brush: js">function addHandler() { + var el = document.getElementById('el'); + el.onclick = function() { + el.style.backgroundColor = 'red'; + }; +} +</pre> + +<p>The above code sets up the element to turn red when it is clicked. It also creates a memory leak. Why? Because the reference to <code>el</code> is inadvertently caught in the closure created for the anonymous inner function. This creates a circular reference between a JavaScript object (the function) and a native object (<code>el</code>).</p> + +<p>There are a number of workarounds for this problem. The simplest is not to use the <code>el</code> variable:</p> + +<pre class="example-good brush: js">function addHandler(){ + document.getElementById('el').onclick = function(){ + this.style.backgroundColor = 'red'; + }; +} +</pre> + +<p>Surprisingly, one trick for breaking circular references introduced by a closure is to add another closure:</p> + +<pre class="brush: js">function addHandler() { + var clickHandler = function() { + this.style.backgroundColor = 'red'; + }; + (function() { + var el = document.getElementById('el'); + el.onclick = clickHandler; + })(); +} +</pre> + +<p>The inner function is executed straight away, and hides its contents from the closure created with <code>clickHandler</code>.</p> + +<p>Another good trick for avoiding closures is breaking circular references during the <code>window.onunload</code> event. Many event libraries will do this for you. Note that doing so disables the <a href="/en-US/docs/Working_with_BFCache" title="En/Using_Firefox_1.5_caching">back-forward cache in Firefox</a>, so you should not register an <code>unload</code> listener in Firefox, unless you have other reasons to do so.</p> diff --git a/files/ca/web/javascript/data_structures/index.html b/files/ca/web/javascript/data_structures/index.html new file mode 100644 index 0000000000..5bb63891ed --- /dev/null +++ b/files/ca/web/javascript/data_structures/index.html @@ -0,0 +1,258 @@ +--- +title: JavaScript data types and data structures +slug: Web/JavaScript/Data_structures +translation_of: Web/JavaScript/Data_structures +--- +<div>{{jsSidebar("More")}}</div> + +<p>Tots els llenguatges de programació tenen estructures de dades definides com a part d'ells mateixos. Aquestes estrcutures, però, són sovint varien d'un llenguatge a un altre. Aquest article pretén llistar totes les estructures de dades que JavaScript té de forma interna, així com quines propietats tenen; aquestes estructures es poden utilitzar per a per a construir altres estrcutures. Es mostraran comparacionis amb altres llenguatges de programació quan sigui possible.</p> + +<h2 id="Tipatge_dinàmic">Tipatge dinàmic</h2> + +<p>JavaScript és un llenguatge <em>de tipatge flu</em><em>ix, </em><code>o </code><em>dinàmic</em>. Això vol dir que no cal declarar el tipus d'una variable abans d'utilitzar-la. El seu tipus es determinarà mentre el programa s'executi. Això també implica que la mateixa variable pot rebre valors que tinguin diferents tipus:</p> + +<pre class="brush: js notranslate">var foo = 42; // foo ara és un Number +var foo = "bar"; // foo ara és un String +var foo = true; // foo ara és un Boolean +</pre> + +<h2 id="Tipus_de_dades">Tipus de dades</h2> + +<p>L'últim standard ECMAScript defineix set tipus de dades:</p> + +<ul> + <li>Sis tipus de dades que són {{Glossary("Primitive", "primitius")}}: + <ul> + <li>{{Glossary("Boolean")}}</li> + <li>{{Glossary("Null")}}</li> + <li>{{Glossary("Undefined")}}</li> + <li>{{Glossary("Number")}}</li> + <li>{{Glossary("String")}}</li> + <li>{{Glossary("Symbol")}} (nou, introduït a l'ECMAScript 6)</li> + </ul> + </li> + <li>i {{Glossary("Object")}}</li> +</ul> + +<h2 id="Valors_primitius">Valors primitius</h2> + +<p>Tots els tipus, a excepció dels objectes, defineixen valors immutables (valors que no es poden canviar). Per exemple, al contrari que C, els Strings són immutables. Ens referim a valors d'aquests tipus com a "valors primitius".</p> + +<h3 id="Tipus_Booleà">Tipus Booleà</h3> + +<p>Els booleans representen una entitat lògica i poden tenir un dels dos valors següents: <code>true</code>, o bé <code>false</code>.</p> + +<h3 id="Tipus_Null">Tipus Null</h3> + +<p>El tipus Null té un únic valor: <code>null</code>. Vegeu {{jsxref("null")}} i {{Glossary("Null")}} per a més detalls.</p> + +<h3 id="Tipus_Undefined">Tipus Undefined</h3> + +<p>Una variable a la que no se l'ha assignat cap valor té el valor <code>undefined</code>. Vegeu {{jsxref("undefined")}} i {{Glossary("Undefined")}} per a més detalls.</p> + +<h3 id="Tipus_Number">Tipus Number</h3> + +<p>Segons el standard ECMAScript, només hi ha un tipus que representi nombres: el <a href="http://en.wikipedia.org/wiki/Double_precision_floating-point_format">valor de doble precisió de 64 bits en format binari IEEE 754</a> (capaç de representar nombres entre -(2<sup>53</sup> -1) i 2<sup>53</sup> -1). <strong>No hi ha un tipus específic per a representar nombres sencers</strong>. A més de ser capaç de representar nombres en coma flotant, el tipus Number disposa de tres valors adicionals simbòlics: <code>+Infinity</code>, <code>-Infinity</code>, i <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/NaN"><code>NaN</code></a> (No un Nombre, de l'anglés Not-A-Number).</p> + +<p>Per a comprovar valors més grans o més petits que <code>+/-Infinity</code>, es poden emprar les constants {{jsxref("Number.MAX_VALUE")}} i {{jsxref("Number.MIN_VALUE")}} i, a partir de l'ECMAScript 6, també es pot comprovar si un nombre en coma flotant de doble precisió està dins el rang mitjançant {{jsxref("Number.isSafeInteger()")}}, així com {{jsxref("Number.MAX_SAFE_INTEGER")}} i {{jsxref("Number.MIN_SAFE_INTEGER")}}. Fora d'aquest rang no és segur utilitzar nombres a JavaScript.</p> + +<p>El tipus Number disposa únicament d'un nombre sencer que té dues representacions: 0 s'interpreta com a -0 i +0. ("0" és un alias per a +0). A la pràctica, això no te quasi cap impacte. Per exemple, <code>+0 === -0</code> evalua a <code>true</code>. No obstant, aquesta diferència si existeix quan es divideix per zero:</p> + +<pre class="brush: js notranslate">> 42 / +0 +Infinity +> 42 / -0 +-Infinity +</pre> + +<p>Tot i que un nombre sovint només representa el seu valor, JavaScript disposa d'<a href="/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators" title="en/JavaScript/Reference/Operators/Bitwise_Operators">alguns operadors binaris</a>. Aquests operadors es poden emprar per a representar un conjunt de valors Booleans dins un sol nombre, utilitzen una <a class="external" href="http://en.wikipedia.org/wiki/Mask_%28computing%29">màscara de bits</a>. Això es considera una mala pràctica tot i que JavaScript no ofereix cap altra forma per a representar un conjunt de Booleans (com ara un array de Booleans o un objecte amb valors assignats a propietats amb nom). Utilitzar màscares de bits també tendeix a fer el codi més difícil de llegir, entendre i mantenir. Pot ser necessari l'ús d'aquestes tècniques en entorns força limitats, com ara quan es disposa de pocs recursos d'emmagatzematge local o en casos extrems quan cada bit enviat a la xarxa compta. Només hauria de considerar-se l'ús d'aquesta tècnica quan sigui l'últim recurs que es pot emprar per a optimitzar espai.</p> + +<h3 id="Tipus_String">Tipus String</h3> + +<p>El tipus {{jsxref("Global_Objects/String", "String")}} de JavaScript s'utilitza per a representar dades textuals. Es tracta d'un llistat d'"elements" el valor dels quals és un nombre sencer de 16 bits sense signe. Cada element dins el String ocupa una posició. El primer element té l'índex 0, el segon index 1, etcètera. La llargada d'un String és el nombre d'elements que conté.</p> + +<p>A diferència d'altres llenguatges, com ara C, Els strings a JavaScript són immutables. És a dir, quan un string s'ha creat, no és possible modificar-lo. En comptes d'això, si que és possible crear un nou string basat en un string ja existent mitjançant una operació sobre l'original. Per exemple:</p> + +<ul> + <li>Un substring de l'original via escollint lletres individuals o bé mitjançant {{jsxref("String.substr()")}}.</li> + <li>Una concatenació de dos strings mitjançant l'operador de concatenació (<code>+</code>) o bé {{jsxref("String.concat()")}}.</li> +</ul> + +<h4 id="Alerta_amb_abusar_dels_strings!">Alerta amb abusar dels strings!</h4> + +<p>Pot ser temptador utilitzar strings per a representar dades complexes. Fer-ho comporta beneficis a curt termini:</p> + +<ul> + <li>Resulta senzill construir strings complexos mitjançant la concatenació.</li> + <li>Els strings són fàcils de depurar (el que es veu imprés sempre és el que el string conté).</li> + <li>Els strings són el denominador comú de moltes APIs (<a href="/en-US/docs/Web/API/HTMLInputElement" title="HTMLInputElement">camps d'entrada</a>, valors <a href="/en-US/docs/Storage" title="Storage">emmagatzemats de forma local</a>, respostes {{ domxref("XMLHttpRequest") }} a l'utilitzar <code>responseText</code>, etc.) i pot resultar temptador utilitzar només strings.</li> +</ul> + +<p>Amb les convencions adequades, és possible representar estructures de dades dins un string. Això no vol dir que fer-ho sigui una bona idea. Per exemple, amb un separador, seria possible emular una llista (tot i que un array de JavaScript seria més adient). Malauradament, quan s'utilitzi el separador en un dels elements de la "llista", la llista esdevendrà errònia. Una solució seria escollir un caràcter d'escapament, etcètera. Tot això requereix de convencions i crea un problema de manteniment innecesari.</p> + +<p>Utilitzeu strings només per a dades textuals. Quan representin dades complexes, interpreteu els strings i utilitzeu l'abstracció adequada.</p> + +<h3 id="Tipus_Symbol">Tipus Symbol</h3> + +<p>El tipus Symbol és nou a JavaScript, introduït a l'ECMAScript Edició 6. Un Symbol és un valor primitiu <strong>únic</strong> i <strong>immutable</strong> i pot ser utilitzat com a clau d'una propietat d'un objecte (vegeu més abaix). En alguns llenguatges de programació, als símbols s'els anomena àtoms. També guarden similituts a les enumeracions (enum) de C. Per a més detalls vegeu {{Glossary("Symbol")}} i l'objecte embolcallador {{jsxref("Symbol")}} a JavaScript.</p> + +<h2 id="Objectes">Objectes</h2> + +<p>En l'àmbit de la informàtica, un objecte és un valor en memòria que possiblement és referenciat per un {{Glossary("Identifier", "identificador")}}.</p> + +<h3 id="Propietats">Propietats</h3> + +<p>A JavaScript es poden entendre els objectes com una col·lecció de propietats. Amb la <a href="/en-US/docs/Web/JavaScript/Guide/Values,_variables,_and_literals#Object_literals">sintaxi literal d'objectes</a>, es pot inicialitzar un conjunt de propietats limitat; més tard es poden afegir propietats o bé esborrar-ne. Els valors de les propietats poden ser de qualsevol tipus, incloent altres objectes, el que comporta poder construir estructures de dades complexes. Les propietats s'identifiquen mitjançant valors clau. Una clau és o bé un valor de tipus String o Symbol.</p> + +<p>Hi ha dos tipus de propietats d'objectes, les quals tenen diferents atributs: Les propietats de tipus dada i les propietats de tipus accés.</p> + +<h4 id="Propietats_de_tipus_dada">Propietats de tipus dada</h4> + +<p>Associa una clau a un valor i disposa dels següents atributs:</p> + +<table class="standard-table"> + <caption>Atributs de les propietats de tipus dada</caption> + <tbody> + <tr> + <th>Atribut</th> + <th>Tipus</th> + <th>Descripció</th> + <th>Valor per defecte</th> + </tr> + <tr> + <td>[[Value]]</td> + <td>Qualsevol tipus</td> + <td>El valor obtingut mitjançant un accés de tipus get a la propietat.</td> + <td>undefined</td> + </tr> + <tr> + <td>[[Writable]]</td> + <td>Boolean</td> + <td>Si val <code>false</code>, el [[Value]] de la propietat no es pot canviar.</td> + <td>false</td> + </tr> + <tr> + <td>[[Enumerable]]</td> + <td>Boolean</td> + <td>Si val <code>true</code>, la propietat apareixerà al recòrrer l'objecte pare amb un bucle <a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...in">for...in</a>.</td> + <td>false</td> + </tr> + <tr> + <td>[[Configurable]]</td> + <td>Boolean</td> + <td>Si val <code>false</code>, la propietat no pot ser esborrada i no es pot modificar cap atribut a excepció de [[Value]] i [[Writable]].</td> + <td>false</td> + </tr> + </tbody> +</table> + +<h4 id="Propietats_de_tipus_accés">Propietats de tipus accés</h4> + +<p>Associen una clau amb una o dues funccións d'accés (get i set) per a obtindre o bé emmagatzemar un valor, i tenen els atributs següents:</p> + +<table class="standard-table"> + <caption>Atributs de les propietats de tipus accés</caption> + <tbody> + <tr> + <th>Atribut</th> + <th>Tipus</th> + <th>Descripció</th> + <th>Valor per defecte</th> + </tr> + <tr> + <td>[[Get]]</td> + <td>Objecte de tipus Function o bé undefined</td> + <td>Es crida la funció amb un llistat d'arguments buit i retorna el valor de la propietat. S'executa quan s'accedeix al valor de la propietat. Vegeu també <a href="/en-US/docs/Web/JavaScript/Reference/Operators/get"><code>get</code></a>.</td> + <td>undefined</td> + </tr> + <tr> + <td>[[Set]]</td> + <td>Objecte de tipus Function o bé undefined</td> + <td>Es crida la funció amb un argument, que conté el valor a assignar a la propietat. S'executa quan es vol canviar el valor de la propietat. See also <a href="/en-US/docs/Web/JavaScript/Reference/Operators/set"><code>set</code></a>.</td> + <td>undefined</td> + </tr> + <tr> + <td>[[Enumerable]]</td> + <td>Boolean</td> + <td>Si val <code>true</code>, la propietat apareixerà al recòrrer l'objecte pare amb un bucle <a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...in">for...in</a>.</td> + <td>false</td> + </tr> + <tr> + <td>[[Configurable]]</td> + <td>Boolean</td> + <td>Si val <code>false</code>, no es pot esborrar la propietat i no es pot convertir a una propietat de tipus dada.</td> + <td>false</td> + </tr> + </tbody> +</table> + +<h3 id="Objectes_normals_i_functions">Objectes "normals" i functions</h3> + +<p>A JavaScript, un objecte és un mapa que associa claus amb valors. Les claus sempre són de tipus String mentre que els valors poden ser de qualsevol tipus. Això fa que els objectes es puguin utilitzar de forma intuitiva com a <a class="external" href="http://en.wikipedia.org/wiki/Hash_table">hashmaps</a>.</p> + +<p>Les funcions són objectes normals i correncts amb la característica adicional que poden ser cridats.</p> + +<h3 id="Dates">Dates</h3> + +<p>A l'hora de representar dates la millor opció és utilitzar l'objecte <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date"><code>Date</code></a> que JavaScript incorpora per defecte.</p> + +<h3 id="Col·leccions_indexades_Arrays_i_Arrays_amb_tipus">Col·leccions indexades: Arrays i Arrays amb tipus</h3> + +<p><a href="/en-US/docs/JavaScript/Reference/Global_Objects/Array" title="Array">Els Arrays</a> són objectes normals i corrents en els que hi ha una relació específica entre les propietats, que utilitzen nombres sencers com a claus, i la propietat 'length'. A més, els array hereten de <code>Array.prototype</code>, el qual els proporciona un conjunt de mètodes molt útils per a manipular arrays. Per exemple, <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf" title="en/JavaScript/Reference/Global_Objects/Array/indexOf">indexOf</a></code> (cerca un valor dins l'array) o bé <code><a href="/en-US/docs/JavaScript/Reference/Global_Objects/Array/push" title="en/JavaScript/Reference/Global_Objects/Array/push">push</a></code> (afegeix un element a l'array), etcètera. Això fa que els Arrays siguin el candidat ideal per a representar llistes i <em>sets</em>.</p> + +<p><a href="/en-US/docs/Web/JavaScript/Typed_arrays">Els Arrays amb tipus</a> s'han incorporat a JavaScript recentment amb el standard ECMAScript Edició 6 i ofereixen una forma de treballar sobre buffers de dades binàries com si es tractessin d'arrays. La taula següent mostra el tipus de dades equivalent a C:</p> + +<p>{{page("/ca/docs/Web/JavaScript/Reference/Global_Objects/TypedArray", "TypedArray_objects", "", 0, 3)}}</p> + +<h3 id="Col·leccions_amb_claus_Maps_Sets_WeakMaps_WeakSets">Col·leccions amb claus: Maps, Sets, WeakMaps, WeakSets</h3> + +<p>Aquestes estructures de dades utilitzen referències a objectes com a claus i estan disponibles a partir de l'ECMAScript Edició 6. {{jsxref("Set")}} i {{jsxref("WeakSet")}} representen un conjunt d'objectes, mentre que {{jsxref("Map")}} i {{jsxref("WeakMap")}} associen valors a objectes. La diferència entre Maps i WeakMaps és que als Maps els objectes utilitzats com a clau es poden enumerar mentre que als WeakMaps no. Això permet optimitzar l'alliberament de memòria si es fan anar WeakMaps.</p> + +<p>Els Maps i Sets es podrien implementar utilitzant solament ECMAScript 5 però, com que els objectes no es poden comparar (en el sentit de poder considerar un objecte menor que un altre, per exemple), el rendiment a l'hora de cercar seria linear per força. Les implementacions d'aquestes col·leccions (incloent WeakMaps) permeten un rendiment superior, sent aproximadament entre logarítmic i constant.</p> + +<p>Normalment, a l'hora de vincular dades a un node del DOM, s'assignen propietats directament a l'objecte o s'utilitzen atributs del tipus <code>data-*</code>. Aquesta aproximació té l'inconvenient d'exposar aquestes dades a tots els scripts pertanyents al mateix context. Els Maps i els WeakMaps són una solució que permet vincular dades a objectes de forma privada.</p> + +<h3 id="Dades_estructurades_JSON">Dades estructurades: JSON</h3> + +<p>JSON (JavaScript Object Notation) és un format lleuger per a l'intercanvi de dades, derivat de JavaScript però utilitzat per molts llenguatges de programació. JSON construeix estructures de dades universals. Vegeu {{Glossary("JSON")}} i {{jsxref("JSON")}} per a més detalls.</p> + +<h3 id="Altres_objectes_de_la_llibreria_standard">Altres objectes de la llibreria standard</h3> + +<p>JavaScript disposa d'una llibreria standard d'objectes. Feu un cop d'ull a la <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects">referència</a> per a descobrir més objectes.</p> + +<h2 id="Determinar_el_tipus_utilitzant_loperador_typeof">Determinar el tipus utilitzant l'operador <code>typeof</code></h2> + +<p>L'operador <code>typeof</code> pot ajudar-vos a esbrinar el tipus d'una variable. Llegiu la <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/typeof">pàgina de referència</a> per a més detalls i casos especials.</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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definició inicial.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-8', 'Types')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-ecmascript-data-types-and-values', 'ECMAScript Data Types and Values')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li><a class="link-https" href="https://github.com/nzakas/computer-science-in-javascript/">Col·lecció d'estructures de dades i algorismes comuns en JavaScript, de Nicholas Zakas.</a></li> + <li><a href="https://github.com/monmohan/DataStructures_In_Javascript" title="https://github.com/monmohan/DataStructures_In_Javascript">Search Tre(i)es implemented in JavaScript</a></li> +</ul> diff --git a/files/ca/web/javascript/enumerability_and_ownership_of_properties/index.html b/files/ca/web/javascript/enumerability_and_ownership_of_properties/index.html new file mode 100644 index 0000000000..34daee82e5 --- /dev/null +++ b/files/ca/web/javascript/enumerability_and_ownership_of_properties/index.html @@ -0,0 +1,243 @@ +--- +title: Enumerabilitat i pertanyença de les propietats +slug: Web/JavaScript/Enumerability_and_ownership_of_properties +translation_of: Web/JavaScript/Enumerability_and_ownership_of_properties +--- +<div>{{JsSidebar("More")}}</div> + +<p>Les propietats enumerables són aquelles que es poden iterar en un <a href="/en-US/docs/JavaScript/Reference/Statements/for...in">bucle for..in</a>. La pertanyença de les propietats és determinada pel fet de si la propietat pertany directament a l'objecte en comptes de la seva cadena de prototipus. Les propietats d'un objecte també poden ser contades per a obtenir el nombre de propietats. Hi ha diverses formes de detectar, iterar/enumerar i obtindre les propietats d'un objecte. Es pot veure a la taula quines es poden emprar en cada cas. A continuació trobareu un bocí de codi d'exemple on es mostra com otenir les categories no trobades.</p> + +<table> + <caption>Enumerabilitat i pertanyença de propietats - mètodes de detecció, obtenció i iteració</caption> + <tbody> + <tr> + <th>Funcionalitat</th> + <th>Pertanyença a l'objecte</th> + <th>Pertanyença a l'objecte o la seva cadena de prototipus</th> + <th>Pertanyença només a la cadena de prototipus</th> + </tr> + <tr> + <td>Detecció</td> + <td> + <table> + <thead> + <tr> + <th scope="col">Enumerable</th> + <th scope="col">No enumerable</th> + <th scope="col">Enumerable i No enumerable</th> + </tr> + </thead> + <tbody> + <tr> + <td><code><a href="/en-US/docs/JavaScript/Reference/Global_Objects/Object/propertyIsEnumerable" title="/en-US/docs/JavaScript/Reference/Global_Objects/Object/propertyIsEnumerable">propertyIsEnumerable</a></code></td> + <td><code><a href="/en-US/docs/JavaScript/Reference/Global_Objects/Object/hasOwnProperty" title="/en-US/docs/JavaScript/Reference/Global_Objects/Object/hasOwnProperty">hasOwnProperty</a></code> i no <code><a href="/en-US/docs/JavaScript/Reference/Global_Objects/Object/propertyIsEnumerable" title="/en-US/docs/JavaScript/Reference/Global_Objects/Object/propertyIsEnumerable">propertyIsEnumerable</a></code></td> + <td><code><a href="/en-US/docs/JavaScript/Reference/Global_Objects/Object/hasOwnProperty" title="/en-US/docs/JavaScript/Reference/Global_Objects/Object/hasOwnProperty">hasOwnProperty</a></code></td> + </tr> + </tbody> + </table> + </td> + <td>No disponible sense escriure més codi</td> + <td>No disponible sense escriure més codi</td> + </tr> + <tr> + <td>Obtenció</td> + <td> + <table> + <thead> + <tr> + <th scope="col">Enumerable</th> + <th scope="col">No enumerable</th> + <th scope="col">Enumerable i No enumerable</th> + </tr> + </thead> + <tbody> + <tr> + <td><code><a href="/en-US/docs/JavaScript/Reference/Global_Objects/Object/keys" title="/en-US/docs/JavaScript/Reference/Global_Objects/Object/keys">Object.keys</a></code></td> + <td><code><a href="/en-US/docs/JavaScript/Reference/Global_Objects/Object/getOwnPropertyNames" title="/en-US/docs/JavaScript/Reference/Global_Objects/Object/getOwnPropertyNames">getOwnPropertyNames</a></code> filtrat per a incloure propietats si no se li passa<code> <a href="/en-US/docs/JavaScript/Reference/Global_Objects/Object/propertyIsEnumerable" title="/en-US/docs/JavaScript/Reference/Global_Objects/Object/propertyIsEnumerable">propertyIsEnumerable</a></code></td> + <td><code><a href="/en-US/docs/JavaScript/Reference/Global_Objects/Object/getOwnPropertyNames" title="/en-US/docs/JavaScript/Reference/Global_Objects/Object/getOwnPropertyNames">getOwnPropertyNames</a></code></td> + </tr> + </tbody> + </table> + </td> + <td>No disponible sense escriure més codi</td> + <td>No disponible sense escriure més codi</td> + </tr> + <tr> + <td>Iteració</td> + <td> + <table> + <thead> + <tr> + <th scope="col">Enumerable</th> + <th scope="col">No enumerable</th> + <th scope="col">Enumerable i No enumerable</th> + </tr> + </thead> + <tbody> + <tr> + <td>Iterar sobre <code><a href="/en-US/docs/JavaScript/Reference/Global_Objects/Object/keys" title="/en-US/docs/JavaScript/Reference/Global_Objects/Object/keys">Object.keys</a></code></td> + <td>Iterar sobre <code><a href="/en-US/docs/JavaScript/Reference/Global_Objects/Object/getOwnPropertyNames" title="/en-US/docs/JavaScript/Reference/Global_Objects/Object/getOwnPropertyNames">getOwnPropertyNames</a> </code>filtrat per a incloure propietats si no se li passa<code> <a href="/en-US/docs/JavaScript/Reference/Global_Objects/Object/propertyIsEnumerable" title="/en-US/docs/JavaScript/Reference/Global_Objects/Object/propertyIsEnumerable">propertyIsEnumerable</a></code></td> + <td>Iterar sobre <code><a href="/en-US/docs/JavaScript/Reference/Global_Objects/Object/getOwnPropertyNames" title="/en-US/docs/JavaScript/Reference/Global_Objects/Object/getOwnPropertyNames">getOwnPropertyNames</a></code></td> + </tr> + </tbody> + </table> + </td> + <td> + <table> + <thead> + <tr> + <th scope="col">Enumerable</th> + <th scope="col">No enumerable</th> + <th scope="col">Enumerable i No enumerable</th> + </tr> + </thead> + <tbody> + <tr> + <td><code><a href="/en-US/docs/JavaScript/Reference/Statements/for...in" title="/en-US/docs/JavaScript/Reference/Statements/for...in">for..in</a></code></td> + <td>No disponible sense escriure més codi</td> + <td>No disponible sense escriure més codi</td> + </tr> + </tbody> + </table> + </td> + <td>No disponible sense escriure més codi</td> + </tr> + </tbody> +</table> + +<h2 id="Obtindre_propietats_per_enumerabilitatpertanyença">Obtindre propietats per enumerabilitat/pertanyença</h2> + +<p>Cal recalcar que aquest no és l'algorisme més eficient per a tots els casos, però és útil per a una demostració ràpida.</p> + +<ul> + <li>La detecció es pot aconseguir mitjançant <code>SimplePropertyRetriever.theGetMethodYouWant(obj).indexOf(prop) > -1</code></li> + <li>La iteració es pot aconseguir mitjançant <code>SimplePropertyRetriever.theGetMethodYouWant(obj).forEach(function (value, prop) {});</code> (<code>o bé usant filter()</code>, <code>map()</code>, etc.)</li> +</ul> + +<pre class="brush: js">var SimplePropertyRetriever = { + getOwnEnumerables: function (obj) { + return this._getPropertyNames(obj, true, false, this._enumerable); + // O es podria utilitzar for..in filtrat amb hasOwnProperty o bé simplement això: return Object.keys(obj); + }, + getOwnNonenumerables: function (obj) { + return this._getPropertyNames(obj, true, false, this._notEnumerable); + }, + getOwnEnumerablesAndNonenumerables: function (obj) { + return this._getPropertyNames(obj, true, false, this._enumerableAndNotEnumerable); + // O bé simplement utilitzar: return Object.getOwnPropertyNames(obj); + }, + getPrototypeEnumerables: function (obj) { + return this._getPropertyNames(obj, false, true, this._enumerable); + }, + getPrototypeNonenumerables: function (obj) { + return this._getPropertyNames(obj, false, true, this._notEnumerable); + }, + getPrototypeEnumerablesAndNonenumerables: function (obj) { + return this._getPropertyNames(obj, false, true, this._enumerableAndNotEnumerable); + }, + getOwnAndPrototypeEnumerables: function (obj) { + return this._getPropertyNames(obj, true, true, this._enumerable); + // O bé es podria utilitzar un for..in sense filtrar + }, + getOwnAndPrototypeNonenumerables: function (obj) { + return this._getPropertyNames(obj, true, true, this._notEnumerable); + }, + getOwnAndPrototypeEnumerablesAndNonenumerables: function (obj) { + return this._getPropertyNames(obj, true, true, this._enumerableAndNotEnumerable); + }, + // Private static property checker callbacks + _enumerable : function (obj, prop) { + return obj.propertyIsEnumerable(prop); + }, + _notEnumerable : function (obj, prop) { + return !obj.propertyIsEnumerable(prop); + }, + _enumerableAndNotEnumerable : function (obj, prop) { + return true; + }, + // Inspirat per http://stackoverflow.com/a/8024294/271577 + _getPropertyNames : function getAllPropertyNames(obj, iterateSelfBool, iteratePrototypeBool, includePropCb) { + var props = []; + + do { + if (iterateSelfBool) { + Object.getOwnPropertyNames(obj).forEach(function (prop) { + if (props.indexOf(prop) === -1 && includePropCb(obj, prop)) { + props.push(prop); + } + }); + } + if (!iteratePrototypeBool) { + break; + } + iterateSelfBool = true; + } while (obj = Object.getPrototypeOf(obj)); + + return props; + } +};</pre> + +<h2 id="Taula_de_detecció">Taula de detecció</h2> + +<table> + <thead> + <tr> + <th scope="row"> </th> + <th scope="col"><code>in</code></th> + <th scope="col"><code>for..in</code></th> + <th scope="col"><code>hasOwnProperty</code></th> + <th scope="col"><code>propertyIsEnumerable</code></th> + <th scope="col"><code>in Object.keys</code></th> + <th scope="col"><code>in Object.getOwnPropertyNames</code></th> + </tr> + </thead> + <tbody> + <tr> + <th scope="row">Enumerable</th> + <td>true</td> + <td>true</td> + <td>true</td> + <td>true</td> + <td>true</td> + <td>true</td> + </tr> + <tr> + <th scope="row">No enumerable</th> + <td>true</td> + <td>false</td> + <td>true</td> + <td>false</td> + <td>false</td> + <td>true</td> + </tr> + <tr> + <th scope="row">Enumerable heredat</th> + <td>true</td> + <td>true</td> + <td>false</td> + <td>false</td> + <td>false</td> + <td>false</td> + </tr> + <tr> + <th scope="row">No enumerable heredat</th> + <td>true</td> + <td>false</td> + <td>false</td> + <td>false</td> + <td>false</td> + <td>false</td> + </tr> + </tbody> +</table> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li><code><a href="/en-US/docs/JavaScript/Reference/Operators/in" title="/en-US/docs/JavaScript/Reference/Operators/in">in</a></code></li> + <li><code><a href="/en-US/docs/JavaScript/Reference/Statements/for...in" title="/en-US/docs/JavaScript/Reference/Statements/for...in">for..in</a></code></li> + <li><code><a href="/en-US/docs/JavaScript/Reference/Global_Objects/Object/hasOwnProperty" title="/en-US/docs/JavaScript/Reference/Global_Objects/Object/hasOwnProperty">hasOwnProperty</a></code></li> + <li><code><a href="/en-US/docs/JavaScript/Reference/Global_Objects/Object/propertyIsEnumerable" title="/en-US/docs/JavaScript/Reference/Global_Objects/Object/propertyIsEnumerable">propertyIsEnumerable</a></code></li> + <li><code><a href="/en-US/docs/JavaScript/Reference/Global_Objects/Object/getOwnPropertyNames" title="/en-US/docs/JavaScript/Reference/Global_Objects/Object/getOwnPropertyNames">getOwnPropertyNames</a></code></li> + <li><code><a href="/en-US/docs/JavaScript/Reference/Global_Objects/Object/keys" title="/en-US/docs/JavaScript/Reference/Global_Objects/Object/keys">Object.keys</a></code></li> +</ul> diff --git a/files/ca/web/javascript/eventloop/index.html b/files/ca/web/javascript/eventloop/index.html new file mode 100644 index 0000000000..921e6ffded --- /dev/null +++ b/files/ca/web/javascript/eventloop/index.html @@ -0,0 +1,75 @@ +--- +title: Model de concurrència i bucle d'events +slug: Web/JavaScript/EventLoop +translation_of: Web/JavaScript/EventLoop +--- +<div>{{JsSidebar("Advanced")}}</div> + +<p>JavaScript disposa d'un model de concurrencia basat en un "bucle d'events". Aquest model és força diferent del model de concurrencia que ofereixen altres llenguatges com C o Java.</p> + +<h2 id="Conceptes_sobre_l'execució_de_codi">Conceptes sobre l'execució de codi</h2> + +<p>A les següents seccions s'explica el model teòric de concurrencia. Els motors de JavaScript moderns suporten concurrencia basant-se en aquest model tot i que hi implementen un gran nombre d'optimitzacions.</p> + +<h3 id="Representació_visual">Representació visual</h3> + +<p style="text-align: center;"><img alt="Stack, heap, queue" src="/files/4617/default.svg" style="width: 294px; height: 270px;"></p> + +<h3 id="Stack_(pila_d'execució)">Stack (pila d'execució)</h3> + +<p>Les crides a funcions formen una pila de <em>frames</em>.</p> + +<pre class="brush: js">function f(b){ + var a = 12; + return a+b+35; +} + +function g(x){ + var m = 4; + return f(m*x); +} + +g(21); +</pre> + +<p>Al cridar a <code>g</code> es crea un primer <em>frame</em>, que conté tots els arguments passats a la crida a més de les variables locals. Quan <code>g</code> crida <code>f</code> es crea un segon <em>frame</em>, que s'aplia a sobre del primer. Quan la funció <code>f</code> retorna el seu <em>frame</em> es treu de la pila (deixant només el <em>frame</em> de <code>g</code>). Quan <code>g</code> retorna la pila d'execució queda buida.</p> + +<h3 id="Heap_(regió_de_memòria)">Heap (regió de memòria)</h3> + +<p>Els objectes s'emmagatzemen a la <em>heap</em>, que és una regió de memòria sense cap estructura fixa a la que el motor hi té accès.</p> + +<h3 id="Queue_(cua_d'execució)">Queue (cua d'execució)</h3> + +<p>El procès d'execució de JavaScript conté una cua de missatges, que està formada pel llistat de missatges pendents de ser processats. Cada cop que es buida s'agafa un missatge de la cua i es processa. El processament del missatge consisteix a cridar la funció associada a ell (i en conseqüència s'afegeix un <em>frame</em> inicial a la pila d'execució). El processament conclou quan a la pila d'execució no hi queda cap <em>frame</em>.</p> + +<h2 id="Bucle_d'events">Bucle d'events</h2> + +<p>El <code>bucle d'events</code> rep el seu nom degut a la forma en la que normalment s'implementa, la qual sol ésser semblant al següent exemple:</p> + +<pre class="brush: js">while(cua.esperarMissatge()){ + cua.processarSegüentMissatge(); +}</pre> + +<p><code>cua.esperarMissatge</code> espera de forma síncrona que un missatge arribi si la pila és buida.</p> + +<h3 id="Execució_ininterrompuda">Execució ininterrompuda</h3> + +<p>Cada missatge es processa de forma complerta i ininterrompuda abans un altre missatge no és processat. Aquest fet proporciona certes propietats força útils a tenir en compte a l'hora de pensar com realitzar un programa, com pot ser el fet que mentre s'està executant una funció es garanteix que aquesta mai serà interrompuda de forma que no cal preocupar-se per que cap altre codi pugui modificar dades que puguin afectar el resultat. Aquest comportament és totalment diferent del de llenguatges com C, per exemple, on les funcions es processen en fils d'execució, que poden ser interromputs en qualsevol moment per donar pas a l'execució d'altres fils, els quals poden potencialment modificar dades que poden alterar el resultat del primer fil.</p> + +<p>Un dels inconvenients del model emprat per JavaScript és que si un missatge triga massa a executar-se completament l'aplicació web no pot processar altres interaccions de l'usuari (que es transformen en missatges i van a parar a la cua) com ara clics o desplaçaments. Els navegadors sovint alleugen el problema tot advertint l'usuari amb el diàleg "un script està trigant massa a executar-se". Una bona pràctica consisteix a intentar que els missatges trigin poc temps a executar-se i, si és possible, trencar-los en diferents missatges més petits.</p> + +<h2 id="Afegir_missatges">Afegir missatges</h2> + +<p>Als navegadors web els missatges s'afegeixen a la cua sempre que un event succeeix i aquest event té un <em>event listener</em> associat. Si no hi ha cap <em>listener</em> associat l'event es perd. Així per exemple si es fa un clic a un element que té associada una funció a l'event de clic afegirà un missatge a la cua. Tanmateix amb qualsevol altre tipus d'event.</p> + +<p>Cridar a <code><a href="/en-US/docs/Web/API/WindowTimers.setTimeout" title="/en-US/docs/window.setTimeout">setTimeout</a></code> afegirà un missatge a la cua després que el temps indicat al segon argument hagi passat. Si no hi ha cap altre missatge a la cua, aquest missage s'executarà de forma immediata. Si hi ha altres missatges, però, el missatge afegit per <code>setTimeout</code> esperarà a que s'hagin processat tots els altres. És per aquest motiu que el segon argument indica el temps mínim d'espera i no el temps exacte garantit fins que es processi el missatge.</p> + +<h3 id="Comunicació_entre_diferents_fils_d'execució">Comunicació entre diferents fils d'execució</h3> + +<p>Els <em>web worker</em> (així s'anomenen els fils d'execució que s'encarreguen de processar missatges) i els <em>iframe</em> de tipus <em>cross-origin</em> tenen la seva pròpia pila, <em>heap</em> i cua de missatges. Dos fils d'execució diferents només es poden comunicar enviant-se missatges via el mètode <a href="/ca/docs/DOM/window.postMessage">postMessage</a>. Aquest mètode afegirà un missatge a un altre fil d'execució sempre i quan aquest fil d'execució estigui escoltant events de tipus <code>message</code> (és a dir, sempre que al fil d'execució que vol rebre el missatge hi hagi associat un <em>listener</em> a l'event <code>message</code>).</p> + +<h2 id="Completament_asíncron">Completament asíncron</h2> + +<p>Una propietat molt interessant del model de bucle d'events és que JavaScript, a diferència d'altres llenguatges, no es bloqueja mai a l'espera de res. Les operacions d'Entrada/Sortida (habitualment bloquejants a la majoria de llenguatges) són processades per JavaScript mitjançant events i <em>callbacks</em>, així , per exemple, mentre l'aplicació està esperant que una <em>query</em> a l'<a href="/en-US/docs/Web/API/IndexedDB_API" title="/en-US/docs/IndexedDB">IndexedDB</a> retorni o que una petició <a href="/en-US/docs/Web/API/XMLHttpRequest" title="/en-US/docs/DOM/XMLHttpRequest">XHR</a> retorni JavaScript pot executar altres events, com interaccions amb l'usuari, etcètera, ja que els resultats seràn rebuts i processats mitjançant un missatge diferent, que serà afegit a la cua quan els resultats estiguin llestos.</p> + +<p>Hi ha excepcions (degudes principalment a raons històriques), com el <em>dialog</em> <code>alert</code> o bé crides síncrones de tipus XHR, però es considera una bona pràctica evitar el seu ús. Tingueu en compte que també existeixen <a href="http://stackoverflow.com/questions/2734025/is-javascript-guaranteed-to-be-single-threaded/2734311#2734311">excepcions a l'excepció</a>, però normalment són degudes a errors d'implementació (bugs).</p> diff --git a/files/ca/web/javascript/guide/details_of_the_object_model/index.html b/files/ca/web/javascript/guide/details_of_the_object_model/index.html new file mode 100644 index 0000000000..9c2442d26f --- /dev/null +++ b/files/ca/web/javascript/guide/details_of_the_object_model/index.html @@ -0,0 +1,746 @@ +--- +title: El model d'objectes en detall +slug: Web/JavaScript/Guide/Details_of_the_Object_Model +translation_of: Web/JavaScript/Guide/Details_of_the_Object_Model +--- +<p>{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Working_with_Objects", "Web/JavaScript/Guide/Iterators_and_Generators")}}</p> + +<p>JavaScript és un llenguatge orientat a objectes basat en prototipus en comptes d'estar basat en classes. Degut a aquesta diferència pot resultar menys evident la forma en que JavaScript permet crear jerarquies d'objectes i proporciona herència de propietats i els seus valors. Aquest capítol pretén aclarir aquest tema.</p> + +<p>Aquest capítol assumeix que teniu certa familiaritat amb JavaScript i sabeu crear objectes simples mitjançant funcions.</p> + +<h2 id="Llenguatges_basats_en_classes_vs_llenguatges_basats_en_prototipus">Llenguatges basats en classes vs llenguatges basats en prototipus</h2> + +<p>Els llenguatges orientats a objectes basats en classes, com ara Java i C++, es basen en el concepte de tenir dues entitats diferents: classes i instàncies.</p> + +<ul> + <li>Una <em>classe</em> defineix totes les propietats (considerem que a Java els mètodes i camps, així com els membres a C++, són propietats) que caracteritzen un determinat conjunt d'objectes. Una classe és quelcom abstracte, en contraposició amb un membre específic del grup d'objectes que defineix. Per exemple, la classe <code>Employee</code> podria representar el conjunt de tots els empleats.</li> + <li>Una <em>instància</em>, d'altra banda, és la instanciació d'una classe, és a dir, un dels seus membres. Per exemple, <code>Victoria</code> podría ser una instància de la classe <code>Employee</code>, representant un individu concret com a empleat. Una instància te exactament les propietats de la seva classe pare, ni més ni menys.</li> +</ul> + +<p>Un llenguatge basat en prototipus, com ara JavaScript, no fa aquesta distinció: simplement disposa d'objectes. Un llenguatge basat en prototipus, però, té el concepte de <em>objecte prototipus</em>, un objecte que s'utilitza com a motlle del qual obtindre les propietats inicial d'un nou objecte. Qualsevol objecte pot especificar les seves pròpies propietats, ja sigui quan aquest és creat o be en temps d'execució. A més, qualsevol objecte pot ser associat com el <em>prototipus</em> d'un altre objecte, tot permetent al segon objecte compartir les propietats del primer.</p> + +<h3 id="Definir_una_classe">Definir una classe</h3> + +<p>En llenguatge basats en classes hom defineix una classe de forma separada com una <em>definició de classe</em>. En aquesta definició es poden especificar mètodes especials, anomenats <em>constructors</em>, que serveixen per a crear instàncies de la classe a la que pertanyen. Un mètode constructor pot especificar valors inicials per a les propietats d'una instància, així com realitzar altres tasques en temps de creació de l'objecte. Per a crear instàncies d'una classe s'utilitza l'operador <code>new</code> en associació amb un mètode constructor de la classe.</p> + +<p>JavaScript empra un model similar tot i que no disposa de definicions de classes separades dels constructors. En comptes d'això, es defineix una funció constructora per a crear objectes amb un conjunt específic de propietats i valors. Qualsevol funció de JavaScript pot ser utilitzada com a constructor. S'utilitza l'operador <code>new</code> amb una funció constructora per a crear un nou objecte.</p> + +<h3 id="Subclasses_i_herència">Subclasses i herència</h3> + +<p>En els llenguatges basats en classes, es poden crear jerarquies de classes mitjançant la definició de les classes. En una definició de classe es pot especificar que la nova classe és una <em>subclasse</em> d'una classe que ja existeix. La subclasse hereta totes les propietats de la <em>superclasse</em> i pot afegir noves propietats adicionals o bé modificar les heretades. Per exemple, suposem que la classe <code>Employee</code> només inclou les propietats <code>name</code> i <code>department</code>, i la classe <code>Manager</code> és una subclasse de <code>Employee</code> que afegeix la propietat <code>reports</code>. En aquest cas una instància de la classe <code>Manager</code> tindria totes tres propietats: <code>name</code>, <code>department</code> i <code>reports</code>.</p> + +<p>JavaScript implementa l'herència permetent associar un objecte prototipus a qualsevol funció constructora. D'aquesta forma es pot crear exactament l'exemple <code>Employee</code> — <code>Manager</code>, tot i que fent servir una terminologia lleugerament diferent. Primerament cal definir la funció constructora de <code>Employee</code>, tot especificant les propietats <code>nom</code> i <code>departament</code>. Seguidament es defineix la funció constructora de <code>Manager</code>, tot cridant el constructor de <code>Employee</code> i especificant la propietat <code>informes</code>. Finalment s'assigna el nou objecte derivat de <code>Employee.prototype</code> com el <code>prototype</code> de la funció constructora de <code>Manager</code>. Llavors quan es crea un nou objecte de tipus <code>Manager</code> aquest hereta les propietats <code>name</code> i <code>department</code> de l'objecte <code>Employee</code>.</p> + +<h3 id="Afegir_i_esborrar_propietats">Afegir i esborrar propietats</h3> + +<p>En llenguatges basats en classes les classes són normalment creades en temps de compilació i mentre que les instàncies de la classe poden ser creades tant en temps de compilació com en temps d'execució. No és possible canviar el nombre o el tipus de les propietats d'una classe després d'haver definit la classe. En JavaScript, però, és possible afegir o eliminar propietats de qualsevol objecte en temps d'execució. Si s'afegeix una propietat a un objecte que està sent utilitzat com a prototipus d'un conjunt d'objectes, aquests objectes també rebran la nova propietat.</p> + +<h3 id="Resum_de_diferències">Resum de diferències</h3> + +<p>La taula següent proporciona un breu resum d'algunes d'aquestes diferències. La resta del capítol descriu els detalls d'utilitzar constructors i prototipus a JavaScript per a crear jerarquies d'objectes i ho compara amb com es faria amb Java.</p> + +<table class="fullwidth-table"> + <caption>Taula 8.1 Comparació de sistems d'objectes basats en classes (Java) i basats en prototipus (JavaScript)</caption> + <thead> + <tr> + <th scope="col">Basat en classes (Java)</th> + <th scope="col">Basat en prototipus (JavaScript)</th> + </tr> + </thead> + <tbody> + <tr> + <td>Les classes i les instàncies són entitats diferents.</td> + <td>Qualsevol objecte pot heretar d'un altre objecte.</td> + </tr> + <tr> + <td>Es defineix una classe mitjançant una definició de classe; Es crea una instància d'una classe mitjançant un dels seus mètodes constructors.</td> + <td>Es defineix i es crea un conunt d'objectes mitjançant funcions constructores.</td> + </tr> + <tr> + <td>Es crea un sol objecte amb l'operador <code>new</code>.</td> + <td>Es crea un sol objecte amb l'operador <code>new</code>.</td> + </tr> + <tr> + <td> + <p>Les jerarquies d'objectes es construeixen mitjançant definicions de classes per a especificar subclasses de les classes existents.</p> + </td> + <td> + <p>Les jerarquies d'objectes es construeixen tot assignant un objecte com el prototipus associat amb una funció constructora.</p> + </td> + </tr> + <tr> + <td>Hereta les propietats tot següient la cadena de classes.</td> + <td> + <p>Hereta les propietats tot seguint la cadena de prototipus.</p> + </td> + </tr> + <tr> + <td> + <p>La definició d'una classe especifica <em>totes</em> les propietats per totes les instàncies de la classe. No és possible afegir propietats dinàmicament en temps d'execució.</p> + </td> + <td> + <p>Una funció constructora o un prototipus especifiquen un <em>conjunt inicial</em> de propietats. És possible afegir o eliminar propietats de forma dinàmica per a objectes individuals o bé de tot el conjunt d'objectes.</p> + </td> + </tr> + </tbody> +</table> + +<p> </p> + +<h2 id="L'exemple_Employee">L'exemple Employee</h2> + +<p>La resta d'aquest capítol utilitza la jerarquia de <code>Employee</code> que es mostra en la següent figura.</p> + +<p><img alt="" class="internal" src="/@api/deki/files/4452/=figure8.1.png" style="height: 194px; width: 281px;"></p> + +<p><small><strong>Figura 8.1: Una jerarquia d'objectes simple</strong></small></p> + +<p>Aquest exemple utilitza els objectes següents:</p> + +<ul> + <li><code>Employee</code> té les propietats <code>name</code> (el valor de la qual és una cadena buida per defecte) i <code>dept</code> (el valor de la qual és "general" per defecte).</li> + <li><code>Manager</code> està basada en <code>Employee</code>. Afegeix la propietat <code>reports</code> (el valor de la qual és un array buit per defecte, i destinada a emmagatzemar un array d'objectes de tipus <code>Employee</code> com a valor).</li> + <li><code>WorkerBee</code> també està basada en <code>Employee</code>. afegeix la propietat<code> projects</code> (el valor de la qual és un array buit per defecte, i destinada a emmagatzemar un array de strings com a valor).</li> + <li><code>SalesPerson</code> està basada en <code>WorkerBee</code>. Afegeix la propietat <code>quota</code> (el valor de la qual és 100 per defecte). També sobreescriu la propietat <code>dept</code> amb el valor "sales", tot indicant que tots els objectes del tipus salespersons pertanyen al mateix department.</li> + <li><code>Engineer</code> està basat en <code>WorkerBee</code>. Afegeix la propietat <code>machine</code> (el valor de la qual és una string buida per defecte) i també sobreescriu la propietat <code>dept</code> amb el valor "engineering".</li> +</ul> + +<h2 id="Crear_una_jerarquia">Crear una jerarquia</h2> + +<p>Hi ha diverses formes de definir les funcions constructores adequades per a implementar una jerarquia de Employee. Quina escollir-ne una depen en gran mesura del que es vol fer en l'aplicació.</p> + +<p>Aquesta secció mostra com utilitzar definicions molt simples (i comparativament poc flexibles) per a demostrar com funciona l'herència. En aquestes definicions no es pot especificar cap valor de les propietats al crear un objecte. L'objecte creat recentment senzillament té els valors per defecte, que es poden canviar després.</p> + +<p>En una aplicació real probablement es definirien constructors que permetessin especificar valors per les propietats de l'objecte al crear-lo (vegeu <a href="#Constructors_més_flexibles">Constructors més flexibles</a> per a més informació). De moment aquestes definicions simples demostren com funciona l'herència.</p> + +<p>Les següents definicions en Java i JavaScript de <code>Employee</code> són similars. L'única diferència és que a Java s'ha d'especificar el tipus de cada propietat de forma explícita mentre que a JavaScript no (degut a que Java és un <a href="http://en.wikipedia.org/wiki/Strong_and_weak_typing">llenguatge de tipatge fort</a> mentre que JavaScript és un llenguatge de tipatge dèbil).</p> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">JavaScript</th> + <th scope="col">Java</th> + </tr> + </thead> + <tbody> + <tr> + <td> + <pre class="brush: js"> +function Employee() { + this.name = ""; + this.dept = "general"; +} +</pre> + </td> + <td> + <pre class="brush: java"> +public class Employee { + public String name = ""; + public String dept = "general"; +} +</pre> + </td> + </tr> + </tbody> +</table> + +<p>Les definicions de <code>Manager</code> i <code>WorkerBee</code> mostren com especificar quin és l'objecte pare dins la cadena d'herència. A JavaScript s'afegeix una instància prototipus com a valor de la propietat <code>prototype</code> de la funció constructora. Això es pot fer en qualsevol moment després d'haver definit el constructor. A Java, en canvi, s'ha d'especificar la superclasse dins la definició de la classe, i aquesta, en conseqüència, no pot canviar-se fora de la definició de classe.</p> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">JavaScript</th> + <th scope="col">Java</th> + </tr> + </thead> + <tbody> + <tr> + <td> + <pre class="brush: js"> +function Manager() { + Employee.call(this); + this.reports = []; +} +Manager.prototype = Object.create(Employee.prototype); + +function WorkerBee() { + Employee.call(this); + this.projects = []; +} +WorkerBee.prototype = Object.create(Employee.prototype); +</pre> + </td> + <td> + <pre class="brush: java"> +public class Manager extends Employee { + public Employee[] reports; + public Manager () { + super(); + this.reports = new Employee[0]; + } +} + +public class WorkerBee extends Employee { + public String[] projects; + public WorkerBee () { + super(); + this.projects = new String[0]; + } +} +</pre> + </td> + </tr> + </tbody> +</table> + +<p>Les definicions de <code>Engineer</code> i <code>SalesPerson</code> creen objectes que descendeixen de <code>WorkerBee</code> i, per extensió, de <code>Employee</code>. Un objecte d'algun d'aquests tipus té les propietats de tots els objectes de damunt seu a la cadena d'herència. A més les definicions sobreescriuen els valors heretats de la propietat <code>dept</code> amb els nous valors especificats per a aquests objectes.</p> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">JavaScript</th> + <th scope="col">Java</th> + </tr> + </thead> + <tbody> + <tr> + <td> + <pre class="brush: js"> +function SalesPerson() { + WorkerBee.call(this); + this.dept = "sales"; + this.quota = 100; +} +SalesPerson.prototype = Object.create(WorkerBee.prototype); + +function Engineer() { + WorkerBee.call(this); + this.dept = "engineering"; + this.machine = ""; +} +Engineer.prototype = Object.create(WorkerBee.prototype); +</pre> + </td> + <td> + <pre class="brush: java"> +public class SalesPerson extends WorkerBee { + public double quota; + public SalesPerson () { + super(); + this.dept = "sales"; + this.quota = 100.0; + } +} + +public class Engineer extends WorkerBee { + public String machine; + public Engineer () { + super(); + this.dept = "engineering"; + this.machine = ""; + } +} +</pre> + </td> + </tr> + </tbody> +</table> + +<p>A l'utilitzar aquestes definicions les instàncies creades per aquests objectes tenen els valors per defecte apropiats per a les seves propietats. La figura 8.3 mostra com utilitzar aquestes definicions de JavaScript per a crear objectes nous i mostra els valors de les propietats per als nous objectes.</p> + +<div class="note"> +<p>El terme <em>instància</em> té un significat tècnic específic per a llenguatges basats en classes. En aquests llenguatges una instància és una instanciació individual d'una classe i és fundamentalment diferent de la classe. A JavaScript, "instància" no té aquest significat tècnic perquè aquest no diferencia entre classes i instàncies, tot i que parlant informalment de JavaScript es pot utilitzar el terme "instància" per a indicar un objecte creat utilitzant una funció constructora particular. Així, en aquest exemple, hom pot dir informalment que <code>jane</code> és una instància d'<code>Engineer</code>. De la mateixa manera, tot i que els termes <em>fill</em>, <em>predecessor</em> i <em>descendent</em> no tenen cap significat formal a JavaScript, aquests poden emprar-se de forma informal per a fer referència a objectes més amunt o bé més avall de la cadena de prototipus.</p> +</div> + +<p> </p> + +<p><img alt="figure8.3.png" class="default internal" id="figure8.3" src="/@api/deki/files/4403/=figure8.3.png"><br> + <a id="8.3" name="8.3"><small><strong>Figura 8.3: Creació d'objectes amb definicions simples</strong></small></a></p> + +<h2 id="Propietats_d'un_objecte">Propietats d'un objecte</h2> + +<p>Aquesta secció explica com els objectes hereten propietats d'altres objecte mitjançant la cadena de prototipus i què succeeix quan s'afegeix una propietat en temps d'execució.</p> + +<h3 id="Heretar_propietats">Heretar propietats</h3> + +<p>Suposem que creem l'objecte <code>mark</code> a partir de <code>WorkerBee</code> (tal i com es mostra a la <a href="#8.3">Figura 8.3</a>) amb la sentència següent:</p> + +<pre class="brush: js">var mark = new WorkerBee; +</pre> + +<p>Quan JavaScript es troba amb l'operador <code>new</code>, aquest crea un nou objecte genèric i passa aquest nou objecte com a valor de la paraula clau <code>this</code> a la funció constructora de <code>WorkerBee</code>. La funció constructora assigna el valor de la propietat project de forma explícita, i assigna implícitament el valor <code>WorkerBee.prototype</code> a la propietat interna <code>__proto__</code> (el nom d'aquesta propietat conté dos guions baixos tant al principi com al final). La propietat <code>__proto__</code> determina la cadena de prototipus que s'emprarà per a retornar valors de propietats. Un cop assignades aquestes propietats, JavaScript retorna el nou objecte i la sentència d'assignació associa l'objecte a la variable <code>mark</code>.</p> + +<p>Aquest procés no assigna valors de forma explícita a l'objecte <code>mark</code> (valors <em>locals</em>) per a les propietats que mark hereta a través de la cadena de prototipus. Quan s'intenta obtindre el valor d'una propietat JavaScript primer mira si el valor existeix en aquest objecte. Si és així, aquest és el valor retornat. Si el valor no existeix de forma <em>local</em>, JavaScript recorre la cadena prototipus (mitjançant la propietat <code>__proto__</code>). Si un objecte de la cadena prototipus té un valor per assignat a la propietat, aquest és el valor retornat. Si aquesta propietat no es troba a cap objecte de la cadena prototipus JavaScript determina que l'objete no té aquesta propietat. D'aquesta forma, l'objete <code>mark</code> té les següents propietats i valors:</p> + +<pre class="brush: js">mark.name = ""; +mark.dept = "general"; +mark.projects = []; +</pre> + +<p>L'objecte <code>mark</code> hereta els valors per a les propietats <code>name</code> i <code>dept</code> de l'objecte prototipus a <code>mark.__proto__</code>. La propietat <code>projects</code> rep un valor local designat pel constructor <code>WorkerBee</code>. Així és com funciona l'herència de propietats i els seus valors a JavaScript. Es poden trobar alguns detalls d'aquest procès a <a href="#Un_segon_cop_d'ull_a_l'herència_de_propietats">Un segon cop d'ull a l'herència de propietats</a>.</p> + +<p>Com que aquests constructors no permeten valors per a l'instància aquesta informació és genèrica. Els valors de les propietats són compartits per defecte, compartits per tots els nous objectes creats a partir de <code>WorkerBee</code>. Per suposat, es poden canviar els valors inicials d'aquestes propietats. A continuació es mostra com canviar informació específica:</p> + +<pre class="brush: js">mark.name = "Doe, Mark"; +mark.dept = "admin"; +mark.projects = ["navigator"];</pre> + +<h3 id="Afegir_propietats">Afegir propietats</h3> + +<p>A JavaScript, es poden afegir propietats a qualsevol objecte en temps d'execució. No hi ha cap limitació que ens forci a utilitzar només les propietats que ofereix la funció constructora. Per a afegir una propietat específicament a només un objecte, s'assigna un valor a l'objecte de la manera següent:</p> + +<pre class="brush: js">mark.bonus = 3000; +</pre> + +<p>Ara l'objecte <code>mark</code> té una propietat anomenada <code>bonus</code>, però cap altre objecte de tipus WorkerBee tindrà aquesta propietat.</p> + +<p>Si s'afegeix una nova propietat a un objecte que és emprat com a prototipus per una funció constructora, la propietat s'afegeix a tots els objectes que hereten propietats del prototipus. Per exemple, podem afegir la propietat <code>specialty</code> a tots els empleats amb la sentència següent:</p> + +<pre class="brush: js">Employee.prototype.specialty = "none"; +</pre> + +<p>Un cop la sentència s'ha executat l'objecte <code>mark</code> també disposa de la propietat <code>specialty</code>, amb el valor <code>"none"</code>. La figura següent mostra l'efecte d'afegir aquesta propietat al prototipus <code>Employee</code> i tot seguit sobreescriure-la per al prototipus <code>Engineer</code>.</p> + +<p><img alt="" class="internal" src="/@api/deki/files/4422/=figure8.4.png" style="height: 519px; width: 833px;"><br> + <small><strong>Figura 8.4: Afegir propietats</strong></small></p> + +<h2 id="Constructors_més_flexibles">Constructors més flexibles</h2> + +<p>Les funcions constructores emprades fins ara no permeten especificar els valors de les propietats al crear una instància. Tal i com succeeix amb Java, es poden passar arguments als constructors per a inicialitzar els valors de les propietats de les instàncies a crear. La figura següent mostra una forma d'aconseguir-ho.</p> + +<p><img alt="" class="internal" id="figure8.5" src="/@api/deki/files/4423/=figure8.5.png" style="height: 481px; width: 1012px;"><br> + <a id="8.5" name="8.5"><small><strong>Figura 8.5: Determinar propietats en un constructor, primera aproximació</strong></small></a></p> + +<p>La taula següent mostra les definicions tant en Java com en JavaScript d'aquests objectes.</p> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">JavaScript</th> + <th scope="col">Java</th> + </tr> + </thead> + <tbody> + <tr> + <td> + <pre class="brush: js"> +function Employee (name, dept) { + this.name = name || ""; + this.dept = dept || "general"; +} +</pre> + </td> + <td> + <pre class="brush: java"> +public class Employee { + public String name; + public String dept; + public Employee () { + this("", "general"); + } + public Employee (String name) { + this(name, "general"); + } + public Employee (String name, String dept) { + this.name = name; + this.dept = dept; + } +} +</pre> + </td> + </tr> + <tr> + <td> + <pre class="brush: js"> +function WorkerBee (projs) { + + this.projects = projs || []; +} +WorkerBee.prototype = new Employee; +</pre> + </td> + <td> + <pre class="brush: java"> +public class WorkerBee extends Employee { + public String[] projects; + public WorkerBee () { + this(new String[0]); + } + public WorkerBee (String[] projs) { + projects = projs; + } +} + +</pre> + </td> + </tr> + <tr> + <td> + <pre class="brush: js"> + +function Engineer (mach) { + this.dept = "engineering"; + this.machine = mach || ""; +} +Engineer.prototype = new WorkerBee; +</pre> + </td> + <td> + <pre class="brush: java"> +public class Engineer extends WorkerBee { + public String machine; + public Engineer () { + dept = "engineering"; + machine = ""; + } + public Engineer (String mach) { + dept = "engineering"; + machine = mach; + } +} +</pre> + </td> + </tr> + </tbody> +</table> + +<p>Aquestes definicions de JavaScript utilitzen un modisme especial per a assignar els valors per defecte:</p> + +<pre class="brush: js">this.name = name || ""; +</pre> + +<p>L'operador lògic OR de JavaScript (<code>||</code>) avalua el primer argument. Si aquest argument esdevé cert, l'operador el retorna. En cas constrari l'operador retorna el valor del segon argument. Així, aquesta línia de codi comprova que la propietat name tingui un valor útil. Si és així, assigna aquest valor a <code>this.name</code>. En cas contrari, assigna una string buida a <code>this.name</code>. Aquest capítol utilitza aquest modisme per a abreujar tot i que pot resultar desconcertant a primera vista.</p> + +<div class="note"> +<p>Això pot no tindre el comportament esperat si la funció constructora es crida amb arguments que s'avaluen a fals (com <code>0</code> (zero) o la cadena buida (<code>""</code>). En aquest cas el valor per defecte serà l'escollit.</p> + +<p>Amb aquestes definicions, al crear una instància d'un objecte, podem especificar valors per a les propietats locals definides. Tal i com es mostra a la <a href="#8.5">Figura 8.5</a>, es pot utilitzar la sentència següent per a crear un now <code>Engineer</code>:</p> +</div> + +<pre class="brush: js">var jane = new Engineer("belau"); +</pre> + +<p>Les propietats de <code>Jane</code> ara són:</p> + +<pre class="brush: js">jane.name == ""; +jane.dept == "engineering"; +jane.projects == []; +jane.machine == "belau" +</pre> + +<p>Fixeu-vos que amb aquestes definicions no és possible especificar un valor inicial per a propietats heretades, com ara <code>name</code>. Si es vol especificar un valor inicial per a propietats heretades a JavaScript és necesari afegir més codi a la funció constructora.</p> + +<p>Fins ara les funcions constructores han creat objectes genèrics i han pogut assignar valors a les propietats locals del nou objecte. El constructor mateix també pot afegir més propietats mitjançant la crida a la funció constructora d'un objecte més adalt en la cadena de propotitpus. La figura següent mostra aquestes noves definicions.</p> + +<p><img alt="" class="internal" src="/@api/deki/files/4430/=figure8.6.png" style="height: 534px; width: 1063px;"><br> + <small><strong>Figura 8.6 Especificar propietats al consctructor, segona aproximació</strong></small></p> + +<p>Fem un cop d'ull a una d'aquestes definicions en detall. Aquesta és la nova definició del constructor de <code>Engineer</code>:</p> + +<pre class="brush: js">function Engineer (name, projs, mach) { + this.base = WorkerBee; + this.base(name, "engineering", projs); + this.machine = mach || ""; +} +</pre> + +<p>Suposem que creem un nou objecte de tipus <code>Engineer</code> de la forma següent:</p> + +<pre class="brush: js">var jane = new Engineer("Doe, Jane", ["navigator", "javascript"], "belau"); +</pre> + +<p>JavaScript realitza els següents passos:</p> + +<ol> + <li>L'operador new crea un objecte genèric i assigna <code>Engineer.prototype</code> a la propietat <code>__proto__</code> d'aquest nou objecte.</li> + <li>L'operador new passa el nou objecte al constructor de <code>Engineer</code> com a valor de la paraula clau <code>this</code>.</li> + <li>El constructor crea una nova propietat anomenada <code>base</code> per a aquest objecte i assigna el valor del constructor de <code>WorkerBee</code> a aquesta propietat. Això fa que el constructor <code>WorkerBee</code> pugui ser emprat com un mètode de l'objecte <code>Engineer</code>. El nom de la propietat base no és especial. Es pot emprar qualsevol nom de propietat que sigui vàlid; <code>base</code> ha estat escollit perquè simplement és adient per al seu propòsit.</li> + <li>El constructor crida el mètode <code>base</code>, tot passant-li com a arguments dos dels arguments passats al constructor (<code>"Doe, Jane"</code> and <code>["navigator", "javascript"]</code>) i també la string <code>"engineering"</code>. Al passar <code>"engineering"</code> explícitament al constructor tots els objectes de tipus <code>Engineer</code> tindran el mateix valor per a la propietat hertada <code>dept</code>, i aquest valor sobreescriurà el valor heretat de <code>Employee</code>.</li> + <li> + <p>Com que base és un mètode de <code>Engineer</code>, durant la crida a base JavaScript assigna a la paraula clau this l'objecte creat al pas 1. D'aquesta forma, la funció <code>WorkerBee</code> passa els arguments <code>"Doe, Jane"</code> i <code>"engineering"</code> a la funció constructora <code>Employee</code>. Un cop la funció constructora <code>Employee</code> ha retornat, la funció <code>WorkerBee</code> utilitza l'argument restant per a assignar un valor a la propietat <code>projects</code>.</p> + </li> + <li>Un cop el mètode base ha retornat, el constructor <code>Engineer</code> initialitza la propietat <code>machine</code> de l'objecte al valor <code>"belau"</code>.</li> + <li>Un cop el constructor ha retornat, JavaScript assigna el nou objecte a la variable <code>jane</code>.</li> +</ol> + +<p>Es pot pensar que, debug a que s'ha cridat al constructor <code>WorkerBee</code> des de dins el constructor <code>Engineer</code>, s'ha inicialitzat la herència de forma adequada per als objectes <code>Engineer</code>. No és el cas. Cridar el constructor <code>WorkerBee</code> ens asegura que l'objecte <code>Engineer</code> comença amb les propietats especificades per a totes les funcions constructores que es criden. Però, si més tard afegim propietats als prototipus <code>Employee</code> o <code>WorkerBee</code>, aquestes propietats no són heretades per l'objecte <code>Engineer</code>. Per exemple, suposem que tenim les sentències següents:</p> + +<pre class="brush: js">function Engineer (name, projs, mach) { + this.base = WorkerBee; + this.base(name, "engineering", projs); + this.machine = mach || ""; +} +var jane = new Engineer("Doe, Jane", ["navigator", "javascript"], "belau"); +Employee.prototype.specialty = "none"; +</pre> + +<p>L'objecte <code>jane</code> no hereta la propietat <code>specialty</code>. Es fa necesari inicialitzar el prototipus per a assegurar que hi haurà herència de forma dinàmica. Suposem que tenim les sentències següents:</p> + +<pre class="brush: js">function Engineer (name, projs, mach) { + this.base = WorkerBee; + this.base(name, "engineering", projs); + this.machine = mach || ""; +} +Engineer.prototype = new WorkerBee; +var jane = new Engineer("Doe, Jane", ["navigator", "javascript"], "belau"); +Employee.prototype.specialty = "none"; +</pre> + +<p>Ara el valor de la propietat specialty de l'objecte <code>jane</code> és "none".</p> + +<p>Una altra forma d'heretar és mitjançant els mètodes <a href="/en-US/docs/JavaScript/Reference/Global_Objects/Function/call" title="en-US/docs/JavaScript/Reference/Global Objects/Function/call"><code>call()</code></a> / <a href="/en-US/docs/JavaScript/Reference/Global_Objects/Function/apply" title="en-US/docs/JavaScript/Reference/Global Objects/Function/apply"><code>apply()</code></a>. Les funcions següents són equivalents:</p> + +<table> + <tbody> + <tr> + <td> + <pre class="brush: js"> +function Engineer (name, projs, mach) { + this.base = WorkerBee; + this.base(name, "engineering", projs); + this.machine = mach || ""; +} +</pre> + </td> + <td> + <pre class="brush: js"> +function Engineer (name, projs, mach) { + WorkerBee.call(this, name, "engineering", projs); + this.machine = mach || ""; +} +</pre> + </td> + </tr> + </tbody> +</table> + +<p>Utilitzar el mètode de JavaScript <code>call()</code> esdevé en una implementació més neta perquè ja no es requereix la propietat <code>base</code>.</p> + +<h2 id="Un_segon_cop_d'ull_a_la_herència_de_propietats">Un segon cop d'ull a la herència de propietats</h2> + +<p>Les seccions anteriors han descrit com utilitzar els constructors de JavaScript i els prototipus per crear jerarquies i proporcionar herència. Aquesta secció explica alguns detalls que poden no haver estat obvis en les seccions anteriors.</p> + +<h3 id="Valors_locals_versus_valors_heretats">Valors locals versus valors heretats</h3> + +<p>A l'accedir a la propietat d'un objecte, JavaScritp segueix els passos següents, tal i com s'ha descrit abans en aquest mateix capítol:</p> + +<ol> + <li>Es comprova si el valor existeix de forma local. En cas afirmatiu es retorna aquest valor.</li> + <li>Si ho hi ha valor local, es cerca a la cadena de prototipus (mitjançant la propietat<code> __proto__</code>).</li> + <li>Si un objecte de la cadena de prototipus té un valor per la propietat especificada, es retorna aquest valor.</li> + <li>Si no es troba aquesta propietat, s'infereix que l'objecte no té aquesta propietat.</li> +</ol> + +<p>El resultat d'aquests passos depèn de com s'hagin definit les coses. L'exemple original disposaba de les següents definicions:</p> + +<pre class="brush: js">function Employee () { + this.name = ""; + this.dept = "general"; +} + +function WorkerBee () { + this.projects = []; +} +WorkerBee.prototype = new Employee; +</pre> + +<p>Amb aquestes definicions, suposem que creem amy com una instància de WorkerBee amb la sentència següent:</p> + +<pre class="brush: js">var amy = new WorkerBee; +</pre> + +<p>L'objecte <code>amy</code> té una propietat local, <code>projects</code>. Els valors per a les propietats <code>name</code> i <code>dept</code> no són locals per a <code>amy</code> i en conseqüència s'obtenen a partir de la propietat <code>__proto__</code> de <code>amy</code>. Així, <code>amy</code> té els següents valors a les seves propietats:</p> + +<pre class="brush: js">amy.name == ""; +amy.dept == "general"; +amy.projects == []; +</pre> + +<p>Ara suposem que canviem el valor de la propietat <code>name</code> en el prototipus associat a <code>Employee</code>:</p> + +<pre class="brush: js">Employee.prototype.name = "Unknown" +</pre> + +<p>A primer cop d'ull podeu pensar que el nou valor es propagarà afectant a totes les instàncies de <code>Employee</code>. Tanmateix això no succeeix.</p> + +<p>Quan es crea <em>qualsevol</em> instància de l'objecte <code>Employee</code>, aquesta instància un valor local per a la propietat <code>name</code> (la cadena buida). Això vol dir que quan s'assigna el prototipus <code>WorkerBee</code> al crear un nou objecte <code>Employee</code>, <code>WorkerBee.propotype</code> té un valor local per a la propietat <code>name</code>. Així, quan JavaScript cerca la propietat <code>name</code> per a l'objecte <code>amy</code> (una instància de <code>WorkerBee</code>), JavaScript trova la variable local per a aquesta propietat a <code>WorkerBee.prototype</code>. Degut a això no cerca la propietat més enllà dins la cadena de prototipus, cap a <code>Employee.prototype</code>.</p> + +<p>Si es vol canviar el valor de la propietat d'un objecte en temps d'execució i que el nou valor sigui heretat per tots els descendents d'un objecte, no es pot definir la propietat dins la funció constructora de l'objecte. En comptes d'això, s'afegeix al constructor del protipus associat. Per exemple, suposem que canviem el codi anterir pel següent:</p> + +<pre class="brush: js">function Employee () { + this.dept = "general"; +} +Employee.prototype.name = ""; + +function WorkerBee () { + this.projects = []; +} +WorkerBee.prototype = new Employee; + +var amy = new WorkerBee; + +Employee.prototype.name = "Unknown"; +</pre> + +<p>En aquest cas, la propietat <code>name</code> de <code>amy</code> esdevé "Unknown".</p> + +<p>Tal i com mostren els exemples, si es vol tenir un valor predefinit per a les propietats d'un objecte i es vol poder canviar aquest valor predefinit en temps d'execució, les propietats s'han d'assignar al constructor del prototipus i no a la funció constructora de l'objecte mateix.</p> + +<h3 id="Determining_instance_relationships">Determining instance relationships</h3> + +<p>Property lookup in JavaScript looks within an object's own properties and, if the property name is not found, it looks within the special object property <code>__proto__</code>. This continues recursively; the process is called "lookup in the prototype chain".</p> + +<p>The special property <code>__proto__</code> is set when an object is constructed; it is set to the value of the constructor's <code>prototype</code> property. So the expression <code>new Foo()</code> creates an object with <code>__proto__ == <code class="moz-txt-verticalline">Foo.prototype</code></code>. Consequently, changes to the properties of <code class="moz-txt-verticalline">Foo.prototype</code> alters the property lookup for all objects that were created by <code>new Foo()</code>.</p> + +<p>Every object has a <code>__proto__</code> object property (except <code>Object</code>); every function has a <code>prototype</code> object property. So objects can be related by 'prototype inheritance' to other objects. You can test for inheritance by comparing an object's <code>__proto__</code> to a function's <code>prototype</code> object. JavaScript provides a shortcut: the <code>instanceof</code> operator tests an object against a function and returns true if the object inherits from the function prototype. For example,</p> + +<pre class="brush: js">var f = new Foo(); +var isTrue = (f instanceof Foo);</pre> + +<p>For a more detailed example, suppose you have the same set of definitions shown in <a href="#Inheriting_properties">Inheriting properties</a>. Create an <code>Engineer</code> object as follows:</p> + +<pre class="brush: js">var chris = new Engineer("Pigman, Chris", ["jsd"], "fiji"); +</pre> + +<p>With this object, the following statements are all true:</p> + +<pre class="brush: js">chris.__proto__ == Engineer.prototype; +chris.__proto__.__proto__ == WorkerBee.prototype; +chris.__proto__.__proto__.__proto__ == Employee.prototype; +chris.__proto__.__proto__.__proto__.__proto__ == Object.prototype; +chris.__proto__.__proto__.__proto__.__proto__.__proto__ == null; +</pre> + +<p>Given this, you could write an <code>instanceOf</code> function as follows:</p> + +<pre class="brush: js">function instanceOf(object, constructor) { + object = object.__proto__; + while (object != null) { + if (object == constructor.prototype) + return true; + if (typeof object == 'xml') { + return constructor.prototype == XML.prototype; + } + object = object.__proto__; + } + return false; +} +</pre> + +<div class="note"><strong>Note:</strong> The implementation above checks the type of the object against "xml" in order to work around a quirk of how XML objects are represented in recent versions of JavaScript. See {{ bug(634150) }} if you want the nitty-gritty details.</div> + +<p class="note">Using the <code>instanceOf</code> function defined above, these expressions are true:</p> + +<pre class="brush: js">instanceOf (chris, Engineer) +instanceOf (chris, WorkerBee) +instanceOf (chris, Employee) +instanceOf (chris, Object) +</pre> + +<p>But the following expression is false:</p> + +<pre class="brush: js">instanceOf (chris, SalesPerson) +</pre> + +<h3 id="Informació_global_als_constructors">Informació global als constructors</h3> + +<p>A l'hora de crear constructors cal anar amb compte si es manega informació global dins el constructor. Per exemple, suposem que volem crear un identificador (ID) únic que serà assignat automàticament per a cada nou <code>Employee</code>. Podríem utilitzar la definició següent per a <code>Employee</code>:</p> + +<pre class="brush: js">var idCounter = 1; + +function Employee (name, dept) { + this.name = name || ""; + this.dept = dept || "general"; + this.id = idCounter++; +} +</pre> + +<p>Amb aquesta definició quan es crea un nou <code>Employee</code>, el constructor assigna la següent ID seqüencialment i llavors incrementa el valor del contador global de ID. Així, suposant el codi següent, tenim que <code>victoria.id</code> val 1 i <code>harry.id</code> val 2:</p> + +<pre class="brush: js">var victoria = new Employee("Pigbert, Victoria", "pubs") +var harry = new Employee("Tschopik, Harry", "sales") +</pre> + +<p> </p> + +<p>At first glance that seems fine. However, <code>idCounter</code> gets incremented every time an <code>Employee</code> object is created, for whatever purpose. If you create the entire <code>Employee</code> hierarchy shown in this chapter, the <code>Employee</code> constructor is called every time you set up a prototype. Suppose you have the following code:</p> + +<pre class="brush: js">var idCounter = 1; + +function Employee (name, dept) { + this.name = name || ""; + this.dept = dept || "general"; + this.id = idCounter++; +} + +function Manager (name, dept, reports) {...} +Manager.prototype = new Employee; + +function WorkerBee (name, dept, projs) {...} +WorkerBee.prototype = new Employee; + +function Engineer (name, projs, mach) {...} +Engineer.prototype = new WorkerBee; + +function SalesPerson (name, projs, quota) {...} +SalesPerson.prototype = new WorkerBee; + +var mac = new Engineer("Wood, Mac"); +</pre> + +<p>Ara suposem que les definicions omeses aquí tenen la propietat <code>base</code> i criden el constructor que tenen damunt de la cadena de prototipus. En aquest cas, quan es crea l'objecte <code>mac</code>, <code>mac.id</code> rep el valor de 5.</p> + +<p>Depenent de l'aplicació, el fet que el contador s'incrementi aquests cops adicionals pot tenir o no conseqüències. Si el valor exacte d'aquest contador és important una possible solució pot ser el constructor següent:</p> + +<pre class="brush: js">function Employee (name, dept) { + this.name = name || ""; + this.dept = dept || "general"; + if (name) + this.id = idCounter++; +} +</pre> + +<p>Al crear una instància de <code>Employee</code> per a ser emprada com a prototipus, no es passen paràmetres al constructor. Aquesta definició del constructor no assigna un valor a la id i no actualitza el contador quan el constructor no rep paràmetres. Així, per a que un <code>Employee</code> rebi una id, requerim que rebi un nom. Executar l'exemple anterior amb el nou constructor esdevindrà en que <code>mac.id</code> rebi el valor 1.</p> + +<h3 id="No_hi_ha_herència_múltiple">No hi ha herència múltiple</h3> + +<p>Alguns llenguatges orientats a objectes permeten l'herència múltiple, és a dir, que un objecte pugui heretar propietats i valors de pares que no tenen res a veure entre ells. JavaScript no suporta l'herència múltiple.</p> + +<p>L'herència de valors de propietats succeeix en temps d'execució i és proporcionada per fet que JavaScript cerqui un valor dins la cadena de prototipus de l'objecte. Com que un objecte disposa d'un sol prototipus associat a ell JavaScript no pot heretar dinàmicament de més d'una cadena de prototipus.</p> + +<p>A JavaScript, però, es pot fer que una funció constructora cridi a més d'una funció constructora dins d'ella. Això crea la ilusió d'herència múltiple. Per exemple, suposem les sentències següents:</p> + +<pre class="brush: js">function Hobbyist (hobby) { + this.hobby = hobby || "scuba"; +} + +function Engineer (name, projs, mach, hobby) { + this.base1 = WorkerBee; + this.base1(name, "engineering", projs); + this.base2 = Hobbyist; + this.base2(hobby); + this.machine = mach || ""; +} +Engineer.prototype = new WorkerBee; + +var dennis = new Engineer("Doe, Dennis", ["collabra"], "hugo") +</pre> + +<p>Ara suposem que la definició de WorkerBee és l'emprada abans en aquest capítol. En aquest case l'objecte <code>dennis</code> rep les propietats següents:</p> + +<pre class="brush: js">dennis.name == "Doe, Dennis" +dennis.dept == "engineering" +dennis.projects == ["collabra"] +dennis.machine == "hugo" +dennis.hobby == "scuba" +</pre> + +<p>Així tenim que dennis rep la propietat <code>hobby</code> del constructor <code>Hobbyist</code>. Tot i així, suposem llavors que afegim una propietat al constructor del prototipus <code>Hobbyist</code>:</p> + +<pre class="brush: js">Hobbyist.prototype.equipment = ["mask", "fins", "regulator", "bcd"] +</pre> + +<p>L'objecte <code>dennis</code> no hereta aquesta nova propietat.</p> + +<div>{{PreviousNext("Web/JavaScript/Guide/Working_with_Objects", "Web/JavaScript/Guide/Iterators_and_Generators")}}</div> diff --git a/files/ca/web/javascript/guide/expressions_i_operadors/index.html b/files/ca/web/javascript/guide/expressions_i_operadors/index.html new file mode 100644 index 0000000000..9985daa497 --- /dev/null +++ b/files/ca/web/javascript/guide/expressions_i_operadors/index.html @@ -0,0 +1,846 @@ +--- +title: Expressions i operadors +slug: Web/JavaScript/Guide/Expressions_i_Operadors +translation_of: Web/JavaScript/Guide/Expressions_and_Operators +--- +<div>{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Functions", "Web/JavaScript/Guide/Numbers_and_dates")}}</div> + +<p>Aquest capítol explica les expressions i els operadors de JavaScript, incloent l'assignació, comparació, airtmètic, operadors de bits, lògics, cadenes, i operadors especials.</p> + +<h2 id="Expressions">Expressions</h2> + +<p>Una <em>expressió</em> és qualsevol unitat de codi vàlida que esdevé un valor.</p> + +<p>Conceptualment hi ha dos tipus d'expressions: les que assignen un valor a una variable i les que simplement tenen un valor.</p> + +<p>L'expressió <code>x = 7</code> és un exemple del primer tipus. Aquesta expressió fa servir l'operador<em> </em> = per a assignar el valor set a la variable <code>x</code>. L'expressió per si mateixa s'avalua com a 7.</p> + +<p>El codi 3 + 4 és un exemple d'expressió del segon tipus. Aquesta expressió utilitza l'operador + per a sumar tres i quatre sense assignar el resultat, set, a una variable.<br> + <br> + JavaScript té les següents categories d'expressions:</p> + +<ul> + <li>Aritmètiques: s'avaluen a un nombre, per exemple 3.14159. (Generalment utilitzen {{ web.link("#Arithmetic_operators", "operadors aritmètics") }}.)</li> + <li>String: s'avaluen a una cadena de caràcters, per exemple, "Pau" o "234". (Generalment utilitzen {{ web.link("#String_operators", "operadors d'strings") }}.)</li> + <li>Lògiques: s'avaluen a cert o fals. (sovint inclouen {{ web.link("#Logical_operators", "operadors lògics") }}.)</li> + <li>Objecte: s'avaluen a un objecte. (Vegeu els {{ web.link("#Special_operators", "operadors especials") }} més informació.)</li> +</ul> + +<h2 id="Operadors">Operadors</h2> + +<p>JavaScript disposa dels següents tipus d'operadors. Aquesta secció descriu els operadors i conté informació sobre la seva precedència.</p> + +<ul> + <li>{{ web.link("#Assignment_operators", "Operadors d'assignació") }}</li> + <li>{{ web.link("#Comparison_operators", "Operadors de comparació") }}</li> + <li>{{ web.link("#Arithmetic_operators", "Operadors aritmètics") }}</li> + <li>{{ web.link("#Bitwise_operators", "Operadors de bits") }}</li> + <li>{{ web.link("#Logical_operators", "Operadors lògics") }}</li> + <li>{{ web.link("#String_operators", "Operadors de strings") }}</li> + <li>{{ web.link("#Special_operators", "Operadors especials") }}</li> +</ul> + +<p>JavaScript té operadors <em>binaris</em> i <em>unaris</em>, també disposa d'un operador especial ternari, l'operador condicional. Un operador binari requereix dos operands, un abans l'operador i l'altre després de l'operador:</p> + +<pre><em>operand1</em> <em>operador</em> <em>operand2</em> +</pre> + +<p>Per exemple, <code>3+4</code> o <code>x*y</code>.</p> + +<p>Un operador unari A requereix d'un sol operand, ja sigui abans o després de l'operador:</p> + +<pre><em>operador</em> <em>operand</em> +</pre> + +<p>o be</p> + +<pre><em>operand</em> <em>operador</em> +</pre> + +<p>Per exemple, <code>x++</code> o <code>++x</code>.</p> + +<h3 id="Operadors_d'assignació">Operadors d'assignació</h3> + +<p>Un operador d'assignació assigna un valor a l'operand de la seva esquerra basat en l'operand de la seva dreta. L'operador d'assignació simple és l'igual (<code>=</code>), que assigna el valor de l'operand de la dreta a l'operand de l'esquerra. És a dir, <code>x = y</code> assigna el valor de <code>y</code> a <code>x</code>.</p> + +<p>També hi ha operadors d'assignació compostos, que són abreviacions per als operadors llistats a la taula següent:</p> + +<table class="standard-table"> + <caption>Taula 3.1 Operadors d'assignació</caption> + <thead> + <tr> + <th scope="col">Operadors d'assignació compostos</th> + <th scope="col">Significat</th> + </tr> + </thead> + <tbody> + <tr> + <td><code>x += y</code></td> + <td><code>x = x + y</code></td> + </tr> + <tr> + <td><code>x -= y</code></td> + <td><code>x = x - y</code></td> + </tr> + <tr> + <td><code>x *= y</code></td> + <td><code>x = x * y</code></td> + </tr> + <tr> + <td><code>x /= y</code></td> + <td><code>x = x / y</code></td> + </tr> + <tr> + <td><code>x %= y</code></td> + <td><code>x = x % y</code></td> + </tr> + <tr> + <td><code>x <<= y</code></td> + <td><code>x = x << y</code></td> + </tr> + <tr> + <td><code>x >>= y</code></td> + <td><code>x = x >> y</code></td> + </tr> + <tr> + <td><code>x >>>= y</code></td> + <td><code>x = x >>> y</code></td> + </tr> + <tr> + <td><code>x &= y</code></td> + <td><code>x = x & y</code></td> + </tr> + <tr> + <td><code>x ^= y</code></td> + <td><code>x = x ^ y</code></td> + </tr> + <tr> + <td><code>x |= y</code></td> + <td><code>x = x | y</code></td> + </tr> + </tbody> +</table> + +<h3 id="Operadors_de_comparació">Operadors de comparació</h3> + +<p><span class="comment">This seems to me kind of poorly explained, mostly the difference betwen "==" and "==="...</span>Els operadors de comparació comparen els operands i retornen un valor lògic basat en si la comparació és certa o no. Els operands poden ser numèrics, string, lògics, o bé valors d'objectes. Els Strings es comparen basant-se en l'ordre lexicogràfic standard, utilitzant valors Unicode. Quan els dos operands no són del mateix tipus, en la majoria dels casos JavaScript intenta convertir-los a un tipus apropiat per a realitzar la comparació.<br> + Aquest comportament generalment resulta en una comparació amb els operands transformats a nombres. La única excepció quant a la conversió de tipus és quan s'utilitzen els operands <code>===</code> i <code>!==</code>, els quals realitzen comparacións estrictes de igualtat i no-igualtat, respectivament. Aquests operadors no intenten convertir els operands a tipus compatibles abans de aplicar l'igualtat. La taula següent descriu els operadors de comparació en base a aquest exemple:</p> + +<pre class="brush: js">var var1 = 3, var2 = 4; +</pre> + +<table class="standard-table"> + <caption>Taula 3.2 Operadors de comparació</caption> + <thead> + <tr> + <th scope="col">Operador</th> + <th scope="col">Descripció</th> + <th scope="col">Exemples que s'avaluen a cert</th> + </tr> + </thead> + <tbody> + <tr> + <td>Igualtat (<code>==</code>)</td> + <td>Retorna true si els operands són iguals.</td> + <td><code>3 == var1</code> + <p><code>"3" == var1</code></p> + <code>3 == '3'</code></td> + </tr> + <tr> + <td>No-igualtat (<code>!=</code>)</td> + <td>Retorna true si els operands són diferents.</td> + <td><code>var1 != 4<br> + var2 != "3"</code></td> + </tr> + <tr> + <td>Igualtat estricta (<code>===</code>)</td> + <td>Retorna true si els operands són iguals i del mateix tipus. Vegeu també <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is"><code>Object.is</code></a> i <a href="/en-US/docs/Web/JavaScript/Guide/Sameness" title="/en-US/docs/Web/JavaScript/Guide/Sameness">igualtat a JS</a>.</td> + <td><code>3 === var1</code></td> + </tr> + <tr> + <td>No-igualtat estricta (<code>!==</code>)</td> + <td>Retorna true si els operands no són iguals i/o del mateix tipus.</td> + <td><code>var1 !== "3"<br> + 3 !== '3'</code></td> + </tr> + <tr> + <td>Major que (<code>></code>)</td> + <td>Retorna true si l'operand de l'esquerra és més gran que l'operand e la dreta.</td> + <td><code>var2 > var1<br> + "12" > 2</code></td> + </tr> + <tr> + <td>Major o igual que (<code>>=</code>)</td> + <td>Retorna true si l'operand de l'esquera és major o igual que l'operand de la dreta.</td> + <td><code>var2 >= var1<br> + var1 >= 3</code></td> + </tr> + <tr> + <td>Menor que (<code><</code>)</td> + <td>Retorna true si l'operand de l'esquerra és més petit que l'operand de la dreta.</td> + <td><code>var1 < var2<br> + "2" < "12"</code></td> + </tr> + <tr> + <td>Menor o igual que (<code><=</code>)</td> + <td>Retorna true si l'operand de l'esquerra és menor o igual que l'operand de la dreta.</td> + <td><code>var1 <= var2<br> + var2 <= 5</code></td> + </tr> + </tbody> +</table> + +<h3 id="Operadors_aritmètics">Operadors aritmètics</h3> + +<p>Els operadors aritmètics prenen valors numèrics (ja siguin literals o variables) com a operands i retornen un sol valors numèric. Els operadors aritmètics standard són la suma (+), la resta (-), la multiplicació (*) i la divisió (/). Aquests operadors funcionen de la mateixa manera que a la majoria d'altres llenguatges de programació quan s'utilitzen amb nombres de coma flotant (particularment, cal destacar que la divisió entre zero produeix <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Infinity"><code>Infinity</code></a>). Per exemple:</p> + +<pre class="brush: js">console.log(1 / 2); /* imprimeix 0.5 */ +console.log(1 / 2 == 1.0 / 2.0); /* això també és cert */ +</pre> + +<p>Adicionalment, JavaScript proporciona els operadors aritmètics llistats a la taula següent:</p> + +<table class="fullwidth-table"> + <caption>Taula 3.3 Operadors aritmètics</caption> + <thead> + <tr> + <th scope="col">Operador</th> + <th scope="col">Descripció</th> + <th scope="col">Exemple</th> + </tr> + </thead> + <tbody> + <tr> + <td><code>%</code><br> + (Mòdul)</td> + <td>Operador binari. Retorna el residu de dividir els dos operands.</td> + <td>12 % 5 retorna 2.</td> + </tr> + <tr> + <td><code>++</code><br> + (Increment)</td> + <td> + <p>Operador unari. Afegeix un al seu operand. Si s'utilitza com a prefix (<code>++x</code>), retorna el valor del seu operand després d'afexir-li un; si s'utilitza com a sufix (<code>x++</code>), retorna el valor del seu operand abans d'afegir-li un.</p> + </td> + <td>Si <code>x</code> és 3, llavors <code>++x</code> assigna 4 a <code>x</code> i retorna 4, mentre que <code>x++</code> retorna 3 i, només llavors, assigna 4 a <code>x</code>.</td> + </tr> + <tr> + <td><code>--</code><br> + (Decrement)</td> + <td>Operador uniari. Resta un al seu operand. Retorna el valor anàleg a l'operador increment.</td> + <td>Si <code>x</code> és 3, llavors <code>--x</code> assigna 2 a <code>x</code> i retorna 2, mentre que <code>x--</code> retorna 3 i, només llavors, assigna 2 a<code> x</code>.</td> + </tr> + <tr> + <td><code>-</code><br> + (Negació unària)</td> + <td>Operador unari. Retorna el resultat de negar el seu operand.</td> + <td>Si <code>x</code> val 3, llavors <code>-x</code> retorna -3.</td> + </tr> + </tbody> +</table> + +<h3 id="Operadors_de_bits">Operadors de bits</h3> + +<p>Els operadors de bits tracten els seus operands com a conunts de 32 bits (zeros i uns), en comptes de com a nombres decimals, hexadecimals o octals. Per exemple, el nombre decimal 9 és representat de forma binària per 1001. Els operadors de bits realitzen operacions sobre aquestes representacions binàries, però sempre retornen valors numèrics de JavaScript.</p> + +<p>La taula següent resumeix els operadors de bits disponibles a JavaScript.</p> + +<table class="standard-table"> + <caption>Taula 3.4 Operadors de bits</caption> + <thead> + <tr> + <th scope="col">Operador</th> + <th scope="col">Ús</th> + <th scope="col">Descripció</th> + </tr> + </thead> + <tbody> + <tr> + <td>AND binari</td> + <td><code>a & b</code></td> + <td>Retorna 1 a cada posició de bit on la posició corresponent a ambdós operadors conten uns.</td> + </tr> + <tr> + <td>OR binari</td> + <td><code>a | b</code></td> + <td> + <p>Retorna 1 a cada posició de bit on al menys un dels operands té un 1 a la posició corresponent.</p> + </td> + </tr> + <tr> + <td>XOR binari</td> + <td><code>a ^ b</code></td> + <td> + <p>Retorna un 1 a cada posició de bit on només un dels operands té un 1 a la posicio corresponent, però no ambdós.</p> + </td> + </tr> + <tr> + <td>NOT binari</td> + <td><code>~ a</code></td> + <td>Inverteix els bits del seu operand.</td> + </tr> + <tr> + <td>Desplaçament a l'esquerra</td> + <td><code>a << b</code></td> + <td>Desplaça la representació binària de <code>a</code> <code>b</code> bits a l'esquerra, afegint zeros a la dreta.</td> + </tr> + <tr> + <td>Desplaçament a la dreta amb propagació de signe</td> + <td><code>a >> b</code></td> + <td>Desplaça la representació binària de <code>a</code> <code>b</code> bits a la dreta, descartant els bits que no hi caben.</td> + </tr> + <tr> + <td>Desplaçament a la dreta amb inserció de zeros</td> + <td><code>a >>> b</code></td> + <td>Desplaça la representació binària de <code>a</code> <code>b</code> bits a la dreta, descartant els bits que no hi caben i inserint zeros a l'esquerra.</td> + </tr> + </tbody> +</table> + +<h4 id="Bitwise_Logical_Operators" name="Bitwise_Logical_Operators">Operadors lògics de bits</h4> + +<p>Conceptualment, els operadors lògics de bits funcionen de la següent manera:</p> + +<ul> + <li>Es converteixen els operands a nombres sencers de 32 bits expressats per una sèrie de bits (zeros i uns).</li> + <li>S'emparella cada bit del primer operand amb el bit corresponent del segond operand: el primer bit amb el primer bit, el segon amb el segon, etcètera.</li> + <li>S'aplica l'operador per a cada parella de bits, i el resultat es construeix de forma binària.</li> +</ul> + +<p>Per exemple, la representació binària de 9 és 1001, mentre que la representació binària de quinze és 1111. Així, quan els operadors de bits s'apliquen a aquests valors el resultat és el següent:</p> + +<table class="standard-table"> + <caption>Taula 3.5 Exemples d'operadors de bits</caption> + <thead> + <tr> + <th scope="col">Expressió</th> + <th scope="col">Resultat</th> + <th scope="col">Descripció binària</th> + </tr> + </thead> + <tbody> + <tr> + <td><code>15 & 9</code></td> + <td><code>9</code></td> + <td><code>1111 & 1001 = 1001</code></td> + </tr> + <tr> + <td><code>15 | 9</code></td> + <td><code>15</code></td> + <td><code>1111 | 1001 = 1111</code></td> + </tr> + <tr> + <td><code>15 ^ 9</code></td> + <td><code>6</code></td> + <td><code>1111 ^ 1001 = 0110</code></td> + </tr> + <tr> + <td><code>~15</code></td> + <td><code>-16</code></td> + <td><code>~</code><code>00000000...</code><code>00001111 = </code><code>1111</code><code>1111</code><code>...</code><code>11110000</code></td> + </tr> + <tr> + <td><code>~9</code></td> + <td><code>-10</code></td> + <td><code>~</code><code>00000000</code><code>...</code><code>0000</code><code>1001 = </code><code>1111</code><code>1111</code><code>...</code><code>1111</code><code>0110</code></td> + </tr> + </tbody> +</table> + +<p>Fixeu-vos que a l'utilitzar l'operador de bits <code>NOT</code> tots 32 bits són invertit, i que els valors amb el bit més significatiu (el de l'esquerra) amb valor 1 representen nombres negatius (representació en complement a dos).</p> + +<h4 id="Bitwise_Shift_Operators" name="Bitwise_Shift_Operators">Operadors de desplaçament de bits</h4> + +<p>Els operadors de desplaçament de bits requereixen de dos operands: el primer és un conjunt de bits a desplaçar. El segon operand és el nombre de posicions que es desplaçaran els bits del primer operand. La direcció des desplaçament és controlada per l'operador utilitzat.</p> + +<p>Els operadors de desplaçament de bits converteixen els seus operands a nombres de 32 bits i el valor retornat és del mateix tipus que l'operand de l'esquerra. Trobareu un llistat amb els operadors de desplaçament de bits a la taula següent.</p> + +<table class="fullwidth-table"> + <caption>Taula 3.6 Operadors de desplaçament de bits</caption> + <thead> + <tr> + <th scope="col">Operador</th> + <th scope="col">Descripció</th> + <th scope="col">Exemple</th> + </tr> + </thead> + <tbody> + <tr> + <td><code><<</code><br> + (Desplaçament a l'esquerra)</td> + <td> + <p>Aquest operador desplaça a l'esquerra el primer operand el nombre de bits especificat. Els bits que no hi caben es descarten. Les noves posicions de la dreta s'omplen amb zeros.</p> + </td> + <td><code>9<<2</code> retorna 36, perquè 1001 desplaçat 2 bits a l'esquerra esdevé 100100, que és la representació binaria de 36.</td> + </tr> + <tr> + <td><code>>></code><br> + (Desplaçament a la dreta amb propagació de signe)</td> + <td> + <p>Aquest operador desplaça el primer operand el nombre de bits especificats cap a la dreta. Els nous bits de l'esquerra són copies del bit originalment més significatiu.</p> + </td> + <td><code>9>>2</code> retorna 2, perquè 1001 desplaçat 2 bits a la dreta esdevé 10, que és la representació binària de 2. De la mateixa manera, <code>-9>>2</code> retorna -3, perquè el signe l'operand preseva el signe.</td> + </tr> + <tr> + <td><code>>>></code><br> + (Desplaçament a la dreta omplint amb zeros)</td> + <td> + <p>Aquest operador desplaça l'operand el nombre de bits especificat a la dreta. Els bits sobrant són descartats. Els nous bits de l'esquerra s'omplen amb zeros.</p> + </td> + <td><code>19>>>2</code> retorna 4, perquè 10011 desplaçat 2 bits a la dreta esdevé 100, que és la representació binària de 4. Per a nombres no negatius aquest operador retorna el mateix resultat que l'operador de desplaçament a la dreta amb propagació de signe.</td> + </tr> + </tbody> +</table> + +<h3 id="Operadors_lògics">Operadors lògics</h3> + +<p>Els operadors lògics utilitzen típicament amb valors booleans (lògics); quan ho són, retornen un valor de tipus Boolean. Els operadors && i || , però, en realitat retornen el valor d'un dels operands, de tal manera que si aquests operadors s'utilitzen amb valors no booleans poden retornar un valor no booleà. A la següent taula es descriuen els operadors lògics.</p> + +<table class="fullwidth-table"> + <caption>Taula 3.6 Operadors lògics</caption> + <thead> + <tr> + <th scope="col">Operador</th> + <th scope="col">Ús</th> + <th scope="col">Descripció</th> + </tr> + </thead> + <tbody> + <tr> + <td><code>&&</code></td> + <td><code>expr1 && expr2</code></td> + <td>(AND lògic) Retorna <code>expr1</code> si pot ser convertida a fals; en qualsevol altre cas retorna <code>expr2</code>. Així, quan es proporcionen operands booleans, <code>&&</code> retorna true si ambdós operands són true: en qualsevol altre cas retorna fals.</td> + </tr> + <tr> + <td><code>||</code></td> + <td><code>expr1 || expr2</code></td> + <td>(OR lògic) Retorna <code>expr1</code> si pot ser convertida a true; en qualsevol altre cas retorna <code>expr2</code>. És a dir, quan s'utilitza amb operands booleans, <code>||</code> retorna true si qualsevol dels dos operands és true; si ambdós operands són false, retorna false.</td> + </tr> + <tr> + <td><code>!</code></td> + <td><code>!expr</code></td> + <td>(NOT lògic) Retorna false si el seu únic operand es pot convertir a true; en qualsevol altre cas retorna true.</td> + </tr> + </tbody> +</table> + +<p>Alguns exemples d'expressions que es poden convertir a false són aquelles que s'avaluen a <code>null</code>, <code>0</code>, <code>NaN</code>, l'string buit (<code>""</code>), o <code>undefined</code>.</p> + +<p>El codi següent mostra exemples de l'operador && (AND lògic).</p> + +<pre class="brush: js">var a1 = true && true; // t && t retorna true +var a2 = true && false; // t && f retorna false +var a3 = false && true; // f && t retorna false +var a4 = false && (3 == 4); // f && f retorna false +var a5 = "Cat" && "Dog"; // t && t retorna Dog +var a6 = false && "Cat"; // f && t retorna false +var a7 = "Cat" && false; // t && f retorna false +</pre> + +<p>El codi següent mostra exemples de l'operador || (OR lògic).</p> + +<pre class="brush: js">var o1 = true || true; // t || t retorna true +var o2 = false || true; // f || t retorna true +var o3 = true || false; // t || f retorna true +var o4 = false || (3 == 4); // f || f retorna false +var o5 = "Cat" || "Dog"; // t || t retorna Cat +var o6 = false || "Cat"; // f || t retorna Cat +var o7 = "Cat" || false; // t || f retorna Cat +</pre> + +<p>El codi següent mostra exemples de l'operador ! (NOT lògic).</p> + +<pre class="brush: js">var n1 = !true; // !t retorna false +var n2 = !false; // !f retorna true +var n3 = !"Cat"; // !t retorna false +</pre> + +<h4 id="Short-Circuit_Evaluation" name="Short-Circuit_Evaluation">Avaluació en curtcircuit</h4> + +<p>Mentre les expressions lògiques es van avaluant una a una d'esquerra a dreta, a l'avaluar cadascuna també s'avalua si curtcirquiatar l'expressió mitjançant les regles següents:</p> + +<ul> + <li><code>false</code> && <em>quelcom</em> es curtcircuita avaluant-se a false.</li> + <li><code>true</code> || quelcom es curtcircuita avaluant-se a true.</li> +</ul> + +<p>Les regles de la lògica garanteixen que aquestes avaluacions sempre són correctes. Cal remarca que la part <em>quelcom</em> no arriva a avaluar-se mai, així que cap efecte secundari provocat per la seva avaluació tindrà efecte.</p> + +<h3 id="Operadors_de_Strings">Operadors de Strings</h3> + +<p>A més dels operadors de comparació, que poden utilitzar-se amb valors de tipus string, l'operador de concatenació (+) concatena dos valors string, retornant un altre string format per la unió dels dos strings operands. Per exemple, <code>"la meva " + "string"</code> retorna la string <code>"la meva string"</code>.</p> + +<p>L'abreviació de operador d'assignació += també pot ser emprat per a concatenar strings. Per exemple, si la variable <code>mystring</code> te el valor "alfa", llavors l'expressió <code>mystring += "bet"</code> s'avalua a "alfabet" i assigna aquest valor a <code>mystring</code>.</p> + +<h3 id="Operadors_especial">Operadors especial</h3> + +<p>JavaScript ofereix els següents operadors especials:</p> + +<ul> + <li>{{ web.link("#Conditional_operator", "Operador condicional") }}</li> + <li>{{ web.link("#Comma_operator", "Operador coma") }}</li> + <li><code>{{ web.link("#delete", "delete") }}</code></li> + <li><code>{{ web.link("#in", "in") }}</code></li> + <li><code>{{ web.link("#instanceof", "instanceof") }}</code></li> + <li><code>{{ web.link("#new", "new") }}</code></li> + <li><code>{{ web.link("#this", "this") }}</code></li> + <li><code>{{ web.link("#typeof", "typeof") }}</code></li> + <li><code>{{ web.link("#void", "void") }}</code></li> +</ul> + +<h4 id="conditional_operator" name="conditional_operator">Operador condicional</h4> + +<p>L'operador condicional és l'únic operador de JavaScript que accepta tres operands. L'operador retorna un de dos valors basant-se en una condició. La sintaxi és la següent:</p> + +<pre><em>condició</em> ? <em>val1</em> : <em>val2</em> +</pre> + +<p>Si <code>condició</code> és certa, l'operador retorna el valor <code>val1</code>. En qualsevol altre cas retorna el valor <code>val2</code>. Es pot emprar l'operador condicional a qualsevol lloc on es pugui utilitzar un operador standard.</p> + +<p>Per exemple,</p> + +<pre class="brush: js">var estat = (edat >= 18) ? "adult" : "menor"; +</pre> + +<p>Aquesta sentència assigna el valor "adult" a la variable <code>estat</code> si edat és 18 o més. En qualsevol altre cas assigna el valor "menor" a <code>estat</code>.</p> + +<h4 id="comma_operator" name="comma_operator">Operador coma</h4> + +<p>L'operador coma (<code>,</code>) simplement avalua els seus dos operands i retorna el valor del segon operand. Aquest operdor s'utilitza principalment dins el bucle <code>for</code> per a permetre que múltiples variables s'actualitzin per a cada volta del bucle.</p> + +<p>Per exemple, si <code>a</code> és un array de dues dimensions amb 10 elements per dimensió, el codi següent utilitza l'operador coma per a incrementar dues variables a l'hora. El codi mostra els valors dels elements de la diagonal de l'array:</p> + +<pre class="brush: js">for (var i = 0, j = 9; i <= j; i++, j--) + document.writeln("a[" + i + "][" + j + "]= " + a[i][j]); +</pre> + +<h4 id="delete" name="delete"><code>delete</code></h4> + +<p>L'operador <code>delete</code> esborra un objecte, una propietat d'un objecte o l'element a la posició especificada d'un array. La sintaxi és:</p> + +<pre class="brush: js">delete nomObjecte; +delete nomObjecte.property; +delete nomObjecte[index]; +delete propietat; // Només és legal dins una sentència with +</pre> + +<p>on <code>nomObjecte</code> és el nom d'un objecte, <code>propietat</code> és una propietat existent i <code>index</code> és un nombre sencer que representa la posició d'un element dins un array.</p> + +<p>La quarta forma només és legal dins una sentència <code>with</code>, per a esborrar la propietat d'un objecte.</p> + +<p>Es pot emprar l'operador <code>delete</code> per a esborrar variables declarades implícitament però no serveix per a variables declarades amb la sentència <code>var</code>.</p> + +<p>Si l'operador delete aconsegueix el seu objectiu, assigna el valor <code>undefined</code> a la propietat o element esmentat. L'operador <code>delete</code> retorna true si l'operació és posible; retorna false si l'operació no és posible.</p> + +<pre class="brush: js">x = 42; +var y = 43; +myobj = new Number(); +myobj.h = 4; // crea la propietat h +delete x; // retorna true (pot esborrar si la variable ha estat declarada implicitament) +delete y; // retorna false (no pot esborrar si la variable ha estat declarada amb var) +delete Math.PI; // retorna false (no pot esborrar propietats predefinides) +delete myobj.h; // retorna true (pot esborrar propietats definides per l'usuari) +delete myobj; // retorna true (pot esborrar si l'objecte ha estat declarat implícitament) +</pre> + +<h5 id="Esborrar_elements_d'un_array">Esborrar elements d'un array</h5> + +<p>A l'esborrar l'element d'un array, la longitud de l'array no es veu afectada. Per exemple, si s'esborrar <code>a[3]</code>, <code>a[4]</code> roman a <code>a[4]</code> mentre que <code>a[3]</code> passa a valer <code>undefined</code>.</p> + +<p>Quan l'operador delete esborra un element d'un array, aquest element ja no és a l'array. Al següent exemple, s'esborra <code>trees[3]</code> amb delete. Tot i així, <code>trees[3]</code> encara és accessible i retorna <code>undefined</code>.</p> + +<pre class="brush: js">var trees = new Array("redwood", "bay", "cedar", "oak", "maple"); +delete trees[3]; +if (3 in trees) { + // aquest codi no s'arriba a executar mai +} +</pre> + +<p>Si es vol que un element d'un array existeixi però tingui un valor indefinit, es pot emprar la paraula clau undefined en comptes de l'operador <code>delete</code>. Al següent exemple, <code>trees[3]</code> rep el valor <code>undefined</code>, però l'elelement de l'array encara existeix:</p> + +<pre class="brush: js">var trees = new Array("redwood", "bay", "cedar", "oak", "maple"); +trees[3] = undefined; +if (3 in trees) { + // aquest codi s'executa +} +</pre> + +<h4 id="in" name="in"><code>in</code></h4> + +<p>L'operador <code>in</code> retorna true si la propietat especificada existeix en l'objecte especificat. La sintaxi és:</p> + +<pre class="brush: js">nomPropOnombre in nomObjecte +</pre> + +<p>on <code>nomPropOnombre</code> és una string que representa el nom d'una propietat o bé una expressió numèrica que representa la posició d'un element dins un array, i <code>nomObjecte</code> és el nom d'un objecte.</p> + +<p>Els següents exemples mostren alguns usos de l'operador <code>in</code>.</p> + +<pre class="brush: js">// Arrays +var trees = new Array("redwood", "bay", "cedar", "oak", "maple"); +0 in trees; // retorna true +3 in trees; // retorna true +6 in trees; // retorna false +"bay" in trees; // retorna false (s'ha de proporcionar l'índex, + // no el valor a aquell índex) +"length" in trees; // retorna true (length és una propietat de Array) + +// Objects predefinits +"PI" in Math; // retorna true +var myString = new String("coral"); +"length" in myString; // retorna true + +// Objectes creats per l'usuari +var mycar = {make: "Honda", model: "Accord", year: 1998}; +"make" in mycar; // retorna true +"model" in mycar; // retorna true +</pre> + +<h4 id="instanceof" name="instanceof"><code>instanceof</code></h4> + +<p>L'operador <code>instanceof</code> retorna cert si l'objecte especificat és del tipus especificat. La sintaxi és:</p> + +<pre class="brush: js">nomObjecte instanceof tipusObjecte +</pre> + +<p>on <code>nomObjecte</code> és el nom de l'objecte a comprarar amb <code>tipusObjecte</code>, i tipusObjecte és un tipus d'objecte, com ara <code>Date</code> o <code>Array</code>.</p> + +<p>Utilitzeu <code>instanceof</code> quan necessiteu confirmar el tipus d'un objecte en temps d'execució. Per exemple, a l'hora de capturar execepcions és posible executar diferent codi segons el tipus d'excepció llençada.</p> + +<p>Per exemple, el següent codi utilitza instanceof per a determinar si <code>dia</code> és un objecte de tipus <code>Date</code>. Com que dia és un objecte de tipus <code>Date</code> les sentències dins la sentència <code>if</code> s'executaran.</p> + +<pre class="brush: js">var dia = new Date(1995, 12, 17); +if (dia instanceof Date) { + // bloc de codi que s'executarà +} +</pre> + +<h4 id="new" name="new"><code>new</code></h4> + +<p>L'operador <code>new</code> s'utilitza per a crear una instància d'un tipus d'objete definit per l'usuari o bé un dels tipus d'objectes predefinits <code>Array</code>, <code>Boolean</code>, <code>Date</code>, <code>Function</code>, <code>Image</code>, <code>Number</code>, <code>Object</code>, <code>Option</code>, <code>RegExp</code>, o <code>String</code>. Al servidor també es pot emprar amb <code>DbPool</code>, <code>Lock</code>, <code>File</code>, i <code>SendMail</code>. La sintaxi de <code>new</code> és la següent:</p> + +<pre class="brush: js">var nomObjecte = new tipusObjecte([param1, param2, ..., paramN]); +</pre> + +<p>També és posible crear objectes mitjançant inicialitzadors d'objectes, tal i com s'explica a {{ web.link("Working_with_objects#Using_object_initializers", "utilitzar inicialitzadors d'objectes") }}.</p> + +<p>Vegeu la pàgina de l'<a href="/en-US/docs/Web/JavaScript/Reference/Operators/new">operador <code>new</code></a> a la Referència del nucli de JavaScript per a més informació.</p> + +<h4 id="this" name="this"><code>this</code></h4> + +<p>La paraula clau <code>this</code> s'utilitza per a referir-se a l'objecte actual. En general this fa referència a l'objecte que ha realitzat la crida dins un mètode. La sintaxi de <code>this</code> és la següent:</p> + +<pre class="brush: js">this["nomPropietat"] +</pre> + +<pre class="brush: js">this.nomPropietat +</pre> + +<p><strong>Exemple 1.</strong><br> + Suposem que una funció anomenada <code>validate</code> valida la propietat <code>value</code> d'un objecte, donat l'objecte i el rang de valors:</p> + +<pre class="brush: js">function validate(obj, lowval, hival){ + if ((obj.value < lowval) || (obj.value > hival)) + alert("Valor no vàlid!"); +} +</pre> + +<p>Podríem cridar <code>validate</code> a cada manegador d'events <code>onChange</code> dels elements d'un formulari, utilitzant <code>this</code> per a passar l'element del formulari, tal i com es mostra al següent exemple:</p> + +<pre class="brush: html"><B>Introduïu un nombre entre 18 i 99:</B> +<INPUT TYPE="text" NAME="edat" SIZE=3 + onChange="validate(this, 18, 99);"> +</pre> + +<p><strong>Exemple 2.</strong><br> + Al combinar-lo amb la propietat del <code>form</code>, <code>this</code> fa referència al pare de l'objecte del formulari. Al següent exemple el form <code>myForm</code> conté un bojecte <code>Text</code> i un botó. Quan l'usuari fa clic al botó, el valor de l'objecte <code>Text</code> és assignat al nom del formulari. El manegador de l'event <code>onClick</code> del botó utilitza <code>this.form</code> per a fererir-se al fomulari pare, <code>myForm</code>.</p> + +<pre class="brush: html"><FORM NAME="myForm"> +Nom del formulari:<INPUT TYPE="text" NAME="text1" VALUE="Beluga"/> +<INPUT NAME="button1" TYPE="button" VALUE="Mostrar el nom del formulari" + onClick="this.form.text1.value = this.form.name;"/> +</FORM> +</pre> + +<h4 id="typeof" name="typeof"><code>typeof</code></h4> + +<p>L'operador <code>typeof</code> es pot utilitzar de qualsevol de les formes següents:</p> + +<ol> + <li> + <pre class="brush: js">typeof operand +</pre> + </li> + <li> + <pre class="brush: js">typeof (operand) +</pre> + </li> +</ol> + +<p>L'operador <code>typeof</code> retorna una string indicant el tipus de l'operand, que no és avaluat. operand és una string, variable, paraula clau u objecte del qual es retornarà el tipus. Els parèntesi són opcionals.</p> + +<p>Suposem que es defineixen les següents variables:</p> + +<pre class="brush: js">var myFun = new Function("5 + 2"); +var forma = "rodona"; +var tamany = 1; +var avui = new Date(); +</pre> + +<p>L'operador <code>typeof</code> retornarà els següents resultats per a aquestes variables:</p> + +<pre class="brush: js">typeof myFun; // retorna "function" +typeof forma; // retorna "string" +typeof tamany; // retorna "number" +typeof avui; // retorna "object" +typeof noExisteix; // retorna "undefined" +</pre> + +<p>Per a les paraules clau <code>true</code> i <code>null</code>, l'operador <code>typeof</code> retorna els següents resultats:</p> + +<pre class="brush: js">typeof true; // retorna "boolean" +typeof null; // retorna "object" +</pre> + +<p>Per a un nombre o string, l'operador <code>typeof</code> retorna els següents resultats:</p> + +<pre class="brush: js">typeof 62; // retorna "number" +typeof 'Hola món'; // retorna "string" +</pre> + +<p>Per a valors de propietats, l'operador <code>typeof</code> retorna el tipus del valor que conté la propietat:</p> + +<pre class="brush: js">typeof document.lastModified; // retorna "string" +typeof window.length; // retorna "number" +typeof Math.LN2; // retorna "number" +</pre> + +<p>Per a mètodes i funcions, l'operador <code>typeof</code> retorna els següents resultats:</p> + +<pre class="brush: js">typeof blur; // retorna "function" +typeof eval; // retorna "function" +typeof parseInt; // retorna "function" +typeof shape.split; // retorna "function" +</pre> + +<p>Per a objectes predefinits, l'operador <code>typeof</code> retorna els resultats següents:</p> + +<pre class="brush: js">typeof Date; // retorna "function" +typeof Function; // retorna "function" +typeof Math; // retorna "object" +typeof Option; // retorna "function" +typeof String; // retorna "function" +</pre> + +<h4 id="void" name="void"><code>void</code></h4> + +<p>L'operador <code>void</code> es pot emprar de qualsevol de les maneres següents:</p> + +<ol> + <li> + <pre class="brush: js">void (expression) +</pre> + </li> + <li> + <pre class="brush: js">void expression +</pre> + </li> +</ol> + +<p>L'operador <code>void</code> avalua una expressió però no retorna cap valor. <code>expression</code> és l'expressió JavaScript a avaluar. Els parèntesi que embocallen l'expressió són opcionals, però es considera una bona pràctica utilitzar-los.</p> + +<p>És possible utilitzar l'operador <code>void</code> per a especificar una expressió com a hipervincle. L'expressió serà avaluada però el seu contingut no reemplaçarà el contingut del document actual.</p> + +<p>El codi següent crea un hipervincle que no fa res quan l'usuari faci clic a l'hipervincle. Quan l'usuari fa clic al l'hipervincle, <code>void(0)</code> serà avaluada com a <code>undefined</code>, la qual cosa no té cap efecte en JavaScript.</p> + +<pre class="brush: html"><A HREF="javascript:void(0)">Cliqueu aquí per a no fer res</A> +</pre> + +<p>El codi següent crea un hipervincle que envia un formulari quan l'usuari fa clic sobre ell.</p> + +<pre class="brush: html"><A HREF="javascript:void(document.form.submit())"> +Feu clic aquí per a enviar el formulari</A></pre> + +<h3 id="Precedència_d'operadors">Precedència d'operadors</h3> + +<p>La <em>precedència</em> d'operadors determina l'ordre en el qual aquests s'apliquen quan s'avalua una expressió. Es pot canviar aquest comportament mitjançant parèntesi.</p> + +<p>La taula següent descriu la precedència dels operadors, del més prioritari al que ho és menys.</p> + +<table class="standard-table"> + <caption>Taula 3.7 Precedència d'operadors</caption> + <thead> + <tr> + <th scope="col">Tipus d'operador</th> + <th scope="col">Operadors individuals</th> + </tr> + </thead> + <tbody> + <tr> + <td>membre</td> + <td><code>. []</code></td> + </tr> + <tr> + <td>crida / creació d'una instància</td> + <td><code>() new</code></td> + </tr> + <tr> + <td>negació/increment</td> + <td><code>! ~ - + ++ -- typeof void delete</code></td> + </tr> + <tr> + <td>multiplicació/divisió</td> + <td><code>* / %</code></td> + </tr> + <tr> + <td>suma/resta</td> + <td><code>+ -</code></td> + </tr> + <tr> + <td>desplaçament de bits</td> + <td><code><< >> >>></code></td> + </tr> + <tr> + <td>relacionals</td> + <td><code>< <= > >= in instanceof</code></td> + </tr> + <tr> + <td>igualtat</td> + <td><code>== != === !==</code></td> + </tr> + <tr> + <td>AND binari</td> + <td><code>&</code></td> + </tr> + <tr> + <td>XOR binari</td> + <td><code>^</code></td> + </tr> + <tr> + <td>OR binari</td> + <td><code>|</code></td> + </tr> + <tr> + <td>AND lògic</td> + <td><code>&&</code></td> + </tr> + <tr> + <td>OR lògic</td> + <td><code>||</code></td> + </tr> + <tr> + <td>condicional</td> + <td><code>?:</code></td> + </tr> + <tr> + <td>assignació</td> + <td><code>= += -= *= /= %= <<= >>= >>>= &= ^= |=</code></td> + </tr> + <tr> + <td>coma</td> + <td><code>,</code></td> + </tr> + </tbody> +</table> + +<p>Trobareu una versió més detallada d'aqueta taula, completa amb enllaços a a detalls adicionals per a cada operador a la <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence#Table">Referència de JavaScript</a>.</p> diff --git a/files/ca/web/javascript/guide/functions/index.html b/files/ca/web/javascript/guide/functions/index.html new file mode 100644 index 0000000000..503937d85a --- /dev/null +++ b/files/ca/web/javascript/guide/functions/index.html @@ -0,0 +1,697 @@ +--- +title: Funcions +slug: Web/JavaScript/Guide/Functions +translation_of: Web/JavaScript/Guide/Functions +--- +<div>{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Loops_and_iteration", "Web/JavaScript/Guide/Expressions_and_Operators")}}</div> + +<p>Les funcions són uns dels blocs de construcció elementals en JavaScript. Una funció és un procediment de JavaScript—un conjunt de sentències que performa una tasca o calcula un valor. Per tal de fer servir una funció, primer s'ha de defnir en alguna part de l'ámbit en que es vol cridar.</p> + +<h2 id="Definir_funcions">Definir funcions</h2> + +<p>Una<strong> definició de funció</strong> (també anomenada<strong> declaració de funció</strong>) consta de la paraula clau <a href="/en-US/docs/JavaScript/Reference/Statements/function" title="function"><code>function</code></a>, seguit per:</p> + +<ul> + <li>El nom de la funció.</li> + <li>Una llista de paràmetres de la funció, continguts entre parèntesis i separats per comes.</li> + <li>Les sentències de JavaScript que defineixen la funció, contingudes entre claus, <code>{ }</code>.</li> +</ul> + +<p>Per exemple, el codi següent defineix una funció simple anomenada <code>square</code>:</p> + +<div style="margin-right: 270px;"> +<pre class="brush: js">function square(number) { + return number * number; +} +</pre> +</div> + +<p>La funció <code>square</code> té un paràmetre, anomenat <code>number</code>. Aquesta funció consisteix d'una sentència que retorna l'argument de la funció ( <code>number</code>) multiplicat per ell mateix. La sentència <a href="/en-US/docs/JavaScript/Reference/Statements/return" title="return"><code>return</code></a> especifica el valor retornat per la funció.</p> + +<pre class="brush: js">return number * number; +</pre> + +<p>Els paràmetres primitius (com ara un nombre) són passat a les funcions <strong> per valor</strong>; el valor és passat a la funció, però si la funció canvia el valor del paràmetre, aquest canvia sense reflectir-se globalment o en la funció de crida.</p> + +<p>Si es pasa un objecte (p.ex. un <a href="/en-US/docs/JavaScript/Glossary" title="en-US/docs/JavaScript/Glossary">valor no primitiu</a>, com ara un <a href="/en-US/docs/JavaScript/Reference/Global_Objects/Array" title="Array"><code>Array</code></a> o un objecte definit per l'usuari) com a paràmetre i la funció canvia les propietats de l'objecte, aquest canvi és visible fora de la funció, com es mostra en l'exemple següent:</p> + +<pre class="brush: js">function myFunc(theObject) { + theObject.make = "Toyota"; +} + +var mycar = {make: "Honda", model: "Accord", year: 1998}, + x, + y; + +x = mycar.make; // x gets the value "Honda" + +myFunc(mycar); +y = mycar.make; // y gets the value "Toyota" + // (the make property was changed by the function) +</pre> + +<div class="note"> +<p>Nota: Assignar un nou objecte als paràmetres <strong>no</strong> té cap efecte fora de la funció, ja que aquest canvia el valor del paràmetre i no del valor d'una de les propietats de l'objecte:</p> +</div> + +<pre class="brush: js">function myFunc(theObject) { + theObject = {make: "Ford", model: "Focus", year: 2006}; +} + +var mycar = {make: "Honda", model: "Accord", year: 1998}, + x, + y; + +x = mycar.make; // x gets the value "Honda" + +myFunc(mycar); +y = mycar.make; // y still gets the value "Honda" </pre> + +<p>Mentre que la declaració de la funció d'adalt és sintàcticament una sentència, les funcions també poden ser creades per l'<strong> expressió d'una funció</strong>. Aquesta funció pot ser <strong>anònima</strong>; no té cap nom. Per exemple, la funció <code style="font-size: 14px;">square</code> podria ésser definida com:</p> + +<pre class="brush: js" style="font-size: 14px;">var square = function(number) {return number * number}; +var x = square(4) //x gets the value 16</pre> + +<p>Tanmateix, un nom es pot proporcionar amb una expressió d'una funció i es pot utilitzar dins la funció per referir-se a si mateix, o en un depurador per identificar la funció en la traça de la pila.</p> + +<pre class="brush: js" style="font-size: 14px;">var factorial = function fac(n) {return n<2 ? 1 : n*fac(n-1)}; + +console.log(factorial(3)); +</pre> + +<p>Les expressions d'una funció són convenients quan es passa una funció com a argument d'una altra funció. El següent exemple mostra la definició d'una funció de mapa, i la posterior crida amb una funció anònima com a primer paràmetre.</p> + +<pre class="brush: js" style="font-size: 14px;">function map(f,a) { + var result = [], // Create a new Array + i; + for (i = 0; i != a.length; i++) + result[i] = f(a[i]); + return result; +} +</pre> + +<p>El codi següent:</p> + +<pre class="brush: js" style="font-size: 14px;">map(function(x) {return x * x * x}, [0, 1, 2, 5, 10]); +</pre> + +<p>retorna [0, 1, 8, 125, 1000].</p> + +<p>En JavaScript, una funció pot ser definida basant-se en una condició. Per exemple, la següent definició de la funció defineix <code>myFunc</code> només si <code>num</code> és igual 0:</p> + +<pre class="brush: js">var myFunc; +if (num == 0){ + myFunc = function(theObject) { + theObject.make = "Toyota" + } +}</pre> + +<p><span style="line-height: 1.572;">A més de definir les funcions com ho fem aquí, podeu utilitzar el </span><a href="/en-US/docs/JavaScript/Guide/Predefined_Core_Objects#Function_Object" style="line-height: 1.572;" title="en-US/docs/JavaScript/Guide/Predefined Core Objects#Function Object">constructor de funció</a><span style="line-height: 1.572;"> per crear funcions d'una cadena en temps d'execució, igual que </span><a href="/en-US/docs/JavaScript/Guide/Functions#eval_Function" style="line-height: 1.572;" title="en-US/docs/JavaScript/Guide/Functions#eval_Function"><code>eval()</code></a><span style="line-height: 1.572;">.</span></p> + +<p>Un <strong>mètode</strong> és una funció que es propietat d'un objecte. Podeu llegir més sobre mètodes i funcions a <a href="/en-US/docs/JavaScript/Guide/Working_with_Objects" title="en-US/docs/JavaScript/Guide/Working with Objects">Treballar amb objectes</a>.</p> + +<h2 id="Crida_de_funcions">Crida de funcions</h2> + +<p>Definir una funció no l'executa. Definir una funció simplement anomena la funció i especifica que fer quan es crida la funció. <strong>Cridar</strong> la funció en realitat realitza les accions especificades amb els paràmetres indicats. Per exemple, si es defineix la funció <code>square</code>, aquesta es cridaria de la següent manera:</p> + +<pre class="brush: js">square(5); +</pre> + +<p>La sentència anterior crida la funció amb un argument de 5. La funció executa executes les seves sentències i retorna el valor 25.</p> + +<p>Les funcions han de ser en un àmbit quan son cridades, però la declaració de la funció pot estar abans de la crida, com és en aquest exemple:</p> + +<pre>console.log(square(5)); +/* ... */ +function square(n){return n*n} +</pre> + +<p>L'àmbit de la funció es troba en la funció en la qual s'ha declarat, o en el programa complet si s'ha declarat is the function in which it is declared, or the entire program if it is declared a nivell global.</p> + +<div class="note"> +<p>Nota: Això només funciona quan definim la funció fent servir la sintaxis d'adalt (p.ex. <code>function funcName(){}</code>). El codi d'abaix no funcionaria.</p> +</div> + +<pre class="brush: js">console.log(square(5)); +square = function (n) { + return n * n; +} +</pre> + +<p>Els arguments d'una funció no estan limitats a cadenes o nombres. Es pot passar objectes sencers a una funció. La funció <code>show_props</code> (definida a <a href="/en-US/docs/JavaScript/Guide/Working_with_Objects#Objects_and_Properties" title="https://developer.mozilla.org/en-US/docs/JavaScript/Guide/Working_with_Objects#Objects_and_Properties">Treballant amb Objectes</a>) és un exemple d'una funció que pren un objecte com a argument.</p> + +<p>Una funció pot cridar-se a si mateixa. Per exemple, aquí baix trobem una funció que is a function that calcula factorials recursivament:</p> + +<pre class="brush: js">function factorial(n){ + if ((n == 0) || (n == 1)) + return 1; + else + return (n * factorial(n - 1)); +} +</pre> + +<p>D'aquesta manera es podria calcular els factorials de l'ú al cinc de la forma següent:</p> + +<pre class="brush: js">var a, b, c, d, e; +a = factorial(1); // a gets the value 1 +b = factorial(2); // b gets the value 2 +c = factorial(3); // c gets the value 6 +d = factorial(4); // d gets the value 24 +e = factorial(5); // e gets the value 120 +</pre> + +<p>Hi ha altres maneres de cridar funcions. Sovint hi ha casos en que s'ha de cridar la funció dinàmicament, o casos en que el nombre d'arguments d'una funció pot variar o en els que el context de la crida a la funció de s'ha d'establir a un objecte específic determinat en temps d'execució. Resulta que les funcions són per elles mateixes, objectes, i aquests objectes, al seu torn, tenen mètodes (vegeu l'<a href="/en-US/docs/JavaScript/Guide/Obsolete_Pages/Predefined_Core_Objects/Function_Object" title="Function Object">objecte funció</a>). Un d'aquests, el mètode <a href="/en-US/docs/JavaScript/Reference/Global_Objects/Function/apply" title="apply"><code>apply()</code></a>, pot ser usat per aconseguir aquest objectiu.</p> + +<h2 class="deki-transform" id="Àmbit_d'una_funció">Àmbit d'una funció</h2> + +<p>Les variables definides dins d'una funció no són accessibles des de llocs de fora de la funció, ja que la variable es defineix només en l'àmbit de la funció. No obstant això, una funció pot accedir a totes les variables i funcions definides dins de l'àmbit en el qual es defineix. En altres paraules, una funció definida en l'àmbit global pot tenir accés a totes les variables definides en l'àmbit global. Una funció definida dins d'una altra funció pot accedir a totes les variables definides en la funció pare i qualsevol altra variable a la qual la funció pare té accés.</p> + +<pre class="brush: js">// The following variables are defined in the global scope +var num1 = 20, + num2 = 3, + name = "Chamahk"; + +// This function is defined in the global scope +function multiply() { + return num1 * num2; +} + +multiply(); // Returns 60 + +// A nested function example +function getScore () { + var num1 = 2, + num2 = 3; + + function add() { + return name + " scored " + (num1 + num2); + } + + return add(); +} + +getScore(); // Returns "Chamahk scored 5" +</pre> + +<h2 id="Scope_and_the_function_stack" name="Scope_and_the_function_stack">Àmbit d'aplicació i la pila de la funció</h2> + +<h3 id="Recursion" name="Recursion">Recursivitat</h3> + +<p>Una funció pot referir-se i cridar-se a ella mateixa. Hi ha tres formes per a que una funció es refereixi a ella mateixa:</p> + +<ol> + <li>El nom de la funció</li> + <li><code><a href="/en-US/docs/JavaScript/Reference/Functions_and_function_scope/arguments/callee">arguments.callee</a></code></li> + <li>Una variable continguda en l'àmbit que refereixi a la funció</li> +</ol> + +<p>Per exemple, la definició de funció següent:</p> + +<pre class="brush: js">var foo = function bar() { + // statements go here +}; +</pre> + +<p>Dins del cos de la funció, els següent són tots equivalents:</p> + +<ol> + <li><code>bar()</code></li> + <li><code>arguments.callee()</code></li> + <li><code>foo()</code></li> +</ol> + +<p>Una funció que es pot cridar a ella mateixa és una<em> funció recursiva</em>. En certa manera, la recursió és anàleg a un bucle. En ambdós casos el codi s'executa múltiples vegades, i els dos requereixen d'una condició (per evitar el bucle infinit, o més aviat, la infinita recursió en aquest cas). Per exemple, en el següent bucle:</p> + +<pre class="brush: js">var x = 0; +while (x < 10) { // "x < 10" is the loop condition + // do stuff + x++; +} +</pre> + +<p>Es pot converitr en una funció recursiva i una crida a una funció:</p> + +<pre class="brush: js">function loop(x) { + if (x >= 10) // "x >= 10" is the exit condition (equivalent to "!(x < 10)") + return; + // do stuff + loop(x + 1); // the recursive call +} +loop(0); +</pre> + +<p>Tanmateix, alguns algorismes no poden ser bucles iteratius simples. Per exemple, obtenir tots els nodes de l'estructura d'arbre (e.x. el <a href="/en-US/docs/DOM">DOM</a>) és fa més fàcilment usant la recursió:</p> + +<pre class="brush: js">function walkTree(node) { + if (node == null) // + return; + // do something with node + for (var i = 0; i < node.childNodes.length; i++) { + walkTree(node.childNodes[i]); + } +} +</pre> + +<p>Comparat amb la funció <code>loop</code>, cada crida recursiva que es crida a si mateixa fa varies crides recursives aquí.</p> + +<p>És possible convertir qualsevol algorisme recursiu a un no recursiu, però sovint la llògica és molt més complexa i fer-ho requereix l'ús d'una pila. De fet, la recursió per si mateixa fa servir una pila: la funció stack.</p> + +<p>El comportament de l'stack es pot veure en el següent exemple:</p> + +<pre class="brush: js">function foo(i) { + if (i < 0) + return; + document.writeln('begin:' + i); + foo(i - 1); + document.writeln('end:' + i); +} +foo(3); +</pre> + +<p>El qual mostra:</p> + +<pre>begin:3 +begin:2 +begin:1 +begin:0 +end:0 +end:1 +end:2 +end:3 +</pre> + +<h3 id="Nested_functions_and_closures" name="Nested_functions_and_closures">Funcions aniuades i <em>closures</em></h3> + +<p>Es pot aniuar una funció dins d'una altra funció. El contingut de la funció aniuada (la de dins) és privada a la funció que la conté (la de fora). També forma un <em>closure</em>.</p> + +<dl> + <dd>Un <em>closure</em> és una expressió (normalment una funció) que pot tenir variables lliures juntes amb un àmbit que lliga aquestes variables (que "<em>closes</em>" l'expresió).</dd> +</dl> + +<p>Ja que una funció aniuada és un <em>closure</em>, això significa que una funció aniuada pot "heredar" els arguments i variables de la funció que la conté. En altres paraules, la funció de dins conté l'àmbit de la funció de fora.</p> + +<p>Resumint:</p> + +<ul> + <li>Es pot accedir a la funció de dins només des de sentències que es troben dins la funció de fora.</li> +</ul> + +<ul> + <li>La funció de dins forma un <em>closure</em>: la funció de dins pot usar els arguments i les variables de la funció de fora, mentre que la funció de fora no pot usar els arguments i les variables de la funció de dins.</li> +</ul> + +<p>El següent exemple mostra funcions aniuades:</p> + +<pre class="brush: js">function addSquares(a,b) { + function square(x) { + return x * x; + } + return square(a) + square(b); +} +a = addSquares(2,3); // returns 13 +b = addSquares(3,4); // returns 25 +c = addSquares(4,5); // returns 41 +</pre> + +<p>Atès que la funció interior forma un <em>closure</em>, es pot cridar la funció exterior i especificar els arguments per ambdues funcions, l'exterior i l'interior:</p> + +<pre class="brush: js">function outside(x) { + function inside(y) { + return x + y; + } + return inside; +} +fn_inside = outside(3); // Think of it like: give me a function that adds 3 to whatever you give it +result = fn_inside(5); // returns 8 + +result1 = outside(3)(5); // returns 8 +</pre> + +<h3 id="Efficiency_considerations" name="Efficiency_considerations">Preservació de les variables</h3> + +<p>Vegeu com és preserva <code>x</code> quan es retorna <code>inside</code>. Un <em>closure</em> ha de preservar els arguments i variables en tots els àmbits de les seves referències. Donat que cada crida proveeix potencialment diferents arguments, es crea una nova <em>closure </em>per cada crida que es fa a l'exterior. La memòria pot ser alliberada només quan no es pot accedir més al retorn d'<span style="font-family: Consolas,Monaco,'Andale Mono',monospace;">inside.</span></p> + +<p>Això no és diferent d'emmagatzemar referències en altres objectes, però sovint és menys obvi perque no podem establir les referències directament ni inspeccionar-les. </p> + +<h3 id="Multiply-nested_functions" name="Multiply-nested_functions">Funcions aniuades múltiples</h3> + +<p>Les funcions també poden ser aniuades múltiples, p.ex. Una funció (A) conté una funció (B) que conté una funció (C). Ambudes funcions B i C formen aquí <em>closures,</em> de forma que B pot accedir a A i C pot accedir a B. A més a més, ja que C pot accedir a B, el qual pot accedir a A, C també pot accedir a A. D'aquesta forma, els <em>closures</em> poden contenir múltiples àmbits; contenen recursivament l'àmbit de les funcionsthey recursively contain the scope of the functions containing it. Això s'anomena <em>scope chaining</em>. (El perquè s'anomena "<em>chaining</em>" s'explicarà més tard.)</p> + +<p>Considereu l'exemple següent:</p> + +<pre class="brush: js">function A(x) { + function B(y) { + function C(z) { + alert(x + y + z); + } + C(3); + } + B(2); +} +A(1); // alerts 6 (1 + 2 + 3) +</pre> + +<p>En aquest exemple, <code>C</code> accedeix a <code>y</code> de <code>B</code> i <code>x</code> d'<code>A</code>. Això és possible perquè:</p> + +<ol> + <li><code>B</code> forma un <em>closure</em> incloïent <code>A</code>, és a dir, <code>B</code> pot accedir als arguments i les variables d'<code>A</code>.</li> + <li><code>C</code> forma un <em>closure</em> que inclou <code>B</code>.</li> + <li>Com que el <em>clousure</em> de <code>B</code> inclou <code>A</code>, el <em>closure</em> de <code>C</code> inclou <code>A</code>, <code>C</code> pot accedir tant als arguments i les variables de <code>B</code> com als d'<code>A</code>. En altres paraules, <code>C</code> encadena l'accés als àmbits de <code>B</code> i <code>A</code> en aquest ordre.</li> +</ol> + +<p>El revers, però, no és cert. <code>A</code> no pot accedir a <code>C</code>, perquè <code>A</code> no pot accedir a cap argument o variable de <code>B</code>, de la qual <code>C</code> n'és una variable. D'aquesta forma, <code>C</code> roman privat només a <code>B</code>.</p> + +<h3 id="Name_conflicts" name="Name_conflicts">Conflictes de noms</h3> + +<p>Quan dos arguments o variables de l'àmbit del closure tenen el mateix nom, hi ha un <em>conflicte de nom</em>. Els àmbits més interns tenen prioritat, de forma que l'àmbit més intern té la màxima prioritat, mentre que l'àmbit més exterior no en tét. Això és l cadena d'àmbit. El primer de la cadena és l'àmbit més intern, i l'últim és l'àmbit més extern. Vegeu l'exemple següent:</p> + +<pre class="brush: js">function outside() { + var x = 10; + function inside(x) { + return x; + } + return inside; +} +result = outside()(20); // returns 20 instead of 10 +</pre> + +<p>El conflicte de nom ocorre en la sentència <code>return x</code> i es troba entreand is between <code>inside</code>'s parameter <code>x</code> and <code>outside</code>'s variable <code>x</code>. The scope chain here is {<code>inside</code>, <code>outside</code>, global object}. Therefore <code>inside</code>'s <code>x</code> takes precedences over <code>outside</code>'s <code>x</code>, and 20 (<code>inside</code>'s <code>x</code>) is returned instead of 10 (<code>outside</code>'s <code>x</code>).</p> + +<h2 id="Closures">Closures</h2> + +<p>Els<em> closures</em> son unes de les característiques més poderoses de JavaScript. JavaScript permet l'aniuament de funcions i concedeix a la funció interior accès total a totes les variables i funcions definides dins de la funció exterior (i totes les altres variables i funcions que la funció exterior té accés). Tanmateix, la funció exterior no té accés a les variables i funcions definides dins la funció interior. Això proveeix seguretat a les variables de la funció interior. A més, ja que la funció interior té accés a l'àmbit de la funcio exterior, les variables i funcions definides en la funció de fora viuran més que la mateixa funció de fora, si la funció interior se les arregla per sobreviure a partir de la vida de la funció exterior. Un <em>closure</em> es crea quan la funció interior és d'alguna manera accessible per qualsevol àmbit fora de la funció exterior.</p> + +<pre class="brush: js">var pet = function(name) { // The outer function defines a variable called "name" + var getName = function() { + return name; // The inner function has access to the "name" variable of the outer function + } + + return getName; // Return the inner function, thereby exposing it to outer scopes + }, + myPet = pet("Vivie"); + +myPet(); // Returns "Vivie" +</pre> + +<p>Pot ser molt més complex que el codi d'adalt. Un objecte que conté mètodes per manipular les variables interior d'una funció exterior poder ser retornades.</p> + +<pre class="brush: js">var createPet = function(name) { + var sex; + + return { + setName: function(newName) { + name = newName; + }, + + getName: function() { + return name; + }, + + getSex: function() { + return sex; + }, + + setSex: function(newSex) { + if(typeof newSex == "string" && (newSex.toLowerCase() == "male" || newSex.toLowerCase() == "female")) { + sex = newSex; + } + } + } +} + +var pet = createPet("Vivie"); +pet.getName(); // Vivie + +pet.setName("Oliver"); +pet.setSex("male"); +pet.getSex(); // male +pet.getName(); // Oliver +</pre> + +<p>En els codis d'adalt, la variable <code>name</code> de la funció exterior és accesible des de les funcions interiors, i no hi ha cap altra forma d'accedir a les variables interiors apart the fer-ho a través de les funcions interiors. Les variables interiors de la funció interior es comporten com a magatzems segurs per a les funcions interiors. Aquestes emmagatzemen de forma "persistent", però segures, les dades amb que les funcions interiors han de treballar. Les funcions no tenen ni tant sols ser assignades a una variable, tampoc han de tenir un nom.</p> + +<pre class="brush: js">var getCode = (function(){ + var secureCode = "0]Eal(eh&2"; // A code we do not want outsiders to be able to modify... + + return function () { + return secureCode; + }; +})(); + +getCode(); // Returns the secureCode +</pre> + +<p>Hi ha, tanmateix, un nombre de trampes o obstacles que vigilar quan es fa servir <em>closures</em>. Si una <em>closure</em><u><em> </em></u>defineix una variable amb el mateix nom que el nom de la variable que es troba en l'àmbit exterior, no hi ha cap manera de referir-se una altra vegada a la variable de l'àmbit exterior.</p> + +<pre class="brush: js">var createPet = function(name) { // Outer function defines a variable called "name" + return { + setName: function(name) { // Enclosed function also defines a variable called "name" + name = name; // ??? How do we access the "name" defined by the outer function ??? + } + } +} +</pre> + +<p>La variable màgica <code>this</code> és força delicada en<em> closures</em>. S'ha de saber fer servir acuradament, ja que al que <code>this</code> es refereix depen completament del lloc on la funció es cridada, i no d'on és definida.</p> + +<h2 id="Ús_de_l'objecte_arguments">Ús de l'objecte arguments</h2> + +<p>Els arguments d'una funció és mantenen en un objecte semblant a un array. Dins una funció, és pot accedir als arguments passats a la funció de la següent forma:</p> + +<pre class="brush: js">arguments[i] +</pre> + +<p>On <code>i</code> és el nombre ordinal de l'argument, que comença amb zero. Així, el primer argument passat a una funció seria <code>arguments[0]</code>. El nombre total d'arguments és indicat per <code>arguments.length</code>.</p> + +<p>Fent servir l'objecte <code>arguments</code>, es pot cridar una funció amb més arguments dels que formament està declarat a acceptar. Això sovint és útil si no es sap amb anticipació quants arguments seràn passats a la funció. Es pot fer servir <code>arguments.length</code> per determinar el nombre d'arguments que se li passen a la funció, i després accedir a cada arguments fent ús de l'objecte <code>arguments</code>.</p> + +<p>Per exemple, sospeseu una funció que concatena diverses cadenes. L'únic argument formal per la funció és una cadena que especifica els caràcters que separen els ítems per concatenar. La funció és defineix com:</p> + +<pre class="brush: js">function myConcat(separator) { + var result = "", // initialize list + i; + // iterate through arguments + for (i = 1; i < arguments.length; i++) { + result += arguments[i] + separator; + } + return result; +} +</pre> + +<p>Es pot passar qualsevol nombre d'arguments a aquesta funció, i concatena cada argument dins d'una "llista" de cadenes:</p> + +<pre class="brush: js">// returns "red, orange, blue, " +myConcat(", ", "red", "orange", "blue"); + +// returns "elephant; giraffe; lion; cheetah; " +myConcat("; ", "elephant", "giraffe", "lion", "cheetah"); + +// returns "sage. basil. oregano. pepper. parsley. " +myConcat(". ", "sage", "basil", "oregano", "pepper", "parsley"); +</pre> + +<div class="note"> +<p>Nota: la variable <code>arguments</code> és semblant a un array, però no és un array. S'assembla a un array en que té un índex numerat i la propietat <code>length</code>. Tanmateix, no poseeix tots els mètodes de manipulació d'un array.</p> +</div> + +<p>Vegeu l'<a href="/en-US/docs/JavaScript/Reference/Global_Objects/Function" title="en-US/docs/JavaScript/Reference/Global Objects/Function">objecte</a> <a href="/en-US/docs/JavaScript/Reference/Global_Objects/Function" title="en-US/docs/JavaScript/Reference/Global Objects/Function"><code>Function</code></a> en la referència de JavaScript per més informació.</p> + +<h2 id="Functions_as_event_handlers" name="Functions_as_event_handlers">Funcions com a controladors d'events</h2> + +<p>En JavaScript, els controladors d'events <a href="/en-US/docs/DOM">DOM</a> són funcions (a diferència dels objectes que contenen un mètode <code>handleEvent</code> en altres enllaços de llenguatge DOM). Les funcions passen un objecte d'<a href="/en-US/docs/DOM/event">event</a> com el primer i únic paràmetre. Com qualsevol altre paràmetre, si l'objecte event no s'ha de fer servir, es pot ometre de la llista de paràmetres formals.</p> + +<p>Alguns probables objectius d'un document <a href="/en-US/docs/Web/HTML">HTML</a> inclouen: <code>window</code> (l'objecte<code> Window</code>, incloent frames), <code>document</code> (l'objecte <code>HTMLDocument</code>), i elements (<code>Element</code> objects). En el <a href="http://www.w3.org/TR/DOM-Level-2-HTML/">HTML DOM</a>, els objectius d'events tenen propietats de controladors d'events. Aquestes propietats seràn nomes d'events amb minúscules amb el prefix "on", p.ex. <code>onfocus</code>. Una altra forma de fer, més robusta, d'afegir detectors d'events és ser proveït pel <a href="http://www.w3.org/TR/DOM-Level-2-Events/">nivell 2 d'events DOM</a>.</p> + +<p>Nota: Events formen part del DOM, no de JavaScript. (JavaScript només proveeix un enllaç al DOM.)</p> + +<p>El següent exemple assigna una funció al controlador d'events "focus" d'una finestra.</p> + +<pre class="brush: js">window.onfocus = function() { + document.body.style.backgroundColor = 'white'; +}; +</pre> + +<p>Si una funció és assignada a una variable, es pot assignar la variable a un controlador d'event. El codi següent assigna una funció a la variable <code>setBGColor</code>.</p> + +<pre class="brush: js">var setBGColor = new Function("document.body.style.backgroundColor = 'white';"); +</pre> + +<p>Es pot fer servir aquesta variable per assignar una funció a un controlador d'event de diverses formes. Aquí mostrem dues formes de fer-ho:</p> + +<ol> + <li>scripting amb propietats d'event DOM HTML + <pre class="brush: js">document.form1.colorButton.onclick = setBGColor; +</pre> + </li> + <li>Atribut event HTML + <pre class="brush: html"><input name="colorButton" type="button" + value="Change background color" + onclick="setBGColor();"/> +</pre> + + <p>Un controlador d'events establert d'aquesta manera, és de fet, una funció, named after the attribute, wrapped around the specified code. Això explica perquè els parèntesis en "<code>setBGColor()</code>" són necessaris aquí (en lloc de només "<code>setBGColor</code>"). És equivalent a:</p> + + <pre class="brush: js">document.form1.colorButton.onclick = function onclick(event) { + setBGColor(); +}; +</pre> + + <p>Vegeu com l'objecte event object es passa a aquesta funció com a paràmetre <code>event</code>. Això permet al codi específic utilitzar l'objecte Event:</p> + + <pre class="brush: html"><input ... + onclick="alert(event.target.tagName);"/> +</pre> + </li> +</ol> + +<p>Com qualsevol altra propietat que fa referència a una funció, el controlador d'event pot comportat-se com un mètode, i <code>this</code> faria referència a l'element que conté el controlador d'event. En l'exemple següent, la funció que fa referència <code>onfocus</code> es crida amb <code>this</code> que equival a <code>window</code>.</p> + +<pre class="brush: js">window.onfocus(); +</pre> + +<p>Un error comú de principiants de Javascript és snnexar parèntesis i/o paràmetres al final de la variable p.ex. cridar un controlador d'event quan es fa l'assignació. Afeguir aquests parèntesis assignarà el valor<em> returned from calling the event handler</em>, que sovint és <code>undefined</code> (si la funció no retorna res), rather than the event handler itself:</p> + +<pre class="brush: js">document.form1.button1.onclick = setBGColor(); +</pre> + +<p>Per passar paràmetres a un controlador d'event, el controlador ha d'estar embolcallat dins d'una altra funció com la següent:</p> + +<pre class="brush: js">document.form1.button1.onclick = function() { + setBGColor('some value'); +}; +</pre> + +<h2 id="Funcions_predefinides">Funcions predefinides</h2> + +<p>JavaScript té diverses funcions predefinides que poden emprar-se des de qualsevol àmbit:</p> + +<ul> + <li>{{ web.link("#eval_function", "eval") }}</li> + <li>{{ web.link("#isFinite_function", "isFinite") }}</li> + <li>{{ web.link("#isNaN_function", "isNaN") }}</li> + <li>{{ web.link("#parseInt_and_parseFloat_functions", "parseInt and parseFloat") }}</li> + <li>{{ web.link("#Number_and_String_functions", "Number and String") }}</li> + <li>{{ web.link("#escape_and_unescape_functions", "encodeURI, decodeURI, encodeURIComponent, and decodeURIComponent") }} (all available with Javascript 1.5 and later).</li> +</ul> + +<p>Les seccions següents introdueixen aquestes funcions. Vegeu el <a href="/en-US/docs/JavaScript/Reference" title="en-US/docs/JavaScript/Reference">JavaScript Reference</a> per informació detallada de totes aquestes funcions.</p> + +<h3 id="Funció_eval">Funció eval</h3> + +<p>La funció <code>eval</code>avalua una cadena del codi de JavaScript sense fer referència a cap objecte en particular. La sintaxi de <code>eval</code> és:</p> + +<pre class="brush: js">eval(expr); +</pre> + +<p>on <code>expr</code> és una cadena per ser avaluada.</p> + +<p>Si la cadena representa una expressió, <code>eval</code> evalua l'expressió. Si l'argument representa una sentència o més de JavaScript, eval performa aquestes sentències. L'àmbit del codi d'<code>eval</code> és idèntic a l'àmbit del codi de crida. No s'ha de cridar <code>eval</code> per avaluar una expressió aritmèica; JavaScript aritmètiques automàticament.</p> + +<h3 id="Funció_isFinite">Funció isFinite</h3> + +<p>La funció <code>isFinite</code> avalua un argument per determinar si és un nombre finit. La sintaxi d' <code>isFinite</code> és:</p> + +<pre class="brush: js">isFinite(number); +</pre> + +<p>on <code>number</code> és el nombre que s'ha d'avaluar.</p> + +<p>Si l'argument és <code>NaN </code>(no un nombre), infinit positiu o infinit negatiu, aquest mètode retorna <code>false</code>, sinó retornarà <code>true</code>.</p> + +<p>El codi següent comprova si ClientInput per determinar si és un nombre finit.</p> + +<pre class="brush: js">if(isFinite(ClientInput)){ + /* take specific steps */ +} +</pre> + +<h3 id="Funció_isNaN">Funció isNaN</h3> + +<p>La funció <code>isNaN</code> avalua un argument que determina si és "NaN." La sintaxi d'<code>isNaN</code> és:</p> + +<pre class="brush: js">isNaN(testValue); +</pre> + +<p>On <code>testValue</code> és el valor que es vol avaluar.</p> + +<p>Les funcions <code>parseFloat</code> i <code>parseInt</code> retornen "NaN" quan avaluen un valor que no és un nombre. <code>isNaN</code> retorna true si passa "NaN," i false sinó ho fa.</p> + +<p>El codi següent avalua <code>floatValue</code> que determina si és un nombre i després crida un procediment de la manera adequada:</p> + +<pre class="brush: js">var floatValue = parseFloat(toFloat); + +if (isNaN(floatValue)) { + notFloat(); +} else { + isFloat(); +} +</pre> + +<h3 id="Funcions_parseInt_i_parseFloat">Funcions parseInt i parseFloat</h3> + +<p>Les dos funcions "parse", <code>parseInt</code> i <code>parseFloat</code>, retornen un valor numèric quan es dóna com a argument una cadena.</p> + +<p>La sintaxi de <code>parseFloat</code> és:</p> + +<pre class="brush: js">parseFloat(str); +</pre> + +<p>On <code>parseFloat</code> parses el seu argument,la cadena <code>str</code>, and attempts to return a floating-point number. If it encounters a character other than a sign (+ or -), a numeral (0-9), a decimal point, or an exponent, then it returns the value up to that point and ignores that character and all succeeding characters. If the first character cannot be converted to a number, it returns "NaN" (not a number).</p> + +<p>La sintaxi de <code>parseInt</code> és:</p> + +<pre class="brush: js">parseInt(str [, radix]); +</pre> + +<p><code>parseInt</code> interpreta el seu primer argument, la cadena de caràcters <code>str</code>, i intenta retornar un nombre sencer de la base especificada pel paràmetre opcional <code>radix</code>. Per exemple, si <code>radix</code> és 10 això indica que es demana una conversió al sistema decimal (base 10), si és 8 octal, si és 16 hexadecimal, etcètera. Per a bases majors que 10 es fan anar lletres de l'alfabet per a indicar els numerals majors que 9. Per exemple, per a nombres hexadecimals (base 16), s'empren les lletres de la A fins la F.</p> + +<p>Si <code>parseInt</code> troba un caràcter que no és un numeral de la base especificada, aquest és ignorat així com la resta de caràcters que el segueixen i retorna el valor sencer interpretat fins aquest punt. Si el primer caràcter no es pot convertir a un nombre de la base especificada es retorna "NaN". La funció <code>parseInt</code> trunca la cadena de caràcters a valors sencers.</p> + +<h3 id="Funcions_Number_i_String">Funcions Number i String</h3> + +<p>Les funcions <code>Number</code> i <code>String</code> permeten convertir un objecte a un nombre o a una cadena. La sintaxi d'aquestes funcions és:</p> + +<pre class="brush: js">var objRef; +objRef = Number(objRef); +objRef = String(objRef); +</pre> + +<p>On <code>objRef</code> és una referència a l'objecte. Number fa servir el valorOf() method of the object; String uses the toString() method of the object.</p> + +<p>L'exemple següent converteix l'objecte <code><a href="/en-US/docs/JavaScript/Reference/Global_Objects/Date" title="en-US/docs/JavaScript/Reference/Global Objects/Date">Date</a></code> a una cadena de caràcters fàcilment interpretrable per humans.</p> + +<pre class="brush: js">var D = new Date(430054663215), + x; +x = String(D); // x equals "Thu Aug 18 04:37:43 GMT-0700 (Pacific Daylight Time) 1983" +</pre> + +<p>L'exemple següent converteix l'objecte <code><a class="internal" href="/en-US/docs/JavaScript/Reference/Global_Objects/String" title="en-US/docs/JavaScript/Reference/Global Objects/String">String</a></code> a l'objecte <code><a class="internal" href="/en-US/docs/JavaScript/Reference/Global_Objects/Number" title="en-US/docs/JavaScript/Reference/Global Objects/Number">Number</a></code>.</p> + +<pre class="brush: js">var str = "12", + num; +num = Number(str); +</pre> + +<p>Es pot comprovar utilitzant el mètode del DOM <code>write()</code> i l'operador de JavaScript <code>typeof</code>.</p> + +<pre class="brush: js">var str = "12", + num; +document.write(typeof str); +document.write("<br/>"); +num = Number(str); +document.write(typeof num); +</pre> + +<h3 id="Funcions_escape_i_unescape_(Obsoletes_a_partir_de_JavaScript_1.5)">Funcions escape i unescape (Obsoletes a partir de JavaScript 1.5)</h3> + +<p>Les funcions <code>escape</code> i <code>unescape</code> no funcionen correctamenr per a caràcter que no siguin ASCII i han quedat obsoletes. En la versió de JavaScript 1.5 i posteriors, es fa servir <code><a href="/en-US/docs/JavaScript/Reference/Global_Objects/encodeURI" title="en-US/docs/JavaScript/Reference/Global_Functions/encodeURI">encodeURI</a></code>, <code><a href="/en-US/docs/JavaScript/Reference/Global_Objects/decodeURI" title="en-US/docs/JavaScript/Reference/Global_Functions/decodeURI">decodeURI</a></code>, <code><a href="/en-US/docs/JavaScript/Reference/Global_Objects/encodeURIComponent" title="en-US/docs/JavaScript/Reference/Global_Functions/encodeURIComponent">encodeURIComponent</a></code>, i <code><a href="/en-US/docs/JavaScript/Reference/Global_Objects/decodeURIComponent" title="en-US/docs/JavaScript/Reference/Global_Functions/decodeURIComponent">decodeURIComponent</a></code>.</p> + +<p>Les funcions <code>escape</code> i <code>unescape</code> permeten codificar i descodificar cadenes. La funció <code>escape</code> retorna function returns the hexadecimal encoding of an argument in the ISO Latin character set. The <code>unescape</code> function returns the ASCII string for the specified hexadecimal encoding value.</p> + +<p>La sintaxi d'aquestes funcions és:</p> + +<pre class="brush: js">escape(string); +unescape(string); +</pre> + +<p>Aquestes funcions s'usen principalment amb JavaScript que s'executa al servidor per codificar i descodificar parells de clau/valor en URLs.</p> diff --git a/files/ca/web/javascript/guide/index.html b/files/ca/web/javascript/guide/index.html new file mode 100644 index 0000000000..5bd35b4659 --- /dev/null +++ b/files/ca/web/javascript/guide/index.html @@ -0,0 +1,127 @@ +--- +title: Guia de JavaScript +slug: Web/JavaScript/Guide +tags: + - Guide + - JavaScript + - NeedsTranslation + - TopicStub +translation_of: Web/JavaScript/Guide +--- +<div>{{jsSidebar("JavaScript Guide")}}</div> + +<p class="summary">La Guia de JavaScript mostra com utilitzar <a href="/ca/docs/Web/JavaScript">JavaScript</a> a l'hora que proporciona una visió general del llenguatge. Per a començar amb JavaScript o a programar en general podeu consultar els article de l'<a href="/ca/Learn">zona d'aprenentatge</a>. Per a informació exhaustiva sobre qualsevol característica del llenguatge podeu consultar la<a href="/ca/docs/Web/JavaScript/Referencia"> referència de JavaScript</a>.</p> + +<h2 id="Capítols">Capítols</h2> + +<p>Aquesta guia es divideix en diversos capítols:</p> + +<ul class="card-grid"> + <li><span><a href="/ca/docs/Web/JavaScript/Guide/Introducció">Introducció</a></span> + + <p><a href="/ca/docs/Web/JavaScript/Guide/Introducció#Where_to_find_JavaScript_information">Quant a aquesta guia</a><br> + <a href="/ca/docs/Web/JavaScript/Guide/Introducció#What_is_JavaScript.3F">Quant a JavaScript</a><br> + <a href="/ca/docs/Web/JavaScript/Guide/Introducció#JavaScript_and_Java">JavaScript i Java</a><br> + <a href="/ca/docs/Web/JavaScript/Guide/Introducció#JavaScript_and_the_ECMAScript_Specification">ECMAScript</a><br> + <a href="/ca/docs/Web/JavaScript/Guide/Introducció#Getting_started_with_JavaScript">Eines</a><br> + <a href="/ca/docs/Web/JavaScript/Guide/Introducció#Hello_world">Hola Món</a></p> + </li> + <li><span><a href="/ca/docs/Web/JavaScript/Guide/Grammar_and_types">Gramàtica i tipus</a></span> + <p><a href="/ca/docs/Web/JavaScript/Guide/Grammar_and_types#Basics">Sintaxi bàsica i comentaris</a><br> + <a href="/ca/docs/Web/JavaScript/Guide/Grammar_and_types#Declarations">Declaracions</a><br> + <a href="/ca/docs/Web/JavaScript/Guide/Grammar_and_types#Variable_scope">Àmbit de variables</a><br> + <a href="/ca/docs/Web/JavaScript/Guide/Grammar_and_types#Variable_hoisting">Hoisting de variables</a><br> + <a href="/ca/docs/Web/JavaScript/Guide/Grammar_and_types#Data_structures_and_types">Estructures de dades i tipus</a><br> + <a href="/ca/docs/Web/JavaScript/Guide/Grammar_and_types#Literals">Literals</a></p> + </li> + <li><span><a href="/ca/docs/Web/JavaScript/Guide/Control_flow_and_error_handling">Control de fluxe i manegament d'errors</a></span> + <p><code><a href="/ca/docs/Web/JavaScript/Guide/Control_flow_and_error_handling#if...else_statement">if...else</a></code><br> + <code><a href="/ca/docs/Web/JavaScript/Guide/Control_flow_and_error_handling#switch_statement">switch</a></code><br> + <a href="/ca/docs/Web/JavaScript/Guide/Control_flow_and_error_handling#Exception_handling_statements"><code>try</code>/<code>catch</code>/<code>throw</code></a><br> + <a href="/ca/docs/Web/JavaScript/Guide/Control_flow_and_error_handling#Utilizing_Error_objects">Objecte Error</a><br> + <a href="/ca/docs/Web/JavaScript/Guide/Control_flow_and_error_handling#Promises">Objecte Promise</a></p> + </li> + <li><span><a href="/ca/docs/Web/JavaScript/Guide/Loops_and_iteration">Bucles i iteració</a></span> + <p><code><a href="/ca/docs/Web/JavaScript/Guide/Loops_and_iteration#for_statement">for</a><br> + <a href="/ca/docs/Web/JavaScript/Guide/Loops_and_iteration#while_statement">while</a><br> + <a href="/ca/docs/Web/JavaScript/Guide/Loops_and_iteration#do...while_statement">do...while</a><br> + <a href="/ca/docs/Web/JavaScript/Guide/Loops_and_iteration#break_statement">break</a>/<a href="/ca/docs/Web/JavaScript/Guide/Loops_and_iteration#continue_statement">continue</a><br> + <a href="/ca/docs/Web/JavaScript/Guide/Loops_and_iteration#for...in_statement">for..in</a><br> + <a href="/ca/docs/Web/JavaScript/Guide/Loops_and_iteration#for...of_statement">for..of</a></code></p> + </li> +</ul> + +<ul class="card-grid"> + <li><span><a href="/ca/docs/Web/JavaScript/Guide/Functions">Funcions</a></span> + + <p><a href="/ca/docs/Web/JavaScript/Guide/Functions#Defining_functions">Definir funcions</a><br> + <a href="/ca/docs/Web/JavaScript/Guide/Functions#Calling_functions">Cridar funcions</a><br> + <a href="/ca/docs/Web/JavaScript/Guide/Functions#Function_scope">Àmbit de funcions</a><br> + <a href="/ca/docs/Web/JavaScript/Guide/Functions#Closures">Closures</a><br> + <a href="/ca/docs/Web/JavaScript/Guide/Functions#Using_the_arguments_object">Arguments</a> i <a href="/ca/docs/Web/JavaScript/Guide/Functions#Function_parameters">paràmeters</a><br> + <a href="/ca/docs/Web/JavaScript/Guide/Functions#Arrow_functions">Functions fletxa</a></p> + </li> + <li><span><a href="/ca/docs/Web/JavaScript/Guide/Expressions_i_Operadors">Expressions i Operadors</a></span> + <p><a href="/ca/docs/Web/JavaScript/Guide/Expressions_i_Operadors#Assignment_operators">Assignaments</a> i <a href="/ca/docs/Web/JavaScript/Guide/Expressions_i_Operadors#Comparison_operators">Comparacions</a><br> + <a href="/ca/docs/Web/JavaScript/Guide/Expressions_i_Operadors#Arithmetic_operators">Operadors aritmètics</a><br> + <a href="/ca/docs/Web/JavaScript/Guide/Expressions_i_Operadors#Bitwise_operators">Operadors de bits</a> i <a href="/ca/docs/Web/JavaScript/Guide/Expressions_i_Operadors#Logical_operators">operadors lògics</a><br> + <a href="/ca/docs/Web/JavaScript/Guide/Expressions_i_Operadors#Conditional_(ternary)_operator">Operador condicional (ternari)</a></p> + </li> + <li><span><a href="/ca/docs/Web/JavaScript/Guide/Numbers_and_dates">Nombres i dates</a></span> + <p><a href="/ca/docs/Web/JavaScript/Guide/Numbers_and_dates#Numbers">Literals de nombres</a><br> + <a href="/ca/docs/Web/JavaScript/Guide/Numbers_and_dates#Number_object">Objecte <code>Number</code></a><br> + <a href="/ca/docs/Web/JavaScript/Guide/Numbers_and_dates#Math_object">Objecte <code>Math</code></a><br> + <a href="https://developer.mozilla.org/ca/docs/Web/JavaScript/Guide/Numbers_and_dates#Date_object">Objecte <code>Date</code></a></p> + </li> + <li><span><a href="/ca/docs/Web/JavaScript/Guide/Text_formatting">Formateig de text</a></span> + <p><a href="/ca/docs/Web/JavaScript/Guide/Text_formatting#String_literals">Literals String</a><br> + <a href="/ca/docs/Web/JavaScript/Guide/Text_formatting#String_objects"><code>String</code> object</a><br> + <a href="/ca/docs/Web/JavaScript/Guide/Text_formatting#Multi-line_template_strings">Strings plantilla</a><br> + <a href="/ca/docs/Web/JavaScript/Guide/Text_formatting#Internationalization">Internacionalització</a><br> + <a href="/ca/docs/Web/JavaScript/Guide/Regular_Expressions">Expressions regulars</a></p> + </li> +</ul> + +<ul class="card-grid"> + <li><span><a href="/ca/docs/Web/JavaScript/Guide/Indexed_collections">Col·leccions indexades</a></span> + + <p><a href="/ca/docs/Web/JavaScript/Guide/Indexed_collections#Array_object">Arrays</a><br> + <a href="/ca/docs/Web/JavaScript/Guide/Indexed_collections#Array_comprehensions">Comprensions per a Arrays</a><br> + <a href="/ca/docs/Web/JavaScript/Guide/Indexed_collections#Typed_Arrays">Arrays amb tipus</a></p> + </li> + <li><span><a href="/ca/docs/Web/JavaScript/Guide/Keyed_collections">Col·leccions clau-valor</a></span> + <p><code><a href="/ca/docs/Web/JavaScript/Guide/Keyed_collections#Map_object">Map</a></code><br> + <code><a href="/ca/docs/Web/JavaScript/Guide/Keyed_collections#WeakMap_object">WeakMap</a></code><br> + <code><a href="/ca/docs/Web/JavaScript/Guide/Keyed_collections#Set_object">Set</a></code><br> + <code><a href="/ca/docs/Web/JavaScript/Guide/Keyed_collections#WeakSet_object">WeakSet</a></code></p> + </li> + <li><span><a href="/ca/docs/Web/JavaScript/Guide/Treballar_amb_Objectes">Treballar amb Objectes</a></span> + <p><a href="/ca/docs/Web/JavaScript/Guide/Treballar_amb_Objectes#Objects_and_properties">Objectes i propietats</a><br> + <a href="/ca/docs/Web/JavaScript/Guide/Treballar_amb_Objectes#Creating_new_objects">Crear objectes</a><br> + <a href="/ca/docs/Web/JavaScript/Guide/Treballar_amb_Objectes#Defining_methods">Definir mètodes</a><br> + <a href="/ca/docs/Web/JavaScript/Guide/Treballar_amb_Objectes#Defining_getters_and_setters">Getters i setters</a></p> + </li> + <li><span><a href="/ca/docs/Web/JavaScript/Guide/Details_of_the_Object_Model">Detalls del model d'objectes</a></span> + <p><a href="/ca/docs/Web/JavaScript/Guide/Details_of_the_Object_Model#Class-based_vs._prototype-based_languages">Programació Orientada a Objectes basada en Prototipus</a><br> + <a href="/ca/docs/Web/JavaScript/Guide/Details_of_the_Object_Model#Creating_the_hierarchy">Crear jerarquies d'objectes</a><br> + <a href="/ca/docs/Web/JavaScript/Guide/Details_of_the_Object_Model#Property_inheritance_revisited">Herència</a></p> + </li> +</ul> + +<ul class="card-grid"> + <li><span><a href="/ca/docs/Web/JavaScript/Guide/Iterators_and_Generators">Iteradors i generadors</a></span> + + <p><a href="/ca/docs/Web/JavaScript/Guide/Iterators_and_Generators#Iterators">Iteradors</a><br> + <a href="/ca/docs/Web/JavaScript/Guide/Iterators_and_Generators#Iterables">Iterables</a><br> + <a href="/ca/docs/Web/JavaScript/Guide/Iterators_and_Generators#Generators">Generdors</a><br> + <a href="/ca/docs/Web/JavaScript/Guide/Iterators_and_Generators#Generator_comprehensions">Comprensions per a Generadors</a></p> + </li> + <li><span><a href="/ca/docs/Web/JavaScript/Guide/Meta_programming">Meta programació</a></span> + <p><code><a href="/ca/docs/Web/JavaScript/Guide/Meta_programming#Proxies">Proxy</a></code><br> + <a href="/ca/docs/Web/JavaScript/Guide/Meta_programming#Handlers_and_traps">Manegadors i trampes</a><br> + <a href="/ca/docs/Web/JavaScript/Guide/Meta_programming#Revocable_Proxy">Proxy Revocable</a><br> + <code><a href="/ca/docs/Web/JavaScript/Guide/Meta_programming#Reflection">Reflect</a></code></p> + </li> +</ul> + +<p>{{Next("Web/JavaScript/Guide/Introduction")}}</p> diff --git a/files/ca/web/javascript/guide/introducció/index.html b/files/ca/web/javascript/guide/introducció/index.html new file mode 100644 index 0000000000..1b598dad9b --- /dev/null +++ b/files/ca/web/javascript/guide/introducció/index.html @@ -0,0 +1,140 @@ +--- +title: Introducció +slug: Web/JavaScript/Guide/Introducció +translation_of: Web/JavaScript/Guide/Introduction +--- +<div>{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide", "Web/JavaScript/Guide/Grammar_and_types")}}</div> + +<div class="summary"> +<p>Aquest capítol presenta JavaScript i comenta alguns dels seus conceptes fonamentals.</p> +</div> + +<h2 id="Coneixements_previs">Coneixements previs</h2> + +<p>Aquesta guia asumeix que el lector te els següents coneixements previs:</p> + +<ul> + <li>Una idea general de Internet i la World Wide Web ({{Glossary("WWW")}}).</li> + <li>Bon coneixement de l'HyperText Markup Language ({{Glossary("HTML")}}).</li> + <li>Alguns coneixements de programació. Si sou nous quant a la programació proveu qualsevol dels tutorials que trobareu a la pàgina principal sobre <a href="/en-US/docs/Web/JavaScript" title="/en-US/docs/">JavaScript</a>.</li> +</ul> + +<h2 id="On_trobar_informació_sobre_JavaScript">On trobar informació sobre JavaScript</h2> + +<p>La documentació de JavaScript al MDN inclou els següents apartats:</p> + +<ul> + <li><a href="/en-US/Learn">Aprenent la Web</a> proporciona informació per a nouvinguts i introdueix conceptes bàsics de programació i Internet.</li> + <li><a href="/en-US/docs/Web/JavaScript/Guide" title="en/Core_JavaScript_1.5_Guide">La guia de JavaScript</a> (aquesta guia) proporciona un resum del llenguatge JavaScript així com els seus objectes.</li> + <li><a href="/en-US/docs/Web/JavaScript/Reference" title="en/JavaScript/Reference">La referència de JavaScript</a> proporciona material de referència detallat per a JavaScript.</li> +</ul> + +<p>Si vostè és nou al món de JavaScript es recomana començar amb els articles que es poden trobar a l'<a href="/en-US/Learn">àrea d'aprenentatge</a> i la <a href="/en-US/docs/Web/JavaScript/Guide" title="en/Core_JavaScript_1.5_Guide">Guia de JavaScript</a>. Un cop assolits els conceptes fonamentals podeu obtindre més detalls sobre objectes individuals i sentències mitjançant la <a href="/en-US/docs/Web/JavaScript/Reference" title="en/JavaScript/Reference">Referència de JavaScript</a>.</p> + +<h2 id="Què_és_JavaScript">Què és JavaScript?</h2> + +<p>JavaScript és un llenguatge d'script multiplataforma i orientat a objectes. És un llenguatge petit i lleuger. Dins l'entorn d'un amfitrió, es pot connectar JavaScript als objectes del l'entorn per a tenir un control programàtic sobre aquests.</p> + +<p>JavaScript conté una llibreria estàndard d'objectes, com <code>Array</code>, <code>Date</code> i <code>Math</code>, o un conjunt bàsic d'elements del llenguatge, com ara operadors, estructures de control o sentències. El nucli de JavaScript es pot estendre per a diferents propòsits mitjançant objectes adicionals; per exemple:</p> + +<ul> + <li><em>JavaScript al cantó del client</em> estén el llenguatge bàsic tot proveint objectes per a controlar un navegador i el seu Document Object Model (DOM). Per exemple, les extensions del cantó del client permeten a una aplicació posar elements en un formulari HTML i respondre a esdeveniments (events) d'usuari com ara clics del ratolí, entrada de formularis o navegació per la pàgina.</li> + <li><em>JavaScript al cantó del servidor</em> estén el llenguatge bàsic tot proveint objectes rellevants a córrer JavaScript en un servidor. Per exemple, les extensions del cantó del servidor permeten a una aplicació comunicar-se amb una base de dades, proveir continuitat d'informació d'una instància a una altra de l'aplicació, o bé realitzar manipulacions de fitxers al servidor.</li> +</ul> + +<h2 id="JavaScript_and_Java" name="JavaScript_and_Java">JavaScript i Java</h2> + +<p>JavaScript i Java són similars des d'alguns punts de vista però són fonamentalment diferents des d'uns altres. El llenguatge JavaScript s'assembla al Java però no té el tipatge estàtic ni les comprovacions de tipatge fort de Java. JavaScript segueix la majoria de les expressions de sintaxi de Java, convencions de nomenclatura i construccions de control de flux bàsiques, la qual és la raó per la qual el seu nom va ser canviat de LiveScript a JavaScript.</p> + +<p>En contrast amb el sistema de classes de Java en temps de compilació fabricat per declaracions, JavaScript suporta un sistema en temps d'execució basat en un petit nombre de tipus de dades que representen valors numèrics, booleans i cadenes de caràcters. JavaScript té model d'objecte basat en prototipus en comptes del model més comú, basat en classes. El model basat en prototipus ofereix herència dinàmica, és a dir, el que és heretat pot variar entre diferents objectes individuals. JavaScript també suporta funcions sense cap mena de requeriment declaratiu especial. Les funcions poden ser propietats d'objectes, sent executades com a mètodes de tipatge lliure.</p> + +<p>JavaScript és un llenguatge de forma molt lliure en comparació amb Java. No és necessari declarar totes les variables, classes i mètodes. No és necessari preocupar-se per quins mètodes són públics, privats o protegits, i no és necessari implementar interfícies. Variables, paràmetres i tipus de retorn de funcions so són de tipatge explícit.</p> + +<p>Java és un llenguatge de programació basat en classes dissenyat per a executar-se ràpidament i ser segur quant a tipatge. Ser segur quant al tipatge vol dir que, per exemple, no es pot assignar un nombre sencer de Java a una referència d'objecte, o accedir memòria privada tot corrompent bytecode de Java. El model basat en classes de Java implica que els programes consisteixen exclusivament de classes i els seus mètodes. L'herència de classes a Java i el tipatge fort generalment requereixen jerarquies d'objectes fortament acoblades. Aquests requisits fan que programar en Java sigui més complex que programar en JavaScript.</p> + +<p>En contrast, JavaScript descendeix en esperit d'una línia de llenguatges més petits, amb tipatge dinàmic com ara HyperTalk i dBASE. Aquests llenguatges d'scripting ofereixen eines de programació a una audiència molt més àmplia a causa de la seva sintaxi més simple, funcionalitats especialitzades integrades i uns requeriments mínims per a la creació d'objectes.</p> + +<table class="standard-table"> + <caption>JavaScript en comparació a Java</caption> + <thead> + <tr> + <th scope="col">JavaScript</th> + <th scope="col">Java</th> + </tr> + </thead> + <tbody> + <tr> + <td> + <p>Basat en objectes. No hi ha distinció entre tipus d'objectes. L'herència funciona a través del mecanisme de prototipus i les propietats i mètodes es poden afegir a qualsevol objecte de forma dinàmica.</p> + </td> + <td> + <p>Basat en classes. Els objectes es divideixen entre classes i instàncies, amb l'herència aplicada mitjançant la jerarquia de classes. No es poden afegir propietats ni mètodes dinàmicament ni a classes ni a instàncies.</p> + </td> + </tr> + <tr> + <td>El tipus de dades de les variables no es declaren (tipatge dinàmic).</td> + <td>El tipus de dades de les variables s'ha de declarar (tipatge estàtic).</td> + </tr> + <tr> + <td>No pot escriure a disc de forma automàtica.</td> + <td>No pot escriure a disc de forma automàtica.</td> + </tr> + </tbody> +</table> + +<p>Per a més informació sobre les diferències entre JavaScript i Java vegeu el capítol <a href="/en-US/docs/Web/JavaScript/Guide/Details_of_the_Object_Model" title="JavaScript/Guide/Details of the Object Model">Detalls del model d'objecte</a>.</p> + +<h2 id="JavaScript_and_the_ECMAScript_Specification" name="JavaScript_and_the_ECMAScript_Specification">JavaScript i l'especificació ECMAScript</h2> + +<p>L'estandardització de JavaScript es realitza a <a class="external" href="http://www.ecma-international.org/">Ecma International</a> — l'associació Europea per a l'estandardització de sistemes d'informació i comunicació (ECMA era anteriorment un acrònim d'European Computer Manufacturers Association) per a proporcionar un llenguatge de programació estàndard i internacional basat en JavaScript. Aquesta versió estandarditzada de JavaScript, anomenada ECMAScript, es comporta de la mateixa manera a totes les aplicacions que suporten l'estàndard. Les empreses poden utilitzar el llenguatge estàndard obert per a desenvolupar la seva pròpia implementació de JavaScript. L'estàndard ECMAScript està documentat en l'especificació ECMA-262. Vegeu <a href="/en-US/docs/Web/JavaScript/New_in_JavaScript">Nou a JavaScript</a> per a aprendre sobre les diferents versions de JavaScript així com les diferents edicions de l'especificació d'ECMAScript.</p> + +<p>A més, l'estàndard ECMA-262 també està aprovat per l'<a class="external" href="http://www.iso.ch/">ISO</a> (International Organization of Standarization) com a ISO-16262. Podeu trobar l'especificació al <a class="external" href="http://www.ecma-international.org/publications/standards/Ecma-262.htm">lloc web d'Ecma International</a>. L'especificació de l'ECMAScript no descriu el Model d'Objecte Document (DOM), el qual està estandaritzat pel <a class="external" href="http://www.w3.org/">World Wide Web Consortium (W3C)</a>. El DOM defineix la forma en què els objectes d'un document HTML s'exposen a l'script. Per a fer-se una millor idea de les diferents tecnologies usades en programar en JavaScript, consulteu l'article: <a href="/en-US/docs/Web/JavaScript/JavaScript_technologies_overview">resum de tecnologies de JavaScript</a>.</p> + +<h3 id="JavaScript_Documentation_versus_the_ECMAScript_Specification" name="JavaScript_Documentation_versus_the_ECMAScript_Specification">La documentació de JavaScript versus l'especificació de l'ECMAScript</h3> + +<p>L'especificació de l'ECMAScript és un conjunt de requeriments per a implementar ECMAScript; és útil si es vol implementar característiques del llenguatge que compleixin amb els estàndards a la vostra pròpia implementació d'ECMAScript o a un motor JavaScript (com per exemple el SpiderMonkey a Firefox, o el v8 a Chrome).</p> + +<p>El document d'ECMAScript no pretén ajudar als programadors de scripts; utilitzeu la documentació de JavaScript per a obtenir informació sobre com escriure scripts.</p> + +<p>L'especificació d'ECMAScript utilitza terminologia i sintaxi que poden no ser familiars per a programador de JavaScript. Tot i que la descripció del llenguatge pot variar a ECMAScript, el llenguatge en si roman sense canvis. JavaScript suporta totes les funcionalitats definides a l'especificació d'ECMAScript.</p> + +<p>La documentació de JavaScript descriu aspectes del llenguatge que són apropiats per al programador de JavaScript.</p> + +<h2 id="Iniciant-se_en_JavaScript">Iniciant-se en JavaScript</h2> + +<p>Iniciar-se en JavaScript és senzill: tot el que fa falta és un navegador Web modern. Aquesta guia inclou algunes de les característiques de JavaScript que només estan disponibles a les últimes versions de Firefox, per això es recomana utilitzar la versió de Firefox més recent.</p> + +<p>Hi ha dues eines que formen part de Firefox que són útils per a experimentar amb JavaScript: la Consola del Web i Scratchpad.</p> + +<h3 id="La_Consola_del_Web">La Consola del Web</h3> + +<p>La <a href="/en-US/docs/Tools/Web_Console">Consola del Web</a> mostra informació sobre la pàgina Web carregada actualment i també inclou una <a href="/en-US/docs/Tools/Web_Console#The_command_line_interpreter">línia d'ordres</a> que podeu utilitzar per a executar expressions JavaScript a la pàgina actual.</p> + +<p>Per a obrir la Consola del Web, seleccioneu "Web Console" des del menú "Web Developer", que trobareu sota el menú "Tools" a Firefox. Apareixerà a la part de sota de la finestra del navegador. A la part de sota de la consola hi ha la línia d'ordres que podeu utilitzar per a introduir JavaScript, i la sortida apareix al panell de sobre:</p> + +<p><img alt="" src="https://mdn.mozillademos.org/files/7363/web-console-commandline.png" style="display: block; margin-left: auto; margin-right: auto;"></p> + +<h3 id="Scratchpad">Scratchpad</h3> + +<p>La Consola del Web és excel·lent per a executar línies individuals de JavaScript, però tot i que pot executar múltiples línies no és gaire còmoda per a això, i no permet desar mostres de codi. És per això que per a exemples més complexos <a href="/en-US/docs/Tools/Scratchpad">Scratchpad</a> és una eina més adient.</p> + +<p>Per a obrir Scratchpad, seleccioneu "Scratchpad" al menú "Web Developer", que trobareu dins el menú "Tools" al Firefox. S'obre en una finestra separada i consisteix d'un editor que podeu utilitzar per a escriure i executar JavaScript al navegador. També podeu desar scripts al disc i carregar scripts des del disc.</p> + +<p>Si seleccioneu l'opció "Inspect", el codi a l'editor és executat al navegador i els resultats són inserits tot seguit a l'editor en forma de comentari:</p> + +<p><img alt="" src="https://mdn.mozillademos.org/files/7365/scratchpad.png" style="display: block; margin-left: auto; margin-right: auto;"></p> + +<h3 id="Hola_món">Hola món</h3> + +<p>Per a iniciar-vos a escriure JavaScript, obriu la Consola del Web o bé l'Scratchpad i escriviu el vostre primer codi "Hola món" en JavaScript.</p> + +<pre class="brush: js notranslate">function saluda(user) { + return "Hola " + user; +} + +saluda("Alice"); // "Hola Alice" +</pre> + +<p>A les següents pàgines, aquesta guia us introduirà la sintaxi de JavaScript així com les seves característiques, de manera que sereu capaços d'escriure aplicacions més complexes.</p> + +<p>{{PreviousNext("Web/JavaScript/Guide", "Web/JavaScript/Guide/Grammar_and_types")}}</p> diff --git a/files/ca/web/javascript/index.html b/files/ca/web/javascript/index.html new file mode 100644 index 0000000000..2aef119061 --- /dev/null +++ b/files/ca/web/javascript/index.html @@ -0,0 +1,105 @@ +--- +title: JavaScript +slug: Web/JavaScript +tags: + - JavaScript + - NeedsTranslation + - References + - TopicStub +translation_of: Web/JavaScript +--- +<div>{{JsSidebar()}}</div> + +<div class="summary"> +<p><strong>JavaScript</strong><sup>®</sup> (tot sovint abreujat com a <strong>JS</strong>) és un llenguatge orientat a objectes, lleuger i interpretat, amb <a href="https://en.wikipedia.org/wiki/First-class_functions" title="https://en.wikipedia.org/wiki/First-class_functions">funcions de primera classe</a>, més conegut per ser el llenguatge d'scripting per a pàgines Web, però també <a class="external" href="http://en.wikipedia.org/wiki/JavaScript#Uses_outside_web_pages">utilitzat en molts àmbits fora d'un navegador web</a> com ara <a class="external" href="http://nodejs.org/">node.js</a> o <a href="http://couchdb.apache.org">Apache CouchDB</a>. Es tracta d'un llenguatge d'scripting multi-paradigma, <a class="mw-redirect" href="https://en.wikipedia.org/wiki/Prototype-based" title="Prototype-based">basat en prototipus</a>, que és dinamic i suporta estils de programació funcional, imperativa i orientada a objectes. Llegiu més <a href="/ca/docs/Web/JavaScript/About_JavaScript">sobre JavaScript</a>.</p> +</div> + +<p>El standard JavaScript és <a href="/ca/docs/JavaScript/Language_Resources">ECMAScript</a>. A l'any 2012, tots els navegadors moderns suporten plenament l'ECMAScript 5.1. Navegadors més vells suporten com a mínim l'ECMAScript 3. Una sisena gran revisió del standard està en procés i s'espera que estigui enllestida al voltant de mitjans de 2015.</p> + +<p>Aquesta secció del lloc Web està dedicada al llenguatge JavaScript en si mateix, les parts que no són específiques per a pàgines Web o d'altres entorns que l'acullen. Per a més informació sobre les APIs específiques per a pàgines Web, vegeu <a href="/ca/docs/Web/API">APIs Web</a> i <a href="/ca/docs/Glossary/DOM">DOM</a>.</p> + +<p>És important no confondre JavaScript amb el <a href="http://en.wikipedia.org/wiki/Java_(programming_language)">llenguatge de programació Java</a>. Java és una marca comercial o marca enregistrada pertanyent a Oracle als Estats Units d'Amèrica i d'altres països.</p> + +<div class="column-container"> +<div class="column-half"> +<h2 id="Creating" name="Creating">Tutorials</h2> + +<p>Apreneu com programar en JavaScript.</p> + +<h3 id="Nivell_introductori">Nivell introductori</h3> + +<dl> + <dt><a href="https://developer.mozilla.org/ca/docs/Web/JavaScript/Guide">Guia de JavaScript</a></dt> + <dd>Si sou nous quant a JavaScript, aquesta guia recorre el llenguatge.</dd> + <dt><a href="/ca/docs/Web/JavaScript/JavaScript_technologies_overview">Resum de tecnologies de JavaScript</a></dt> + <dd>Introducció al món de JavaScript dins el navegador web.</dd> + <dt><a href="https://developer.mozilla.org/ca/docs/Web/JavaScript/Introduction_to_Object-Oriented_JavaScript">Introducció al JavaScript Orientat a Objectes</a></dt> + <dd>Introducció als conceptes de programació orientada a objectes en JavaScript.</dd> +</dl> + +<h3 id="Nivell_intermig">Nivell intermig</h3> + +<dl> + <dt><a href="https://developer.mozilla.org/ca/docs/Web/JavaScript/A_re-introduction_to_JavaScript">Una re-introducció a JavaScript</a></dt> + <dd>Un resum per a aquells que <em>creuen</em> que ja ho saben tot sobre JavaScript.</dd> +</dl> + +<dl> + <dt><a href="https://developer.mozilla.org/ca/docs/Web/JavaScript/Data_structures">Estructures de dades de JavaScript</a></dt> + <dd>Resum de les estructures de dades disponibles a JavaScript.</dd> + <dt><a href="https://developer.mozilla.org/ca/docs/Web/JavaScript/Equality_comparisons_and_when_to_use_them">Comparacions d'equitat i quan utilitzar-les</a></dt> + <dd>JavaScript proporciona dos operacions diferents per a comparar valors: l'igualtat estricta mitjançant <code>===</code> i l'igualtat relaxada mitjançant <code>==.</code></dd> +</dl> + +<h3 id="Nivell_avançat">Nivell avançat</h3> + +<dl> + <dt><a href="https://developer.mozilla.org/ca/docs/Web/JavaScript/Guide/Inheritance_and_the_prototype_chain">Herència i la cadena de prototipus</a></dt> + <dd>Explicació de l'herència basada en prototipus, tot sovint malentesa i poc valorada.</dd> + <dt><a href="/ca/docs/Web/JavaScript/Reference/Strict_mode">El mode estricte</a></dt> + <dd>Una variant restringida de JavaScript.</dd> + <dt><a href="https://developer.mozilla.org/ca/docs/Web/JavaScript/Typed_arrays">Arrays amb tipus a JavaScript</a></dt> + <dd>Les arrays amb tipus de JavaScript proporcionen un mecanisme per a accedir a dades binàries sense tractar.</dd> + <dt><a href="https://developer.mozilla.org/ca/docs/Web/JavaScript/Memory_Management">Manegament de Memòria</a></dt> + <dd>El cicle de vida de la memòria i la recolecció de la brossa a JavaScript.</dd> +</dl> +</div> + +<div class="column-half"> +<h2 id="Referència">Referència</h2> + +<p>Navegue per la documentació de <a href="/ca/docs/Web/JavaScript/Reference">referència de JS</a> complerta.</p> + +<dl> + <dt><a href="/ca/docs/Web/JavaScript/Referencia/Objectes_standard">Objectes standard</a></dt> + <dd>Conegueu els objectes standard proporcionats per JavaScript <code><a href="https://developer.mozilla.org/ca/docs/Web/JavaScript/Reference/Global_Objects/Array" title="The JavaScript Array global object is a constructor for arrays, which are high-level, list-like objects."><code>Array</code></a></code>, <a href="https://developer.mozilla.org/ca/docs/Web/JavaScript/Reference/Global_Objects/Boolean" title="The Boolean object is an object wrapper for a boolean value."><code>Boolean</code></a>, <a href="https://developer.mozilla.org/ca/docs/Web/JavaScript/Reference/Global_Objects/Date" title="Creates a JavaScript Date instance that represents a single moment in time. Date objects are based on a time value that is the number of milliseconds since 1 January, 1970 UTC."><code>Date</code></a>, <a href="https://developer.mozilla.org/ca/docs/Web/JavaScript/Reference/Global_Objects/Error" title="The Error constructor creates an error object. Instances of Error objects are thrown when runtime errors occur. The Error object can also be used as a base objects for user-defined exceptions. See below for standard built-in error types."><code>Error</code></a>, <a href="https://developer.mozilla.org/ca/docs/Web/JavaScript/Reference/Global_Objects/Function" title="The Function constructor creates a new Function object. In JavaScript every function is actually a Function object."><code>Function</code></a>, <a href="https://developer.mozilla.org/ca/docs/Web/JavaScript/Reference/Global_Objects/JSON" title="The JSON object contains methods for parsing JavaScript Object Notation (JSON) and converting values to JSON. It can't be called or constructed, and aside from its two method properties it has no interesting functionality of its own."><code>JSON</code></a>, <a href="https://developer.mozilla.org/ca/docs/Web/JavaScript/Reference/Global_Objects/Math" title="Math is a built-in object that has properties and methods for mathematical constants and functions. Not a function object."><code>Math</code></a>, <a href="https://developer.mozilla.org/ca/docs/Web/JavaScript/Reference/Global_Objects/Number" title="The Number JavaScript object is a wrapper object allowing you to work with numerical values. A Number object is created using the Number() constructor."><code>Number</code></a>, <a href="/ca/docs/Web/JavaScript/Reference/Global_Objects/Object"><code>Object</code></a>, <a href="https://developer.mozilla.org/ca/docs/Web/JavaScript/Reference/Global_Objects/RegExp" title="The RegExp constructor creates a regular expression object for matching text with a pattern."><code>RegExp</code></a>, <a href="https://developer.mozilla.org/ca/docs/Web/JavaScript/Reference/Global_Objects/String" title="The String global object is a constructor for strings, or a sequence of characters."><code>String</code></a>, <a href="https://developer.mozilla.org/ca/docs/Web/JavaScript/Reference/Global_Objects/Map" title="The Map object is a simple key/value map. Any value (both objects and primitive values) may be used as either a key or a value."><code>Map</code></a>, <code><a href="/ca/docs/Web/JavaScript/Reference/Global_Objects/Set">Set</a></code>, <code><a href="https://developer.mozilla.org/ca/docs/Web/JavaScript/Reference/Global_Objects/WeakMap" title="The WeakMap object is a collection of key/value pairs in which the keys are objects and the values can be arbitrary values."><code>WeakMap</code></a></code>, <a href="https://developer.mozilla.org/ca/docs/Web/JavaScript/Reference/Global_Objects/WeakSet" title="The WeakSet object lets you store weakly held objects in a collection."><code>WeakSet</code></a>, i d'altres.</dd> + <dt><a href="/ca/docs/Web/JavaScript/Reference/Operators">Expressions i operadors</a></dt> + <dd>Apreneu més sobre el comportament dels operadors de JavaScript <code><a href="https://developer.mozilla.org/ca/docs/Web/JavaScript/Reference/Operators/instanceof">instanceof</a></code>, <code><a href="https://developer.mozilla.org/ca/docs/Web/JavaScript/Reference/Operators/typeof">typeof</a></code>, <code><a href="https://developer.mozilla.org/ca/docs/Web/JavaScript/Reference/Operators/new">new</a></code>, <code><a href="https://developer.mozilla.org/ca/docs/Web/JavaScript/Reference/Operators/this">this</a></code>, i més.</dd> + <dt><a href="/ca/docs/Web/JavaScript/Reference/Statements">Sentències i declaracions</a></dt> + <dd>Apreneu com funcionen les sentències <code><a href="https://developer.mozilla.org/ca/docs/Web/JavaScript/Reference/Statements/do...while">do-while</a></code>, <code><a href="https://developer.mozilla.org/ca/docs/Web/JavaScript/Reference/Statements/for...in">for-in</a></code>, <code><a href="https://developer.mozilla.org/ca/docs/Web/JavaScript/Reference/Statements/for...of">for-of</a></code>, <code><a href="https://developer.mozilla.org/ca/docs/Web/JavaScript/Reference/Statements/try...catch">try-catch</a></code>, <code><a href="https://developer.mozilla.org/ca/docs/Web/JavaScript/Reference/Statements/let">let</a></code>, <code><a href="https://developer.mozilla.org/ca/docs/Web/JavaScript/Reference/Statements/var">var</a></code>, <code><a href="https://developer.mozilla.org/ca/docs/Web/JavaScript/Reference/Statements/const">const</a></code>, <code><a href="https://developer.mozilla.org/ca/docs/Web/JavaScript/Reference/Statements/if...else">if-else</a></code>, <code><a href="https://developer.mozilla.org/ca/docs/Web/JavaScript/Reference/Statements/switch">switch</a></code>, així com d'altres sentències i paraules clau de JavaScript.</dd> + <dt><a href="/ca/docs/Web/JavaScript/Reference/Functions">Funcions</a></dt> + <dd>Apreneu com treballar amb funcions a JS per a desenvolupar aplicacions.</dd> +</dl> + +<h2 id="Eines_i_recursos">Eines i recursos</h2> + +<p>Eines útils per a escriure i depurar codi JavaScript.</p> + +<dl> + <dt><a href="/ca/docs/Tools">Firefox Developer Tools</a></dt> + <dd><a href="/ca/docs/Tools/Scratchpad">Scratchpad</a>, <a href="/ca/docs/Tools/Web_Console">Web Console</a>, <a href="/ca/docs/Tools/Profiler">JavaScript Profiler</a>, <a href="/ca/docs/Tools/Debugger">Debugger</a>, i més.</dd> + <dt><a class="external" href="http://www.getfirebug.com/">Firebug</a></dt> + <dd>Editeu, depureu i controleu CSS, HTML i JavaScript en directe a qualsevol pàgina web.</dd> + <dt><a href="/ca/docs/Web/JavaScript/Shells">Consoles JavaScript</a></dt> + <dd>Les consoles JavaScript permeten provar ràpidament bocins de codi JavaScript.</dd> + <dt><a href="https://togetherjs.com/">TogetherJS</a></dt> + <dd> + <p class="hero-header-text large">Colaborar de forma senzilla.</p> + </dd> + <dt><a href="http://stackoverflow.com/questions/tagged/javascript">Stack Overflow</a></dt> + <dd>Preguntes a Stack Overflow amb l'etiqueta "JavaScript".</dd> + <dt><a href="/ca/docs/Web/JavaScript/New_in_JavaScript">Versions de JavaScript i notes de versió</a></dt> + <dd>Navegeu per l'històric de característiques de JavaScript així com l'estat de la seva implementació.</dd> +</dl> +</div> +</div> diff --git a/files/ca/web/javascript/inheritance_and_the_prototype_chain/index.html b/files/ca/web/javascript/inheritance_and_the_prototype_chain/index.html new file mode 100644 index 0000000000..d4c5aee693 --- /dev/null +++ b/files/ca/web/javascript/inheritance_and_the_prototype_chain/index.html @@ -0,0 +1,299 @@ +--- +title: Herència i la cadena de prototipus +slug: Web/JavaScript/Inheritance_and_the_prototype_chain +tags: + - Avançat + - Guía + - Herencia + - JavaScript + - OOP +translation_of: Web/JavaScript/Inheritance_and_the_prototype_chain +--- +<div>{{jsSidebar("Advanced")}}</div> + +<p>JavaScript pot resultar una mica confús per als desenvolupadors amb experiència en llenguatges bassats en classes (com ara Java o C++), ja que al ser un llenguatge dinàmic no proporciona una implementació de <code>class</code> per se (la paraula clau <code>class</code> va ser introduïda al ES2015, però sintàcticament és irrellevant, JavaScript continua essent basat en prototipus).</p> + +<p>En quant a l'herència, JavaScript només disposa d'una construcció: objectes. Cada objecte té una propietat privada (referida com a [[Prototipus]]) que conté un un enllaç a un altre objecte, anomenat el seu <strong>prototipus</strong>. Aquest objecte prototipus també té el seu propi prototipus, i així es crea una cadena fins que s'arriba a un objecte que tingui <code>null</code> com a prototipus. <code>null</code>, per definició, no te prototipus, i actua com a enllaç final en aquesta <strong>cadena de prototipus</strong>.</p> + +<p>Gairebé tots els objectes en JavaScript són instàncies de {{jsxref("Object")}}, que resta al principi de la cadena de prototipus.</p> + +<p>Encara que això es consideri freqüentment com a un dels punts dèbils de JavaScript, el model d'herència basat en prototipus és, de fet, més potent que el model clàssic. És, per exemple, força senzill construir un model clàssic mitjançant un model basat en prototipus.</p> + +<h2 id="Herència_mitjançant_la_cadena_de_prototipus">Herència mitjançant la cadena de prototipus</h2> + +<h3 id="Propietats_heretades">Propietats heretades</h3> + +<p>Els objectes a JavaScript són "bosses" dinàmiques de propietats (referenciades com a <strong>propietats pròpies</strong>). Els objectes a JavaScript tenen una referènia a un objecte prototipus. A l'hora d'intentar accedir a una propietat d'un objecte, no només es cercarà la propietat dins l'objecte mateix, sinò també al prototipus de l'objecte, el prototipus del prototipus, i així fins a que o bé es trobi la propietat amb el nom que es buscava o bé es troba el final de la cadena de prototipus.</p> + +<div class="note"> +<p>Tot seguint l'standard ECMAScript, utilitzem la notació <code>unObjecte.[[Prototipus]]</code> per a designar el prototipus de <code>unObjecte</code><code>.</code> Des de l'ECMAScript 2015, el [[Prototipus]] és accedit utilitzant les funcions d'accés {{jsxref("Object.getPrototypeOf()")}} i {{jsxref("Object.setPrototypeOf()")}}. El resultat és el mateix que el d'utilitzar la propietat <code>__proto__</code> que no és estàndard però l'implementen la majoria de navegadors. </p> + +<p>No s'ha de confondre amb la propietat <em>func</em>.prototype de les funcions, que especifica el [[Prototipus]] que s'assigna a totes les <em>instàncies </em>dels objectes creats per una funció quan aquesta s'utilitza com a constructora. La propietat <strong>Object.prototype</strong> representa l'objecte prototipus {{jsxref("Object")}}.</p> +</div> + +<p>A continuació es mostra el que succeeix quan s'intenta accedir a una propietat:</p> + +<pre class="brush: js">// Assumim que disposem de l'objecte o, amb les seves pròpies propietats a i b: +// {a: 1, b: 2} +// o.[[Prototipus]] té les propietats b i c: +// {b: 3, c: 4} +// Finalment, o.[[Prototipus]].[[Prototipus]] és null. +// Aquest és el final de la cadena de prototipus ja que null, +// per definició, no té [[Prototipus]]. +// Aleshores, la cadena de prototipus sencera és la següent: +// {a:1, b:2} ---> {b:3, c:4} ---> null + +console.log(o.a); // 1 +// Hi ha una propietat 'a' pròpia a l'objecte o? Sí, i el seu valor és 1. + +console.log(o.b); // 2 +// Hi ha una propietat 'b' pròpia a l'objecte o? Sí, i el seu valor és 2. +// El prototipus també té una propietat 'b', però aquest no s'arriba a visitar. +// Aquest fenòmen es coneix com a "property shadowing" + +console.log(o.c); // 4 +// Hi ha una propietat 'c' pròpia a l'objecte o? No, cerca-la al seu prototipus. +// Hi ha una propietat 'c' pròpia a o[[Prototipus]]? Sí, i el seu valor és 4. + +console.log(o.d); // undefined +// Hi ha una propietat 'd' pròpia a l'objecte o? No, cerca-la al seu prototipus. +// Hi ha una propietat 'd' pròpia a o[[Prototipus]]? No, cerca-la al seu prototipus. +// o.[[Prototipus]].[[Prototipus]] és null, atura la cerca, +// no s'ha trobat la propietat, retornem undefined +</pre> + +<p>Assignar una propietat a un objecte crea una propietat pròpia. L'única excepció al les regles de comportament d'assignació i obtenció és quan hi ha una propietat heretada que disposa d'un <a href="/en-US/docs/Web/JavaScript/Guide/Working_with_Objects#Defining_getters_and_setters" title="Defining Getters and Setters">getter o un setter</a>.</p> + +<h3 id="Herència_de_mètodes">Herència de "mètodes"</h3> + +<p>JavaScript no té "mètodes" de la manera en que els llenguatges bassats en classes els defineixen. En JavaScript, qualsevol funció pot ser afegida a un objecte com a propietat. Una funció heretada actua com qualsevol altra propietat, incloent <em>shadowing</em> de propietats, tal i com es mostra més amunt (en aquest cas, una forma de <em>sobreescritura de mètodes</em>).</p> + +<p>Quan s'executa una funció heretada, el valor de <a href="/en-US/docs/Web/JavaScript/Reference/Operators/this" title="this"><code>this</code></a> passa a apuntar a l'objecte que l'hereta, no a l'objecte prototipus al qual la funció pertany com a propietat pròpia.</p> + +<pre class="brush: js">var o = { + a: 2, + m: function(b){ + return this.a + 1; + } +}; + +console.log(o.m()); // 3 +// Al cridar a o.m en aquest cas, 'this' fa referència a o + +var p = Object.create(o); +// p és un objecte que hereta de o + +p.a = 12; // crea una propietat pròpia 'a' a l'objecte p +console.log(p.m()); // 13 +// quan es crida p.m 'this' fa referència a p. +// Així quan p hereta la funció m de o, +// 'this.a' s'avalua com a p.a, la propietat pròpia 'a' de p +</pre> + +<h2 id="Formes_diferents_de_crear_objectes_i_la_cadena_de_prototipus_resultant">Formes diferents de crear objectes i la cadena de prototipus resultant</h2> + +<h3 id="Crear_objectes_amb_sintaxi_de_construcció">Crear objectes amb sintaxi de construcció</h3> + +<pre class="brush: js">var o = {a: 1}; + +// L'objecte recentment creat o té Object.prototype com al seu [[Prototipus]] +// o no te cap propietat pròpia anomenada 'hasOwnProperty' +// hasOwnProperty és una propietat pròpia de Object.prototype. +// Així o hereta hasOwnProperty de Object.prototype +// El prototipus de Object.prototype val null. +// o ---> Object.prototype ---> null + +var a = ["yo", "whadup", "?"]; + +// Els Arrays hereten de Array.prototype +// (el qual té mètodes com ara indexOf, forEach, etc.) +// La cadena de prototipus té la forma següent: +// a ---> Array.prototype ---> Object.prototype ---> null + +function f(){ + return 2; +} + +// Les funcions hereten de Function.prototype +// (que té mètodes com ara call, bind, etc.) +// f ---> Function.prototype ---> Object.prototype ---> null +</pre> + +<h3 id="Crear_objectes_mitjançant_un_constructor">Crear objectes mitjançant un constructor</h3> + +<p>En JavaScript, una "constructora" és "simplement" una funció que es crida amb l'<a href="/en-US/docs/Web/JavaScript/Reference/Operators/new" title="new">operador new</a>.</p> + +<pre class="brush: js">function Graph() { + this.vertices = []; + this.edges = []; +} + +Graph.prototype = { + addVertex: function(v){ + this.vertices.push(v); + } +}; + +var g = new Graph(); +// g és un objecte amb propietats pròpies 'vertices' i 'edges'. +// g.[[Prototipus]] és el valor de Graph.prototype quan s'executa new Graph(). +</pre> + +<h3 id="Crear_objectes_mitjançant_Object.create">Crear objectes mitjançant <code>Object.create</code></h3> + +<p>ECMAScript 5 va introduïr un nou mètode: {{jsxref("Object.create()")}}. Cridar aquest mètode crea un nou objecte. El prototipus d'aquest objecte es el primer argument de la funció:</p> + +<pre class="brush: js">var a = {a: 1}; +// a ---> Object.prototype ---> null + +var b = Object.create(a); +// b ---> a ---> Object.prototype ---> null +console.log(b.a); // 1 (heretat) + +var c = Object.create(b); +// c ---> b ---> a ---> Object.prototype ---> null + +var d = Object.create(null); +// d ---> null +console.log(d.hasOwnProperty); +// undefined, perque d no hereta de Object.prototype +</pre> + +<div> +<h3 id="Crear_objectes_mitjançant_la_paraula_clau_class">Crear objectes mitjançant la paraula clau <code>class</code></h3> + +<p>ECMAScript 2015 va introduïr un nou conjunt de paraules clau per a implementar <a href="/en-US/docs/Web/JavaScript/Reference/Classes">classes</a>. Encara que aquestes construccions s'assemblen a les que es poden trobar en llenguatges bassats en classes, no són iguals. JavaScript continua sent un llenguatge bassat en prototipus. Les noves paraules clau inclouen {{jsxref("Statements/class", "class")}}, {{jsxref("Classes/constructor", "constructor")}}, {{jsxref("Classes/static", "static")}}, {{jsxref("Classes/extends", "extends")}}, i {{jsxref("Operators/super", "super")}}.</p> + +<pre class="brush: js">"use strict"; + +class Polygon { + constructor(height, width) { + this.height = height; + this.width = width; + } +} + +class Square extends Polygon { + constructor(sideLength) { + super(sideLength, sideLength); + } + get area() { + return this.height * this.width; + } + set sideLength(newLength) { + this.height = newLength; + this.width = newLength; + } +} + +var square = new Square(2); +</pre> + +<h3 id="Rendiment">Rendiment</h3> + +<p>El temps que es triga a resoldre propietats que estan lluny dins la cadena de prototipups pot tenir un impacte negatiu en el rendiment, i aquest impacte pot ser significatiu en parts del codi on el rendiment és crític. A més, intentar accedir a propietats que no existeixen sempre atravessarà totalment la cadena de prototipus.</p> + +<p>Adicionalment, quan s'itera sobre propietats d'un objecte, <strong>totes</strong> les propietats enumerables de la cadena de prototipus seran enumerades.</p> + +<p>Per a comprovar si un objecte té una propietat definida <em>en si mateix</em> (pròpia) en comptes de heretada de la cadena de prototipus, s'ha d'utilitzar el mètode <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/hasOwnProperty" title="/ru/docs/JavaScript/Reference/Global_Objects/Object/hasOwnProperty"><code>hasOwnProperty</code></a>, el qual és heretat per tots els objectes mitjançant <code>Object.prototype</code>.</p> + +<p><code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/hasOwnProperty" title="/ru/docs/JavaScript/Reference/Global_Objects/Object/hasOwnProperty">hasOwnProperty</a></code> és l'únic element de JavaScript que treballa amb propietats i <strong>no</strong> recorre la cadena de prototipus.</p> +Nota: <strong>No n'hi ha prou</strong> amb comprovar si una propietat és <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined" title="/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined"><code>undefined</code></a>. La propietat pot existir perfectament, però tenir assignat el valor <code>undefined</code>.</div> + +<h3 id="sect1"> </h3> + +<h3 id="Males_pràctiques_Extensió_de_prototipus_nadius">Males pràctiques: Extensió de prototipus nadius</h3> + +<p>Una característica que sovint es mal utilitza és extendre <code>Object.prototype</code> o qualsevol altre prototipus nadiu.</p> + +<p>Aquesta tècnica, anomenada <em>monkey patching</em>, trenca l'<em>encapsulació</em>. Malgrat ser utilitzada per llibreries populars, com ara Prototype.js, no hi ha cap bona raó per saturar els tipus nadius amb funcionalitats no estàndards.</p> + +<p>La <strong>única</strong> possible bona raó per a extendre un prototipus nadiu és per a afegir característiques dels nous motors de JavaScript no suportades per motors més antics (funcions <em>polifill</em>), com ara <code>Array.forEach</code>.</p> + +<h2 id="Exemple">Exemple</h2> + +<p><code>B</code> hauria d'heretar de <code>A</code>:</p> + +<pre class="brush: js">function A(a){ + this.varA = a; +} + +// Quin és el propòsit d'incloure varA al prototipus quan A.prototype.varA <em>sempre </em>estarà amagat (<em>shadowed</em>) per +// this.varA, donada la definició de la funció A de dalt? +A.prototype = { + varA : null, // No hauriem de treure varA del prototipus ja que no fa res? + // potser es tracta d'una optimització per a reservar espai a classes ocultes? + // https://developers.google.com/speed/articles/optimizing-javascript#Initializing instance variables + // seria vàlid si varA no s'inicialitzés de forma única per a cada instància + doSomething : function(){ + // ... + } +} + +function B(a, b){ + A.call(this, a); + this.varB = b; +} +B.prototype = Object.create(A.prototype, { + varB : { + value: null, + enumerable: true, + configurable: true, + writable: true + }, + doSomething : { + value: function(){ // sobreescriu + A.prototype.doSomething.apply(this, arguments); // crida a super + // ... + }, + enumerable: true, + configurable: true, + writable: true + } +}); +B.prototype.constructor = B; + +var b = new B(); +b.doSomething(); +</pre> + +<p>Les parts importants són:</p> + +<ul> + <li>Els tipus es defineixen a <code>.prototype</code></li> + <li>S'utilitza <code>Object.create()</code> per a heretar</li> +</ul> + +<h2 id="prototype_i_Object.getPrototypeOf"><code>prototype</code> i <code>Object.getPrototypeOf</code></h2> + +<p>JavaScript pot resultar una mica confús per a desenvolupadors que vinguin de Java o C++ degut a que és completament dinàmic, tot succeeix en temps d'execució i no té classes. Només té instàncies (objectes). Fins i tot les "classes" que simulem són simplement un objecte de tipus funció.</p> + +<p>Potser ja us heu adonat que la nostra funció <code>A</code> té una propietat especial anomenada <code>prototype</code>. Aquesta propietat especial funciona en conjunció amb l'operador de JavaScript <code>new</code>. La referència a l'objecte prototipus es copia a la propietat interna <code>[[Prototype]]</code> de la nova instància. Per exemple, amb el codi <code>var a1 = new A()</code>, JavaScript (després de crear l'objecte en memòria però abans d'executar la funció <code>A()</code> amb <code>this</code> definit i apuntant a si mateixa) assigna <code>a1.[[Prototype]] = A.prototype</code>. Després, quan accedim a les propietats de la instància, JavaScript primer comprova si aquestes existeixen dins l'objecte mateix i, en cas contrari, les cerca dins el <code>[[Prototipus]]</code>. Això implica que tot allò que es defineix al <code>prototype</code> és compartit per totes les instàncies, i més tard es poden canviar parts de <code>prototype</code> de forma que els canvis afectaran a totes les instàncies que existeixen, si es vol.</p> + +<p>Si, a l'exemple anterior, s'executa <code>var a1 = new A(); var a2 = new A();</code> llavors <code>a1.doSomething</code> faria referència en realitat a <code>Object.getPrototypeOf(a1).doSomething</code>, que és el mateix que <code>A.prototype.doSomething</code> que heu definit, per exemple, <code>Object.getPrototypeOf(a1).doSomething == Object.getPrototypeOf(a2).doSomething == A.prototype.doSomething</code>.</p> + +<p>Resumint, <code>prototype</code> és per als tipus mentre que <code>Object.getPrototypeOf()</code> és el mateix per les instàncies.</p> + +<p><code>[[Prototype]]</code> s'accedeix <em>de forma recursiva</em>, per exemple: <code>a1.doSomething</code>, <code>Object.getPrototypeOf(a1).doSomething</code>, <code>Object.getPrototypeOf(Object.getPrototypeOf(a1)).doSomething</code> etc., fins que es troba o bé <code>Object.getPrototypeOf retorna null</code>.</p> + +<p>Així, quan cridem:</p> + +<pre class="brush: js">var o = new Foo();</pre> + +<p>JavaScript simplement executa:</p> + +<pre class="brush: js">var o = new Object(); +o.[[Prototype]] = Foo.prototype; +Foo.call(o);</pre> + +<p>(o quelcom similar) i quan després executem:</p> + +<pre class="brush: js">o.someProp;</pre> + +<p>comprova si <code>o</code> té definida la propietat <code>someProp</code>. En cas que no, comprova <code>Object.getPrototypeOf(o).someProp</code> i si aquesta tampoc existeix llavors comprova <code>Object.getPrototypeOf(Object.getPrototypeOf(o)).someProp</code>, etcètera.</p> + +<div> +<h2 id="Conclusions">Conclusions</h2> + +<p>Resulta <strong>essencial</strong> entendre el model d'herència basat en prototipus abans de començar a escriure codi complex que es basi en ell. Així mateix, és important tenir en compte la longitud de la cadena de prototipus dins el nostre codi i trencar-la en cas necesari, per a evitar possibles problemes de rendiment. A més els prototipus natius no s'haurien d'extendre <strong>mai</strong> a no ser que el motiu sigui afegir compatibilitat amb característiques més modernes de JavaScript.</p> +</div> diff --git a/files/ca/web/javascript/introducció_al_javascript_orientat_a_objectes/index.html b/files/ca/web/javascript/introducció_al_javascript_orientat_a_objectes/index.html new file mode 100644 index 0000000000..6e5a4e2922 --- /dev/null +++ b/files/ca/web/javascript/introducció_al_javascript_orientat_a_objectes/index.html @@ -0,0 +1,361 @@ +--- +title: Introducció al Javascript orientat a Objectes +slug: Web/JavaScript/Introducció_al_Javascript_orientat_a_Objectes +translation_of: Learn/JavaScript/Objects +--- +<div>{{jsSidebar("Introductory")}}</div> + +<p>JavaScript és orientat a objectes des del nucli, amb unes capacitats potents, flexibles {{Glossary("OOP")}}. Aquest article comença amb la introducció de la programació orientada a objectes, després es revisa el model d'objectes de Javascript, i finalment es mostren els conceptes de la programació orientada a objectes en JavaScript.</p> + +<h2 id="JavaScript_Review" name="JavaScript_Review">Revisió de JavaScript</h2> + +<p>Si no us sentiu segurs amb els conceptes de Javascript com ara variables, tipus, funcions, i àmbits podeu llegir sobre aquests temes en <a href="/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript">Una reintroducció a JavaScript</a>. També podeu consultar la <a href="/en-US/docs/Web/JavaScript/Guide">Guia de JavaScript</a>.</p> + +<h2 id="Object-oriented_programming" name="Object-oriented_programming">Programació orientada a Objectes</h2> + +<p>La programació orientada a Objectes és un paradigma de programació que usa l'abstracció per crear models basants en el món real. Fa servir diverseses tècniques de paradigmes previament establerts, inclosa la modularitat, poliformisme, i l'encapsulament. Avui, moltes llengües de programació (com Java, JavaScript, C#, C++, Python, PHP, Ruby i Objective-C) suporten la programació orientada a Objectes (POO).</p> + +<p>La programació orientada a Objectes es pot entendre com el disseny de software fent servir una col·lecció d'objectes que cooperen, al contrari de la visió tradicional en el qual un programa es vist com una col·lecció de funcions, o simplement com una llista d'instruccions per a un ordinador. En POO, cada objecte és capaç de rebre missatges, processar data, i enviar missatges a altres objectes. Cada objecte pot ser entès com una petita màquina independent amb un rol diferent o amb responsabilitat.</p> + +<p>La programació orientada a Objectes intenta promoure una major flexibilitat, mantenibilitat en programació, i és àmpliament popular en enginyeria de software a gran esala. En virtut de la seva forta èmfasi en modularitat, el codi orientat a objecte intenta ser més simple de desenvolupar i més facil d'entendre després, es presta a una anàlisi més directa, codificació, i comprensió de situacions complexes i procediments en comptes d'altres mètodes de programació menys modulars.<a href="#cite-1"><sup>1</sup></a></p> + +<h2 id="Terminology" name="Terminology">Terminologia</h2> + +<dl> + <dt>{{Glossary("Namespace")}}</dt> + <dd>Un contenidor que permet als desenvolupadors agrupar totes les funcionalitats sota un nom únic d'aplicació específica.</dd> + <dt>{{Glossary("Class")}}</dt> + <dd>Defineix les característiques de l'objecte. És la definició d'una plantilla de variables i mètodes d'un objecte.</dd> + <dt>{{Glossary("Object")}}</dt> + <dd>Una instància d'una classe.</dd> + <dt>{{Glossary("Property")}}</dt> + <dd>Una característca d'un objecte, com ara un color.</dd> + <dt>{{Glossary("Method")}}</dt> + <dd>Una capacitat d'un objecte, com ara caminar. És una subrutina o funció associada amb una classe.</dd> + <dt>{{Glossary("Constructor")}}</dt> + <dd>Un mètode que es crida en el moment d'instanciació d'un objecte. Normalment té el mateix nom que el de la classe que el conté.</dd> + <dt>{{Glossary("Inheritance")}}</dt> + <dd>Una classe pot heretar les característiques d'una altra classe.</dd> + <dt>{{Glossary("Encapsulation")}}</dt> + <dd>Una manera d'agrupar les dades i mètodes que es fan servir juntes.</dd> + <dt>{{Glossary("Abstraction")}}</dt> + <dd>La conjunció d'una herència complexa, mètodes, les propietats d'un objecte, han de ser capaces de simular una realitat a modelar.</dd> + <dt>{{Glossary("Polymorphism")}}</dt> + <dd>Poli significa "<em>molts</em>" i morfisme significa "<em>formes</em>". Classes diferents poden definir el mateix mètode o propietat.</dd> +</dl> + +<p>Per una descripció més extensa sobre la programació orientada a objectes vegeu {interwiki("wikipedia", "Object-oriented programming")}} a la Viquipèdia.</p> + +<h2 id="Programació_basada_en_prototipus">Programació basada en prototipus</h2> + +<p>Programació basat en prototipus és un estil de programació orientada a objectes que no fa ús de les classes. En el seu lloc, la reutilització del comportament (conegut com a herència en llenguatges basats en classes) es porta a terme a través d'un procés de decoració (o d'ampliació) on els objectes que ja existeixen serveixen com a prototipus. Aquest model també és conegut com a model sense classes, orientat a prototip, o programació basadad en instàncies.</p> + +<p>L'exemple original (i més canònic) d'un llenguatge basat en prototipus és el llenguatge de programació {{interwiki("wikipedia", "Self (programming language)", "Self")}} desenvolupat per David Ungar i Randall Smith. Tanmateix, l'estil de programació sense classes s'ha anat fent més i més popular, i ha sigut adoptat per llenguatges de programació com JavaScript, Cecil, NewtonScript, Io, MOO, REBOL, Kevo, Squeak (quan s'utilitza el marc Viewer per manipular components Morphic), i altres.<a href="#cite-1"><sup>1</sup></a></p> + +<h2 id="JavaScript_Object_Oriented_Programming" name="JavaScript_Object_Oriented_Programming">Programació orientada a Objectes de JavaScript</h2> + +<h3 id="Namespace">Namespace</h3> + +<p>Un namespace és un contenidor el qual permet als desenvolupadors agrupar totes les funcionalitats sota un únic, nom d'aplicació específic. <strong>En JavaScript un namespace és només un altre objecte que conté mètodes, propietats, i objectes.</strong></p> + +<div class="note"> +<p><strong>Nota:</strong> Es important remarcar que en JavaScript, no hi ha diferèn<u>cia de nivell d'idioma entre els objectes regulars i els namespace</u>s. Això dista d'altres llenguatges orientats a objectes, i pot resultat confús als programadors nous en JavaScript.</p> +</div> + +<p>La idea darrera la creació d'un namespace en JavaScript és simple: Un objecte global és creat i totes les variables, metòdes, i funcions es converteixen en propietats d'aquest objecte.<u> L'ús de namespaces també minimitza la possibilitat de conflictes de noms en l'aplicació, ja que cada objecte d'aplicació son propietats d'un objecte global d'aplicació definit</u>.</p> + +<p>Creem un objecte global anomenat MYAPP:</p> + +<pre class="brush: js">// global namespace +var MYAPP = MYAPP || {};</pre> + +<p>En el codi de mostra superior, primer hem comprovat si MYAPP ja està definit (ja sigui en el mateix arxiu o en un altre arxiu). En cas de ser així, s'usa l'objecte global MYAPP existent, del contrari es crea un objecte buit anomenat MYAPP el qual encapsula el mètode, funcions, variables, i objectes.</p> + +<p>També podem crear sub-namespaces:</p> + +<pre class="brush: js">// sub namespace +MYAPP.event = {};</pre> + +<p>Abaix es troba la sintaxi de codi per crear un namespace i afegir variables, funcions, i un mètode:</p> + +<pre class="brush: js">// Create container called MYAPP.commonMethod for common method and properties +MYAPP.commonMethod = { + regExForName: "", // define regex for name validation + regExForPhone: "", // define regex for phone no validation + validateName: function(name){ + // Do something with name, you can access regExForName variable + // using "this.regExForName" + }, + + validatePhoneNo: function(phoneNo){ + // do something with phone number + } +} + +// Object together with the method declarations +MYAPP.event = { + addListener: function(el, type, fn) { + // code stuff + }, + removeListener: function(el, type, fn) { + // code stuff + }, + getEvent: function(e) { + // code stuff + } + + // Can add another method and properties +} + +// Syntax for Using addListener method: +MYAPP.event.addListener("yourel", "type", callback);</pre> + +<h3 id="Core_Objects" name="Core_Objects">Objectes estàndards integrats</h3> + +<p>JavaScript té alguns objectes inclosos en el seu nucli, per exemple, trobem objectes come Math, Object, Array, i String. L'exemple d'abaix ens mostra com fer servir l'objecte Math per aconseguir números aleatoris usant el seu mètode <code>random()</code>.</p> + +<pre class="brush: js">console.log(Math.random()); +</pre> + +<div class="note"><strong>Nota:</strong> Aquest i tots els exemples següents suposen que la funció anomenada {{domxref("console.log()")}} es defineix globalment. De fet, la funció <code>console.log()</code> no és part del llenguatge de JavaScript en si, però molts navegadors ho implementen per tal d'ajudar en la depuració.</div> + +<p>Vegeu <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects" title="en-US/docs/Web/JavaScript/Reference/Global_Objects">Referència de JavaScript: Objectes estàndards integrats</a> per una llista d'objectes cor en JavaScript.</p> + +<p>Cada objecte en JavaScript és una instància de l'objecte <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object"><code>Object</code></a> i per tant, n'hereda totes les seves propietats i mètodes.</p> + +<h3 id="Custom_Objects" name="Custom_Objects">Objectes personalitzats</h3> + +<h4 id="The_Class" name="The_Class">La classe</h4> + +<p>JavaScript és un llenguatge basat en prototipus que no conté<u> cap <code>class</code> statement, </u>el qual si que es pot trobar en C++ o Java. Això és confós a vegades per a programadors acostumats a llenguatges amb el <u><code>class</code> statement.</u> En el seu lloc, JavaScript fa servir funcions com a classes. Definir duna classe és tan fàcil com definir una funció. En l'exemple d'abaix definim una nova classe anomenada Person.</p> + +<pre class="brush: js">var Person = function () {}; +</pre> + +<h4 id="The_Object_.28Class_Instance.29" name="The_Object_.28Class_Instance.29">L'objecte (instància de classe)</h4> + +<p>Per crear una nova instància d'un objecte <code>obj</code> fem servir la declaració <code>new obj</code>, assignant el resultat (el qual és de tipus <code>obj</code>) a una variable per accedir-hi més tard. <span style="font-size: 14px; line-height: 1.5;">Una forma alternativa de crear una nova instància és fent servir {{jsxref("Object.create()")}}. Aquesta crearà una instància This will create an <u>uninititalized instance.</u></span></p> + +<p>En l'exemple d'adalt definim una classe anomenada <code>Person</code>. En l'exemple següent creem dues instàncies (<code>person1</code> i <code>person2</code>).</p> + +<pre class="brush: js">var person1 = new Person(); +var person2 = new Person(); +</pre> + +<div class="note"><strong>Nota:</strong> Siusplau vegeu {{jsxref("Object.create()")}} per un mètode instantacional nou, addiccional new, additional, instantiation mètode.</div> + +<h4 id="The_Constructor" name="The_Constructor">El constructor</h4> + +<p>El constructor és cridat en el moment de la instantiation (el moment en que la instància de l'objecte és creat). El constructor és ún mètode de la classe. En JavaScript la funció serveix com el constructor de l'objecte, therefore there is no need to explicitly define a constructor method. Every action declared in the class gets executed at the time of instantiation.</p> + +<p>El constructor es fa servir per establir les propietats de l'objecte o per cridar mè call methods to prepare the object for use. Per afegir mètodes de classes i les seves definicions es necessita una sintaxi diferent que s'explicarà més tard en aquest article.</p> + +<p>En l'exemple d'abaix, el constructor de la classe <code>Person</code> mostra un missatge quan és crea una instànca <code>Person</code>.</p> + +<pre class="brush: js">var Person = function () { + console.log('instance created'); +}; + +var person1 = new Person(); +var person2 = new Person(); +</pre> + +<h4 id="The_Property_.28object_attribute.29" name="The_Property_.28object_attribute.29">La propietat (atribut de l'objecte)</h4> + +<p>Les propietats són variables contingudes en la classe; cada instància de l'objecte té aquestes propietats. Les propietats són asssignades en el constructor (funció) de la classe de forma que es creen en cada instància.</p> + +<p>Per treballar amb propietats de dins de la classe s'utilitza la paraula clau <code>this</code>, que fa referència a l'objecte actual. Accedir (llegir o escriure) a una propietat fora d'aquesta classe es fa mitjançant la sintaxi: <code>InstanceName.Property</code>; Aquesta és la mateixa sintaxi que es fa servir en C++, Java, i numeroses altres llengües. (Dins la classe, la sintaxi <code>this.Property</code> s'utilitza per obtindre o escriure el valor de les propietats.)</p> + +<p>En l'exemple següent definim la propietat <code>firstName</code> property per la classe <code>Person</code> i ho definim com a instanciació.</p> + +<pre class="brush: js">var Person = function (firstName) { + this.firstName = firstName; + console.log('Person instantiated'); +}; + +var person1 = new Person('Alice'); +var person2 = new Person('Bob'); + +// Show the firstName properties of the objects +console.log('person1 is ' + person1.firstName); // logs "person1 is Alice" +console.log('person2 is ' + person2.firstName); // logs "person2 is Bob" +</pre> + +<h4 id="The_methods" name="The_methods">Els mètodes</h4> + +<p>Els mètodes segueixen la mateixa llògica que les propietats; la diferència es que són funcions i estan definides com a funcions. Cridar un mètode és similar a accedir a una propietat, però s'afegeix <code>()</code> al final the nom del mètode, possiblement amb arguments. Per definir un mètode, s'assigna una funció a una propietat amb nom de la propietat de la classe <code>prototype</code>; el nom que s'assigna a la funció és el mateix que el nom que té el mètode en l'objecte.</p> + +<p>En l'exemple següent definim i usem el mètode <code>sayHello()</code> per la classe <code>Person</code>.</p> + +<pre class="brush: js">var Person = function (firstName) { + this.firstName = firstName; +}; + +Person.prototype.sayHello = function() { + console.log("Hello, I'm " + this.firstName); +}; + +var person1 = new Person("Alice"); +var person2 = new Person("Bob"); + +// call the Person sayHello method. +person1.sayHello(); // logs "Hello, I'm Alice" +person2.sayHello(); // logs "Hello, I'm Bob" +</pre> + +<p>En JavaScript els mètodes són funcions normals dels objectes que són lligats a un objecte com una propietat, El que vol dir que poden ser invocats "fora del context". Vegeu el codi d'exemple següent:</p> + +<pre class="brush: js">var Person = function (firstName) { + this.firstName = firstName; +}; + +Person.prototype.sayHello = function() { + console.log("Hello, I'm " + this.firstName); +}; + +var person1 = new Person("Alice"); +var person2 = new Person("Bob"); +var helloFunction = person1.sayHello; + +// logs "Hello, I'm Alice" +person1.sayHello(); + +// logs "Hello, I'm Bob" +person2.sayHello(); + +// logs "Hello, I'm undefined" (or fails +// with a TypeError in strict mode) +helloFunction(); + +// logs true +console.log(helloFunction === person1.sayHello); + +// logs true +console.log(helloFunction === Person.prototype.sayHello); + +// logs "Hello, I'm Alice" +helloFunction.call(person1);</pre> + +<p>Com l'exemple mostra, totes les referències a la funció <code>sayHello</code> — les que existeixen a <code>person1</code>, a <code>Person.prototype</code>, a la variable <code>helloFunction</code>, etc. — fan referència a la <em>mateixa funció</em>. El valor de <code>this</code> durant una crida a la funció depen en com es crida. En el cas comú en que es crida la funció des d'una propietat de l'objecte — <code>person1.sayHello()</code> — <code>this</code> rep el valor de l'objecte d'on prové la propietat (<code>person1</code>), és per això que <code>person1.sayHello()</code> fa servir el nom "Alice" i <code>person2.sayHello()</code> fa servir el nom "Bob". Però si ho cridem d'altres maneres, <code>this</code> rebrà un valor diferent: Cridar-la des d'una variable — <code>helloFunction()</code> — <code>this</code> rep el valor de l'objecte global (<code>window</code>, en navegadors). Al no tenir la propietat <code>firstName aquest </code>objecte (probablement) , acabem amb el resultat "Hello, I'm undefined". (Això és en el mode no estricte; en el <a href="/en-US/docs/Web/JavaScript/Reference/Strict_mode" title="/en/docs/Web/JavaScript/Reference/Functions_and_function_scope/Strict_mode">mode estricte </a>seria diferent [un error], però per evitar confussions no entrarem aquí en detall.) O podem assignar explícitament el valor de <code>this</code> mitjançant <code>Function#call</code> (o <code>Function#apply</code>), com es mostra al final de l'exemple.</p> + +<div class="note"><strong>Nota:</strong> Vegeu més sobre <code>this</code> a <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/call" title="https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Function/call">Function#call</a> i <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/apply" title="https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Function/apply">Function#apply</a></div> + +<h4 id="Inheritance" name="Inheritance">L'herència</h4> + +<p>L'herència és una manera de crear una classe com una versió especialitzada d'una o més classes (<em>JavaScript només suporta l'herència única</em>). La classe especialitzada és communment anomenada el <em>fill</em>, i l'altra classe es comunment anomenada el <em>pare</em>. En JavaScript això s'aconsegueix mitjançant l'assignació d'una instància de la classe pare a la classe fill, i després s'especialitza. En navegadors moderns també es pot usar <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/create#Classical_inheritance_with_Object.create" title="/en-US/docs/JavaScript/Reference/Global_Objects/Object/create#Classical_inheritance_with_Object.create">Object.create</a> per implementar herències.</p> + +<div class="note"> +<p><strong>Nota:</strong> JavaScript does no detecta la classe fill <code>prototype.constructor</code> (vegeu <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/prototype">Object.prototype</a>), així que ho hem de declarar manualment.</p> +</div> + +<p>En l'exemple d'abaix, definim la classe <code>Student</code> com una classe fill de <code>Person</code>. Després redefinim el mètode <code>sayHello()</code> i afegim el mètode <code>sayGoodBye()</code>.</p> + +<pre class="brush: js">// Define the Person constructor +var Person = function(firstName) { + this.firstName = firstName; +}; + +// Add a couple of methods to Person.prototype +Person.prototype.walk = function(){ + console.log("I am walking!"); +}; + +Person.prototype.sayHello = function(){ + console.log("Hello, I'm " + this.firstName); +}; + +// Define the Student constructor +function Student(firstName, subject) { + // Call the parent constructor, making sure (using Function#call) + // that "this" is set correctly during the call + Person.call(this, firstName); + + // Initialize our Student-specific properties + this.subject = subject; +}; + +// Create a Student.prototype object that inherits from Person.prototype. +// Note: A common error here is to use "new Person()" to create the +// Student.prototype. That's incorrect for several reasons, not least +// that we don't have anything to give Person for the "firstName" +// argument. The correct place to call Person is above, where we call +// it from Student. +Student.prototype = Object.create(Person.prototype); // See note below + +// Set the "constructor" property to refer to Student +Student.prototype.constructor = Student; + +// Replace the "sayHello" method +Student.prototype.sayHello = function(){ + console.log("Hello, I'm " + this.firstName + ". I'm studying " + + this.subject + "."); +}; + +// Add a "sayGoodBye" method +Student.prototype.sayGoodBye = function(){ + console.log("Goodbye!"); +}; + +// Example usage: +var student1 = new Student("Janet", "Applied Physics"); +student1.sayHello(); // "Hello, I'm Janet. I'm studying Applied Physics." +student1.walk(); // "I am walking!" +student1.sayGoodBye(); // "Goodbye!" + +// Check that instanceof works correctly +console.log(student1 instanceof Person); // true +console.log(student1 instanceof Student); // true +</pre> + +<p>Pel que fa a la línia <code>Student.prototype = Object.create(Person.prototype)</code>: En els motors de Javascript més antics sense <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/create" title="Object.create"><code>Object.create</code></a>, es pot utilitzar tant un "polyfill" (també conegut com a "falca", vegeu l'article enllaçat), o fer servir una funció que aconegueixi assolir el mateix resultat, tal com:</p> + +<pre class="brush: js">function createObject(proto) { + function ctor() { } + ctor.prototype = proto; + return new ctor(); +} + +// Usage: +Student.prototype = createObject(Person.prototype); +</pre> + +<div class="note"><strong>Nota:</strong> Vegeu <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/create" title="Object.create">Object.create</a> per més informació sobre el que fa, i una falca per a motors més vells.</div> + +<h4 id="Encapsulation" name="Encapsulation">L'encapsulació</h4> + +<p>En l'exemple anterior, <code>Student</code> no necessita saber com el mètode <code>Person</code> class's <code>walk()</code> és implementat, però tot i així pot fer-lo servir com a mètode; la classe <code>Student</code>no necessita definir explícitament aquest mètode a no ser que ho volguem canviar. D'això se'n diu <strong>encapsulació</strong>, per la qual cada classe empaqueta data i mètodes en una sola unitat.</p> + +<p>L'ocultació d'informació és una característica comuna en altres llenguatges sovint com a mètodes/propietats privats i protegits. Tot i que es podria simular alguna cosa com aquesta en JavaScript, no és un requeriment per fer programació orientada a objectes.<a href="#cite-2"><sup>2</sup></a></p> + +<h4 id="Abstraction" name="Abstraction">L'abstracció</h4> + +<p>L'abstracció és un mecanisme que permet modelar la part que ens ocupa del problema en el qual estem treballant. Això es pot aconseguir per mitjar de l'herència (especialització), o composició. JavaScript aconsegueix l'especialització per mitjà de l'herència, i la composició per mitjà de deixar a les instàncies de classes ser valors d'atributs d'altres objectes.</p> + +<p>La classe Function de JavaScript hereta de la classe Object (això demostra la especialització del model) i la propietat Function.prototype property és una instància d'Object (Això demostra composició).</p> + +<pre class="brush: js">var foo = function () {}; + +// logs "foo is a Function: true" +console.log('foo is a Function: ' + (foo instanceof Function)); + +// logs "foo.prototype is an Object: true" +console.log('foo.prototype is an Object: ' + (foo.prototype instanceof Object));</pre> + +<h4 id="Polymorphism" name="Polymorphism">El polimorfisme</h4> + +<p>Tal i com tots els mètodes i propietats són definides dins la propietat Prototype, classes diferents poden definir mètodes amb el mateix nom; els mètodes estan en l'àmbit de la classe en la qual estan definits. Això només és cert quan les dues classes no tenen una relació pare-fill (quan un no hereta de l'altre en una cadena d'herència).</p> + +<h2 id="Notes" name="Notes">Notes</h2> + +<p>Les tècniques presentades en aquesta article per implementar programació orientada a objectes no són les úniques que es poden fer servir en JavaScript, que és molt flexible en termes de com es pot realitzar la programació orientada a objectes.</p> + +<p>De la mateixa manera, les tècniques que s'han mostrat aquí no utilitzen cap <em>hack</em> del llenguatge, ni imiten cap implementació de teories d'objectes d'altres llenguatges.</p> + +<p>Hi ha altres tècniques que proporcionen programació orientada a objectes més avançada en JavaScript, però aquests estan fora de l'abast d'aquest article introductori.</p> + +<h2 id="References" name="References">Referències</h2> + +<ol> + <li><a name="cite-1"></a>Viquipèdia. "<a href="http://ca.wikipedia.org/wiki/Programaci%C3%B3_orientada_a_objectes">Programació orientada a Objectes</a>"</li> + <li><a name="cite-2"></a>Viquipèdia. "<a href="http://ca.wikipedia.org/wiki/Encapsulaci%C3%B3">Encapsulació (programació orientada a Objectes)</a>"</li> +</ol> diff --git a/files/ca/web/javascript/language_resources/index.html b/files/ca/web/javascript/language_resources/index.html new file mode 100644 index 0000000000..843ee185e4 --- /dev/null +++ b/files/ca/web/javascript/language_resources/index.html @@ -0,0 +1,98 @@ +--- +title: Recursos pel llenguatge JavaScript +slug: Web/JavaScript/Language_Resources +translation_of: Web/JavaScript/Language_Resources +--- +<div>{{JsSidebar()}}</div> + +<p><strong>ECMAScript</strong> és el llenguatge que forma el nucli de <a href="/en-US/docs/JavaScript">JavaScript</a>. ECMAScript és un standard definit per la organització d'standards <a href="http://www.ecma-international.org/" title="http://www.ecma-international.org/">Ecma International</a> sota les <strong>especificacions ECMA-262 i ECMA-402.</strong> Els següents standards de ECMAScript han sigut aprovats:</p> + +<table class="standard-table"> + <tbody> + <tr> + <th>Nom</th> + <th>Enllaços</th> + <th>Data</th> + <th>Descripció</th> + </tr> + <tr> + <td>ECMA-262 Edició 5.1</td> + <td><a href="http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-262.pdf">PDF</a>, <a href="http://www.ecma-international.org/ecma-262/5.1/">HTML</a></td> + <td>Juny 2011</td> + <td> + <p>ECMAScript 5.1, l'última revisió publicada de la Especificació del Llenguatge.</p> + + <p>Aquesta versió està en sincronia amb la 3a edició de l'standard internacional <a href="http://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=55755">ISO/IEC 16262:2011</a>.<br> + Inclou esmenes a errades al ES5, però cap característica adicional.</p> + </td> + </tr> + <tr> + <td>ECMA-402</td> + <td><a href="http://ecma-international.org/ecma-402/1.0/ECMA-402.pdf">PDF</a>, <a href="http://ecma-international.org/ecma-402/1.0/index.html">HTML</a></td> + <td>Desembre 2012</td> + <td>API d'internacionalització de l'ECMAScript.</td> + </tr> + <tr> + <td>ECMA-357 Edició 2</td> + <td><a href="http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-357.pdf">PDF</a></td> + <td>Desembre 2005</td> + <td><a href="/en-US/docs/E4X" title="E4X">ECMAScript for XML (E4X)</a>.</td> + </tr> + <tr> + <th colspan="4">Edicions obsoletes</th> + </tr> + <tr> + <td>ECMA-262</td> + <td><a href="http://www.ecma-international.org/publications/files/ECMA-ST-ARCH/ECMA-262,%201st%20edition,%20June%201997.pdf">PDF</a></td> + <td>Juny 1997</td> + <td>L'standard original d'ECMAScript.</td> + </tr> + <tr> + <td>ECMA-262 Edició 2</td> + <td><a href="http://www.ecma-international.org/publications/files/ECMA-ST-ARCH/ECMA-262,%202nd%20edition,%20August%201998.pdf">PDF</a></td> + <td>Agost 1998</td> + <td>La segona revisió de l'standard ECMAScript; també conegut com a standard ISO 16262.</td> + </tr> + <tr> + <td>ECMA-262 Edició 3</td> + <td><a href="http://www.ecma-international.org/publications/files/ECMA-ST-ARCH/ECMA-262,%203rd%20edition,%20December%201999.pdf">PDF</a></td> + <td>Desembre 1999</td> + <td>La tercera revisió de l'standard ECMAScript; es correspon a la versió 1.5 de JavaScript.<br> + Vegeu també la <a href="http://www.mozilla.org/js/language/E262-3-errata.html">fe d'errades</a>.</td> + </tr> + <tr> + <td>ECMA-262 Edició 5</td> + <td><a href="http://www.ecma-international.org/publications/files/ECMA-ST-ARCH/ECMA-262%205th%20edition%20December%202009.pdf">PDF</a></td> + <td>Desembre 2009</td> + <td>ECMAScript 5<br> + Vegeu també <a href="http://wiki.ecmascript.org/doku.php?id=es3.1:es3.1_proposal_working_draft">fe d'errades del ES5</a> i el <a href="/en-US/docs/JavaScript/ECMAScript_5_support_in_Mozilla" title="JavaScript/ECMAScript 5 support in Mozilla">suport a ECMAScript 5 a Mozilla</a></td> + </tr> + <tr> + <td>ECMA-357</td> + <td><a href="http://www.ecma-international.org/publications/files/ECMA-ST-WITHDRAWN/ECMA-357,%201st%20edition,%20June%202004.pdf">PDF</a></td> + <td>June 2004</td> + <td><a href="/en-US/docs/E4X" title="E4X">ECMAScript per a XML (E4X)</a>.<br> + Vegeu també la <a class="link-https" href="https://bugzilla.mozilla.org/attachment.cgi?id=169406">fe d'errades E4X</a>.</td> + </tr> + </tbody> +</table> + +<p>Vegeu la <a href="http://en.wikipedia.org/wiki/ECMAScript" title="http://en.wikipedia.org/wiki/ECMAScript">entrada d'ECMAScript a la viquipèdia</a> per a més informació sobre la història de l'ECMAScript.</p> + +<p>Es pot participar o simplement seguir el treball realitzat a les properes revisions de l'especificació del llenguatge ECMAScript, la qual rep el nom clau de "Harmony", així com la Especificació de la API d'internacionalització de ECMAScript mitjançant la wiki pública i la <a class="link-https" href="https://mail.mozilla.org/listinfo/es-discuss" title="https://mail.mozilla.org/listinfo/es-discuss">llista de correu es-discuss</a> que es poden trobar enllaçades des de <a href="http://www.ecmascript.org/community.php" title="http://www.ecmascript.org/community.php">ecmascript.org</a>.</p> + +<h2 id="Implementacions">Implementacions</h2> + +<ul> + <li><a href="/en-US/docs/SpiderMonkey" title="SpiderMonkey">SpiderMonkey</a> - el motor de JavaScript utilitzat per Firefox;</li> + <li><a href="/en-US/docs/Rhino" title="Rhino">Rhino</a> - un motor de JavaScript escrit en Java;</li> + <li><a href="/en-US/docs/Tamarin" title="Tamarin">Tamarin</a> - la màquina virtual de ActionScript (utilitzat per l'Adobe® Flash® Player);</li> + <li><a href="http://en.wikipedia.org/wiki/List_of_ECMAScript_engines" title="http://en.wikipedia.org/wiki/List_of_ECMAScript_engines">Altres implementacions</a> (viquipèdia).</li> +</ul> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li><a href="http://brendaneich.com/" title="http://brendaneich.com/">El bloc de Brendan Eich</a>. Brendan és el creador de JavaScript i el motor SpiderMonkey. Encara treballa amb el grup de treball de ECMA per a millorar el llenguatge.</li> + <li><a href="http://dmitrysoshnikov.com/" title="http://dmitrysoshnikov.com/">L'anàlisi de les edicions 3 i 5 de ECMA-262 de Dmitry Soshnikov</a></li> +</ul> diff --git a/files/ca/web/javascript/quant_a_javascript/index.html b/files/ca/web/javascript/quant_a_javascript/index.html new file mode 100644 index 0000000000..f581aa7021 --- /dev/null +++ b/files/ca/web/javascript/quant_a_javascript/index.html @@ -0,0 +1,55 @@ +--- +title: Sobre JavaScript +slug: Web/JavaScript/quant_a_JavaScript +translation_of: Web/JavaScript/About_JavaScript +--- +<div>{{JsSidebar()}}</div> + +<h2 id="What_is_JavaScript.3F" name="What_is_JavaScript.3F">Què és JavaScript?</h2> + +<p><span class="external">JavaScript</span><sup>®</sup> és el llenguatge de tipus scripting orientat a objectes desenvolupat per Netscape, utilitzat en millions de pàgines web i aplicacions de servidor arreu del món. El JavaScript de Netscape extén el llenguatge de scripting standard definit a l'ECMA-262 Edició 3 (<a href="/en-US/docs/Web/JavaScript/Language_Resources" title="en-US/docs/ECMAScript">ECMAScript</a>), amb només lleus diferències de l'standard publicat.</p> + +<p>Al contrari del que popular ment es creu de forma errònia, JavaScript no és "Java interpretat". En resum, JavaScript és un llegunatge d'scripting dinàmic que suporta contrucció d'objectes <a href="/ca/docs/Web/JavaScript/Guide/Details_of_the_Object_Model#Class-Based_vs._Prototype-Based_Languages">basada en prototipus</a>. La sintaxi bàsica és similar a Java i C++ de forma intencionada per a reduir el nombre de conceptes nous requerits per a aprendre el llenguatge. Construccions del llenguatge, com ara sentències <code>if</code>, bucles <code>for</code> i <code>while</code>, blocs <code>switch</code> i <code>try ... catch</code> funcionen de la mateixa forma que en aquests llenguatges (o bé d'una forma molt semblant).</p> + +<p>JavaScript pot funcionar com un llenguatge tant <a href="http://en.wikipedia.org/wiki/Procedural_programming">procedural</a> com <a href="/ca/docs/Web/JavaScript/Introduction_to_Object-Oriented_JavaScript">orientat a objectes</a>. Els objectes es creen de forma programàtica en JavaScript tot afegint-hi mètodes i propietats a objectes <strong>en temps d'execució</strong> que d'altra forma serien buits, contràriament a les definicions sintàctiques de classes tan comunes a llenguatges compilats com C++ i Java. Un cop construit un objecte aquest pot ser utilitzat com a motlle (o prototipus) per a crear objectes similars.</p> + +<p>Les capacitats dinàmiques de JavaScript inclouen construcció d'objectes en temps d'execució, llistats de paràmetres variables, funcions com a variables, creació dinàmica de scripts (via <code><a href="/ca/docs/Web/JavaScript/Reference/Global_Objects/eval">eval</a></code>), introspecció d'objectes (via <code>for ... in</code>) i recuperació del codi font (els programes escrits en JavaScript poden decompilar els cosos de funcions a la seva forma original de codi font).</p> + +<p>Els objectes intrínsecs són <code>Number</code>, <code>String</code>, <code>Boolean</code>, <code>Date</code>, <code>RegExp</code>, i <code>Math</code>.</p> + +<p>Per a una discussió més profunda de la programació en JavaScript seguiu els enllaços de <a href="#JavaScript_resources">recursos de JavaScript</a> que trobareu a sota.</p> + +<h2 id="What_JavaScript_implementations_are_available.3F" name="What_JavaScript_implementations_are_available.3F">Quines implementacions de JavaScript hi ha disponibles?</h2> + +<p>mozilla.org alberga dues implementacions de JavaScript. La primera implementació de JavaScript <strong>de tots els temps</strong> va ser creada per Brendan Eich a Netscape, i des de llavors ha sigut actualitzada per a compliar amb la ECMA-262 Edició 5 i versions posteriors. Aquest motor, anomenat <a href="/ca/docs/Mozilla/Projects/SpiderMonkey">SpiderMonkey</a>, està implementat en C. El motor <a href="/ca/docs/Rhino">Rhino</a>, creat principalment per Norris Boyd (també a Netscape) és una implementació JavaScript en Java. Com el SpiderMonkey, Rhino compleix amb ECMA-262 Edició 3.</p> + +<p>Al llarg del temps s'han anat afegint diverses optimitzacions al motor de JavaScript SpiderMonkey, com ara TraceMonkey (Firefox 3.5), JägerMonkey (Firefox 4) i IonMonkey.</p> + +<p>A més de les implementacions anomenades a dalt, existeixen altres motors JavaScript, com ara:</p> + +<ul> + <li>El <a class="external" href="http://code.google.com/p/v8/" title="http://code.google.com/p/v8/">V8</a> de Google, utilitzat al navegador Google Chrome i a les versions més recents del navegador Opera.</li> + <li>El <a class="external" href="http://www.webkit.org/projects/javascript/index.html" title="http://www.webkit.org/projects/javascript/index.html">JavaScriptCore</a> (SquirrelFish/Nitro), utilitzat a alguns navegadors basats en WebKit, com ara l'Apple Safari.</li> + <li>El <a class="external" href="http://my.opera.com/ODIN/blog/carakan-faq" title="http://my.opera.com/ODIN/blog/carakan-faq">Carakan</a>, utilitzats en versions antigues d'Opera.</li> + <li>El <a class="external" href="http://en.wikipedia.org/wiki/Chakra_%28JScript_engine%29" title="http://en.wikipedia.org/wiki/Chakra_%28JScript_engine%29">Chakra</a>, utilitzat en Internet Explorer (tot i que el llenguatge que implementa és anomenat formalment "JScript" per a evitar problemes amb marques registrades).</li> +</ul> + +<p>Tots els motors de JavaScript de mozilla.org exposen una API pública que les aplicacions poden emprar per a saber sobre el suport de JavaScript. L'entorn més comú per a JavaScript són els navegadors web, amb diferència. Els navegadors web usualment utilitzen una API pública per a crear 'objectes host' responsables d'exposar el <a href="http://www.w3.org/DOM/">DOM</a> dins de JavaScript.</p> + +<p>Una altra aplicació comuna de JavaScript és com a llenguatge d'escripting al cantó del servidor (web). Un servidor web de JavaScript exposaria els objectes host que representen peticions HTTP i objectes resposta, que podrien llavors ser manipulats per un programa JavaScript per a generar pàgines web de forma dinàmica.</p> + +<h2 id="JavaScript_resources" name="JavaScript_resources">Recursos de JavaScript</h2> + +<dl> + <dt><a href="/en-US/docs/Mozilla/Projects/SpiderMonkey" title="en-US/docs/SpiderMonkey">SpiderMonkey</a></dt> + <dd>Informació específica per a incrustar el motor JavaScript escrit en C (també conegut com a SpiderMonkey).</dd> +</dl> + +<dl> + <dt><a href="/en-US/docs/Rhino" title="en-US/docs/Rhino">Rhino</a></dt> + <dd>Informació específica sobre la implementació de JavaScript escrita en Java (també coneguda com a Rhino).</dd> + <dt><a href="/en-US/docs/Web/JavaScript/Language_Resources" title="en-US/docs/JavaScript_Language_Resources">Recursos del llenguatge</a></dt> + <dd>Recull dels standards de JavaScript publicats.</dd> + <dt><a href="/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript" title="en-US/docs/A_re-introduction_to_JavaScript">Una re-introducció a JavaScript</a></dt> + <dd><a href="/en-US/docs/Web/JavaScript/Guide" title="en-US/docs/JavaScript/Guide">Guia de JavaScript</a> i <a href="/en-US/docs/Web/JavaScript/Reference" title="en-US/docs/JavaScript/Reference">referència de JavaScript</a>.</dd> +</dl> diff --git a/files/ca/web/javascript/reference/errors/index.html b/files/ca/web/javascript/reference/errors/index.html new file mode 100644 index 0000000000..c295fccea6 --- /dev/null +++ b/files/ca/web/javascript/reference/errors/index.html @@ -0,0 +1,31 @@ +--- +title: JavaScript error reference +slug: Web/JavaScript/Reference/Errors +tags: + - Debugging + - Error + - Errors + - Exception + - JavaScript + - NeedsTranslation + - TopicStub + - exceptions +translation_of: Web/JavaScript/Reference/Errors +--- +<p>{{jsSidebar("Errors")}}</p> + +<p>Below, you'll find a list of errors which are thrown by JavaScript. These errors can be a helpful debugging aid, but the reported problem isn't always immediately clear. The pages below will provide additional details about these errors. Each error is an object based upon the {{jsxref("Error")}} object, and has a <code>name</code> and a <code>message</code>.</p> + +<p>Errors displayed in the Web console may include a link to the corresponding page below to help you quickly comprehend the problem in your code.</p> + +<h2 id="List_of_errors">List of errors</h2> + +<p>In this list, each page is listed by name (the type of error) and message (a more detailed human-readable error message). Together, these two properties provide a starting point toward understanding and resolving the error. For more information, follow the links below!</p> + +<p>{{ListSubPages("/en-US/docs/Web/JavaScript/Reference/Errors")}}</p> + +<h2 id="See_also">See also</h2> + +<ul> + <li><a href="/en-US/docs/Learn/JavaScript/First_steps/What_went_wrong">What went wrong? Troubleshooting JavaScript</a>: Beginner's introductory tutorial on fixing JavaScript errors.</li> +</ul> diff --git a/files/ca/web/javascript/reference/errors/nomes-lectura/index.html b/files/ca/web/javascript/reference/errors/nomes-lectura/index.html new file mode 100644 index 0000000000..30c70c40dd --- /dev/null +++ b/files/ca/web/javascript/reference/errors/nomes-lectura/index.html @@ -0,0 +1,78 @@ +--- +title: 'TipusError: "x" es només de lectura' +slug: Web/JavaScript/Reference/Errors/Nomes-Lectura +tags: + - Errors + - JavaScript + - TypeError +translation_of: Web/JavaScript/Reference/Errors/Read-only +--- +<div>{{jsSidebar("Errors")}}</div> + +<h2 id="Missatge">Missatge</h2> + +<pre class="syntaxbox">TipusError: "x" es només de lectura (Firefox) +TipusError: 0 es només de lectura (Firefox) +TipusError: No es pot fer l'assignació a la propietat 'x' de #<Object> que es només de lectura (Chrome) +TipusError: No es pot fer l'assignació a la propietat '0' de [object Array] (Chrome) +</pre> + +<h2 id="Tipus_d'error">Tipus d'error</h2> + +<p>{{jsxref("TypeError")}}</p> + +<h2 id="Qué_ha_anat_malament">Qué ha anat malament?</h2> + +<p>La variable global o propietat de l'objecte a la qual s'ha volgut fer l'assignació es només de lectura. (Tècnicament, es una <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty#Writable_attribute">propietat de no-escriptura</a>.)</p> + +<p>Aquest error succeeix només en <a href="/en-US/docs/Web/JavaScript/Reference/Strict_mode">codi en mode estricte</a>. En codi en mode no estricte, l'assignació es ignorada de manera silenciosa.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Casos_invàlids">Casos invàlids</h3> + +<p>Propietats de només lectura no son súper comuns, però es poden donar quan es fa servir {{jsxref("Object.defineProperty()")}} o {{jsxref("Object.freeze()")}}.</p> + +<pre class="brush: js example-bad">'use strict'; +var obj = Object.freeze({name: 'Elsa', score: 157}); +obj.score = 0; // TypeError + +'use strict'; +Object.defineProperty(this, 'LUNG_COUNT', {value: 2, writable: false}); +LUNG_COUNT = 3; // TypeError + +'use strict'; +var frozenArray = Object.freeze([0, 1, 2]); +frozenArray[0]++; // TypeError +</pre> + +<p>També hi ha unes poques propietats de només lectura en la construcció de JavaScript. Potser que hagis provat de redefinir una constant matemàtica.</p> + +<pre class="brush: js example-bad">'use strict'; +Math.PI = 4; // TypeError</pre> + +<p>Ho sentim, no pots fer això.</p> + +<p>La variable global <code>undefined</code> també es només de lectura, llavors no pots silenciar l'infame error "undefined no es una funció" fent això:</p> + +<pre class="brush: js example-bad">'use strict'; +undefined = function() {}; // TypeError: "undefined" es només de lectura +</pre> + +<h3 id="Valid_cases">Valid cases</h3> + +<pre class="brush: js example-good">'use strict'; +var obj = Object.freeze({name: 'Score', points: 157}); +obj = {name: obj.name, points: 0}; // reemplaçant-ho amb un nou objecte funciona + +'use strict'; +var LUNG_COUNT = 2; // Una `var` funciona, perque no es de només lectura +LUNG_COUNT = 3; // ok (anatòmicament potser, però poc probable) +</pre> + +<h2 id="See_also">See also</h2> + +<ul> + <li>{{jsxref("Object.defineProperty()")}}</li> + <li>{{jsxref("Object.freeze()")}}</li> +</ul> diff --git a/files/ca/web/javascript/reference/functions/arguments/caller/index.html b/files/ca/web/javascript/reference/functions/arguments/caller/index.html new file mode 100644 index 0000000000..b0a6afdf3e --- /dev/null +++ b/files/ca/web/javascript/reference/functions/arguments/caller/index.html @@ -0,0 +1,93 @@ +--- +title: arguments.caller +slug: Web/JavaScript/Reference/Functions/arguments/caller +translation_of: Archive/Web/JavaScript/arguments.caller +--- +<div>{{jsSidebar("Functions")}}</div> + +<p>La propietat obsoleta <strong><code>arguments.caller</code></strong> solia proporcionar la funció que invoca la funció que s'està executant en aquest moment. Aquesta propietat s'ha eleminitat i ja no funciona.</p> + +<h2 id="Descripció">Descripció</h2> + +<p>La propietat ja no és troba disponible, però encara es pot utilitzar {{jsxref("Function.caller")}}.</p> + +<pre class="brush: js">function whoCalled() { + if (whoCalled.caller == null) + console.log('I was called from the global scope.'); + else + console.log(whoCalled.caller + ' called me!'); +}</pre> + +<h2 id="Exemples">Exemples</h2> + +<p>El codi següent s'utilitzava per comprovar el valor de <code>arguments.caller</code> en una funció, però ja no funciona.</p> + +<pre class="brush: js">function whoCalled() { + if (arguments.caller == null) + console.log('I was called from the global scope.'); + else + console.log(arguments.caller + ' called me!'); +} +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<p>No forma part de cap estàndard. Implementat en JavaScript 1.1 i eliminat en {{bug(7224)}} a causa una potencial vulnerabilitat de seguretat.</p> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome per Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Function")}}</li> +</ul> diff --git a/files/ca/web/javascript/reference/functions/arguments/index.html b/files/ca/web/javascript/reference/functions/arguments/index.html new file mode 100644 index 0000000000..da5237bdf0 --- /dev/null +++ b/files/ca/web/javascript/reference/functions/arguments/index.html @@ -0,0 +1,211 @@ +--- +title: Arguments object +slug: Web/JavaScript/Reference/Functions/arguments +tags: + - Functions + - JavaScript + - NeedsTranslation + - TopicStub + - arguments +translation_of: Web/JavaScript/Reference/Functions/arguments +--- +<div> +<div>{{jsSidebar("Functions")}}</div> +</div> + +<p>The <strong><code>arguments</code></strong> object is an <code>Array</code>-like object corresponding to the arguments passed to a function.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">arguments</pre> + +<h2 id="Description">Description</h2> + +<p>The <code>arguments</code> object is a local variable available within all functions. <code>arguments</code> as a property of <code>Function</code> can no longer be used.</p> + +<p>You can refer to a function's arguments within the function by using the <code>arguments</code> object. This object contains an entry for each argument passed to the function, the first entry's index starting at 0. For example, if a function is passed three arguments, you can refer to the argument as follows:</p> + +<pre class="brush: js">arguments[0] +arguments[1] +arguments[2] +</pre> + +<p>The arguments can also be set:</p> + +<pre class="brush: js">arguments[1] = 'new value';</pre> + +<p>The <code>arguments</code> object is not an {{jsxref("Array")}}. It is similar to an <code>Array</code>, but does not have any <code>Array</code> properties except <code><a href="/en-US/docs/Web/JavaScript/Reference/Functions/arguments/length" title="JavaScript/Reference/Functions_and_function_scope/arguments/length">length</a></code>. For example, it does not have the <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/pop" title="JavaScript/Reference/Global_Objects/Array/pop">pop</a></code> method. However it can be converted to a real <code>Array</code>:</p> + +<pre class="brush: js">var args = Array.prototype.slice.call(arguments);</pre> + +<div class="warning"> +<p><strong>Important:</strong> You should not slice on arguments because it prevents optimizations in JavaScript engines (V8 for example). Instead, try constructing a new array by iterating through the arguments object. <a href="https://github.com/petkaantonov/bluebird/wiki/Optimization-killers#3-managing-arguments">More information</a>.</p> +</div> + +<p>If <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array#Array_generic_methods" title="https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array#Array_generic_methods">Array generics</a> are available, one can use the following instead:</p> + +<pre class="brush: js">var args = Array.slice(arguments);</pre> + +<p>The <code>arguments</code> object is available only within a function body. Attempting to access the <code>arguments</code> object outside a function declaration results in an error.</p> + +<p>You can use the <code>arguments</code> object if you call a function with more arguments than it is formally declared to accept. This technique is useful for functions that can be passed a variable number of arguments. You can use <code><a href="/en-US/docs/JavaScript/Reference/Functions_and_function_scope/arguments/length" title="JavaScript/Reference/Functions_and_function_scope/arguments/length">arguments.length</a></code> to determine the number of arguments passed to the function, and then process each argument by using the <code>arguments</code> object. (To determine the number of arguments declared when a function was defined, use the <code><a href="/en-US/docs/JavaScript/Reference/Global_Objects/Function/length" title="JavaScript/Reference/Global_Objects/Function/length">Function.length</a></code> property.)</p> + +<h2 id="Properties">Properties</h2> + +<dl> + <dt><code><a href="/en-US/docs/Web/JavaScript/Reference/Functions/arguments/callee" title="JavaScript/Reference/Functions_and_function_scope/arguments/callee">arguments.callee</a></code></dt> + <dd>Reference to the currently executing function.</dd> + <dt><code><a href="/en-US/docs/Web/JavaScript/Reference/Functions/arguments/caller" title="JavaScript/Reference/Functions_and_function_scope/arguments/caller">arguments.caller</a></code> {{ Obsolete_inline() }}</dt> + <dd>Reference to the function that invoked the currently executing function.</dd> + <dt><code><a href="/en-US/docs/Web/JavaScript/Reference/Functions/arguments/length" title="JavaScript/Reference/Functions_and_function_scope/arguments/length">arguments.length</a></code></dt> + <dd>Reference to the number of arguments passed to the function.</dd> +</dl> + +<h2 id="Examples">Examples</h2> + +<h3 id="Defining_a_function_that_concatenates_several_strings">Defining a function that concatenates several strings</h3> + +<p>This example defines a function that concatenates several strings. The only formal argument for the function is a string that specifies the characters that separate the items to concatenate. The function is defined as follows:</p> + +<pre class="brush:js">function myConcat(separator) { + var args = Array.prototype.slice.call(arguments, 1); + return args.join(separator); +}</pre> + +<p>You can pass any number of arguments to this function, and it creates a list using each argument as an item in the list.</p> + +<pre class="brush:js">// returns "red, orange, blue" +myConcat(", ", "red", "orange", "blue"); + +// returns "elephant; giraffe; lion; cheetah" +myConcat("; ", "elephant", "giraffe", "lion", "cheetah"); + +// returns "sage. basil. oregano. pepper. parsley" +myConcat(". ", "sage", "basil", "oregano", "pepper", "parsley");</pre> + +<h3 id="Defining_a_function_that_creates_HTML_lists">Defining a function that creates HTML lists</h3> + +<p>This example defines a function that creates a string containing HTML for a list. The only formal argument for the function is a string that is "<code>u</code>" if the list is to be unordered (bulleted), or "<code>o</code>" if the list is to be ordered (numbered). The function is defined as follows:</p> + +<pre class="brush:js">function list(type) { + var result = "<" + type + "l><li>"; + var args = Array.prototype.slice.call(arguments, 1); + result += args.join("</li><li>"); + result += "</li></" + type + "l>"; // end list + + return result; +}</pre> + +<p>You can pass any number of arguments to this function, and it adds each argument as an item to a list of the type indicated. For example:</p> + +<pre class="brush:js">var listHTML = list("u", "One", "Two", "Three"); + +/* listHTML is: + +"<ul><li>One</li><li>Two</li><li>Three</li></ul>" + +*/</pre> + +<h3 id="Rest_default_and_destructured_parameters">Rest, default and destructured parameters</h3> + +<p>The <code>arguments</code> object can be used in conjunction with <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/rest_parameters">rest parameters</a>, <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Default_parameters">default parameters</a> or <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment">destructured parameters</a>.</p> + +<pre class="brush: js">function foo(...args) { + return arguments; +} +foo(1, 2, 3); // { "0": 1, "1": 2, "2": 3 } +</pre> + +<p>However, in non-strict functions, a <strong>mapped <code>arguments</code> object</strong> is only provided if the function does <strong>not</strong> contain any <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/rest_parameters">rest parameters</a>, any <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Default_parameters">default parameters</a> or any <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment">destructured parameters</a>. For example, in the following function that uses a default parameter, <code>1</code>0 instead of 100 is returned:</p> + +<pre class="brush: js">function bar(a=1) { + arguments[0] = 100; + return a; +} +bar(10); // 10 +</pre> + +<h2 id="Specifications">Specifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Initial definition. Implemented in JavaScript 1.1</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-10.6', 'Arguments Object')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-arguments-exotic-objects', 'Arguments Exotic Objects')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</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>Feature</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>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also">See also</h2> + +<ul> + <li>{{jsxref("Function")}}</li> +</ul> diff --git a/files/ca/web/javascript/reference/functions/arguments/length/index.html b/files/ca/web/javascript/reference/functions/arguments/length/index.html new file mode 100644 index 0000000000..cf2660b7e4 --- /dev/null +++ b/files/ca/web/javascript/reference/functions/arguments/length/index.html @@ -0,0 +1,117 @@ +--- +title: arguments.length +slug: Web/JavaScript/Reference/Functions/arguments/length +translation_of: Web/JavaScript/Reference/Functions/arguments/length +--- +<div>{{jsSidebar("Functions")}}</div> + +<p>La propietat <strong><code>arguments.length</code></strong> conté el número d'arguments passats a la funció.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox">arguments.length</pre> + +<h2 id="Descripció">Descripció</h2> + +<p>La propietat arguments.length proporciona el número d'arguments passats a la funció. Aquest pot ser major o menor que el nombre total de paràmetres definits. (Vegeu {{jsxref("Function.length")}}).</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_arguments.length">Utilitzar <code>arguments.length</code></h3> + +<p>En aquest exemple definim una funció que pot afegir dos o més nombres.</p> + +<pre class="brush: js">function adder(base /*, n2, ... */) { + base = Number(base); + for (var i = 1; i < arguments.length; i++) { + base += Number(arguments[i]); + } + return base; +} +</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-10.6', 'Arguments Object')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-arguments-exotic-objects', 'Arguments Exotic Objects')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome per Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Function")}}</li> + <li>{{jsxref("Function.length")}}</li> +</ul> diff --git a/files/ca/web/javascript/reference/functions/get/index.html b/files/ca/web/javascript/reference/functions/get/index.html new file mode 100644 index 0000000000..92a9de2965 --- /dev/null +++ b/files/ca/web/javascript/reference/functions/get/index.html @@ -0,0 +1,217 @@ +--- +title: getter +slug: Web/JavaScript/Reference/Functions/get +translation_of: Web/JavaScript/Reference/Functions/get +--- +<div>{{jsSidebar("Functions")}}</div> + +<p>la sintaxi <strong><code>get</code></strong> lliga la propietat d'un objecte a una funció que es cridarà quan la propietat sigui cercada.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox">{get <em>prop</em>() { ... } } +{get <em>[expressió]</em>() { ... } }</pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>prop</code></dt> + <dd>El nom de la propietat que es pretén lligar a la funció donada.</dd> + <dt>expressió</dt> + <dd>A partir d'ECMAScript 6, també es pot utilitzar expressions per a calcular el nom d'una propietat a lligar a la funció donada.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>A vegades és desitjable permetre l'accès a una propietat que retorna un valor calculat dinàmicament, o potser es vol reflectir l'estat d'una variable interna sense ésser necessari l'ús de crides explícites a mètodes. En JavaScript, Això es pot aconseguir utilitzant un <em>getter</em>. No és possible tenir simultàniament un lligam a una propietat i que aquesta mateixa propietat contingui un valor, tot i que sí és possible utilitzar un getter i un setter en conjunt per crear un tipus de pseudo-propietat.</p> + +<p>Tingueu en compte el següent quan treballeu amb la sintàxi <code>get</code>:</p> + +<div> +<ul> + <li>Pot tenir com a identificador tant un número com una string;</li> + <li>Ha de tenir exactament zero paràmetres (vegeu <a class="external" href="http://whereswalden.com/2010/08/22/incompatible-es5-change-literal-getter-and-setter-functions-must-now-have-exactly-zero-or-one-arguments/" rel="external nofollow">Canvi incompatible <abbr title="ECMAScript 5th edition">ES5</abbr>: les funcions getter i setter literals han de tenir zero o un argument</a> per més informació).</li> + <li>No pot aparèixer en un objecte literla amb un altre <code>get</code> o amb una entrada de dades per la mateixa propietat (<code>{ get x() { }, get x() { } }</code> i <code>{ x: ..., get x() { } }</code> estàn prohibits).</li> +</ul> +</div> + +<p>Un getter pot ser eliminiat utilitzant l'operador <code><a href="/en-US/docs/Web/JavaScript/Reference/Operators/delete" title="en/Core_JavaScript_1.5_Reference/Operators/Special_Operators/delete_Operator">delete.</a></code></p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Definir_un_getter_en_nous_objectes_en_inicialitzadors_d'objectes">Definir un getter en nous objectes, en inicialitzadors d'objectes</h3> + +<p>Això crearà una pseudo-propietat <code>latest</code> per l'objecte <code>obj</code>, el qual retornarà l'últim ítem de l'array en <code>log</code>.</p> + +<pre class="brush: js">var log = ['test']; +var obj = { + get latest () { + if (log.length == 0) retorna undefined; + return log[log.length - 1] + } +} +console.log (obj.latest); // Retornarà "test". +</pre> + +<p>Recordeu que intentar assignar un valor a <code>latest</code> no el canviarà.</p> + +<h3 id="Eliminar_un_getter_utilitzanr_l'operador_delete">Eliminar un getter utilitzanr l'operador <code>delete</code></h3> + +<p>Si voleu eliminar el getter, simplement utilitzeu <code><a href="/en-US/docs/Web/JavaScript/Reference/Operators/delete">delete</a></code>:</p> + +<pre class="brush: js">delete obj.latest; +</pre> + +<h3 id="Definir_un_getter_en_objectes_existents_utilitzant_la_Propietat_define">Definir un getter en objectes existents utilitzant la<code> Propietat</code> <code>define</code></h3> + +<p>Per annexar un getter a un objecte existent posteriorment en qualsevol moment, utilitzeu {{jsxref("Object.defineProperty()")}}.</p> + +<pre class="brush: js">var o = { a:0 } + +Object.defineProperty(o, "b", { get: function () { return this.a + 1; } }); + +console.log(o.b) // Executa el getter, el qual produeix a + 1 (que és 1)</pre> + +<h3 id="Utilitzar_un_nom_de_propietat_calculat">Utilitzar un nom de propietat calculat</h3> + +<div class="note"> +<p><strong>Nota:</strong> Les propietats calculades són una tecnologia experimental, que forma part de la proposta d'ECMAScript 6, i encara no estàn ampliament suportats pels navegadors. Això llençarà un error de sintàxi en entorns que no les suportin.</p> +</div> + +<pre class="brush: js">var expr = "foo"; + +var obj = { + get [expr]() { return "bar"; } +}; + +console.log(obj.foo); // "bar"</pre> + +<h3 id="Getters_smart_self-overwriting_lazy"> Getters smart / self-overwriting / lazy</h3> + +<p>Getters et donen una forma de definir una propietat d'un objecte, però aquests no calculen el valor de la propietat fins que no s'hi ha accedit. getter posposen el cost de calcular el valor fins el moment en que es necessiti el valor, i si no és mai necessari, mai es pagarà el cost.</p> + +<p>Una tècnica d'optimització addiccional per retardar o realitzar de forma lenta el càlcul del valor d'una propietat i guardar-ho per a accedir-hi posteriorment són els<strong> getters smart o<em> <a href="https://en.wikipedia.org/wiki/Memoization">memoized</a> </em></strong>. El valor és calculat el primer cop que es crida el getter, i és llavors guardat per tal els accessos subsegüents retornin el calor guardat en caché sense recalcular-lo. Això és útil en les situacions següents:</p> + +<ul> + <li>Si el càlcul del valor d'una propietat és car (utilitza massa RAM o massa temps de CPU, spawns worker thread, recupera els arxius remots, etc).</li> + <li>Si el valor no és necessari ara mateix. S'utilitzarà després, o en alguns casos no s'utilitzarà mai.</li> + <li>Si s'utilitza, serà accedit diverses vegades, i no hi ha necessitat de recalcular el valor que no es canviarà, o no s'hauria de recalcular.</li> +</ul> + +<p>Això vol dir que no haurieu d'utilitzar un getter lazy per una propietat el valor de la qual espereu canviar, ja que el getter no recalcularà el valor.</p> + +<p>En l'exemple següent, l'objecte té un getter com propietat pròpia. Obtenint la propietat, la propietat s'elimina de l'objecte i es reafegeix, però implícitament com a propietat de tipus data aquest cop. Finalment el valor es retorna.</p> + +<pre class="brush: js">get notifier() { + delete this.notifier; + return this.notifier = document.getElementById("bookmarked-notification-anchor"); +},</pre> + +<p>Per codi Firefox, vegeu també el mòdul de codi XPCOMUtils.jsm, el qual defineix la funció <code><a href="/en-US/docs/Mozilla/JavaScript_code_modules/XPCOMUtils.jsm#defineLazyGetter()">defineLazyGetter()</a></code>.</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-11.1.5', 'Object Initializer')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Definició inicial.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-method-definitions', 'Method definitions')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Noms de propietats calculats afegits.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-method-definitions', 'Method definitions')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatChrome(1)}}</td> + <td>{{ CompatGeckoDesktop("1.8.1") }}</td> + <td>{{ CompatIE(9) }}</td> + <td>9.5</td> + <td>3</td> + </tr> + <tr> + <td>Noms de propietats calculats</td> + <td>{{CompatChrome(46)}}</td> + <td>{{ CompatGeckoDesktop("34") }}</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>Feature</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("1.8.1") }}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + <tr> + <td>Noms de propietats calculats</td> + <td>47</td> + <td>{{CompatNo}}</td> + <td>{{ CompatGeckoMobile("34.0") }}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Functions/set">setter</a></li> + <li>{{jsxref("Operators/delete", "delete")}}</li> + <li>{{jsxref("Object.defineProperty()")}}</li> + <li>{{jsxref("Object.defineGetter", "__defineGetter__")}}</li> + <li>{{jsxref("Object.defineSetter", "__defineSetter__")}}</li> + <li><a href="/en-US/docs/Web/JavaScript/Guide/Working_with_Objects#Defining_getters_and_setters">Definir Getters i Setters</a> en la guia de JavaScript</li> +</ul> diff --git a/files/ca/web/javascript/reference/functions/index.html b/files/ca/web/javascript/reference/functions/index.html new file mode 100644 index 0000000000..1dbb672ef5 --- /dev/null +++ b/files/ca/web/javascript/reference/functions/index.html @@ -0,0 +1,617 @@ +--- +title: Functions +slug: Web/JavaScript/Reference/Functions +tags: + - Function + - Functions + - JavaScript + - NeedsTranslation + - TopicStub +translation_of: Web/JavaScript/Reference/Functions +--- +<div>{{jsSidebar("Functions")}}</div> + +<p>Generally speaking, a function is a "subprogram" that can be <em>called</em> by code external (or internal in the case of recursion) to the function. Like the program itself, a function is composed of a sequence of statements called the <em>function body</em>. Values can be <em>passed</em> to a function, and the function can <em>return</em> a value.</p> + +<p>In JavaScript, functions are first-class objects, i.e. they are objects and can be manipulated and passed around just like any other object. Specifically, they are <code><a href="/en-US/docs/JavaScript/Reference/Global_Objects/Function">Function</a></code> objects.</p> + +<p>For more examples and explanations, see also the <a href="/en-US/docs/Web/JavaScript/Guide/Functions">JavaScript guide about functions</a>.</p> + +<h2 id="Description">Description</h2> + +<p>Every function in JavaScript is a <code>Function</code> object. See {{jsxref("Function")}} for information on properties and methods of <code>Function</code> objects.</p> + +<p>Functions are not the same as procedures. A function always returns a value, but a procedure may or may not return any value.</p> + +<p>To return a specific value other than the default, a function must have a <code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/return">return</a></code> statement that specifies the value to return. A function without a return statement will return a default value. In the case of a <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/constructor">constructor</a> called with the <code><a href="/en-US/docs/Web/JavaScript/Reference/Operators/new">new</a></code> keyword, the default value is the value of its <code>this</code> parameter. For all other functions, the default return value is <code>undefined</code>.</p> + +<p>The parameters of a function call are the function's <em>arguments</em>. Arguments are passed to functions <em>by value</em>. If the function changes the value of an argument, this change is not reflected globally or in the calling function. However, object references are values, too, and they are special: if the function changes the referred object's properties, that change is visible outside the function, as shown in the following example:</p> + +<pre class="brush: js">/* Declare the function 'myFunc' */ +function myFunc(theObject) { + theObject.brand = "Toyota"; + } + + /* + * Declare variable 'mycar'; + * create and initialize a new Object; + * assign reference to it to 'mycar' + */ + var mycar = { + brand: "Honda", + model: "Accord", + year: 1998 + }; + + /* Logs 'Honda' */ + console.log(mycar.brand); + + /* Pass object reference to the function */ + myFunc(mycar); + + /* + * Logs 'Toyota' as the value of the 'brand' property + * of the object, as changed to by the function. + */ + console.log(mycar.brand); +</pre> + +<p>The <a href="/en-US/docs/Web/JavaScript/Reference/Operators/this"><code>this</code> keyword</a> does not refer to the currently executing function, so you must refer to <code>Function</code> objects by name, even within the function body.</p> + +<h2 id="Defining_functions">Defining functions</h2> + +<p>There are several ways to define functions:</p> + +<h3 id="The_function_declaration_(function_statement)">The function declaration (<code>function</code> statement)</h3> + +<p>There is a special syntax for declaring functions (see <a href="/en-US/docs/Web/JavaScript/Reference/Statements/function">function statement</a> for details):</p> + +<pre class="syntaxbox">function <em>name</em>([<em>param</em>[, <em>param</em>[, ... <em>param</em>]]]) { + <em>statements</em> +} +</pre> + +<dl> + <dt><code>name</code></dt> + <dd>The function name.</dd> +</dl> + +<dl> + <dt><code>param</code></dt> + <dd>The name of an argument to be passed to the function. A function can have up to 255 arguments.</dd> +</dl> + +<dl> + <dt><code>statements</code></dt> + <dd>The statements comprising the body of the function.</dd> +</dl> + +<h3 id="The_function_expression_(function_expression)">The function expression (<code>function</code> expression)</h3> + +<p>A function expression is similar to and has the same syntax as a function declaration (see <a href="/en-US/docs/Web/JavaScript/Reference/Operators/function">function expression</a> for details):</p> + +<pre class="syntaxbox">function [<em>name</em>]([<em>param</em>] [, <em>param</em>] [..., <em>param</em>]) { + <em>statements</em> +} +</pre> + +<dl> + <dt><code>name</code></dt> + <dd>The function name. Can be omitted, in which case the function becomes known as an anonymous function.</dd> +</dl> + +<dl> + <dt><code>param</code></dt> + <dd>The name of an argument to be passed to the function. A function can have up to 255 arguments.</dd> + <dt><code>statements</code></dt> + <dd>The statements which comprise the body of the function.</dd> +</dl> + +<h3 id="The_generator_function_declaration_(function*_statement)">The generator function declaration (<code>function*</code> statement)</h3> + +<div class="note"> +<p><strong>Note:</strong> Generator function are an <em>experimental technology,</em> part of the ECMAScript 6 proposal, and are not widely supported by browsers yet.</p> +</div> + +<p>There is a special syntax for declaration generator functions (see {{jsxref('Statements/function*', 'function* statement')}} for details):</p> + +<pre class="syntaxbox">function* <em>name</em>([<em>param</em>[, <em>param</em>[, ... <em>param</em>]]]) { + <em>statements</em> +} +</pre> + +<dl> + <dt><code>name</code></dt> + <dd>The function name.</dd> +</dl> + +<dl> + <dt><code>param</code></dt> + <dd>The name of an argument to be passed to the function. A function can have up to 255 arguments.</dd> +</dl> + +<dl> + <dt><code>statements</code></dt> + <dd>The statements comprising the body of the function.</dd> +</dl> + +<h3 id="The_generator_function_expression_(function*_expression)">The generator function expression (<code>function*</code> expression)</h3> + +<div class="note"> +<p><strong>Note:</strong> Generator function are an <em>experimental technology,</em> part of the ECMAScript 6 proposal, and are not widely supported by browsers yet.</p> +</div> + +<p>A generator function expression is similar to and has the same syntax as a generator function declaration (see {{jsxref('Operators/function*', 'function* expression')}} for details):</p> + +<pre class="syntaxbox">function* [<em>name</em>]([<em>param</em>] [, <em>param</em>] [..., <em>param</em>]) { + <em>statements</em> +} +</pre> + +<dl> + <dt><code>name</code></dt> + <dd>The function name. Can be omitted, in which case the function becomes known as an anonymous function.</dd> +</dl> + +<dl> + <dt><code>param</code></dt> + <dd>The name of an argument to be passed to the function. A function can have up to 255 arguments.</dd> + <dt><code>statements</code></dt> + <dd>The statements which comprise the body of the function.</dd> +</dl> + +<h3 id="The_arrow_function_expression_(>)">The arrow function expression (=>)</h3> + +<div class="note"> +<p><strong>Note:</strong> Arrow function expressions are an <em>experimental technology,</em> part of the ECMAScript 6 proposal, and are not widely supported by browsers yet.</p> +</div> + +<p>An arrow function expression has a shorter syntax and lexically binds its this value (see <a href="/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions">arrow functions</a> for details):</p> + +<pre class="syntaxbox">([param] [, param]) => { + statements +} + +param => expression +</pre> + +<dl> + <dt><code>param</code></dt> + <dd>The name of an argument. Zero arguments need to be indicated with <code>()</code>. For only one argument the parentheses are not required. (like <code>foo => 1</code>)</dd> + <dt><code>statements or expression</code></dt> + <dd>Multiple statements need to be enclosed in brackets. A single expression requires no brackets. The expression is also the implicit return value of that function.</dd> +</dl> + +<h3 id="The_Function_constructor">The <code>Function</code> constructor</h3> + +<div class="note"> +<p><strong>Note:</strong> Using the <code>Function</code> constructor to create functions is not recommended since it needs the function body as a string which may prevent some JS engine optimizations and can also cause other problems.</p> +</div> + +<p>As all other objects, {{jsxref("Function")}} objects can be created using the <code>new</code> operator:</p> + +<pre class="syntaxbox">new Function (<em>arg1</em>, <em>arg2</em>, ... <em>argN</em>, <em>functionBody</em>) +</pre> + +<dl> + <dt><code>arg1, arg2, ... arg<em>N</em></code></dt> + <dd>Zero or more names to be used by the function as formal argument names. Each must be a string that conforms to the rules for a valid JavaScript identifier or a list of such strings separated with a comma; for example "<code>x</code>", "<code>theValue</code>", or "<code>a,b</code>".</dd> +</dl> + +<dl> + <dt><code>functionBody</code></dt> + <dd>A string containing the JavaScript statements comprising the function definition.</dd> +</dl> + +<p>Invoking the <code>Function</code> constructor as a function (without using the <code>new</code> operator) has the same effect as invoking it as a constructor.</p> + +<h3 id="The_GeneratorFunction_constructor">The <code>GeneratorFunction</code> constructor</h3> + +<div class="note"> +<p><strong>Note:</strong> Arrow function expressions are an <em>experimental technology,</em> part of the ECMAScript 6 proposal, and are not widely supported by browsers yet.</p> +</div> + +<div class="note"> +<p><strong>Note:</strong> <code>GeneratorFunction</code> is not a global object, but could be obtained from generator function instance (see {{jsxref("GeneratorFunction")}} for more detail).</p> +</div> + +<div class="note"> +<p><strong>Note:</strong> Using the <code>GeneratorFunction</code> constructor to create functions is not recommended since it needs the function body as a string which may prevent some JS engine optimizations and can also cause other problems.</p> +</div> + +<p>As all other objects, {{jsxref("GeneratorFunction")}} objects can be created using the <code>new</code> operator:</p> + +<pre class="syntaxbox">new GeneratorFunction (<em>arg1</em>, <em>arg2</em>, ... <em>argN</em>, <em>functionBody</em>) +</pre> + +<dl> + <dt><code>arg1, arg2, ... arg<em>N</em></code></dt> + <dd>Zero or more names to be used by the function as formal argument names. Each must be a string that conforms to the rules for a valid JavaScript identifier or a list of such strings separated with a comma; for example "<code>x</code>", "<code>theValue</code>", or "<code>a,b</code>".</dd> +</dl> + +<dl> + <dt><code>functionBody</code></dt> + <dd>A string containing the JavaScript statements comprising the function definition.</dd> +</dl> + +<p>Invoking the <code>Function</code> constructor as a function (without using the <code>new</code> operator) has the same effect as invoking it as a constructor.</p> + +<h2 id="Function_parameters">Function parameters</h2> + +<div class="note"> +<p><strong>Note:</strong> Default and rest parameters are <em>experimental technology,</em> part of the ECMAScript 6 proposal, and are not widely supported by browsers yet.</p> +</div> + +<h3 id="Default_parameters">Default parameters</h3> + +<p>Default function parameters allow formal parameters to be initialized with default values if no value or <code>undefined</code> is passed. For more details, see<a href="/en-US/docs/Web/JavaScript/Reference/Functions/Default_parameters"> default parameters</a>.</p> + +<h3 id="Rest_parameters">Rest parameters</h3> + +<p>The rest parameter syntax allows to represent an indefinite number of arguments as an array. For more details, see <a href="/en-US/docs/Web/JavaScript/Reference/Functions/rest_parameters">rest parameters</a>.</p> + +<h2 id="The_arguments_object">The <code>arguments</code> object</h2> + +<p>You can refer to a function's arguments within the function by using the <code>arguments</code> object. See <a href="/en-US/docs/Web/JavaScript/Reference/Functions/arguments">arguments</a>.</p> + +<ul> + <li><code><a href="/en-US/docs/JavaScript/Reference/Functions_and_function_scope/arguments">arguments</a></code>: An array-like object containing the arguments passed to the currently executing function.</li> + <li><code><a href="/en-US/docs/JavaScript/Reference/Functions_and_function_scope/arguments/callee">arguments.callee</a></code> {{Deprecated_inline}}: The currently executing function.</li> + <li><code><a href="/en-US/docs/JavaScript/Reference/Functions_and_function_scope/arguments/caller">arguments.caller</a></code> {{Obsolete_inline}} : The function that invoked the currently executing function.</li> + <li><code><a href="/en-US/docs/JavaScript/Reference/Functions_and_function_scope/arguments/length">arguments.length</a></code>: The number of arguments passed to the function.</li> +</ul> + +<h2 id="Defining_method_functions">Defining method functions</h2> + +<h3 id="Getter_and_setter_functions">Getter and setter functions</h3> + +<p>You can define getters (accessor methods) and setters (mutator methods) on any standard built-in object or user-defined object that supports the addition of new properties. The syntax for defining getters and setters uses the object literal syntax.</p> + +<dl> + <dt><a href="/en-US/docs/Web/JavaScript/Reference/Functions/get">get</a></dt> + <dd> + <p>Binds an object property to a function that will be called when that property is looked up.</p> + </dd> + <dt><a href="/en-US/docs/Web/JavaScript/Reference/Functions/set">set</a></dt> + <dd>Binds an object property to a function to be called when there is an attempt to set that property.</dd> +</dl> + +<h3 id="Method_definition_syntax">Method definition syntax</h3> + +<div class="note"> +<p><strong>Note:</strong> <em>Method definitions are experimental technology,</em> part of the ECMAScript 6 proposal, and are not widely supported by browsers yet.</p> +</div> + +<p>Starting with ECMAScript 6, you are able to define own methods in a shorter syntax, similar to the getters and setters. See <a href="/en-US/docs/Web/JavaScript/Reference/Functions/Method_definitions">method definitions</a> for more information.</p> + +<pre class="brush: js">var obj = { + foo() {}, + bar() {} +};</pre> + +<h2 id="Function_constructor_vs._function_declaration_vs._function_expression"><code>Function</code> constructor vs. function declaration vs. function expression</h2> + +<p>Compare the following:</p> + +<p>A function defined with the <code>Function</code> constructor assigned to the variable <code>multiply:</code></p> + +<pre class="brush: js">function multiply(x, y) { + return x * y; +} +</pre> + +<p>A <em>function expression</em> of an anonymous function assigned to the variable <code>multiply:</code></p> + +<pre class="brush: js">var multiply = function(x, y) { + return x * y; +}; +</pre> + +<p>A <em>function expression</em> of a function named <code>func_name</code> assigned to the variable <code>multiply:</code></p> + +<pre class="brush: js">var multiply = function func_name(x, y) { + return x * y; +}; +</pre> + +<h3 id="Differences">Differences</h3> + +<p>All do approximately the same thing, with a few subtle differences:</p> + +<p>There is a distinction between the function name and the variable the function is assigned to. The function name cannot be changed, while the variable the function is assigned to can be reassigned. The function name can be used only within the function's body. Attempting to use it outside the function's body results in an error (or <code>undefined</code> if the function name was previously declared via a <code>var</code> statement). For example:</p> + +<pre class="brush: js">var y = function x() {}; +alert(x); // throws an error +</pre> + +<p>The function name also appears when the function is serialized via <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/toString"><code>Function</code>'s toString method</a>.</p> + +<p>On the other hand, the variable the function is assigned to is limited only by its scope, which is guaranteed to include the scope where the function is declared in.</p> + +<p>As the 4th example shows, the function name can be different from the variable the function is assigned to. They have no relation to each other.A function declaration also creates a variable with the same name as the function name. Thus, unlike those defined by function expressions, functions defined by function declarations can be accessed by their name in the scope they were defined in:</p> + +<p>A function defined by '<code>new Function'</code> does not have a function name. However, in the <a href="/en-US/docs/Mozilla/Projects/SpiderMonkey">SpiderMonkey</a> JavaScript engine, the serialized form of the function shows as if it has the name "anonymous". For example, <code>alert(new Function())</code> outputs:</p> + +<pre class="brush: js">function anonymous() { +} +</pre> + +<p>Since the function actually does not have a name, <code>anonymous</code> is not a variable that can be accessed within the function. For example, the following would result in an error:</p> + +<pre class="brush: js">var foo = new Function("alert(anonymous);"); +foo(); +</pre> + +<p>Unlike functions defined by function expressions or by the <code>Function</code> constructor, a function defined by a function declaration can be used before the function declaration itself. For example:</p> + +<pre class="brush: js">foo(); // alerts FOO! +function foo() { + alert('FOO!'); +} +</pre> + +<p>A function defined by a function expression inherits the current scope. That is, the function forms a closure. On the other hand, a function defined by a <code>Function</code> constructor does not inherit any scope other than the global scope (which all functions inherit).</p> + +<p>Functions defined by function expressions and function declarations are parsed only once, while those defined by the <code>Function</code> constructor are not. That is, the function body string passed to the <code>Function</code> constructor must be parsed each and every time the constructor is called. Although a function expression creates a closure every time, the function body is not reparsed, so function expressions are still faster than "<code>new Function(...)</code>". Therefore the <code>Function</code> constructor should generally be avoided whenever possible.</p> + +<p>It should be noted, however, that function expressions and function declarations nested within the function generated by parsing a <code>Function constructor</code> 's string aren't parsed repeatedly. For example:</p> + +<pre class="brush: js">var foo = (new Function("var bar = \'FOO!\';\nreturn(function() {\n\talert(bar);\n});"))(); +foo(); // The segment "function() {\n\talert(bar);\n}" of the function body string is not re-parsed.</pre> + +<p>A function declaration is very easily (and often unintentionally) turned into a function expression. A function declaration ceases to be one when it either:</p> + +<ul> + <li>becomes part of an expression</li> + <li>is no longer a "source element" of a function or the script itself. A "source element" is a non-nested statement in the script or a function body:</li> +</ul> + +<pre class="brush: js">var x = 0; // source element +if (x == 0) { // source element + x = 10; // not a source element + function boo() {} // not a source element +} +function foo() { // source element + var y = 20; // source element + function bar() {} // source element + while (y == 10) { // source element + function blah() {} // not a source element + y++; // not a source element + } +} +</pre> + +<h3 id="Examples">Examples</h3> + +<pre class="brush: js">// function declaration +function foo() {} + +// function expression +(function bar() {}) + +// function expression +x = function hello() {} + + +if (x) { + // function expression + function world() {} +} + + +// function declaration +function a() { + // function declaration + function b() {} + if (0) { + // function expression + function c() {} + } +} +</pre> + +<h2 id="Conditionally_defining_a_function">Conditionally defining a function</h2> + +<p>Functions can be conditionally defined using either //function statements// (an allowed extension to the <a href="http://www.ecma-international.org/publications/standards/Ecma-262.htm">ECMA-262 Edition 3</a> standard) or the <code>Function</code> constructor. Please note that such <a class="link-https" href="https://bugzilla.mozilla.org/show_bug.cgi?id=609832">function statements are no longer allowed in ES5 strict</a>. Additionally, this feature does not work consistently cross-browser, so you should not rely on it.</p> + +<p>In the following script, the <code>zero</code> function is never defined and cannot be invoked, because '<code>if (0)</code>' evaluates its condition to false:</p> + +<pre class="brush: js">if (0) { + function zero() { + document.writeln("This is zero."); + } +} +</pre> + +<p>If the script is changed so that the condition becomes '<code>if (1)</code>', function <code>zero</code> is defined.</p> + +<p>Note: Although this kind of function looks like a function declaration, it is actually an expression (or statement), since it is nested within another statement. See differences between function declarations and function expressions.</p> + +<p>Note: Some JavaScript engines, not including <a href="/en-US/docs/SpiderMonkey">SpiderMonkey</a>, incorrectly treat any function expression with a name as a function definition. This would lead to <code>zero</code> being defined, even with the always-false <code>if</code> condition. A safer way to define functions conditionally is to define the function anonymously and assign it to a variable:</p> + +<pre class="brush: js">if (0) { + var zero = function() { + document.writeln("This is zero."); + } +} +</pre> + +<h2 id="Examples_2">Examples</h2> + +<h3 id="Returning_a_formatted_number">Returning a formatted number</h3> + +<p>The following function returns a string containing the formatted representation of a number padded with leading zeros.</p> + +<pre class="brush: js">// This function returns a string padded with leading zeros +function padZeros(num, totalLen) { + var numStr = num.toString(); // Initialize return value as string + var numZeros = totalLen - numStr.length; // Calculate no. of zeros + for (var i = 1; i <= numZeros; i++) { + numStr = "0" + numStr; + } + return numStr; +} +</pre> + +<p>The following statements call the padZeros function.</p> + +<pre class="brush: js">var result; +result = padZeros(42,4); // returns "0042" +result = padZeros(42,2); // returns "42" +result = padZeros(5,4); // returns "0005" +</pre> + +<h3 id="Determining_whether_a_function_exists">Determining whether a function exists</h3> + +<p>You can determine whether a function exists by using the <code>typeof</code> operator. In the following example, a test is peformed to determine if the <code>window</code> object has a property called <code>noFunc</code> that is a function. If so, it is used; otherwise some other action is taken.</p> + +<pre class="brush: js"> if ('function' == typeof window.noFunc) { + // use noFunc() + } else { + // do something else + } +</pre> + +<p>Note that in the <code>if</code> test, a reference to <code>noFunc</code> is used—there are no brackets "()" after the function name so the actual function is not called.</p> + +<h2 id="Specifications">Specifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Initial definition. Implemented in JavaScript 1.0</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-13', 'Function Definition')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-function-definitions', 'Function definitions')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>New: Arrow functions, Generator functions, default parameters, rest parameters</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#', 'function*')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-arrow-function-definitions', 'Arrow Function Definitions')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Initial definition.</td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + <tr> + <td>Generator function</td> + <td>39</td> + <td>{{CompatGeckoDesktop("26.0")}}</td> + <td>{{CompatUnknown}}</td> + <td>26</td> + <td>{{CompatUnknown}}</td> + </tr> + <tr> + <td>Arrow function</td> + <td>{{CompatNo}}</td> + <td>{{CompatGeckoDesktop("22.0")}}</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>Feature</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>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + <tr> + <td>Generator function</td> + <td>{{CompatUnknown}}</td> + <td>39</td> + <td>{{CompatGeckoMobile("26.0")}}</td> + <td>{{CompatUnknown}}</td> + <td>26</td> + <td>{{CompatUnknown}}</td> + </tr> + <tr> + <td>Arrow function</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatGeckoMobile("22.0")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also">See also</h2> + +<ul> + <li>{{jsxref("Statements/function", "function statement")}}</li> + <li>{{jsxref("Operators/function", "function expression")}}</li> + <li>{{jsxref("Statements/function*", "function* statement")}}</li> + <li>{{jsxref("Operators/function*", "function* expression")}}</li> + <li>{{jsxref("Function")}}</li> + <li>{{jsxref("GeneratorFunction")}}</li> + <li>{{jsxref("Functions/Arrow_functions", "Arrow functions")}}</li> + <li>{{jsxref("Functions/Default_parameters", "Default parameters")}}</li> + <li>{{jsxref("Functions/rest_parameters", "Rest parameters")}}</li> + <li>{{jsxref("Functions/arguments", "Arguments object")}}</li> + <li>{{jsxref("Functions/get", "getter")}}</li> + <li>{{jsxref("Functions/set", "setter")}}</li> + <li>{{jsxref("Functions/Method_definitions", "Method definitions")}}</li> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Functions_and_function_scope" title="JavaScript/Reference/Functions_and_function_scope">Functions and function scope</a></li> +</ul> diff --git a/files/ca/web/javascript/reference/functions/parameters_rest/index.html b/files/ca/web/javascript/reference/functions/parameters_rest/index.html new file mode 100644 index 0000000000..68fc5f0bba --- /dev/null +++ b/files/ca/web/javascript/reference/functions/parameters_rest/index.html @@ -0,0 +1,156 @@ +--- +title: Paràmetres rest +slug: Web/JavaScript/Reference/Functions/parameters_rest +translation_of: Web/JavaScript/Reference/Functions/rest_parameters +--- +<div>{{jsSidebar("Functions")}}</div> + +<p>El <strong>paràmetre rest</strong> ens permet representar un nombre indefinit d'arguments en forma d 'array.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="brush: js">function f(a, b, ...theArgs) { + // ... +} +</pre> + +<h2 id="Descripció">Descripció</h2> + +<p>Si l'últim argument d'una funció, està prefixat amb l'operador <code>...</code>, aquest esdevé un array el qual té com a elements des de <code>0</code> (inclòs) fins a <code>theArgs.length</code> (no inclòs) els arguments passats a la funció.</p> + +<p>A l'exemple de sobre, <code>theArgs</code> aglutina el tercer argument de la funció, ja que el primer està mapejat a <code>a</code> i el segon està mapejat a <code>b</code> , i tota la resta d'arguments consecutius. </p> + +<h3 id="Diferència_entre_els_paràmetres_rest_i_l'objecte_arguments">Diferència entre els paràmetres rest i l'objecte <code>arguments</code></h3> + +<p>Existeixen tres diferències principals entre els paràmetres rest i l'objecte <code>arguments</code></p> + +<ul> + <li>Els paràmetres rest són aquells als que no s' ha donat un nom per separat, mentre que l' objecte <code>arguments</code> conté tots els paràmetres passats a la funció</li> + <li>L' objecte <code>arguments</code> no és un array real, mentre que els paràmetres rest són instàncies d' <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array" title="Array"><code>Array</code></a> , el qual significa que els hi podem aplicar directamaent els mètodes <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort" title="Array sort method"><code>sort</code></a>, <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map" title="Array map method"><code>map</code></a>, <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach" title="Array forEach method"><code>forEach</code></a> o <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/pop" title="Array pop method">pop</a>.</code></li> + <li>L' objecte <code>arguments</code> té funcionalitat específica a sí mateix (com la propietat <code>calle</code>).</li> +</ul> + +<h3 id="Des_d'_arguments_fins_a_un_array">Des d' arguments fins a un array</h3> + +<p>El paràmetre rest ha estat introduit per tal de reduir la quantitat de codi utilitzat que es introduit per els arguments</p> + +<pre class="brush: js">// Anteriorment a l' existència del paràmetre rest el s' utilitzava seguent codi +function f(a, b) { + var args = Array.prototype.slice.call(arguments, f.length); + + // … +} + +// equivalent a + +function f(a, b, ...args) { + +} +</pre> + +<h3 id="Desestructurant_paràmetres_rest">Desestructurant paràmetres rest</h3> + +<p>Els paràmetres rest es poden desestructurar, que vol dir que els valors que contenen es poden desenpaquetar en variables diferents i separades. Vegeu <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment">Destructuring assignment</a>.</p> + +<pre class="brush: js">function f(...[a, b, c]) { + return a + b + c; +} + +f(1) // NaN (bi c són undefined) +f(1, 2, 3) // 6 +f(1, 2, 3, 4) // 6 (el quart paràmetre no està desetructurat)</pre> + +<h2 id="Exemples">Exemples</h2> + +<p>Com que <code>theArgs</code> és un array, la propietat <code>length</code> en retorna el recompte:</p> + +<pre class="brush: js">function fun1(...theArgs) { + console.log(theArgs.length); +} + +fun1(); // 0 +fun1(5); // 1 +fun1(5, 6, 7); // 3 +</pre> + +<p>En el seguent exemple el paràmetre rest s' utilitza per aglutinar tots els paràmetres passats a la funcció després del primer en un array. Després cadascun d' ells és multiplicat per el primer paràmetre passat a la funció i es retorna l' array.</p> + +<pre class="brush: js">function multiply(multiplier, ...theArgs) { + return theArgs.map(function(element) { + return multiplier * element; + }); +} + +var arr = multiply(2, 1, 2, 3); +console.log(arr); // [2, 4, 6] +</pre> + +<p>El seguent exemple mostra com els mètodes d' <code>Array</code> es poden utilitzar am paràmetres rest, però no amb l' objecte <code>arguments</code> :</p> + +<pre class="brush: js">function sortRestArgs(...theArgs) { + var sortedArgs = theArgs.sort(); + return sortedArgs; +} + +console.log(sortRestArgs(5, 3, 7, 1)); // mostra 1, 3, 5, 7 + +function sortArguments() { + var sortedArgs = arguments.sort(); + return sortedArgs; // aquesta línia mai s' executarà +} + +// genera el TypeError: arguments.sort no és una funció +console.log(sortArguments(5, 3, 7, 1)); +</pre> + +<p>Per tal de poder usar els mètodes d' <code>Array</code> amb l' objecte <code>arguments</code> , aquest s' ha de convertir primer en un array.</p> + +<pre class="brush: js">function sortArguments() { + var args = Array.prototype.slice.call(arguments); + var sortedArgs = args.sort(); + return sortedArgs; +} +console.log(sortArguments(5, 3, 7, 1)); // shows 1, 3, 5, 7 +</pre> + +<h2 id="Specifications">Specifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-function-definitions', 'Function Definitions')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Initial definition</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-function-definitions', 'Function Definitions')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + +<div> + + +<p>{{Compat("javascript.functions.rest_parameters")}}</p> +</div> + +<h2 id="See_also">See also</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Spread_operator" title="spread operator">Spread operator</a> (also ‘<code>...</code>’)</li> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Functions/arguments" title="arguments">Arguments object</a></li> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array" title="Array">Array</a></li> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Functions" title="Functions and function scope">Functions</a></li> + <li><a class="external" href="http://wiki.ecmascript.org/doku.php?id=harmony:rest_parameters">Original proposal at ecmascript.org</a></li> + <li><a class="external" href="http://javascriptweblog.wordpress.com/2011/01/18/javascripts-arguments-object-and-beyond/">JavaScript arguments object and beyond</a></li> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment">Destructuring assignment</a></li> +</ul> diff --git a/files/ca/web/javascript/reference/global_objects/dataview/buffer/index.html b/files/ca/web/javascript/reference/global_objects/dataview/buffer/index.html new file mode 100644 index 0000000000..40da57fa52 --- /dev/null +++ b/files/ca/web/javascript/reference/global_objects/dataview/buffer/index.html @@ -0,0 +1,101 @@ +--- +title: DataView.prototype.buffer +slug: Web/JavaScript/Reference/Global_Objects/DataView/buffer +translation_of: Web/JavaScript/Reference/Global_Objects/DataView/buffer +--- +<div>{{JSRef}}</div> + +<p>La propietat d'accés <strong><code>buffer</code></strong> representa el {{jsxref("ArrayBuffer")}} referenciat per <code>DataView</code> en el temps de construcció.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><var>dataview</var>.buffer</pre> + +<h2 id="Descripció">Descripció</h2> + +<p>La propietat <code>buffer</code> és una propietat d'accés de la qual la seva funció d'accés és <code>undefined</code>, el que vol dir que només es pot llegir aquesta propietat. El valor s'estableix quan <code>DataView</code> és construït i no es pot canviar.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_la_propietat_buffer">Utilitzar la propietat <code>buffer</code></h3> + +<pre class="brush:js">var buffer = new ArrayBuffer(8); +var dataview = new DataView(buffer); +dataview.buffer; // ArrayBuffer { byteLength: 8 } +</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-get-dataview.prototype.buffer', 'DataView.prototype.buffer')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definició inicial.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>9.0</td> + <td>{{ CompatGeckoDesktop("15.0") }}</td> + <td>10</td> + <td>12.1</td> + <td>5.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 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>4.0</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{ CompatGeckoMobile("15") }}</td> + <td>{{CompatUnknown}}</td> + <td>12.0</td> + <td>4.2</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("DataView")}}</li> + <li>{{jsxref("ArrayBuffer")}}</li> +</ul> diff --git a/files/ca/web/javascript/reference/global_objects/dataview/getfloat32/index.html b/files/ca/web/javascript/reference/global_objects/dataview/getfloat32/index.html new file mode 100644 index 0000000000..83de1562e4 --- /dev/null +++ b/files/ca/web/javascript/reference/global_objects/dataview/getfloat32/index.html @@ -0,0 +1,122 @@ +--- +title: DataView.prototype.getFloat32() +slug: Web/JavaScript/Reference/Global_Objects/DataView/getFloat32 +translation_of: Web/JavaScript/Reference/Global_Objects/DataView/getFloat32 +--- +<div>{{JSRef}}</div> + +<p>El mètode <code>getFloat32()</code> obtè un nombre decimal en coma flotant amb signe de 32 bits (float) a la posició en bytes especificada, content des del començament de {{jsxref("DataView")}}.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><var>dataview</var>.getFloat32(byteOffset [, littleEndian])</pre> + +<h2 id="Paràmetres">Paràmetres</h2> + +<dl> + <dt>byteOffset</dt> + <dd>La posició, en bytes, des de l'inici de la vista a la que es llegiran les dades.</dd> + <dt>littleEndian</dt> + <dd>{{optional_inline}} Indica si el nombre decimal en coma flotant de 32 bits es troba emmagatzemat en format {{Glossary("Endianness", "little- o big-endian")}}. De ésser false o undefined, s'interpreta el valor com a big-endian.</dd> +</dl> + +<h3 id="Errors_llençats">Errors llençats</h3> + +<dl> + <dt>{{jsxref("RangeError")}}</dt> + <dd>Es llença si <code>byteOffset</code> té un valor que representa una posició més enllà del final de la vista.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>No hi ha cap restricció d'alineament; es poden llegir valors de múltiples bytes des de qualsevol posició.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_el_mètode_getFloat32">Utilitzar el mètode <code>getFloat32</code></h3> + +<pre class="brush:js">var buffer = new ArrayBuffer(8); +var dataview = new DataView(buffer); +dataview.getFloat32(1); // 0 +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>{{SpecName('Typed Array')}}</td> + <td>{{Spec2('Typed Array')}}</td> + <td>Reemplaçada per ECMAScript 6.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-dataview.prototype.getfloat32', 'DataView.prototype.getFloat32')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definició inicial en un estàndard ECMA.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>9.0</td> + <td>{{CompatGeckoDesktop("15.0")}}</td> + <td>10</td> + <td>12.1</td> + <td>5.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 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>4.0</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{ CompatGeckoMobile("15") }}</td> + <td>{{CompatUnknown}}</td> + <td>12.0</td> + <td>4.2</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("DataView")}}</li> + <li>{{jsxref("ArrayBuffer")}}</li> +</ul> diff --git a/files/ca/web/javascript/reference/global_objects/dataview/index.html b/files/ca/web/javascript/reference/global_objects/dataview/index.html new file mode 100644 index 0000000000..90c9d640ee --- /dev/null +++ b/files/ca/web/javascript/reference/global_objects/dataview/index.html @@ -0,0 +1,174 @@ +--- +title: DataView +slug: Web/JavaScript/Reference/Global_Objects/DataView +tags: + - Constructor + - DataView + - JavaScript + - NeedsTranslation + - TopicStub + - TypedArrays +translation_of: Web/JavaScript/Reference/Global_Objects/DataView +--- +<div>{{JSRef}}</div> + +<p>The <strong><code>DataView</code></strong> view provides a low-level interface for reading data from and writing it to an {{jsxref("ArrayBuffer")}}.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox">new DataView(buffer [, byteOffset [, byteLength]])</pre> + +<h3 id="Parameters">Parameters</h3> + +<dl> + <dt><code>buffer</code></dt> + <dd>An existing {{jsxref("ArrayBuffer")}} to use as the storage for the new <code>DataView</code> object.</dd> + <dt><code>byteOffset</code> {{optional_inline}}</dt> + <dd>The offset, in bytes, to the first byte in the specified buffer for the new view to reference. If not specified, the view of the buffer will start with the first byte.</dd> + <dt><code>byteLength</code> {{optional_inline}}</dt> + <dd>The number of elements in the byte array. If unspecified, length of the view will match the buffer's length.</dd> +</dl> + +<h3 id="Return_value">Return value</h3> + +<p>A new <code>DataView</code> object representing the specified data buffer.</p> + +<h3 id="Errors_thrown">Errors thrown</h3> + +<dl> + <dt><code>{{jsxref("RangeError")}}</code></dt> + <dd>Thrown if the <code>byteOffset</code> and <code>byteLength</code> result in the specified view extending past the end of the buffer.</dd> +</dl> + +<h2 id="Description">Description</h2> + +<h3 id="Detect_endianness">Detect endianness</h3> + +<p>You'll probably need to detect the type of architecture your script is running, here is a little trick to check it. See {{Glossary("Endianness")}} for more information.</p> + +<pre class="brush: js">var littleEndian = (function() { + var buffer = new ArrayBuffer(2); + new DataView(buffer).setInt16(0, 256, true); + return new Int16Array(buffer)[0] === 256; +})(); +console.log(littleEndian); // true or false +</pre> + +<h2 id="Properties">Properties</h2> + +<dl> + <dt>DataView.length</dt> + <dd>The <code>DataView</code> constructor's length property whose value is 3.</dd> + <dt>{{jsxref("DataView.prototype")}}</dt> + <dd>Allows the addition of properties to all <code>DataView</code> objects.</dd> +</dl> + +<h2 id="DataView_instances"><code>DataView</code> instances</h2> + +<p>All <code>DataView</code> instances inherit from {{jsxref("DataView.prototype")}}.</p> + +<h3 id="Properties_2">Properties</h3> + +<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/DataView/prototype','Properties')}}</p> + +<h3 id="Methods">Methods</h3> + +<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/DataView/prototype','Methods')}}</p> + +<h2 id="Example">Example</h2> + +<pre class="brush: js">var buffer = new ArrayBuffer(16); +var dv = new DataView(buffer, 0); + +dv.setInt16(1, 42); +dv.getInt16(1); //42 +</pre> + +<h2 id="Specifications">Specifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-dataview-constructor', 'DataView')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Initial definition in an ECMA standard</td> + </tr> + <tr> + <td>{{SpecName('Typed Array')}}</td> + <td>{{Spec2('Typed Array')}}</td> + <td>Superseded by ECMAScript 6</td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>9.0</td> + <td>{{CompatGeckoDesktop("15.0")}}</td> + <td>10</td> + <td>12.1</td> + <td>5.1</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</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>Basic support</td> + <td>4.0</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoMobile("15")}}</td> + <td>{{CompatUnknown}}</td> + <td>12.0</td> + <td>4.2</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Firefox-specific_notes">Firefox-specific notes</h2> + +<p>Starting with Gecko / SpiderMonkey 40 {{geckoRelease(40)}}, <code>DataView</code> requires to be constructed with a {{jsxref("Operators/new", "new")}} operator. Calling <code>DataView()</code> as a function without <code>new</code>, will throw a {{jsxref("TypeError")}} from now on.</p> + +<pre class="brush: js example-bad">var dv = DataView(buffer, 0); +// TypeError: calling a builtin DataView constructor without new is forbidden</pre> + +<pre class="brush: js example-good">var dv = new DataView(buffer, 0);</pre> + +<h2 id="See_also">See also</h2> + +<ul> + <li><a class="link-https" href="https://github.com/jDataView/jDataView">jDataView</a>: JavaScript library that polyfills and extends the <code>DataView</code> API to all browsers and Node.js.</li> +</ul> diff --git a/files/ca/web/javascript/reference/global_objects/dataview/prototype/index.html b/files/ca/web/javascript/reference/global_objects/dataview/prototype/index.html new file mode 100644 index 0000000000..203e5076e4 --- /dev/null +++ b/files/ca/web/javascript/reference/global_objects/dataview/prototype/index.html @@ -0,0 +1,146 @@ +--- +title: DataView.prototype +slug: Web/JavaScript/Reference/Global_Objects/DataView/prototype +translation_of: Web/JavaScript/Reference/Global_Objects/DataView +--- +<div>{{JSRef}}</div> + +<p>La propietat <code><strong>DataView</strong></code><strong><code>.prototype</code></strong> representa el prototip de l'objecte {{jsxref("DataView")}}.</p> + +<div>{{js_property_attributes(0,0,0)}}</div> + +<h2 id="Descripció">Descripció</h2> + +<p>Les instàncies <code>DataView</code> hereten de <code>DataView.prototype</code>. Com passa amb tots els constructors, podeu canviar l'objecte prototip del constructor per produir canvis a totes les instàncies <code>DataView</code>.</p> + +<h2 id="Propietats">Propietats</h2> + +<dl> + <dt>DataView.prototype.constructor</dt> + <dd>Especifica la funció que crea un prototip de l'objecte. El valor inicial és el constructor integrat estàndard <code>DataView</code>.</dd> + <dt>{{jsxref("DataView.prototype.buffer")}} {{readonlyInline}}</dt> + <dd>L'{{jsxref("ArrayBuffer")}} referenciat per aquesta vista. Fixat en el temps de construcció i per tant és <strong>només de lectura.</strong></dd> + <dt>{{jsxref("DataView.prototype.byteLength")}} {{readonlyInline}}</dt> + <dd>La llargària (en bytes) d'aquesta vista des del començament del seu {{jsxref("ArrayBuffer")}}. Fixat en el temps de construcció i per tant és <strong>només de lectura.</strong></dd> + <dt>{{jsxref("DataView.prototype.byteOffset")}} {{readonlyInline}}</dt> + <dd>La posició (en bytes) d'aquesta vista des de l'inici del seu {{jsxref("ArrayBuffer")}}. Fixat en el temps de construcció i per tant és <strong>només de lectura.</strong></dd> +</dl> + +<h2 id="Mètodes">Mètodes</h2> + +<h3 id="Lectura">Lectura</h3> + +<dl> + <dt>{{jsxref("DataView.prototype.getInt8()")}}</dt> + <dd>Obté un nombre sencer (byte) de 8 bits amb signe al byte de posició especificat des de l'inici de la vista.</dd> + <dt>{{jsxref("DataView.prototype.getUint8()")}}</dt> + <dd>Obté un nombre sencer sense signe de 8 bits (unsigned byte) al byte de posició especificat des de l'inici de la vista.</dd> + <dt>{{jsxref("DataView.prototype.getInt16()")}}</dt> + <dd>Obté un nombre sencer de 16 bits (short) al byte de posició especificat des de l'inici de la vista.</dd> + <dt>{{jsxref("DataView.prototype.getUint16()")}}</dt> + <dd>Obté un nombre sencer sense signe de 16 bits (unsigned short) al byte de posició especificat des de l'inici de la vista.</dd> + <dt>{{jsxref("DataView.prototype.getInt32()")}}</dt> + <dd>Obté un nombre sencer de 32 bits (long) al byte de posició especificat des de l'inici de la vista.</dd> + <dt>{{jsxref("DataView.prototype.getUint32()")}}</dt> + <dd>Obté un nombre sencer sense signe de 31 bits (unsigned long) al byte de posició especificat des de l'inici de la vista.</dd> + <dt>{{jsxref("DataView.prototype.getFloat32()")}}</dt> + <dd>Obté un nombre en coma flotant amb signe de 32 bits (float) al byte de posició especificat des de l'inici de la vista.</dd> + <dt>{{jsxref("DataView.prototype.getFloat64()")}}</dt> + <dd>Obté un nombre en coma flotant amb signe de 64 bits (double) al byte de posició especificat des de l'inici de la vista.</dd> +</dl> + +<h3 id="Escritura">Escritura</h3> + +<dl> + <dt>{{jsxref("DataView.prototype.setInt8()")}}</dt> + <dd>Emmagatzema el valor d'un nombre sencer de 8 bits (byte) al byte de posició especificat des de l'inici de la vista.</dd> + <dt>{{jsxref("DataView.prototype.setUint8()")}}</dt> + <dd>Emmagatzema el valor d'un nombre sencer sense signe de 8 bits (unsigned byte) al byte de posició especificat des de l'inici de la vista.</dd> + <dt>{{jsxref("DataView.prototype.setInt16()")}}</dt> + <dd>Emmagatzema el valor d'un nombre sencer amb signe de 16 bits (short) al byte de posició especificat des de l'inici de la vista.</dd> + <dt>{{jsxref("DataView.prototype.setUint16()")}}</dt> + <dd>Emmagatzema el valor d'un nombre sencer sense signe de 16 bits (unsigned short) al byte de posició especificat des de l'inici de la vista.</dd> + <dt>{{jsxref("DataView.prototype.setInt32()")}}</dt> + <dd>Emmagatzema el valor d'un nombre sencer amb signe de 32 bits (long) al byte de posició especificat des de l'inici de la vista.</dd> + <dt>{{jsxref("DataView.prototype.setUint32()")}}</dt> + <dd>Emmagatzema el valor d'un nombre sencer sense signe de 32 bits (unsigned long) al byte de posició especificat des de l'inici de la vista.</dd> + <dt>{{jsxref("DataView.prototype.setFloat32()")}}</dt> + <dd>Emmagatzema el valor d'un nombre en coma flotant amb signe de 32 bits (float) al byte de posició especificat des de l'inici de la vista.</dd> + <dt>{{jsxref("DataView.prototype.setFloat64()")}}</dt> + <dd>Emmagatzema el valor d'un nombre en coma flotant amb signe de 64 bits (double) al byte de posició especificat des de l'inici de la vista.</dd> +</dl> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-dataview.prototype', 'DataView.prototype')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definició inicial.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegador">Compatibilitat amb navegador</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>9.0</td> + <td>{{ CompatGeckoDesktop("15.0") }}</td> + <td>10</td> + <td>12.1</td> + <td>5.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 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>4.0</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoMobile("15")}}</td> + <td>{{CompatUnknown}}</td> + <td>12.0</td> + <td>4.2</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("DataView")}}</li> +</ul> diff --git a/files/ca/web/javascript/reference/global_objects/evalerror/index.html b/files/ca/web/javascript/reference/global_objects/evalerror/index.html new file mode 100644 index 0000000000..65a4df349e --- /dev/null +++ b/files/ca/web/javascript/reference/global_objects/evalerror/index.html @@ -0,0 +1,161 @@ +--- +title: EvalError +slug: Web/JavaScript/Reference/Global_Objects/EvalError +tags: + - Error + - EvalError + - JavaScript + - NeedsTranslation + - Reference + - TopicStub +translation_of: Web/JavaScript/Reference/Global_Objects/EvalError +--- +<div>{{JSRef}}</div> + +<p>The <strong><code>EvalError</code></strong> object indicates an error regarding the global {{jsxref("Global_Objects/eval", "eval()")}} function.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>new EvalError([<var>message</var>[, <var>fileName</var>[, <var>lineNumber</var>]]])</code></pre> + +<h3 id="Parameters">Parameters</h3> + +<dl> + <dt><code>message</code></dt> + <dd>Optional. Human-readable description of the error</dd> + <dt><code>fileName</code> {{non-standard_inline}}</dt> + <dd>Optional. The name of the file containing the code that caused the exception</dd> + <dt><code>lineNumber</code> {{non-standard_inline}}</dt> + <dd>Optional. The line number of the code that caused the exception</dd> +</dl> + +<h2 id="Description">Description</h2> + +<p>An <code>EvalError</code> is thrown when the global {{jsxref("Global_Objects/eval", "eval()")}} function is used improperly.</p> + +<h2 id="Properties">Properties</h2> + +<dl> + <dt>{{jsxref("EvalError.prototype")}}</dt> + <dd>Allows the addition of properties to an <code>EvalError</code> object.</dd> +</dl> + +<h2 id="Methods">Methods</h2> + +<p>The global <code>EvalError</code> contains no methods of its own, however, it does inherit some methods through the prototype chain.</p> + +<h2 id="EvalError_instances"><code>EvalError</code> instances</h2> + +<h3 id="Properties_2">Properties</h3> + +<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/EvalError/prototype', 'Properties')}}</div> + +<h3 id="Methods_2">Methods</h3> + +<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/EvalError/prototype', 'Methods')}}</div> + +<h2 id="Examples">Examples</h2> + +<p><code>EvalError</code> is not used now, and never be thrown by the runtime.</p> + +<h3 id="Creating_an_EvalError">Creating an <code>EvalError</code></h3> + +<pre class="brush: js">try { + throw new EvalError('Hello', 'someFile.js', 10); +} catch (e) { + console.log(e instanceof EvalError); // true + console.log(e.message); // "Hello" + console.log(e.name); // "EvalError" + console.log(e.fileName); // "someFile.js" + console.log(e.lineNumber); // 10 + console.log(e.columnNumber); // 0 + console.log(e.stack); // "@Scratchpad/2:2:9\n" +} +</pre> + +<h2 id="Specifications">Specifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.11.6.1', 'EvalError')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Not used in this specification. Present for backward compatibility.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-native-error-types-used-in-this-standard-evalerror', 'EvalError')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Not used in this specification. Present for backward compatibility.</td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</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>Feature</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>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also">See also</h2> + +<ul> + <li>{{jsxref("Error")}}</li> + <li>{{jsxref("EvalError.prototype")}}</li> + <li>{{jsxref("Global_Objects/eval", "eval()")}}</li> +</ul> diff --git a/files/ca/web/javascript/reference/global_objects/evalerror/prototype/index.html b/files/ca/web/javascript/reference/global_objects/evalerror/prototype/index.html new file mode 100644 index 0000000000..8aecc42c15 --- /dev/null +++ b/files/ca/web/javascript/reference/global_objects/evalerror/prototype/index.html @@ -0,0 +1,123 @@ +--- +title: EvalError.prototype +slug: Web/JavaScript/Reference/Global_Objects/EvalError/prototype +translation_of: Web/JavaScript/Reference/Global_Objects/EvalError +--- +<div>{{JSRef}}</div> + +<p>La propietat <code><strong>EvalError.prototype</strong></code> representa el prototip del constructor {{jsxref("EvalError")}}.</p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Descripció">Descripció</h2> + +<p>Totes les instàncies {{jsxref("EvalError")}} hereten de <code>EvalError.prototype</code>. Es pot utilitzar el prototip per afegir propietats o mètodes a totes les instàncies.</p> + +<h2 id="Propietats">Propietats</h2> + +<dl> + <dt><code>EvalError.prototype.constructor</code></dt> + <dd>Especifica la funció que ha creat el prototip d'una instància.</dd> + <dt>{{jsxref("Error.prototype.message", "EvalError.prototype.message")}}</dt> + <dd>Missatge d'error. Tot i que l'ECMA-262 especifica que {{jsxref("EvalError")}} hauria de proveir la seva pròpia propietat <code>message</code>, en <a href="/en-US/docs/Mozilla/Projects/SpiderMonkey">SpiderMonkey</a>, hereta {{jsxref("Error.prototype.message")}}.</dd> + <dt>{{jsxref("Error.prototype.name", "EvalError.prototype.name")}}</dt> + <dd>Nom de l'error. Heretat de {{jsxref("Error")}}.</dd> + <dt>{{jsxref("Error.prototype.fileName", "EvalError.prototype.fileName")}}</dt> + <dd>Camí cap al fitxer que ha llançat aquest error. Heretat de {{jsxref("Error")}}.</dd> + <dt>{{jsxref("Error.prototype.lineNumber", "EvalError.prototype.lineNumber")}}</dt> + <dd>Número de línia en el fitxer que ha llançat aquest error. Heretat de {{jsxref("Error")}}.</dd> + <dt>{{jsxref("Error.prototype.columnNumber", "EvalError.prototype.columnNumber")}}</dt> + <dd>Número de columna en la línia que ha llançat aquest error. Heretat de {{jsxref("Error")}}.</dd> + <dt>{{jsxref("Error.prototype.stack", "EvalError.prototype.stack")}}</dt> + <dd>Traça de l'error. Heretat de {{jsxref("Error")}}.</dd> +</dl> + +<h2 id="Mètodes">Mètodes</h2> + +<p>Tot i que l'objecte prototip {{jsxref("EvalError")}} no contè cap mètode en si mateix, les instàncies {{jsxref("EvalError")}} hereten alguns mètodes a través de la cadena prototip.</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('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Definició inicial</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.11.7.6', 'NativeError.prototype')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Definit com a <code><em>NativeError</em>.prototype</code>.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-nativeerror.prototype', 'NativeError.prototype')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definit com a <code><em>NativeError</em>.prototype</code>.</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("Error.prototype")}}</li> + <li>{{jsxref("Function.prototype")}}</li> +</ul> diff --git a/files/ca/web/javascript/reference/global_objects/function/arguments/index.html b/files/ca/web/javascript/reference/global_objects/function/arguments/index.html new file mode 100644 index 0000000000..6371caeb23 --- /dev/null +++ b/files/ca/web/javascript/reference/global_objects/function/arguments/index.html @@ -0,0 +1,125 @@ +--- +title: Function.arguments +slug: Web/JavaScript/Reference/Global_Objects/Function/arguments +translation_of: Web/JavaScript/Reference/Global_Objects/Function/arguments +--- +<div>{{JSRef}} {{deprecated_header}}</div> + +<p>La propietat <code><strong><em>function</em>.arguments</strong></code> es refereix a un objecte que s'assembla a una array corresponent als arguments passats a una funció. Utilitzeu la variable simple {{jsxref("Functions/arguments", "arguments")}}.</p> + +<h2 id="Descripció">Descripció</h2> + +<p>La sintaxis <code><em>function</em>.arguments</code> és obsoleta. El camí recomanat per accedir a l'objecte {{jsxref("Functions/arguments", "arguments")}} disponible en les funcions requereix simplement referir-se a la variable{{jsxref("Functions/arguments", "arguments")}}.</p> + +<p>En cas de recursivitat, és a dir, si la funció <code>f</code> apareix vàries vegades en la pila de crides, el valor det <code>f.arguments</code> representa els arguments corresponents a la invocació més recent de la funció.</p> + +<p>El valor del la propietat arguments normalment és null si no hi ha una invocació excel·lent de la funció (això vol dir, que s'ha cridat la funció però la seva execució encara no s'ha acabat).</p> + +<h2 id="Exemples">Exemples</h2> + +<pre class="brush: js">function f(n) { g(n - 1); } + +function g(n) { + console.log('before: ' + g.arguments[0]); + if (n > 0) { f(n); } + console.log('after: ' + g.arguments[0]); +} + +f(2); + +console.log('returned: ' + g.arguments); + +// Resultat + +// abans: 1 +// abans: 0 +// després: 0 +// després: 1 +// retorn: null +</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.0. Obsolet a favor de {{jsxref("Functions/arguments", "arguments")}} en ES3.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-10.6', 'arguments object')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>{{jsxref("Functions/arguments", "arguments")}} object</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-arguments-object', 'arguments object')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>{{jsxref("Functions/arguments", "arguments")}} object</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ístca</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>Objecte {{jsxref("Functions/arguments", "arguments")}}</li> + <li>{{jsxref("Functions", "Functions and function scope", "", 1)}}</li> +</ul> diff --git a/files/ca/web/javascript/reference/global_objects/function/arity/index.html b/files/ca/web/javascript/reference/global_objects/function/arity/index.html new file mode 100644 index 0000000000..d330307535 --- /dev/null +++ b/files/ca/web/javascript/reference/global_objects/function/arity/index.html @@ -0,0 +1,70 @@ +--- +title: Function.arity +slug: Web/JavaScript/Reference/Global_Objects/Function/arity +translation_of: Archive/Web/JavaScript/Function.arity +--- +<div>{{JSRef}} {{obsolete_header}}</div> + +<p class="note">La propietat <code><strong>arity</strong></code> solia retornar el número d'arguments esperats per la funció, tanmateix, ja no existeix i s'ha reemplaçat per la propietat {{jsxref("Function.prototype.length")}}.</p> + +<h2 id="Especificacions">Especificacions</h2> + +<p>Implementat en JavaScript 1.2. Obsolet en JavaScript 1.4.}</p> + +<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>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome per Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Function.prototype.length")}}</li> +</ul> diff --git a/files/ca/web/javascript/reference/global_objects/function/caller/index.html b/files/ca/web/javascript/reference/global_objects/function/caller/index.html new file mode 100644 index 0000000000..613e163d6a --- /dev/null +++ b/files/ca/web/javascript/reference/global_objects/function/caller/index.html @@ -0,0 +1,124 @@ +--- +title: Function.caller +slug: Web/JavaScript/Reference/Global_Objects/Function/caller +translation_of: Web/JavaScript/Reference/Global_Objects/Function/caller +--- +<div>{{JSRef}} {{non-standard_header}}</div> + +<p>La propietat <code><strong><em>function</em>.caller</strong></code> retorna la funció que ha invocat la funció especificada.</p> + +<h2 id="Descripció">Descripció</h2> + +<p>SI la funció <code>f</code> ha estat invocada pel codi de nivell superior, el valor de <code>f.caller</code> és {{jsxref("null")}}, sinó és la funció que ha cridat <code>f</code>.</p> + +<p>Aquesta propietat reemplaça la propietat obsoleta {{jsxref("Functions/arguments/caller", "arguments.caller")}} de l'objecte {{jsxref("Functions/arguments", "arguments")}}.</p> + +<p>La propietat especial <code>__caller__</code>, la qual retorna l'objecte activatwhich returned the activation object of the caller thus allowing to reconstruct the stack, was removed for security reasons.</p> + +<h3 id="Notes">Notes</h3> + +<p>Vegeu que en cas de recursió, no podeu reconstruir la pila de crida fent servir aquesta propietat. C that in case of recursion, you can't reconstruct the call stack using this property. Tingueu en compte:</p> + +<pre class="brush: js">function f(n) { g(n - 1); } +function g(n) { if (n > 0) { f(n); } else { stop(); } } +f(2); +</pre> + +<p>At the moment <code>stop()</code> is called the call stack will be:</p> + +<pre class="brush: js">f(2) -> g(1) -> f(1) -> g(0) -> stop() +</pre> + +<p>El següent és cert:</p> + +<pre class="brush: js">stop.caller === g && f.caller === g && g.caller === f +</pre> + +<p>so if you tried to get the stack trace in the <code>stop()</code> function like this:</p> + +<pre class="brush: js">var f = stop; +var stack = 'Stack trace:'; +while (f) { + stack += '\n' + f.name; + f = f.caller; +} +</pre> + +<p>El bucle mai s'aturaria.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Checking_the_value_of_a_function's_caller_property">Checking the value of a function's <code>caller</code> property</h3> + +<p>El codi següent comprova que el valor following code checks the value a function's <code>caller</code> property.</p> + +<pre class="brush: js">function myFunc() { + if (myFunc.caller == null) { + return 'The function was called from the top!'; + } else { + return 'This function\'s caller was ' + myFunc.caller; + } +} +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<p>No forma part de cap especificació. Implementat en JavaScript 1.5.</p> + +<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.0")}}</td> + <td>8.0</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>{{CompatGeckoMobile("1.0")}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>Error d'Implementació de SpiderMonkey {{bug(65683)}}</li> +</ul> diff --git a/files/ca/web/javascript/reference/global_objects/function/index.html b/files/ca/web/javascript/reference/global_objects/function/index.html new file mode 100644 index 0000000000..9cb0571d13 --- /dev/null +++ b/files/ca/web/javascript/reference/global_objects/function/index.html @@ -0,0 +1,236 @@ +--- +title: Function +slug: Web/JavaScript/Reference/Global_Objects/Function +tags: + - Constructor + - Function + - JavaScript + - NeedsTranslation + - TopicStub +translation_of: Web/JavaScript/Reference/Global_Objects/Function +--- +<div>{{JSRef}}</div> + +<p>The <strong><code>Function</code> constructor</strong> creates a new <code>Function</code> object. In JavaScript every function is actually a <code>Function</code> object.</p> + +<h2 id="Syntax">Syntax</h2> + +<pre class="syntaxbox"><code>new Function ([<var>arg1</var>[, <var>arg2</var>[, ...<var>argN</var>]],] <var>functionBody</var>)</code></pre> + +<h3 id="Parameters">Parameters</h3> + +<dl> + <dt><code>arg1, arg2, ... arg<em>N</em></code></dt> + <dd>Names to be used by the function as formal argument names. Each must be a string that corresponds to a valid JavaScript identifier or a list of such strings separated with a comma; for example "<code>x</code>", "<code>theValue</code>", or "<code>a,b</code>".</dd> + <dt><code>functionBody</code></dt> + <dd>A string containing the JavaScript statements comprising the function definition.</dd> +</dl> + +<h2 id="Description">Description</h2> + +<p><code>Function</code> objects created with the <code>Function</code> constructor are parsed when the function is created. This is less efficient than declaring a function with a <a href="/en-US/docs/Web/JavaScript/Reference/Operators/function">function expression</a> or <a href="/en-US/docs/Web/JavaScript/Reference/Statements/function">function statement</a> and calling it within your code, because such functions are parsed with the rest of the code.</p> + +<p>All arguments passed to the function are treated as the names of the identifiers of the parameters in the function to be created, in the order in which they are passed.</p> + +<div class="note"> +<p><strong>Note:</strong> Functions created with the <code>Function</code> constructor do not create closures to their creation contexts; they always are created in the global scope. When running them, they will only be able to access their own local variables and global ones, not the ones from the scope in which the <code>Function</code> constructor was called. This is different from using {{jsxref("eval")}} with code for a function expression.</p> +</div> + +<p>Invoking the <code>Function</code> constructor as a function (without using the <code>new</code> operator) has the same effect as invoking it as a constructor.</p> + +<h2 id="Properties_and_Methods_of_Function">Properties and Methods of <code>Function</code></h2> + +<p>The global <code>Function</code> object has no methods or properties of its own, however, since it is a function itself it does inherit some methods and properties through the prototype chain from {{jsxref("Function.prototype")}}.</p> + +<h2 id="Function_prototype_object"><code>Function</code> prototype object</h2> + +<h3 id="Properties">Properties</h3> + +<div>{{page('/en-US/docs/JavaScript/Reference/Global_Objects/Function/prototype', 'Properties')}}</div> + +<h3 id="Methods">Methods</h3> + +<div>{{page('/en-US/docs/JavaScript/Reference/Global_Objects/Function/prototype', 'Methods')}}</div> + +<h2 id="Function_instances"><code>Function</code> instances</h2> + +<p><code>Function</code> instances inherit methods and properties from {{jsxref("Function.prototype")}}. As with all constructors, you can change the constructor's prototype object to make changes to all <code>Function</code> instances.</p> + +<h2 id="Examples">Examples</h2> + +<h3 id="Specifying_arguments_with_the_Function_constructor">Specifying arguments with the <code>Function</code> constructor</h3> + +<p>The following code creates a <code>Function</code> object that takes two arguments.</p> + +<pre class="brush: js">// Example can be run directly in your JavaScript console + +// Create a function that takes two arguments and returns the sum of those arguments +var adder = new Function('a', 'b', 'return a + b'); + +// Call the function +adder(2, 6); +// > 8 +</pre> + +<p>The arguments "<code>a</code>" and "<code>b</code>" are formal argument names that are used in the function body, "<code>return a + b</code>".</p> + +<h3 id="A_recursive_shortcut_to_massively_modify_the_DOM">A recursive shortcut to massively modify the DOM</h3> + +<p>Creating functions with the <code>Function</code> constructor is one of the ways to dynamically create an indeterminate number of new objects with some executable code into the global scope from a function. The following example (a recursive shortcut to massively modify the DOM) is impossible without the invocation of the <code>Function</code> constructor for each new query if you want to avoid closures.</p> + +<pre class="brush: html"><!doctype html> +<html> +<head> +<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /> +<title>MDN Example - a recursive shortcut to massively modify the DOM</title> +<script type="text/javascript"> +var domQuery = (function() { + var aDOMFunc = [ + Element.prototype.removeAttribute, + Element.prototype.setAttribute, + CSSStyleDeclaration.prototype.removeProperty, + CSSStyleDeclaration.prototype.setProperty + ]; + + function setSomething(bStyle, sProp, sVal) { + var bSet = Boolean(sVal), fAction = aDOMFunc[bSet | bStyle << 1], + aArgs = Array.prototype.slice.call(arguments, 1, bSet ? 3 : 2), + aNodeList = bStyle ? this.cssNodes : this.nodes; + + if (bSet && bStyle) { aArgs.push(''); } + for ( + var nItem = 0, nLen = this.nodes.length; + nItem < nLen; + fAction.apply(aNodeList[nItem++], aArgs) + ); + this.follow = setSomething.caller; + return this; + } + + function setStyles(sProp, sVal) { return setSomething.call(this, true, sProp, sVal); } + function setAttribs(sProp, sVal) { return setSomething.call(this, false, sProp, sVal); } + function getSelectors() { return this.selectors; }; + function getNodes() { return this.nodes; }; + + return (function(sSelectors) { + var oQuery = new Function('return arguments.callee.follow.apply(arguments.callee, arguments);'); + oQuery.selectors = sSelectors; + oQuery.nodes = document.querySelectorAll(sSelectors); + oQuery.cssNodes = Array.prototype.map.call(oQuery.nodes, function(oInlineCSS) { return oInlineCSS.style; }); + oQuery.attributes = setAttribs; + oQuery.inlineStyle = setStyles; + oQuery.follow = getNodes; + oQuery.toString = getSelectors; + oQuery.valueOf = getNodes; + return oQuery; + }); +})(); +</script> +</head> + +<body> + +<div class="testClass">Lorem ipsum</div> +<p>Some text</p> +<div class="testClass">dolor sit amet</div> + +<script type="text/javascript"> +domQuery('.testClass') + .attributes('lang', 'en')('title', 'Risus abundat in ore stultorum') + .inlineStyle('background-color', 'black')('color', 'white')('width', '100px')('height', '50px'); +</script> +</body> + +</html> +</pre> + +<h2 id="Specifications">Specifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Initial definition. Implemented in JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.3', 'Function')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-function-objects', 'Function')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</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>Feature</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>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also">See also</h2> + +<ul> + <li>{{jsxref("Functions", "Functions and function scope")}}</li> + <li>{{jsxref("Function")}}</li> + <li>{{jsxref("Statements/function", "function statement")}}</li> + <li>{{jsxref("Operators/function", "function expression")}}</li> + <li>{{jsxref("Statements/function*", "function* statement")}}</li> + <li>{{jsxref("Operators/function*", "function* expression")}}</li> + <li>{{jsxref("GeneratorFunction")}}</li> +</ul> diff --git a/files/ca/web/javascript/reference/global_objects/function/length/index.html b/files/ca/web/javascript/reference/global_objects/function/length/index.html new file mode 100644 index 0000000000..2af00ebf41 --- /dev/null +++ b/files/ca/web/javascript/reference/global_objects/function/length/index.html @@ -0,0 +1,134 @@ +--- +title: Function.length +slug: Web/JavaScript/Reference/Global_Objects/Function/length +translation_of: Web/JavaScript/Reference/Global_Objects/Function/length +--- +<div>{{JSRef}}</div> + +<p>La propietat <code><strong>length</strong></code> especifica el nombre d'arguments que la funció espera.</p> + +<div>{{js_property_attributes(0,0,1)}}</div> + +<h2 id="Descripció">Descripció</h2> + +<p><code>length</code> és una propietat d'un objecte funció, i indica quants arguments la funció espera, és a dir, el nombre de paràmetres formals. Aquest nombre no inclou el {{jsxref("rest_parameters", "rest parameter", "", 1)}}. Per contra, {{jsxref("Functions_and_function_scope/arguments/length", "arguments.length")}} és local a la funció i retorna el nombre d'arguments que s'han passat a la funció.</p> + +<h3 id="Propietat_Data_del_constructor_Function">Propietat Data del constructor <code>Function</code></h3> + +<p>El constructor {{jsxref("Function")}} és per ell mateix un objecte {{jsxref("Function")}}. La seva propietat data <code>length</code> pren un valor d'1. Els atributs de la propietat són: Writable: <code>false</code>, Enumerable: <code>false</code>, Configurable: <code>true</code>.</p> + +<h3 id="Propietat_de_l'objecte_prototipus_Function">Propietat de l'objecte prototipus <code>Function</code></h3> + +<p>La propietat length de l'objecte prototipus {{jsxref("Function")}} pren un valor de 0.</p> + +<h2 id="Exemples">Exemples</h2> + +<pre class="brush: js">console.log(Function.length); /* 1 */ + +console.log((function() {}).length); /* 0 */ +console.log((function(a) {}).length); /* 1 */ +console.log((function(a, b) {}).length); /* 2 etc. */ +console.log((function(...args) {}).length); /* 0, la resta de paràmetres no es conta */ +</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>Definció inicial. Implementat en JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.3.5.1', 'Function.length')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-function-instances-length', 'Function.length')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>L'atribut <code>configurable</code> d'aquesta propietat és ara <code>true</code>.</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> + <tr> + <td>Configurable: true</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatGeckoDesktop(37)}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>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> + <tr> + <td>Configurable: true</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatGeckoMobile(37)}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Function")}}</li> +</ul> diff --git a/files/ca/web/javascript/reference/global_objects/function/name/index.html b/files/ca/web/javascript/reference/global_objects/function/name/index.html new file mode 100644 index 0000000000..6f88ba9be2 --- /dev/null +++ b/files/ca/web/javascript/reference/global_objects/function/name/index.html @@ -0,0 +1,153 @@ +--- +title: Function.name +slug: Web/JavaScript/Reference/Global_Objects/Function/name +translation_of: Web/JavaScript/Reference/Global_Objects/Function/name +--- +<div>{{JSRef}}</div> + +<p>La propietat <code><strong><em>function</em>.name</strong></code> retorna el nom de la funció.</p> + +<div>{{js_property_attributes(0,0,1)}}</div> + +<div>Vegeu que en les implementacions no estàndards anteriors a ES2015 l'atribut <code>configurable</code> també era <code>false</code>.</div> + +<h2 id="Descripció">Descripció</h2> + +<p>La propietat <code>name</code> retorna el nom de la funció, o una cadena buida per les funcions anònimes.</p> + +<pre class="brush: js">function fesAlgo() {} + +console.log(desAlgo.name); // escriu "fesAlgo" +</pre> + +<p>Les funcions creades amb la sintaxis <code>new Function(...)</code> o sols <code>Function(...)</code>tenen la seva propietat <code>name</code> en una cadena buida. En els exemples següents es creen funcions anònimes , de forma que <code>name</code> retorna una cadena buida:</p> + +<pre class="brush: js">var f = function() {}; +var object = { + someMethod: function() {} +}; + +console.log(f.name == ''); // true +console.log(object.someMethod.name == ''); // també true +</pre> + +<p>Es pot definir una funció amb un nom en un {{jsxref("Operators/Function", "function expression", "", 1)}}:</p> + +<pre class="brush: js">var object = { + someMethod: function object_someMethod() {} +}; +console.log(object.someMethod.name); // logs "object_someMethod" + +try { object_someMethod } catch(e) { console.log(e); } +// ReferenceError: object_someMethod no està definit +</pre> + +<p>No es pot canviar el nom de la funció, aquesta propietat és només llegible:</p> + +<pre class="brush: js">var object = { + // anònima + someMethod: function() {} +}; + +object.someMethod.name = 'someMethod'; +console.log(object.someMethod.name); // cadena buida, someMethod és anònima. +</pre> + +<p>Per canviar-ho, es pot utilitzar {{jsxref("Object.defineProperty()")}}.</p> + +<h2 id="Exemples">Exemples</h2> + +<p>Es pot utilitzar <code>obj.constructor.name</code> per comprovar la "classe" d'un objecte:</p> + +<pre class="brush: js">function a() {} + +var b = new a(); + +console.log(b.constructor.name); // escriu "a" +</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('ES2015', '#sec-name', 'name')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Definició inicial.</td> + </tr> + </tbody> +</table> + +<h2 id="Comptabilitat_amb_navegadors">Comptabilitat 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>33</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + <tr> + <td>Configurable: true</td> + <td>43</td> + <td>{{CompatGeckoDesktop(38)}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>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>{{CompatNo}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + <tr> + <td>Configurable: true</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatGeckoMobile(38)}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> diff --git a/files/ca/web/javascript/reference/global_objects/function/tosource/index.html b/files/ca/web/javascript/reference/global_objects/function/tosource/index.html new file mode 100644 index 0000000000..27f135ce13 --- /dev/null +++ b/files/ca/web/javascript/reference/global_objects/function/tosource/index.html @@ -0,0 +1,97 @@ +--- +title: Function.prototype.toSource() +slug: Web/JavaScript/Reference/Global_Objects/Function/toSource +translation_of: Web/JavaScript/Reference/Global_Objects/Function/toSource +--- +<div>{{JSRef}} {{non-standard_header}}</div> + +<p>El mètode <code><strong>toSource()</strong></code>retorna una cadena que representa el codi font de l'objecte.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>function</var>.toSource(); +Function.toSource(); +</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<p>Cap.</p> + +<h2 id="Descripció">Descripció</h2> + +<p>El mètode <code>toSource</code> retorna els valors següents:</p> + +<ul> + <li>Per l'objecte incorporat {{jsxref("Function")}}, <code>toSource()</code> retorna la cadena següent indicant que el codi font no es troba disponible: + + <pre class="brush: js">function Function() { + [native code] +} +</pre> + </li> + <li>Per funcions personalitzades, <code>toSource()</code> retorna la font de JavaScript que defineix l'objecte com una cadena.</li> +</ul> + +<p>Aquest mètode se sol cridar internament per JavaScript i no explícitament en el codi. Podeu cridar <code>toSource</code> durant la depuració per examinar el contingut d'un objecte.</p> + +<h2 id="Especificacions">Especificacions</h2> + +<p>No forma part de cap estàndard. Implementat en JavaScript 1.3.</p> + +<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>{{CompatNo}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>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>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Object.prototype.toSource()")}}</li> +</ul> diff --git a/files/ca/web/javascript/reference/global_objects/object/assign/index.html b/files/ca/web/javascript/reference/global_objects/object/assign/index.html new file mode 100644 index 0000000000..855b5654a6 --- /dev/null +++ b/files/ca/web/javascript/reference/global_objects/object/assign/index.html @@ -0,0 +1,252 @@ +--- +title: Object.assign() +slug: Web/JavaScript/Reference/Global_Objects/Object/assign +translation_of: Web/JavaScript/Reference/Global_Objects/Object/assign +--- +<div>{{JSRef}}</div> + +<p>El mètode <strong><code>Object.assign()</code></strong> s'utilitza per copiar els valors de totes les propietats enumerables pròpies d'un o més objectes d'orígens a un objecte objectiu o destí. Retornarà l'objecte destí.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code>Object.assign(<var>target</var>, ...<var>orígens</var>)</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>target</code></dt> + <dd>L'objecte destí.</dd> + <dt><code>sources</code></dt> + <dd>El(s) objecte(s) d'orígen.</dd> +</dl> + +<h3 id="Valor_retornat">Valor retornat</h3> + +<p>L'objecte destí (o objectiu) es retornat.</p> + +<h2 id="Descripció">Descripció</h2> + +<p>El mètode <code>Object.assign()</code> només copia propietats <em>enumerable</em>s i <em>pròpies</em> d'un objecte orígen a un objecte destí. S'utilitza <code>[[Get]]</code> a l'orígen i <code>[[Put]]</code> al destí, de forma que invocarà getters i setters. Per tant, <em>assigna</em> propietats en comptes de només copiar o definir noves propietats. Axò pot fer que sigui inadequat per juntar noves propietats en un prototipus si les fonts de la unió contenen getters. Per copiar definicions de la propietat, incloent la seva enumerabilitat, en prototipus s'ha de fer servir {{jsxref("Object.getOwnPropertyDescriptor()")}} i {{jsxref("Object.defineProperty()")}}.</p> + +<p>Tant la propietat {{jsxref("String")}} com la propietat {{jsxref("Symbol")}} són copiades.</p> + +<p>En cas d'error, per exemple si una propietat no és modificable, un {{jsxref("TypeError")}} <strong><u>s'incrementarà </u></strong>i l'objecte <code>target</code> object es mantindrà sense canvis.</p> + +<p>Vegeu que <code>Object.assign()</code> does not throw on {{jsxref("null")}} or {{jsxref("undefined")}} source values.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Clonar_un_objecte">Clonar un objecte</h3> + +<pre class="brush: js">var obj = { a: 1 }; +var copy = Object.assign({}, obj); +console.log(copy); // { a: 1 } +</pre> + +<h3 id="Unir_objectes">Unir objectes</h3> + +<pre class="brush: js">var o1 = { a: 1 }; +var o2 = { b: 2 }; +var o3 = { c: 3 }; + +var obj = Object.assign(o1, o2, o3); +console.log(obj); // { a: 1, b: 2, c: 3 } +console.log(o1); // { a: 1, b: 2, c: 3 }, L'objecte de destinació es canvia</pre> + +<h3 id="Copiar_propietats_symbol-typed">Copiar propietats symbol-typed</h3> + +<pre class="brush: js">var o1 = { a: 1 }; +var o2 = { [Symbol('foo')]: 2 }; + +var obj = Object.assign({}, o1, o2); +console.log(obj); // { a: 1, [Symbol("foo")]: 2 } +</pre> + +<h3 id="Les_propietats_heretades_i_les_propietats_no_enumerables_no_es_poden_copiar">Les propietats heretades i les propietats no enumerables no es poden copiar</h3> + +<pre class="brush: js">var obj = Object.create({ foo: 1 }, { // foo és una propietat heretada. + bar: { + value: 2 // bar és una propietat no enumerable. + }, + baz: { + value: 3, + enumerable: true // baz is an own enumerable property. + } +}); + +var copy = Object.assign({}, obj); +console.log(copy); // { baz: 3 } +</pre> + +<h3 id="Primitives_will_be_wrapped_to_objects">Primitives will be wrapped to objects</h3> + +<pre class="brush: js">var v1 = '123'; +var v2 = true; +var v3 = 10; +var v4 = Symbol('foo') + +var obj = Object.assign({}, v1, null, v2, undefined, v3, v4); +// Primitives will be wrapped, null and undefined will be ignored. +// Note, only string wrappers can have own enumerable properties. +console.log(obj); // { "0": "1", "1": "2", "2": "3" } +</pre> + +<h3 id="Exceptions_will_interrupt_the_ongoing_copying_task">Exceptions will interrupt the ongoing copying task</h3> + +<pre class="brush: js">var target = Object.defineProperty({}, 'foo', { + value: 1, + writeable: false +}); // target.foo is a read-only property + +Object.assign(target, { bar: 2 }, { foo2: 3, foo: 3, foo3: 3 }, { baz: 4 }); +// TypeError: "foo" is read-only +// The Exception is thrown when assigning target.foo + +console.log(target.bar); // 2, the first source was copied successfully. +console.log(target.foo2); // 3, the first property of the second source was copied successfully. +console.log(target.foo); // 1, exception is thrown here. +console.log(target.foo3); // undefined, assign method has finished, foo3 will not be copied. +console.log(target.baz); // undefined, the third source will not be copied either. +</pre> + +<h3 id="Copying_accessors">Copying accessors</h3> + +<pre class="brush: js">var obj = { + foo: 1, + get bar() { + return 2; + } +}; + +var copy = Object.assign({}, obj); +console.log(copy); +// { foo: 1, bar: 2 }, the value of copy.bar is obj.bar's getter's return value. + +// This is an assign function which can copy accessors. +function myAssign(target, ...sources) { + sources.forEach(source => { + Object.defineProperties(target, Object.keys(source).reduce((descriptors, key) => { + descriptors[key] = Object.getOwnPropertyDescriptor(source, key); + return descriptors; + }, {})); + }); + return target; +} + +var copy = myAssign({}, obj); +console.log(copy); +// { foo:1, get bar() { return 2 } } +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>This polyfill doesn't support symbol properties, since ES5 doesn't have symbols anyway:</p> + +<pre class="brush: js">if (!Object.assign) { + Object.defineProperty(Object, 'assign', { + enumerable: false, + configurable: true, + writable: true, + value: function(target) { + 'use strict'; + if (target === undefined || target === null) { + throw new TypeError('Cannot convert first argument to object'); + } + + var to = Object(target); + for (var i = 1; i < arguments.length; i++) { + var nextSource = arguments[i]; + if (nextSource === undefined || nextSource === null) { + continue; + } + nextSource = Object(nextSource); + + var keysArray = Object.keys(Object(nextSource)); + for (var nextIndex = 0, len = keysArray.length; nextIndex < len; nextIndex++) { + var nextKey = keysArray[nextIndex]; + var desc = Object.getOwnPropertyDescriptor(nextSource, nextKey); + if (desc !== undefined && desc.enumerable) { + to[nextKey] = nextSource[nextKey]; + } + } + } + return to; + } + }); +} +</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('ES2015', '#sec-object.assign', 'Object.assign')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Definició inicial</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_de_navegadors">Compatibilitat de navegadors</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Caracteristica</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("34")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome per Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatGeckoMobile("34")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Object.defineProperties()")}}</li> +</ul> diff --git a/files/ca/web/javascript/reference/global_objects/object/count/index.html b/files/ca/web/javascript/reference/global_objects/object/count/index.html new file mode 100644 index 0000000000..ed84c7006c --- /dev/null +++ b/files/ca/web/javascript/reference/global_objects/object/count/index.html @@ -0,0 +1,82 @@ +--- +title: Object.prototype.__count__ +slug: Web/JavaScript/Reference/Global_Objects/Object/count +translation_of: Archive/Web/JavaScript/Object.count +--- +<div>{{JSRef}} {{obsolete_header("2")}}</div> + +<p>La propietat <strong><code>__count__</code></strong> s'utilitzava per emmagatzemar el recompte de les propietats enumerables d'un objecte, però s'ha eliminat.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>obj</var>.__count__</code></pre> + +<h2 id="Exemples">Exemples</h2> + +<pre class="brush: js">{ 1: 1 }.__count__ // 1 +[].__count__ // 0 +[1].__count__ // 1 +[1, /* hole */, 2, 3].__count__ // 3 +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<p>No forma part de cap especificació.</p> + +<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>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome per Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li><a class="external" href="http://whereswalden.com/2010/04/06/more-changes-coming-to-spidermonkey-the-magical-__count__-property-of-objects-is-being-removed/">[Blog post] Més canvis en SpiderMonkey: la propietat màgica __count__ s'ha eliminat</a></li> +</ul> diff --git a/files/ca/web/javascript/reference/global_objects/object/eval/index.html b/files/ca/web/javascript/reference/global_objects/object/eval/index.html new file mode 100644 index 0000000000..8c43cf423a --- /dev/null +++ b/files/ca/web/javascript/reference/global_objects/object/eval/index.html @@ -0,0 +1,85 @@ +--- +title: Object.prototype.eval() +slug: Web/JavaScript/Reference/Global_Objects/Object/eval +translation_of: Archive/Web/JavaScript/Object.eval +--- +<div>{{JSRef}} {{obsolete_header}}</div> + +<p>El mètode <code><strong>Object.eval()</strong></code> solia avaluar una cadena del codi JavaScript en el context d'un objecte, tanmateix, aquest mètode s'ha eliminat.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>obj</var>.eval(<var>cadena</var>)</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>cadena</code></dt> + <dd>Qualsevol cadena que representi una expressió JavaScript, sentència, o una seqüència de sentències. L'expressió pot incloure variables i propietats d'objectes ja existents.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>El mètode <code>eval</code> ja no es pot utilitzar com a mètode d'un objecte. Utilitzeu la funció de més alt nivell {{jsxref("Global_Objects/eval", "eval()")}} per aquesta finalitat.</p> + +<h2 id="Especificacions">Especificacions</h2> + +<p>No forma part de cap especificació.</p> + +<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>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome per Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Global_Objects/eval", "eval()")}}</li> +</ul> diff --git a/files/ca/web/javascript/reference/global_objects/object/freeze/index.html b/files/ca/web/javascript/reference/global_objects/object/freeze/index.html new file mode 100644 index 0000000000..1231afe27f --- /dev/null +++ b/files/ca/web/javascript/reference/global_objects/object/freeze/index.html @@ -0,0 +1,193 @@ +--- +title: Object.freeze() +slug: Web/JavaScript/Reference/Global_Objects/Object/freeze +translation_of: Web/JavaScript/Reference/Global_Objects/Object/freeze +--- +<div>{{JSRef}}</div> + +<p>El mètode <code><strong>Object.freeze()</strong></code> congela un objecte: és a dir, evita que se li puguin afegir noves propietats, eliminar propietats ja existents així com modificar els paràmetres d'enumerabilitat, configurabilitat i possibilitat d'escriptura de les propietats existents. Això, en essència fa que l'objecte esdevingui immutable a efectes pràctics. El mètode retorna l'objecte que s'ha congelat.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code>Object.freeze(<var>obj</var>)</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>obj</code></dt> + <dd>L'objecte a congelar.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Res pot ser afegit o eliminat del conjunt de propietats d'un objecte congelat. Qualsevol intent fallarà o bé sense reportar cap error o bé llençant una excepció {{jsxref("TypeError")}} (és l'excepció més freqüent que serà llençada però en pot llençat altres tipus; a l'utilitzar el {{jsxref("Strict_mode", "mode estricte", "", 1)}}).</p> + +<p>Congelar un objecte també evita que es puguin modificar els valors de les seves propietats. Les propietats d'accés (getters i setters) segueixen funcionan (donant la il·lusió que s'ha canviat el valor). Cal advertir, però, que els valors que siguin objectes sí que es poden modificar, a no ser que aquests objectes també estiguin congelats.</p> + +<h2 id="Exemples">Exemples</h2> + +<pre class="brush: js">var obj = { + prop: function() {}, + foo: 'bar' +}; + +// Es poden afegir noves propietats, així com canviar o eliminar les propietats ja existents +obj.foo = 'baz'; +obj.lumpy = 'woof'; +delete obj.prop; + +var o = Object.freeze(obj); + +assert(Object.isFrozen(obj) === true); + +// A partir d'ara qualsevol canvi fallarà +obj.foo = 'quux'; // falla silenciosament +obj.quaxxor = 'the friendly duck'; // romàn en silenci i no afegeix la propietat + +// ...i en mode estricte qualsevol intent llençarà una excepció TypeError +function fail(){ + 'use strict'; + obj.foo = 'sparky'; // llença TypeError + delete obj.quaxxor; // llença TypeError + obj.sparky = 'arf'; // llença TypeError +} + +fail(); + +// Intentar realitzar canvis a través de Object.defineProperty també resultaran en excepcions +Object.defineProperty(obj, 'ohai', { value: 17 }); // llença TypeError +Object.defineProperty(obj, 'foo', { value: 'eit' }); // llença TypeError +</pre> + +<p>L'exemple següent demostra que valors de tipus objecte pertanyents a propietats d'un objecte congelat sí que es poden modificar.(<code>freeze</code> no s'aplica de manera recursiva).</p> + +<pre class="brush: js">obj1 = { + internal: {} +}; + +Object.freeze(obj1); +obj1.internal.a = 'aValue'; + +obj1.internal.a // 'aValue' + +// Per a fer que obj sigui totalment immutable cal congelar tots els objectes referenciats per aquest. +// Per a aconseguir això utilitzem la funció següent +function deepFreeze(obj) { + + // Obté els nomes de les propietats definides a l'objecte obj + var propNames = Object.getOwnPropertyNames(obj); + + // Congela les propietats abans de congelar l'objecte en si + propNames.forEach(function(name) { + var prop = obj[name]; + + // Congela prop si aquest és un objecte + if (typeof prop == 'object' && !Object.isFrozen(prop)) + deepFreeze(prop); + }); + + // Congela l'objecte pare + return Object.freeze(obj); +} + +obj2 = { + internal: {} +}; + +deepFreeze(obj2); +obj2.internal.a = 'anotherValue'; +obj2.internal.a; // undefined +</pre> + +<h2 id="Notes">Notes</h2> + +<p>A l'EcmaScript 5, si l'argument passat a aquest mètode no és un objecte (un valor primitiu), llençarà un {{jsxref("TypeError")}}. A l'EcmaScript 6, un argument que no sigui un objecte serà tractat com si fós un objecte congelat ordinari, i simplement el retornarà.</p> + +<pre class="brush: js">> Object.freeze(1) +TypeError: 1 no és un objecte // Codi EcmaScript 5 + +> Object.freeze(1) +1 // Codi EcmaScript 6 +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificacions</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.2.3.9', 'Object.freeze')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Definició inicial. Implementat a JavaScript 1.8.5.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-object.freeze', 'Object.freeze')}}</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>Firefox (Gecko)</th> + <th>Chrome</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatGeckoDesktop("2")}}</td> + <td>{{CompatChrome("6")}}</td> + <td>{{CompatIE("9")}}</td> + <td>{{CompatOpera("12")}}</td> + <td>{{CompatSafari("5.1")}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Firefox Mobile (Gecko)</th> + <th>Android</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Object.isFrozen()")}}</li> + <li>{{jsxref("Object.preventExtensions()")}}</li> + <li>{{jsxref("Object.isExtensible()")}}</li> + <li>{{jsxref("Object.seal()")}}</li> + <li>{{jsxref("Object.isSealed()")}}</li> +</ul> diff --git a/files/ca/web/javascript/reference/global_objects/object/getprototypeof/index.html b/files/ca/web/javascript/reference/global_objects/object/getprototypeof/index.html new file mode 100644 index 0000000000..01666d0898 --- /dev/null +++ b/files/ca/web/javascript/reference/global_objects/object/getprototypeof/index.html @@ -0,0 +1,124 @@ +--- +title: Object.getPrototypeOf() +slug: Web/JavaScript/Reference/Global_Objects/Object/getPrototypeOf +translation_of: Web/JavaScript/Reference/Global_Objects/Object/getPrototypeOf +--- +<div>{{JSRef}}</div> + +<p>El mètode <code><strong>Object.getPrototypeOf()</strong></code> retorna el prototipus (és a dir, el valor de la propietat interna <code>[[Prototype]]</code>) de l'objecte especificat.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code>Object.getPrototypeOf(<var>obj</var>)</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>obj</code></dt> + <dd>L'objecte del qual es retornarà el prototipus.</dd> +</dl> + +<h2 id="Exemples">Exemples</h2> + +<pre class="brush: js">var proto = {}; +var obj = Object.create(proto); +Object.getPrototypeOf(obj) === proto; // true +</pre> + +<h2 id="Notes">Notes</h2> + +<p>A l'EcmaScript 5 llençarà una excepció {{jsxref("TypeError")}} si el paràmetre <code>obj</code> no és un objecte. A l'EcmaScript 6 el paràmetre serà forçat al tipus {{jsxref("Object")}}.</p> + +<pre class="brush: js">Object.getPrototypeOf("foo"); +// TypeError: "foo" no és un objecte (codi EcmaScript 5) +Object.getPrototypeOf("foo"); +// String.prototype (codi EcmaScript 6) +</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.2.3.2', 'Object.getPrototypeOf')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Definició inicial.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-object.getprototypeof', 'Object.getProtoypeOf')}}</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("1.9.1")}}</td> + <td>{{CompatIE("9")}}</td> + <td>{{CompatOpera("12.10")}}</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 for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Notes_específiques_per_a_Opera">Notes específiques per a Opera</h2> + +<p>Tot i que versions antigues de Opera no suporten <code>Object.getPrototypeOf()</code>, Opera soporta la propietat no standard {{jsxref("Object.proto", "__proto__")}} a partir de la versió 10.50.</p> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Object.prototype.isPrototypeOf()")}}</li> + <li>{{jsxref("Object.setPrototypeOf()")}} {{experimental_inline}}</li> + <li>{{jsxref("Object.prototype.__proto__")}}</li> + <li>John Resig's post on <a class="external" href="http://ejohn.org/blog/objectgetprototypeof/">getPrototypeOf</a></li> + <li>{{jsxref("Reflect.getPrototypeOf()")}}</li> +</ul> diff --git a/files/ca/web/javascript/reference/global_objects/object/index.html b/files/ca/web/javascript/reference/global_objects/object/index.html new file mode 100644 index 0000000000..1c2a779065 --- /dev/null +++ b/files/ca/web/javascript/reference/global_objects/object/index.html @@ -0,0 +1,213 @@ +--- +title: Object +slug: Web/JavaScript/Reference/Global_Objects/Object +tags: + - Constructor + - JavaScript + - NeedsTranslation + - Object + - TopicStub +translation_of: Web/JavaScript/Reference/Global_Objects/Object +--- +<div>{{JSRef}}</div> + +<p>El constructor <code><strong>Object</strong></code> crea un embolcall d'objecte.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code>// Inicialitzador d'objecte o literal +{ [ <var>parellNomValor1</var>[, <var>parellNomValor2</var>[, ...<var>parellNomValorN</var>] ] ] } + +// Cridat com a constructor +new Object([valor])</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>parellNomValor1, parellNomValor2, ... parellNomValor<em>N</em></code></dt> + <dd>Parells de noms (string) i valors (quasevol valor) on els noms se separen dels valors mitjançant dos punts (:).</dd> + <dt><code>value</code></dt> + <dd>Qualsevol valor.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>El constructor <code>Object</code> crea un embolcall d'objecte per al valor donat. Si el valor és {{jsxref("null")}} o bé {{jsxref("undefined")}}, crearà i retornarà un objecte buit. En cas contrari retornarà un objecte del tipus corresponent al valor donat. Si el valor donat ja és un objecte, retornarà el mateix objecte.</p> + +<p>Quan es crida fora d'un contexte constructor, <code>Object</code> es comporta exactament de la mateixa manera que <code>new Object()</code>.</p> + +<p>Vegeu també la <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Object_initializer">sintaxi literal / d'inicialització d'objectes</a>.</p> + +<h2 id="Propietats_del_constructor_Object">Propietats del constructor <code>Object</code></h2> + +<dl> + <dt><code>Object.length</code></dt> + <dd>Val 1.</dd> + <dt>{{jsxref("Object.prototype")}}</dt> + <dd>Permet l'adició de propietats a tots els objecte del tipus <code>Object</code>.</dd> +</dl> + +<h2 id="Mètodes_del_constructor_Object">Mètodes del constructor <code>Object</code></h2> + +<dl> + <dt>{{jsxref("Object.assign()")}} {{experimental_inline}}</dt> + <dd>Crea un nou objecte copiant els valors de totes les propietats pròpies enumerables d'un o més objectes origin a l'objecte destí.</dd> + <dt>{{jsxref("Object.create()")}}</dt> + <dd>Crea un nou objecte amb l'objecte prototipus que s'especifiqui, així com les propietats passades.</dd> + <dt>{{jsxref("Object.defineProperty()")}}</dt> + <dd>Afegeix a l'objecte la propietat amb nom descrita pel descriptor especificat.</dd> + <dt>{{jsxref("Object.defineProperties()")}}</dt> + <dd>Afegeix a l'objecte les propietats amb nom descrites pels descriptors especificats.</dd> + <dt>{{jsxref("Object.freeze()")}}</dt> + <dd><em>Congela</em> un objecte de forma que les propietats d'aquest no poden ser esborrades o canviades.</dd> + <dt>{{jsxref("Object.getOwnPropertyDescriptor()")}}</dt> + <dd>Retorna un descriptor de propietat per a la propietat donada d'un objecte.</dd> + <dt>{{jsxref("Object.getOwnPropertyNames()")}}</dt> + <dd>Retorna un array que contindrà els nomes de totes les propietats <strong>pròpies</strong> d'un objecte, tant enumerables com no enumerables.</dd> + <dt>{{jsxref("Object.getOwnPropertySymbols()")}} {{experimental_inline}}</dt> + <dd>Retorna un array amb totes les propietats de tipus symbol que siguin pròpies d'un objecte donat.</dd> + <dt>{{jsxref("Object.getPrototypeOf()")}}</dt> + <dd>Retorna el prototipus de l'objecte especificat.</dd> + <dt>{{jsxref("Object.is()")}} {{experimental_inline}}</dt> + <dd>Compara dos valors i determina si són equivalents (és a dir, si són el mateix objecte).</dd> + <dt>{{jsxref("Object.isExtensible()")}}</dt> + <dd>Determina si és permés extendre un objecte.</dd> + <dt>{{jsxref("Object.isFrozen()")}}</dt> + <dd>Determina si l'objecte està congelat.</dd> + <dt>{{jsxref("Object.isSealed()")}}</dt> + <dd>Determina si un objecte està segellat.</dd> + <dt>{{jsxref("Object.keys()")}}</dt> + <dd>Retorna un array que conté els noms de totes les propietats enumerables <strong>pròpies</strong> d'un objecte donat.</dd> + <dt>{{jsxref("Object.observe()")}} {{experimental_inline}}</dt> + <dd>Observa canvies en un objecte de forma asíncrona.</dd> + <dt>{{jsxref("Object.preventExtensions()")}}</dt> + <dd>Desactiva la capacitat d'un objecte per a ser extés.</dd> + <dt>{{jsxref("Object.seal()")}}</dt> + <dd>Desactiva la capacitat de poder esborrar propietats de l'objecte.</dd> + <dt>{{jsxref("Object.setPrototypeOf()")}} {{experimental_inline}}</dt> + <dd>Assigna el prototipus (és a dir, la propietat interna <code>[[Prototype]]</code>)</dd> +</dl> + +<h2 id="Instàncies_de_Object_i_l'objecte_prototipus">Instàncies de <code>Object</code> i l'objecte prototipus</h2> + +<p>A JavaScript, tots els objectes són descendents de <code>Object</code>; tots els objectes hereten els mètodes i propietats de {{jsxref("Object.prototype")}}, tot i que poden ser sobreescrits. Per exemple, els prototipus d'altres constructors sobreescriuen la propietat <code>constructor</code> i ofereixen el seu propi mètode <code>toString()</code>. Els canvis al prototipus <code>Object</code> es propaguen a tots els objectes a no ser que les propietats i mètodes que reben aquests canvis hagin sigut sobreescrites més avall a la cadena de prototipus.</p> + +<h3 id="Propietats">Propietats</h3> + +<div>{{page('/ca/docs/Web/JavaScript/Reference/Global_Objects/Object/prototype', 'Properties') }}</div> + +<h3 id="Mètodes">Mètodes</h3> + +<div>{{page('/ca/docs/Web/JavaScript/Reference/Global_Objects/Object/prototype', 'Methods') }}</div> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_Object_amb_els_tipus_undefined_i_null_types">Utilitzar <code>Object</code> amb els tipus <code>undefined</code> i <code>null</code> types</h3> + +<p>Els següents exemples emmagatzemen un objecte <code>Object</code> buit a <code>o</code>:</p> + +<pre class="brush: js">var o = new Object(); +</pre> + +<pre class="brush: js">var o = new Object(undefined); +</pre> + +<pre class="brush: js">var o = new Object(null); +</pre> + +<h3 id="Utilitzar_Object_per_a_crear_objectes_booleans">Utilitzar <code>Object</code> per a crear objectes booleans</h3> + +<p>Els exemples següents emmagatzemen objectes de tipus {{jsxref("Boolean")}} a <code>o</code>:</p> + +<pre class="brush: js">// equivalent a o = new Boolean(true); +var o = new Object(true); +</pre> + +<pre class="brush: js">// equivalent a o = new Boolean(false); +var o = new Object(Boolean()); +</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.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.2', 'Object')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-object-objects', 'Object')}}</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 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><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Object_initializer">Inicialitzador d'objectes</a></li> +</ul> diff --git a/files/ca/web/javascript/reference/global_objects/object/isextensible/index.html b/files/ca/web/javascript/reference/global_objects/object/isextensible/index.html new file mode 100644 index 0000000000..7b8700654c --- /dev/null +++ b/files/ca/web/javascript/reference/global_objects/object/isextensible/index.html @@ -0,0 +1,138 @@ +--- +title: Object.isExtensible() +slug: Web/JavaScript/Reference/Global_Objects/Object/isExtensible +translation_of: Web/JavaScript/Reference/Global_Objects/Object/isExtensible +--- +<div>{{JSRef}}</div> + +<p>El mètode <strong><code>Object.isExtensible()</code></strong> determina si un objecte és extensible (és a dir, si accepta l'addició de noves propietats).</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code>Object.isExtensible(<var>obj</var>)</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>obj</code></dt> + <dd>L'objecte del que comprovarà l'extensibilitat.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Per defecte tots els objectes són extensibles: se'ls hi poden afegir noves propietats, i (en objectes que suportin {{jsxref("Object.proto", "__proto__")}} {{deprecated_inline}} la seva propietat __proto__ property) es pot modificar. Es pot marcar un objecte com a no extensible utilitzant {{jsxref("Object.preventExtensions()")}}, {{jsxref("Object.seal()")}}, o bé {{jsxref("Object.freeze()")}}.</p> + +<h2 id="Exemples">Exemples</h2> + +<pre class="brush: js">// Els objectes nous són extensibles. +var empty = {}; +Object.isExtensible(empty); // === true + +// ...pero això pot canviar. +Object.preventExtensions(empty); +Object.isExtensible(empty); // === false + +// Els objectes segellats són no extensibles per definició +var sealed = Object.seal({}); +Object.isExtensible(sealed); // === false + +// Els objectes congelats també són no extensibes per definició +var frozen = Object.freeze({}); +Object.isExtensible(frozen); // === false +</pre> + +<h2 id="Notes">Notes</h2> + +<p>A l'EcmaScript 5, si l'argument d'aquest mètode no és un objecte (un valor primitiu) es llençarà una excepció {{jsxref("TypeError")}}. A l'EcmaScript 6, un argument que no sigui un objecte es tractarà com si fós un objecte no extensible ordinari i simplement retornarà <code>false</code>.</p> + +<pre class="brush: js">Object.isExtensible(1); +// TypeError: 1 no és un objecte (codi EcmaScript 5) + +Object.isExtensible(1); +// false (codi EcmaScript 6) +</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.2.3.13', 'Object.isExtensible')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Definició inicial. Implementat a JavaScript 1.8.5.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-object.isextensible', 'Object.isExtensible')}}</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("6")}}</td> + <td>{{CompatGeckoDesktop("2.0")}}</td> + <td>{{CompatIE("9")}}</td> + <td>{{CompatOpera("12")}}</td> + <td>{{CompatSafari("5.1")}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Object.preventExtensions()")}}</li> + <li>{{jsxref("Object.seal()")}}</li> + <li>{{jsxref("Object.isSealed()")}}</li> + <li>{{jsxref("Object.freeze()")}}</li> + <li>{{jsxref("Object.isFrozen()")}}</li> + <li>{{jsxref("Reflect.isExtensible()")}}</li> +</ul> diff --git a/files/ca/web/javascript/reference/global_objects/object/isfrozen/index.html b/files/ca/web/javascript/reference/global_objects/object/isfrozen/index.html new file mode 100644 index 0000000000..46c2e24be2 --- /dev/null +++ b/files/ca/web/javascript/reference/global_objects/object/isfrozen/index.html @@ -0,0 +1,182 @@ +--- +title: Object.isFrozen() +slug: Web/JavaScript/Reference/Global_Objects/Object/isFrozen +translation_of: Web/JavaScript/Reference/Global_Objects/Object/isFrozen +--- +<div>{{JSRef}}</div> + +<p>El mètode <code><strong>Object.isFrozen()</strong></code> determina si un objecte està congelat.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code>Object.isFrozen(<var>obj</var>)</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>obj</code></dt> + <dd>L'objecte que es comprovarà si està congelat o no.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Un objecte està congelat si i només si no és {{jsxref("Object.isExtensible()", "extensible", "", 1)}}, cap de les seves propietats és configurable, i cap de les seves propietats de dades (és a dir, propietats que no són <em>accessor</em> amb components getter o setter) that is, properties which are not accessor properties with getter or setter components) es poden escriure (modificar el seu valor).</p> + +<h2 id="Exemples">Exemples</h2> + +<pre class="brush: js">// Els objectes nous són extensibles, així que no estan congelats. +Object.isFrozen({}); // === false + +// Un objecte buit que no és extensible està congelat ja que no te propietats que trenquin les restriccions. +var vacuouslyFrozen = Object.preventExtensions({}); +Object.isFrozen(vacuouslyFrozen); // === true + +// Un objecte nou amb una propietat és extensible, i per tant no està congelat. +var oneProp = { p: 42 }; +Object.isFrozen(oneProp); // === false + +// Fer-lo no extensible no el fa congelat, +// perquè la propietat encara és configurable (i permet l'escriptura). +Object.preventExtensions(oneProp); +Object.isFrozen(oneProp); // === false + +// ...però, un altre cop, si eliminem la propietat ens trobem amb un objecte buit congelat. +delete oneProp.p; +Object.isFrozen(oneProp); // === true + +// Un objecte no extensible amb una propietat que no permeti l'escriptura però sí que es configurable no està congelat. +var nonWritable = { e: 'plep' }; +Object.preventExtensions(nonWritable); +Object.defineProperty(nonWritable, 'e', { writable: false }); // fer que la propietat no permeti l'escriptura +Object.isFrozen(nonWritable); // === false + +// Fer aquesta propietat no configurable fa que l'objecte estigui congelat +Object.defineProperty(nonWritable, 'e', { configurable: false }); // fer la propietat no configurable +Object.isFrozen(nonWritable); // === true + +// Un objecte no extensible amb una propietat no configurable però que si permeti l'escriptura tampoc està congelat. +var nonConfigurable = { release: 'the kraken!' }; +Object.preventExtensions(nonConfigurable); +Object.defineProperty(nonConfigurable, 'release', { configurable: false }); +Object.isFrozen(nonConfigurable); // === false + +// Canviar aquesta propietat per a que no permeti l'escriptura fa que l'objecte estigui congelat. +Object.defineProperty(nonConfigurable, 'release', { writable: false }); +Object.isFrozen(nonConfigurable); // === true + +// Un objecte amb una propietat accessor no extensible no està congelat. +var accessor = { get food() { return 'yum'; } }; +Object.preventExtensions(accessor); +Object.isFrozen(accessor); // === false + +// ...però si la propietat es fa no configurable l'objecte esdevé congelat. +Object.defineProperty(accessor, 'food', { configurable: false }); +Object.isFrozen(accessor); // === true + +// La forma més fàcil, però, d'aconseguir congelar un objecte és cridant el mètode Object.freeze al mateix objecte. +var frozen = { 1: 81 }; +Object.isFrozen(frozen); // === false +Object.freeze(frozen); +Object.isFrozen(frozen); // === true + +// Per definició, un objecte congelat no és extensible. +Object.isExtensible(frozen); // === false + +// També per definició, un objecte congelat està segellat. +Object.isSealed(frozen); // === true +</pre> + +<h2 id="Notes">Notes</h2> + +<p>A l'EcmaScript 5, si l'argument passat a aquest mètode no és un objecte (un valor primitiu), llençarà un <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>. A l'EcmaScript 6, un argument que no sigui un objecte serà tractat com si fós un objecte congelat ordinari, i simplement el retornarà.</p> + +<pre class="brush: js">Object.isFrozen(1); +// TypeError: 1 no és un objecte (codi EcmaScript 5) + +Object.isFrozen(1); +// true (codi EcmaScript 6) +</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.2.3.12', 'Object.isFrozen')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Definició inicial. Implementat a JavaScript 1.8.5.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-object.isfrozen', 'Object.isFrozen')}}</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("6")}}</td> + <td>{{CompatGeckoDesktop("2.0")}}</td> + <td>{{CompatIE("9")}}</td> + <td>{{CompatOpera("12")}}</td> + <td>{{CompatSafari("5.1")}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Object.freeze()")}}</li> + <li>{{jsxref("Object.preventExtensions()")}}</li> + <li>{{jsxref("Object.isExtensible()")}}</li> + <li>{{jsxref("Object.seal()")}}</li> + <li>{{jsxref("Object.isSealed()")}}</li> +</ul> diff --git a/files/ca/web/javascript/reference/global_objects/object/keys/index.html b/files/ca/web/javascript/reference/global_objects/object/keys/index.html new file mode 100644 index 0000000000..17d05b181c --- /dev/null +++ b/files/ca/web/javascript/reference/global_objects/object/keys/index.html @@ -0,0 +1,189 @@ +--- +title: Object.keys() +slug: Web/JavaScript/Reference/Global_Objects/Object/keys +translation_of: Web/JavaScript/Reference/Global_Objects/Object/keys +--- +<div>{{JSRef}}</div> + +<p>El mètode <code><strong>Object.keys()</strong></code> retorna un array de les propietats enumerables pròpies de l'objecte, en el mateix ordre en que es donarien en un bucle {{jsxref("Statements/for...in", "for...in")}} (la diferència radica en que el bucle for-in també enumera les propietats que pertanyen a la cadena de prototipus).</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code>Object.keys(<var>obj</var>)</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>obj</code></dt> + <dd>L'objecte del qual es retornaran les seves propietats pròpies enumerables.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p><code>Object.keys()</code> retorna un array els elements del qual són strings que corresponen a les propietats enumerables que pertanyen directament a l'objecte <code>obj</code>. L'ordre de les propietats és el mateix que el donat per recòrrer les propieats de l'objecte de forma manual.</p> + +<h2 id="Exemples">Exemples</h2> + +<pre class="brush: js">var arr = ['a', 'b', 'c']; +console.log(Object.keys(arr)); // console: ['0', '1', '2'] + +// objecte en forma d'array +var obj = { 0: 'a', 1: 'b', 2: 'c' }; +console.log(Object.keys(obj)); // console: ['0', '1', '2'] + +// objecte en forma d'array amb les claus ordenades de manera aleatòria +var an_obj = { 100: 'a', 2: 'b', 7: 'c' }; +console.log(Object.keys(an_obj)); // console: ['2', '7', '100'] + +// getFoo és una propietat no enumerable +var my_obj = Object.create({}, { getFoo: { value: function() { return this.foo; } } }); +my_obj.foo = 1; + +console.log(Object.keys(my_obj)); // console: ['foo'] +</pre> + +<p>Si esteu interessats en obtenir totes les propietats, no només les enumerables, vegeu {{jsxref("Object.getOwnPropertyNames()")}}.</p> + +<h2 id="Notes">Notes</h2> + +<p>A l'EcmaScript 5 llençarà una excepció <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> si el paràmetre <code>obj</code> no és un objecte. A l'EcmaScript 6 el paràmetre serà forçat al tipus <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>.</p> + +<pre class="brush: js">Object.keys("foo"); +// TypeError: "foo" no és un objecte (codi EcmaScript 5) +Object.keys("foo"); +// ["0", "1", "2"] (codi EcmaScript 6) +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Per a afegit una funció compatible amb <code>Object.keys</code> en plataformes que no la suporten de forma nativa, podeu utilitzar el codi següent:</p> + +<pre class="brush: js">// Tret de https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/keys +if (!Object.keys) { + Object.keys = (function() { + 'use strict'; + var hasOwnProperty = Object.prototype.hasOwnProperty, + hasDontEnumBug = !({ toString: null }).propertyIsEnumerable('toString'), + dontEnums = [ + 'toString', + 'toLocaleString', + 'valueOf', + 'hasOwnProperty', + 'isPrototypeOf', + 'propertyIsEnumerable', + 'constructor' + ], + dontEnumsLength = dontEnums.length; + + return function(obj) { + if (typeof obj !== 'object' && (typeof obj !== 'function' || obj === null)) { + throw new TypeError('Object.keys called on non-object'); + } + + var result = [], prop, i; + + for (prop in obj) { + if (hasOwnProperty.call(obj, prop)) { + result.push(prop); + } + } + + if (hasDontEnumBug) { + for (i = 0; i < dontEnumsLength; i++) { + if (hasOwnProperty.call(obj, dontEnums[i])) { + result.push(dontEnums[i]); + } + } + } + return result; + }; + }()); +} +</pre> + +<p>Cal destacar que aquest codi inclou també propietats no enumerables a Internet Explorer 7 (i possiblement també a Internet Explorer 8), al passar un objecte pertanyent a una altra finestra.</p> + +<p>Per a una versió simplificada Polyfill per a navegadors vegeu <a href="http://tokenposts.blogspot.com.au/2012/04/javascript-objectkeys-browser.html">Compatibilitat de navegadors amb la funció Object.keys de JavaScript</a>.</p> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.2.3.14', 'Object.keys')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Definició inicial. Implementat a 1.8.5.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-object.keys', 'Object.keys')}}</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("12")}}</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 for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li><a href="/en-US/docs/Enumerability_and_ownership_of_properties">Enumerabilitat i possessió de propietats</a></li> + <li>{{jsxref("Object.prototype.propertyIsEnumerable()")}}</li> + <li>{{jsxref("Object.create()")}}</li> + <li>{{jsxref("Object.getOwnPropertyNames()")}}</li> +</ul> diff --git a/files/ca/web/javascript/reference/global_objects/object/observe/index.html b/files/ca/web/javascript/reference/global_objects/object/observe/index.html new file mode 100644 index 0000000000..7059b86cd8 --- /dev/null +++ b/files/ca/web/javascript/reference/global_objects/object/observe/index.html @@ -0,0 +1,191 @@ +--- +title: Object.observe() +slug: Web/JavaScript/Reference/Global_Objects/Object/observe +translation_of: Archive/Web/JavaScript/Object.observe +--- +<div>{{JSRef}}</div> + +<p>El mètode <strong><code>Object.observe()</code></strong> s'utilitza per observar asincrònicament els canvis en un objecte. Proveeix una corrent de canvis en l'ordre en què es produeixen.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code>Object.observe(<var>obj</var>, <var>callback</var>[, <var>acceptList</var>])</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>obj</code></dt> + <dd>L'objecte que s'observa.</dd> + <dt><code>callback</code></dt> + <dd>La funció es crida cada cop que es realitzen canvis, amb l'argument següent: + <dl> + <dt><code>changes</code></dt> + <dd>Un array d'objectes cadascún d'ells representa un canvi. Les propietats d'aquests objectes canvi són: + <ul> + <li><strong><code>name</code></strong>: El nom de la propietat que s'ha canviat.</li> + <li><strong><code>object</code></strong>: L'objecte canviat després d'haverse realitzat els canvis.</li> + <li><strong><code>type</code></strong>: Una cadena que indica el tipus de canvi que s'ha portat a terme: <code>"add"</code>, <code>"update"</code>, o <code>"delete"</code>.</li> + <li><strong><code>oldValue</code></strong>: Només pels tipus <code>"update"</code> i <code>"delete"</code>. El valor abans del canvi.</li> + </ul> + </dd> + </dl> + </dd> + <dt><code>acceptList</code></dt> + <dd>La llista de tipus de canvis que s'han d'observar en l'objecte donat callback. En cas d'ometre's, s'utilitzarà l'array <code>["add", "update", "delete", "reconfigure", "setPrototype", "preventExtensions"]</code>.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p><code>callback</code> és cridat cada cop que es realitza un canvi a <code>obj</code>, amb un array de tots els canvis en l'ordre en que han succeït.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Mostrant_tots_els_sis_tipus_diferents">Mostrant tots els sis tipus diferents</h3> + +<pre class="brush: js">var obj = { + foo: 0, + bar: 1 +}; + +Object.observe(obj, function(changes) { + console.log(changes); +}); + +obj.baz = 2; +// [{name: 'baz', object: <obj>, type: 'add'}] + +obj.foo = 'hello'; +// [{name: 'foo', object: <obj>, type: 'update', oldValue: 0}] + +delete obj.baz; +// [{name: 'baz', object: <obj>, type: 'delete', oldValue: 2}] + +Object.defineProperty(obj, 'foo', {writable: false}); +// [{name: 'foo', object: <obj>, type: 'reconfigure'}] + +Object.setPrototypeOf(obj, {}); +// [{name: '__proto__', object: <obj>, type: 'setPrototype', oldValue: <prototype>}] + +Object.seal(obj); +// [ +// {name: 'foo', object: <obj>, type: 'reconfigure'}, +// {name: 'bar', object: <obj>, type: 'reconfigure'}, +// {object: <obj>, type: 'preventExtensions'} +// ] +</pre> + +<h3 id="Enllaçar_dades">Enllaçar dades</h3> + +<pre class="brush: js">// Un model d'usuari +var user = { + id: 0, + name: 'Brendan Eich', + title: 'Mr.' +}; + +// Crear una benvinguda per l'usuari +function updateGreeting() { + user.greeting = 'Hello, ' + user.title + ' ' + user.name + '!'; +} +updateGreeting(); + +Object.observe(user, function(changes) { + changes.forEach(function(change) { + // Qualsevol canvi de nom del temps o títol, actualitzar la benvinguda + if (change.name === 'name' || change.name === 'title') { + updateGreeting(); + } + }); +}); +</pre> + +<h3 id="Tipus_de_canvi_personalitzat">Tipus de canvi personalitzat</h3> + +<pre class="brush: js">// Un punt en un pla 2D +var point = {x: 0, y: 0, distance: 0}; + +function setPosition(pt, x, y) { + // Performing a custom change + Object.getNotifier(pt).performChange('reposition', function() { + var oldDistance = pt.distance; + pt.x = x; + pt.y = y; + pt.distance = Math.sqrt(x * x + y * y); + return {oldDistance: oldDistance}; + }); +} + +Object.observe(point, function(changes) { + console.log('Distance change: ' + (point.distance - changes[0].oldDistance)); +}, ['reposition']); + +setPosition(point, 3, 4); +// Distance change: 5 +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<p><a href="https://github.com/arv/ecmascript-object-observe">Proposta de Strawman per ECMAScript 7</a>.</p> + +<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("36")}}</td> + <td>{{CompatNo}} [1]</td> + <td>{{CompatNo}} [2]</td> + <td>{{CompatOpera("23")}}</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("36")}}</td> + <td>{{CompatNo}} [1]</td> + <td>{{CompatNo}} [2]</td> + <td>{{CompatOpera("23")}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<p>[1]: Vegeu {{bug(800355)}}</p> + +<p>[2]: Vegeu rellevant <a href="https://dev.modern.ie/platform/status/objectobserve/">entrada de l'estat de la plataforma MS Edge</a></p> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Object.unobserve()")}} {{experimental_inline}}</li> + <li>{{jsxref("Array.observe()")}} {{experimental_inline}}</li> +</ul> diff --git a/files/ca/web/javascript/reference/global_objects/object/prototype/index.html b/files/ca/web/javascript/reference/global_objects/object/prototype/index.html new file mode 100644 index 0000000000..b18ecc2d5a --- /dev/null +++ b/files/ca/web/javascript/reference/global_objects/object/prototype/index.html @@ -0,0 +1,214 @@ +--- +title: Object.prototype +slug: Web/JavaScript/Reference/Global_Objects/Object/prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Object +--- +<div>{{JSRef}}</div> + +<p>La propietat <code><strong>Object.prototype</strong></code> representa el prototipus per a {{jsxref("Object")}}.</p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Descripció">Descripció</h2> + +<p>A JavaScript, tots els objectes hereten de {{jsxref("Object")}}; tots els objectes hereten els mètodes i propietats de <code>Object.prototype</code>, tot i que es poden sobreescriure (excepte un <code>Object</code> amb prototipus <code>null</code>, és a dir, <code>Object.create(null)</code>). Per exemple, altres prototipus de constructors sobreescriuen la propietat <code>constructor</code> i ofereixen els seus propis mètodes {{jsxref("Object.prototype.toString()", "toString()")}}. Els canvis al prototipus <code>Object</code> es propaguen a tots els objectes a no ser que les propietats i mètodes que reben aquests canvis hagin sigut sobreescrites més avall a la cadena de prototipus.</p> + +<h2 id="Propietats">Propietats</h2> + +<dl> + <dt>{{jsxref("Object.prototype.constructor")}}</dt> + <dd>Especifica la funció que ha creat el prototipus de l'objecte.</dd> + <dt>{{jsxref("Object.prototype.__proto__")}} {{non-standard_inline}}</dt> + <dd>Referencia l'objecte utilitzat com a prototipus quan aquest objecte va ser instanciat.</dd> + <dt>{{jsxref("Object.prototype.__noSuchMethod__")}} {{non-standard_inline}}</dt> + <dd>Permet definir una funció que serà executada quan es cridi com mètode un membre no definit.</dd> + <dt><s class="obsoleteElement">{{jsxref("Object.prototype.__count__")}} {{obsolete_inline}}</s></dt> + <dd><s class="obsoleteElement">Retornava el nombre de propietats enumerables que hi hagués a un objecte definit per l'usuari. S'ha eliminat.</s></dd> + <dt><s class="obsoleteElement">{{jsxref("Object.prototype.__parent__")}} {{obsolete_inline}}</s></dt> + <dd><s class="obsoleteElement">Referenciava el context d'un objecte. S'ha eliminat.</s></dd> +</dl> + +<h2 id="Mètodes">Mètodes</h2> + +<dl> + <dt>{{jsxref("Object.prototype.__defineGetter__()")}} {{non-standard_inline}} {{deprecated_inline}}</dt> + <dd>Associa una funció a una propietat que, quan s'accedeix, executa aquesta funció i retorna el seu valor.</dd> + <dt>{{jsxref("Object.prototype.__defineSetter__()")}} {{non-standard_inline}} {{deprecated_inline}}</dt> + <dd>Associa una funció a una propietat que, quan s'assigna, executa aquesta funció que modifica la propietat.</dd> + <dt>{{jsxref("Object.prototype.__lookupGetter__()")}} {{non-standard_inline}} {{deprecated_inline}}</dt> + <dd>Retorna una funció associada a la propietat especificada pel mètode {{jsxref("Object.defineGetter", "__defineGetter__")}}.</dd> + <dt>{{jsxref("Object.prototype.__lookupSetter__()")}} {{non-standard_inline}} {{deprecated_inline}}</dt> + <dd>Retorna a funció associada a la propietat especificada pel mètode {{jsxref("Object.defineSetter", "__defineSetter__")}}.</dd> + <dt>{{jsxref("Object.prototype.hasOwnProperty()")}}</dt> + <dd>Retorna un booleà que indica si l'objecte conté la propietat especificada com una propietat pròpia d'ell mateix en comptes d'heretar-la a través de la cadena de prototipus.</dd> + <dt>{{jsxref("Object.prototype.isPrototypeOf()")}}</dt> + <dd>Retorna un booleà que indica si l'objecte espeicfifcat pertany a la cadena de prototipus de l'objecte sobre el que es crida aquest mètode.</dd> + <dt>{{jsxref("Object.prototype.propertyIsEnumerable()")}}</dt> + <dd>Retorna un booleà que indica si està activat l'atribut intern <a href="/en-US/docs/ECMAScript_DontEnum_attribute" title="ECMAScript_DontEnum_attribute">DontEnum de l'ECMAScript</a>.</dd> + <dt>{{jsxref("Object.prototype.toSource()")}} {{non-standard_inline}}</dt> + <dd>Retorna un string que conté cofi font que defineix un literal d'objecte que representa l'objecte sobre el que s'executa aquest mètode; aquest valor pot utilitzar-se per a crear un nou objecte.</dd> + <dt>{{jsxref("Object.prototype.toLocaleString()")}}</dt> + <dd>Crida el mètode {{jsxref("Object.toString", "toString()")}}.</dd> + <dt>{{jsxref("Object.prototype.toString()")}}</dt> + <dd>Retorna una representació d'aquest objecte en forma de string.</dd> + <dt>{{jsxref("Object.prototype.unwatch()")}} {{non-standard_inline}}</dt> + <dd>Esborra un <em>watchpoint</em> d'una propietat de l'objecte.</dd> + <dt>{{jsxref("Object.prototype.valueOf()")}}</dt> + <dd>Retorna el valor primitiu de l'objecte especificat.</dd> + <dt>{{jsxref("Object.prototype.watch()")}} {{non-standard_inline}}</dt> + <dd>Afegeix un <em>watchpoint</em> a una propietat de l'objecte.</dd> + <dt><s class="obsoleteElement">{{jsxref("Object.prototype.eval()")}} {{obsolete_inline}}</s></dt> + <dd><s class="obsoleteElement">Evaluava un string de codi font JavaScript dins el context de l'objecte especificat. S'ha eliminat.</s></dd> +</dl> + +<h2 id="Exemples">Exemples</h2> + +<p>Degut a que JavaScript no res semblant a subclasses d'objectes, la propietat <code>prototype</code> és una bona forma d'utilitzar algunes funcions que fan d'objectes com a "classe base". Per exemple:</p> + +<pre class="brush: js">var Person = function() { + this.canTalk = true; +}; + +Person.prototype.greet = function() { + if (this.canTalk) { + console.log('Hi, I am ' + this.name); + } +}; + +var Employee = function(name, title) { + Person.call(this); + this.name = name; + this.title = title; +}; + +Employee.prototype = Object.create(Person.prototype); +Employee.prototype.constructor = Employee; + +Employee.prototype.greet = function() { + if (this.canTalk) { + console.log('Hi, I am ' + this.name + ', the ' + this.title); + } +}; + +var Customer = function(name) { + Person.call(this); + this.name = name; +}; + +Customer.prototype = Object.create(Person.prototype); +Customer.prototype.constructor = Customer; + +var Mime = function(name) { + Person.call(this); + this.name = name; + this.canTalk = false; +}; + +Mime.prototype = Object.create(Person.prototype); +Mime.prototype.constructor = Mime; + +var bob = new Employee('Bob', 'Builder'); +var joe = new Customer('Joe'); +var rg = new Employee('Red Green', 'Handyman'); +var mike = new Customer('Mike'); +var mime = new Mime('Mime'); + +bob.greet(); +// Hi, I am Bob, the Builder + +joe.greet(); +// Hi, I am Joe + +rg.greet(); +// Hi, I am Red Green, the Handyman + +mike.greet(); +// Hi, I am Mike + +mime.greet(); +</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.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.2.3.1', 'Object.prototype')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-object.prototype', 'Object.prototype')}}</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 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><a href="/en-US/docs/Web/JavaScript/Introduction_to_Object-Oriented_JavaScript">Introducció al JavaScript orientat a objectes</a></li> +</ul> diff --git a/files/ca/web/javascript/reference/global_objects/weakmap/clear/index.html b/files/ca/web/javascript/reference/global_objects/weakmap/clear/index.html new file mode 100644 index 0000000000..443e075d46 --- /dev/null +++ b/files/ca/web/javascript/reference/global_objects/weakmap/clear/index.html @@ -0,0 +1,91 @@ +--- +title: WeakMap.prototype.clear() +slug: Web/JavaScript/Reference/Global_Objects/WeakMap/clear +translation_of: Web/JavaScript/Reference/Global_Objects/WeakMap/clear +--- +<div>{{JSRef}} {{obsolete_header}}</div> + +<p>El mètode <code><strong>clear()</strong></code> elimina tots els elements d'un objecte <code>WeakMap.</code></p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><em>wm</em>.clear();</code></pre> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_el_mètode_clear">Utilitzar el mètode <code>clear</code></h3> + +<pre class="brush: js;highlight:[10]">var wm = new WeakMap(); +var obj = {}; + +wm.set(obj, "foo"); +wm.set(window, "bar"); + +wm.has(obj); // true +wm.has(window); // true + +wm.clear(); + +wm.has(obj) // false +wm.has(window) // false +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<p>No forma part de cap especificació o borrador actual. Aquest mètode formava part del borrador de l'especificació d'ECMAScript 6 fins a la revisió número 28 (versió del 14 d'octubre del 2014), però s'ha eliminat en versions posteriors del borrador. No formarà part de l'estàndard final.</p> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>36</td> + <td>{{CompatGeckoDesktop("20.0")}}</td> + <td>11</td> + <td>23</td> + <td>7.1</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>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>{{CompatGeckoMobile("20.0")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("WeakMap")}}</li> +</ul> diff --git a/files/ca/web/javascript/reference/global_objects/weakmap/delete/index.html b/files/ca/web/javascript/reference/global_objects/weakmap/delete/index.html new file mode 100644 index 0000000000..1037fdb3fc --- /dev/null +++ b/files/ca/web/javascript/reference/global_objects/weakmap/delete/index.html @@ -0,0 +1,114 @@ +--- +title: WeakMap.prototype.delete() +slug: Web/JavaScript/Reference/Global_Objects/WeakMap/delete +translation_of: Web/JavaScript/Reference/Global_Objects/WeakMap/delete +--- +<div>{{JSRef}}</div> + +<p>El mètode <code><strong>delete()</strong></code> elimina l'element especificat d'un objecte <code>WeakMap.</code></p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><em>wm</em>.delete(key);</code></pre> + +<h3 id="Parameters">Parameters</h3> + +<dl> + <dt>key</dt> + <dd>Necessari. La clau de l'element a eliminar de l'objecte <code>WeakMap.</code></dd> +</dl> + +<h3 id="Valor_de_retorn">Valor de retorn</h3> + +<p>Retorna <code>true</code> si un element en l'objecte <code>WeakMap</code> s'ha eliminat satisfactòriament.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzarel_mètode_delete">Utilitzarel mètode <code>delete</code></h3> + +<pre class="brush: js;highlight:[4]">var wm = new WeakMap(); +wm.set(window, "foo"); + +wm.delete(window); // Retorna true. Eliminat satisfactòriament + +wm.has(window); // Retorna false. L'objecte window ja no es troba en el WeakMap. +</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-weakmap.prototype.delete', 'WeakMap.prototype.delete')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definició inicial</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>36</td> + <td>{{CompatGeckoDesktop("6.0")}}</td> + <td>11</td> + <td>23</td> + <td>7.1</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>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>{{CompatGeckoMobile("6.0")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Notes_específiques_per_a_Firefox">Notes específiques per a Firefox</h2> + +<ul> + <li>Abans de SpiderMonkey 38 {{geckoRelease(38)}}, aquest mètode llançava un {{jsxref("TypeError")}} quan el paràmetre <code>key</code> no era un objecte. Aquest error s'ha arreglat en la versió 38 i posteriors al retornar <code>false</code> segons l'últim estàndard ES6 ({{bug(1127827)}}).</li> +</ul> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("WeakMap")}}</li> +</ul> diff --git a/files/ca/web/javascript/reference/global_objects/weakmap/get/index.html b/files/ca/web/javascript/reference/global_objects/weakmap/get/index.html new file mode 100644 index 0000000000..f69ca1aa58 --- /dev/null +++ b/files/ca/web/javascript/reference/global_objects/weakmap/get/index.html @@ -0,0 +1,115 @@ +--- +title: WeakMap.prototype.get() +slug: Web/JavaScript/Reference/Global_Objects/WeakMap/get +translation_of: Web/JavaScript/Reference/Global_Objects/WeakMap/get +--- +<div>{{JSRef}}</div> + +<p>El mètode <code><strong>get()</strong></code> retorna un element especificat d'un objecte <code>WeakMap.</code></p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><em>wm</em>.get(key);</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt>key</dt> + <dd>Necessari. La clau d'un element a retornar de l'objecte <code>WeakMap.</code></dd> +</dl> + +<h3 id="Valor_a_retornar">Valor a retornar</h3> + +<p>Retorna l'element associat a la clau especificada o <code>undefined</code> si no es pot trobar la clau en l'objecte <code>WeakMap.</code></p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_el_mètode_get">Utilitzar el mètode <code>get</code></h3> + +<pre class="brush: js">var wm = new WeakMap(); +wm.set(window, "foo"); + +wm.get(window); // Retorna "foo". +wm.get("baz"); // Retorna 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-weakmap.prototype.get', 'WeakMap.prototype.get')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definició inicial</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>36</td> + <td>{{CompatGeckoDesktop("6.0")}}</td> + <td>11</td> + <td>23</td> + <td>7.1</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>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>{{CompatGeckoMobile("6.0")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Notes_específiques_per_a_Firefox">Notes específiques per a Firefox</h2> + +<ul> + <li>Abans de SpiderMonkey 38 {{geckoRelease(38)}}, aquest mètode llençava un {{jsxref("TypeError")}} quan no es trobava el paràmetre key en l'objecte. Tot i així, l'últim estàndard ES6 especifica que en comptes d'això es retorni <code>undefined.</code> És més, <code>WeakMap.prototype.get</code> acceptava un segon argument opcional com a valor com a pla B, el qual no forma part de l'estàndard. Ambdós comportaments no estàndards s'han eliminat en la versió 38 i posterior ({{bug(1127827)}}).</li> +</ul> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("WeakMap")}}</li> + <li>{{jsxref("WeakMap.set()")}}</li> + <li>{{jsxref("WeakMap.has()")}}</li> +</ul> diff --git a/files/ca/web/javascript/reference/global_objects/weakmap/has/index.html b/files/ca/web/javascript/reference/global_objects/weakmap/has/index.html new file mode 100644 index 0000000000..0a2d017462 --- /dev/null +++ b/files/ca/web/javascript/reference/global_objects/weakmap/has/index.html @@ -0,0 +1,118 @@ +--- +title: WeakMap.prototype.has() +slug: Web/JavaScript/Reference/Global_Objects/WeakMap/has +translation_of: Web/JavaScript/Reference/Global_Objects/WeakMap/has +--- +<div>{{JSRef}}</div> + +<p>El mètode <code><strong>has()</strong></code> retorna un booleà indicant si un element amb una clau especificada existeix o no en l'objecte <code>WeakMap.</code></p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><em>wm</em>.has(key);</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt>key</dt> + <dd>Necessari. La clau de l'element a comprovar la seva presència de l'objecte <code>WeakMap.</code></dd> +</dl> + +<h3 id="valor_de_retorn">valor de retorn</h3> + +<dl> + <dt>Booleà</dt> + <dd>Retorna <code>true</code> si un element amb una clau especificada existeix en l'objecte <code>WeakMap</code>; en el cas contrari retornarà <code>false</code>.</dd> +</dl> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_el_mètode_has">Utilitzar el mètode <code>has</code></h3> + +<pre class="brush: js">var wm = new WeakMap(); +wm.set(window, "foo"); + +wm.has(window); // retorna true +wm.has("baz"); // retorna 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('ES6', '#sec-weakmap.prototype.has', 'WeakMap.prototype.has')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definició inicial</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>36</td> + <td>{{CompatGeckoDesktop("6.0")}}</td> + <td>11</td> + <td>23</td> + <td>7.1</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>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>{{CompatGeckoMobile("6.0")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Notes_específiques_per_a_Firefox">Notes específiques per a Firefox</h2> + +<ul> + <li>Abans de SpiderMonkey 38 {{geckoRelease(38)}}, aquest mètode llençava un {{jsxref("TypeError")}} quan el paràmetre <code>key</code> no era un objecte. Això s'ha arreglat en la versió 38 i posteriors per tal de retornar <code>false</code> segons l'últim estàndard ES6 ({{bug(1127827)}}).</li> +</ul> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("WeakMap")}}</li> + <li>{{jsxref("WeakMap.prototype.set()")}}</li> + <li>{{jsxref("WeakMap.prototype.get()")}}</li> +</ul> diff --git a/files/ca/web/javascript/reference/global_objects/weakmap/index.html b/files/ca/web/javascript/reference/global_objects/weakmap/index.html new file mode 100644 index 0000000000..27fdd6a71d --- /dev/null +++ b/files/ca/web/javascript/reference/global_objects/weakmap/index.html @@ -0,0 +1,279 @@ +--- +title: WeakMap +slug: Web/JavaScript/Reference/Global_Objects/WeakMap +tags: + - ECMAScript6 + - Experimental + - JavaScript + - NeedsTranslation + - TopicStub + - WeakMap +translation_of: Web/JavaScript/Reference/Global_Objects/WeakMap +--- +<div>{{JSRef}}</div> + +<p>L'objecte <strong><code>WeakMap</code></strong> és una col·lecció de parelles clau/valor on les claus són dèbilment referenciades. Les claus han de ser objectes i els valors poden ser valors aribitraris.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox notranslate"><code>new WeakMap([iterable]) +</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>iterable</code></dt> + <dd>Iterable és un Array o un altre objecte iterable el qual els seus elements són parelles clau/valor (Array de 2 elements). Cada parella clau/valor serà afegida al nou WeakMap. null és tractat com a undefined.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Les claus de WeakMaps són només de tipus <code>Object.</code> {{Glossary("Primitive", "Primitive data types")}} com a claus no són permesos (e.g. a {{jsxref("Symbol")}} no pot ser una clau <code>WeakMap</code>).</p> + +<p>La clau d'un WeakMap es sostè dèbilment. El que significa que, si no hi ha altres referències fortes a la clau, llavors la entrada sencera serà eliminada del WeakMap pel recol·lector de brossa (garbage collector).</p> + +<h3 id="Per_què_WeakMap">Per què <em>Weak</em>Map?</h3> + +<p>El programador expert en JavaScript s'adonarà que aquesta API es podria implementar en JavaScript amb dos arrays (una per a claus, i una per valors) compartides pels quatre mètodes de l'API. Tal implementació tindria dos inconvenients principals. El primer és que la cerca té un cost de O(n) (on n és el nombre de claus al mapa). El segon és que té problemes de fuita de memòria (memory leak). Amb els mapes mantinguts manualment, l'array de claus mantindria referències a le objectes clau, evitant que aquests fóssin eliminats de memòria pel recol·lector de brossa. Als WeakMaps natius, les referències als objectes clau són "dèbils", que vol dir que el recol·lector de brossa pot eliminar l'objecte de memòria si aquest només és referenciat per referències dèbils.</p> + +<p>Degut a que les referències són dèbils les claus del WeakMap no són enumerables (és a dir, no hi ha cap mètode que us retornarà un llistat de claus). Si aquest mètode existís, aquest dependria de l'estat del recol·lector de brossa, introduïnt un comportament no determinista. Si voleu tenir un llistat amb les claus, l'haureu de mantenir pel vostre compte.</p> + +<h2 id="Propietats">Propietats</h2> + +<dl> + <dt><code>WeakMap.length</code></dt> + <dd>El valor de la propietat <code>length</code> és 0.</dd> + <dt>{{jsxref("WeakMap.prototype")}}</dt> + <dd>Representa el prototip pel constructor <code>WeakMap.</code> Permet l'adició de propietats a tots els objectes <code>WeakMap.</code></dd> +</dl> + +<h2 id="Instàncies_WeakMap">Instàncies <code>WeakMap</code></h2> + +<p>Totes les instàncies <code>WeakMap</code> hereten de {{jsxref("WeakMap.prototype")}}.</p> + +<h3 id="Propietats_2">Propietats</h3> + +<p>{{page('ca/Web/JavaScript/Reference/Global_Objects/WeakMap/prototype','Properties')}}</p> + +<h3 id="Mètodes">Mètodes</h3> + +<p>{{page('ca/Web/JavaScript/Reference/Global_Objects/WeakMap/prototype','Methods')}}</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_WeakMap">Utilitzar <code>WeakMap</code></h3> + +<pre class="brush: js notranslate">var wm1 = new WeakMap(), + wm2 = new WeakMap(), + wm3 = new WeakMap(); +var o1 = {}, + o2 = function(){}, + o3 = window; + +wm1.set(o1, 37); +wm1.set(o2, "azerty"); +wm2.set(o1, o2); // un valor pot ser qualsevol cosa, incloent un objecte object o una funció +wm2.set(o3, undefined); +wm2.set(wm1, wm2); // claus i valors poden ser qualsevol objecte. Fins i tot WeakMaps! + +wm1.get(o2); // "azerty" +wm2.get(o2); // undefined, ja que no hi ha cap valor per o2 a wm2 +wm2.get(o3); // undefined, al tenir assignat aquest valor + +wm1.has(o2); // true +wm2.has(o2); // false +wm2.has(o3); // true (encara que el valor en si sigui 'undefined') + +wm3.set(o1, 37); +wm3.get(o1); // 37 + +wm1.has(o1); // true +wm1.delete(o1); +wm1.has(o1); // false +</pre> + +<h3 id="Implementar_una_classe_tipus_WeakMap_amb_un_mètode_.clear">Implementar una classe tipus <code>WeakMap</code> amb un mètode .clear()</h3> + +<p>Amb fins expositius, l'exemple següent utilitza el nou constructor <code>class</code> d' ECMAScript 6, el qual no està àmpliament implementat.</p> + +<pre class="brush: js notranslate">class ClearableWeakMap { + constructor(init) { + this._wm = new WeakMap(init) + } + clear() { + this._wm = new WeakMap() + } + delete(k) { + return this._wm.delete(k) + } + get(k) { + return this._wm.get(k) + } + has(k) { + return this._wm.has(k) + } + set(k, v) { + this._wm.set(k, v) + return this + } +} +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ES6', '#sec-weakmap-objects', 'WeakMap')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definició inicial.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>36</td> + <td>{{CompatGeckoDesktop("6.0")}}</td> + <td>11</td> + <td>{{ CompatOpera(23) }}</td> + <td>7.1</td> + </tr> + <tr> + <td><code>new WeakMap(iterable)</code></td> + <td>38</td> + <td>{{CompatGeckoDesktop("36")}}</td> + <td>{{CompatNo}}</td> + <td>{{ CompatOpera(25) }}</td> + <td>{{CompatNo}}</td> + </tr> + <tr> + <td><code>clear()</code></td> + <td>36</td> + <td>{{CompatGeckoDesktop("20.0")}}</td> + <td>11</td> + <td>{{ CompatOpera(23) }}</td> + <td>7.1</td> + </tr> + <tr> + <td>Constructor argument: <code>new WeakMap(null)</code></td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoDesktop("37")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + <tr> + <td>Monkey-patched <code>set()</code> in constructor</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoDesktop("37")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + <tr> + <td><code>WeakMap()</code> without <code>new</code> throws</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoDesktop("42")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>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>35</td> + <td>{{CompatGeckoMobile("6.0")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + <tr> + <td><code>new WeakMap(iterable)</code></td> + <td>38</td> + <td>{{CompatGeckoMobile("36")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + <tr> + <td><code>clear()</code></td> + <td>35</td> + <td>{{CompatGeckoMobile("20.0")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + <tr> + <td>Constructor argument: <code>new WeakMap(null)</code></td> + <td>{{CompatUnknown}}</td> + <td>{{CompatGeckoMobile("37")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + <tr> + <td>Monkey-patched <code>set()</code> in constructor</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatGeckoMobile("37")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + <tr> + <td><code>WeakMap()</code> without <code>new</code> throws</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatGeckoMobile("42")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li><a class="link-https" href="https://bugzilla.mozilla.org/show_bug.cgi?id=547941">Bug de WeakMap a Mozilla</a></li> + <li><a href="http://fitzgeraldnick.com/weblog/53/">Amagant detalls d'implementació amb els WeakMaps de l'ECMAScript 6</a></li> + <li>{{jsxref("Map")}}</li> + <li>{{jsxref("Set")}}</li> + <li>{{jsxref("WeakSet")}}</li> +</ul> diff --git a/files/ca/web/javascript/reference/global_objects/weakmap/prototype/index.html b/files/ca/web/javascript/reference/global_objects/weakmap/prototype/index.html new file mode 100644 index 0000000000..5155a0a664 --- /dev/null +++ b/files/ca/web/javascript/reference/global_objects/weakmap/prototype/index.html @@ -0,0 +1,132 @@ +--- +title: WeakMap.prototype +slug: Web/JavaScript/Reference/Global_Objects/WeakMap/prototype +translation_of: Web/JavaScript/Reference/Global_Objects/WeakMap +--- +<div>{{JSRef}}</div> + +<p>La propietat <code><strong>WeakMap</strong></code><strong><code>.prototype</code></strong> representa el prototip pel constructor {{jsxref("WeakMap")}}.</p> + +<div>{{js_property_attributes(0,0,0)}}</div> + +<h2 id="Descripció">Descripció</h2> + +<p>Les instantànies {{jsxref("WeakMap")}} hereten de {{jsxref("WeakMap.prototype")}}. Es pot utilitzar l'objecte prototip del constructor per afegir propietats o mètodes a totes les instàncies <code>WeakMap.</code></p> + +<p><code>WeakMap.prototype</code> és en si mateix només un objecte ordinari:</p> + +<pre class="brush: js">Object.prototype.toString.call(WeakMap.prototype); // "[object Object]"</pre> + +<h2 id="Propietats">Propietats</h2> + +<dl> + <dt><code>WeakMap.prototype.constructor</code></dt> + <dd>Retorna la funció que ha creat un prototip de la instància. Aquesta és la funció {{jsxref("WeakMap")}} per defecte.</dd> +</dl> + +<h2 id="Mètodes">Mètodes</h2> + +<dl> + <dt>{{jsxref("WeakMap.delete", "WeakMap.prototype.delete(key)")}}</dt> + <dd>Elimina qualsevol valor associat a <code>key</code>. <code>WeakMap.prototype.has(key)</code> retornarà <code>false</code> després d'això.</dd> + <dt>{{jsxref("WeakMap.get", "WeakMap.prototype.get(key)")}}</dt> + <dd>Retorna el valor associat a <code>key</code>, o <code>undefined</code> si no n'hi ha cap.</dd> + <dt>{{jsxref("WeakMap.has", "WeakMap.prototype.has(key)")}}</dt> + <dd>Retorna un booleà afirmant si un valor s'ha associat o no a la <code>key</code> en l'objecte <code>WeakMap</code>.</dd> + <dt>{{jsxref("WeakMap.set", "WeakMap.prototype.set(key, value)")}}</dt> + <dd>Estableix el valor per la <code>key</code> en l'objecte <code>WeakMap.</code> Retorna l'objecte <code>WeakMap.</code></dd> + <dt><s class="obsoleteElement">{{jsxref("WeakMap.prototype.clear()")}} {{obsolete_inline}}</s></dt> + <dd><s class="obsoleteElement">Elimina totes les parelles clau/valor de l'objecte <code>WeakMap.</code> Vegeu que es posible implementar un objecte <code>WeakMap</code>-like que tingui un mètode <code>.clear()</code> per mitjà d'encapsular un objecte <code>WeakMap </code>que no ho tingui (vegeu un exemple a la pàgina {{jsxref("WeakMap")}})</s></dd> +</dl> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-weakmap.prototype', 'WeakMap.prototype')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definició inicial</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>36</td> + <td>{{CompatGeckoDesktop("6.0")}}</td> + <td>11</td> + <td>23</td> + <td>7.1</td> + </tr> + <tr> + <td>Objecte ordinari</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatGeckoDesktop("40")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome per Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatGeckoMobile("6.0")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + <tr> + <td>Objecte ordinari</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatGeckoMobile("40")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Map.prototype")}}</li> +</ul> diff --git a/files/ca/web/javascript/reference/global_objects/weakmap/set/index.html b/files/ca/web/javascript/reference/global_objects/weakmap/set/index.html new file mode 100644 index 0000000000..800a097971 --- /dev/null +++ b/files/ca/web/javascript/reference/global_objects/weakmap/set/index.html @@ -0,0 +1,120 @@ +--- +title: WeakMap.prototype.set() +slug: Web/JavaScript/Reference/Global_Objects/WeakMap/set +translation_of: Web/JavaScript/Reference/Global_Objects/WeakMap/set +--- +<div>{{JSRef}}</div> + +<p>El mètode <code><strong>set()</strong></code> afegeix un nou element amb una <code>key</code> i un <code>value</code> especificats a un objecte <code>WeakMap</code>.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><em>wm</em>.set(key, value);</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt>key</dt> + <dd>Necesari. La clau de l'element a afegir al objecte <code>WeakMap.</code></dd> + <dt>value</dt> + <dd>Necesari. El valor de l'element a afegir a l'objecte <code>WeakMap.</code></dd> +</dl> + +<h3 id="Valor_de_retorn">Valor de retorn</h3> + +<p>L'objecte <code>WeakMap</code>.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_el_mètode_set">Utilitzar el mètode <code>set</code></h3> + +<pre class="brush: js">var wm = new WeakMap(); +var obj = {}; + +// Afegir nous elements al WeakMap +wm.set(obj, "foo").set(window, "bar"); // chainable + +// Actualitzem un element en WeakMap +wm.set(obj, "baz"); +</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-weakmap.prototype.set', 'WeakMap.prototype.set')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definició inicial</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>36</td> + <td>{{CompatGeckoDesktop("6.0")}}</td> + <td>11</td> + <td>23</td> + <td>7.1</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>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>{{CompatGeckoMobile("6.0")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Notes_específiques_per_a_Firefox">Notes específiques per a Firefox</h2> + +<ul> + <li>Abans de Firefox 33 {{geckoRelease("33")}}, <code>WeakMap.prototype.set</code> retornava <code>undefined</code> al no poder-se encadenar. Això s'ha arreglat ({{bug(1031632)}}). El comportament es pot trobar també a Chrome/v8 (<a href="https://code.google.com/p/v8/issues/detail?id=3410">problema</a>).</li> +</ul> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("WeakMap")}}</li> + <li>{{jsxref("WeakMap.prototype.get()")}}</li> + <li>{{jsxref("WeakMap.prototype.has()")}}</li> +</ul> diff --git a/files/ca/web/javascript/reference/global_objects/weakset/add/index.html b/files/ca/web/javascript/reference/global_objects/weakset/add/index.html new file mode 100644 index 0000000000..983b24329a --- /dev/null +++ b/files/ca/web/javascript/reference/global_objects/weakset/add/index.html @@ -0,0 +1,103 @@ +--- +title: WeakSet.prototype.add() +slug: Web/JavaScript/Reference/Global_Objects/WeakSet/add +translation_of: Web/JavaScript/Reference/Global_Objects/WeakSet/add +--- +<div>{{JSRef}}</div> + +<p>El mètode <code><strong>add()</strong></code> afegeix un nou objecte al final d'un objecte <code>WeakSet</code>.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><em>ws</em>.add(value);</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt>value</dt> + <dd>Necessari. L'objecte que es vol afegir a la col·lecció de <code>WeakSet.</code></dd> +</dl> + +<h2 id="Utilitzar_el_mètode_add">Utilitzar el mètode <code>add</code></h2> + +<pre class="brush: js">var ws = new WeakSet(); + +ws.add(window); // afegeix l'objecte window al WeakSet + +ws.has(window); // true +</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-weakset.prototype.add', 'WeakSet.prototype.add')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definició inicial.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>36</td> + <td>{{CompatGeckoDesktop(34)}}</td> + <td>{{CompatNo}}</td> + <td>23</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>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>{{ CompatGeckoMobile(34) }}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("WeakSet")}}</li> + <li>{{jsxref("WeakSet.prototype.delete()")}}</li> + <li>{{jsxref("WeakSet.prototype.has()")}}</li> +</ul> diff --git a/files/ca/web/javascript/reference/global_objects/weakset/clear/index.html b/files/ca/web/javascript/reference/global_objects/weakset/clear/index.html new file mode 100644 index 0000000000..4e6b2e6f8c --- /dev/null +++ b/files/ca/web/javascript/reference/global_objects/weakset/clear/index.html @@ -0,0 +1,87 @@ +--- +title: WeakSet.prototype.clear() +slug: Web/JavaScript/Reference/Global_Objects/WeakSet/clear +translation_of: Web/JavaScript/Reference/Global_Objects/WeakSet/clear +--- +<div>{{JSRef}} {{obsolete_header}}</div> + +<p>El mètode <code><strong>clear()</strong></code> elimina tots els elements d'un objecte <code>WeakSet.</code></p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><em>ws</em>.clear();</code></pre> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_el_mètode_clear">Utilitzar el mètode <code>clear</code></h3> + +<pre class="brush: js">var ws = new WeakSet(); + +ws.add(window); +ws.has(window); // true + +ws.clear(); + +ws.has(window); // false +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<p>No forma part de cap especificació actual o borrador. Aquest mètode formava part del borrador de l'especificació d'ECMAScript 6 fins la revisió 28 (versió del 14 d'octubre del 2014), però s'ha eliminat en versions posteriors del borrador. No formarà part de l'estàndard final.</p> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>36</td> + <td>{{CompatGeckoDesktop(34)}}</td> + <td>{{CompatNo}}</td> + <td>23</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>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>{{CompatGeckoMobile(34)}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("WeakSet")}}</li> + <li>{{jsxref("WeakSet.prototype.delete()")}}</li> +</ul> diff --git a/files/ca/web/javascript/reference/global_objects/weakset/delete/index.html b/files/ca/web/javascript/reference/global_objects/weakset/delete/index.html new file mode 100644 index 0000000000..9bfaa0f439 --- /dev/null +++ b/files/ca/web/javascript/reference/global_objects/weakset/delete/index.html @@ -0,0 +1,112 @@ +--- +title: WeakSet.prototype.delete() +slug: Web/JavaScript/Reference/Global_Objects/WeakSet/delete +translation_of: Web/JavaScript/Reference/Global_Objects/WeakSet/delete +--- +<div>{{JSRef}}</div> + +<p>El mètode <code><strong>delete()</strong></code>elimina l'element especificat de l'objecte <code>WeakSet.</code></p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><em>ws</em>.delete(value);</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt>value</dt> + <dd>Necessari. L'objecte que es vol eliminar de l'objecte <code>WeakSet.</code></dd> +</dl> + +<h3 id="Return_value">Return value</h3> + +<p>Retorna <code>true</code> si l'element dins l'objecte <code>WeakSet</code> s'ha eliminat satisfactòriament; Del cas contrari retornarà <code>false</code>.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_el_mètode_delete">Utilitzar el mètode <code>delete</code></h3> + +<pre class="brush: js">var ws = new WeakSet(); +var obj = {}; + +ws.add(window); + +ws.delete(obj); // Retorna false. No s'ha trobat cap obj per eliminar. +ws.delete(window); // Retorna true. Eliminat satisfactòriament. + +ws.has(window); // Retorna false. window ja no és present en WeakSet. +</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-weakset.prototype.delete', 'WeakSet.prototype.delete')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definició inicial.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>36</td> + <td>{{CompatGeckoDesktop(34)}}</td> + <td>{{CompatNo}}</td> + <td>23</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>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>{{ CompatGeckoMobile(34) }}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("WeakSet")}}</li> + <li>{{jsxref("WeakSet.prototype.clear()")}}</li> +</ul> diff --git a/files/ca/web/javascript/reference/global_objects/weakset/has/index.html b/files/ca/web/javascript/reference/global_objects/weakset/has/index.html new file mode 100644 index 0000000000..b2074a9847 --- /dev/null +++ b/files/ca/web/javascript/reference/global_objects/weakset/has/index.html @@ -0,0 +1,113 @@ +--- +title: WeakSet.prototype.has() +slug: Web/JavaScript/Reference/Global_Objects/WeakSet/has +translation_of: Web/JavaScript/Reference/Global_Objects/WeakSet/has +--- +<div>{{JSRef}}</div> + +<p>El mètode <code><strong>has()</strong></code> retorna un booleà indicant si un objecte existeix o no en unmethod returns a boolean indicating whether an object exists in a <code>WeakSet</code> or not.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><em>ws</em>.has(valor);</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt>valor</dt> + <dd>Necessari. L'objecte a comprovar la seva presència en <code>WeakSet</code>.</dd> +</dl> + +<h3 id="Valor_de_retorn">Valor de retorn</h3> + +<dl> + <dt>Booleà</dt> + <dd>Retorna <code>true</code> si un element amb el valor especificat existeix en l'objecte <code>WeakSet</code>; en el cas contrari retornarà <code>false</code>.</dd> +</dl> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_el_mètode_has">Utilitzar el mètode <code>has</code></h3> + +<pre class="brush: js">var ws = new WeakSet(); +var obj = {}; +ws.add(window); + +mySet.has(window); // retorna true +mySet.has(obj); // retorna 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('ES6', '#sec-weakset.prototype.has', 'WeakSet.prototype.has')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definició inicial.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>36</td> + <td>{{CompatGeckoDesktop(34)}}</td> + <td>{{CompatNo}}</td> + <td>23</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>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>{{ CompatGeckoMobile(34) }}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("WeakSet")}}</li> + <li>{{jsxref("WeakSet.prototype.add()")}}</li> + <li>{{jsxref("WeakSet.prototype.delete()")}}</li> +</ul> diff --git a/files/ca/web/javascript/reference/global_objects/weakset/index.html b/files/ca/web/javascript/reference/global_objects/weakset/index.html new file mode 100644 index 0000000000..d1ae3999a6 --- /dev/null +++ b/files/ca/web/javascript/reference/global_objects/weakset/index.html @@ -0,0 +1,201 @@ +--- +title: WeakSet +slug: Web/JavaScript/Reference/Global_Objects/WeakSet +tags: + - ECMAScript6 + - Experimental + - JavaScript + - NeedsTranslation + - TopicStub + - WeakSet +translation_of: Web/JavaScript/Reference/Global_Objects/WeakSet +--- +<div>{{JSRef}}</div> + +<p><u>L'objecte <strong><code>WeakSet</code></strong> permet emmagatzemar dèbilment <em>objects</em> en una col·lecció.</u></p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"> new WeakSet([iterable]);</pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt>iterable</dt> + <dd>Si es pasa un <a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...of">objecte iterable</a>, tots els seus elements seràn afegits al nou <code>WeakSet</code>. null es tractat com a undefined.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Els objectes <code>WeakSet</code> són col·leccions d'objectes. Un objecte al <code>WeakSet</code> només pot passar un cop, és únic en la col·lecció de <code>WeakSet.</code></p> + +<p>Les principals diferències respecte l'objecte {{jsxref("Set")}} són:</p> + +<ul> + <li>Al contrari que <code>Sets</code>, <code>WeakSets</code> són <strong>únicament col·leccions d'objectes</strong> i no de valors arbitraris de qualsevol tipus.</li> + <li> <code>WeakSet</code> és <em>dèbil (weak)</em>: Les referències a la col·lecció es mantenen dèbilment. SI no hi ha cap altra referència a un objecte emmagatzemat en <code>WeakSet</code>,<u> poden ser recollits com a brossa</u>. Això també vol dir que no hi ha cap llista d'objectes actuals emmagatzemats a la col·lecció. <code>WeakSets</code> no són enumerables.</li> +</ul> + +<h2 id="Propietats">Propietats</h2> + +<dl> + <dt><code>WeakSet.length</code></dt> + <dd>El valor de la propietat <code>length</code> és 0.</dd> + <dt>{{jsxref("WeakSet.prototype")}}</dt> + <dd>Representa el prototip per al constructor de <code>Set.</code> Permet afegir propietats a tots els objectes <code>WeakSet</code>.</dd> +</dl> + +<h2 id="Instàncies_WeakSet">Instàncies <code>WeakSet</code></h2> + +<p>Totes les instàncies <code>WeakSet</code> hereten de {{jsxref("WeakSet.prototype")}}.</p> + +<h3 id="Propietats_2">Propietats</h3> + +<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/WeakSet/prototype','Properties')}}</p> + +<h3 id="Mètodes">Mètodes</h3> + +<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/WeakSet/prototype','Methods')}}</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_l'objecte_WeakSet">Utilitzar l'objecte <code>WeakSet</code></h3> + +<pre class="brush: js">var ws = new WeakSet(); +var obj = {}; +var foo = {}; + +ws.add(window); +ws.add(obj); + +ws.has(window); // true +ws.has(foo); // false, foo no s'ha afegit al conjunt + +ws.delete(window); // elimina window del conjunt +ws.has(window); // false, window ha sigut eliminat + +ws.clear(); // buida tot el WeakSet +</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-weakset-objects', 'WeakSet')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definició inicial.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatChrome(36)}}</td> + <td>{{ CompatGeckoDesktop(34) }}</td> + <td>{{CompatNo}}</td> + <td>{{ CompatOpera(23) }}</td> + <td>9</td> + </tr> + <tr> + <td><code>new WeakSet(iterable)</code></td> + <td>38</td> + <td>{{ CompatGeckoDesktop(34) }}</td> + <td>{{CompatNo}}</td> + <td>25</td> + <td>9</td> + </tr> + <tr> + <td>Constructor argument: <code>new WeakSet(null)</code></td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoDesktop("37")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>9</td> + </tr> + <tr> + <td>Monkey-patched <code>add()</code> in Constructor</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoDesktop("37")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</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>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>{{ CompatGeckoMobile(34) }}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>9</td> + </tr> + <tr> + <td><code>new WeakMap(iterable)</code></td> + <td>{{CompatNo}}</td> + <td>{{ CompatGeckoMobile(34) }}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>9</td> + </tr> + <tr> + <td>Constructor argument: <code>new WeakSet(null)</code></td> + <td>{{CompatUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>9</td> + </tr> + <tr> + <td>Monkey-patched <code>add()</code> in Constructor</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>9</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Map")}}</li> + <li>{{jsxref("Set")}}</li> + <li>{{jsxref("WeakMap")}}</li> +</ul> diff --git a/files/ca/web/javascript/reference/global_objects/weakset/prototype/index.html b/files/ca/web/javascript/reference/global_objects/weakset/prototype/index.html new file mode 100644 index 0000000000..2b4cd51048 --- /dev/null +++ b/files/ca/web/javascript/reference/global_objects/weakset/prototype/index.html @@ -0,0 +1,131 @@ +--- +title: WeakSet.prototype +slug: Web/JavaScript/Reference/Global_Objects/WeakSet/prototype +translation_of: Web/JavaScript/Reference/Global_Objects/WeakSet +--- +<div>{{JSRef}}</div> + +<p>La propietat <code><strong>WeakSet</strong></code><strong><code>.prototype</code></strong> representa el prototip pel constructor {{jsxref("WeakSet")}}.</p> + +<div>{{js_property_attributes(0,0,0)}}</div> + +<h2 id="Descripció">Descripció</h2> + +<p>Les instàncies {{jsxref("WeakSet")}} hereten de {{jsxref("WeakSet.prototype")}}. Es pot utilitzar l'objecte prototip del constructor per afegir propietats o mètodes a totes les instàncies <code>WeakSet</code>.</p> + +<p><code>WeakSet.prototype</code> és en si mateix només un objecte ordinari</p> + +<pre class="brush: js">Object.prototype.toString.call(WeakSet.prototype); // "[object Object]"</pre> + +<h2 id="Propietats">Propietats</h2> + +<dl> + <dt><code>WeakSet.prototype.constructor</code></dt> + <dd>Retorna la funció que ha creat un prototip de la instància. Aquesta és la funció {{jsxref("WeakSet")}} per defecte.</dd> +</dl> + +<h2 id="Mètodes">Mètodes</h2> + +<dl> + <dt>{{jsxref("WeakSet.add", "WeakSet.prototype.add(value)")}}</dt> + <dd>Afegeix un nou element amb el valor donat a l'objecte <code>WeakSet.</code></dd> + <dt>{{jsxref("WeakSet.delete", "WeakSet.prototype.delete(value)")}}</dt> + <dd>Elimina l'element associat al <code>value</code>. <code>WeakSet.prototype.has(value)</code> retornarà després <code>false</code>.</dd> + <dt>{{jsxref("WeakSet.has", "WeakSet.prototype.has(value)")}}</dt> + <dd>Retorna un booleà afirmant si un element és o no present amb el valor donat en l'objecte <code>WeakSet</code>.</dd> + <dt><s class="obsoleteElement">{{jsxref("WeakSet.prototype.clear()")}} {{obsolete_inline}}</s></dt> + <dd><s class="obsoleteElement">Elimina tots els elements de l'objecte <code>WeakSet.</code></s></dd> +</dl> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-weakset.prototype', 'WeakSet.prototype')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definició inicial.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>36</td> + <td>{{ CompatGeckoDesktop(34) }}</td> + <td>{{CompatNo}}</td> + <td>23</td> + <td>{{CompatNo}}</td> + </tr> + <tr> + <td>Objecte ordinari</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatGeckoDesktop("40")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome per Android</th> + <th>Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{ CompatGeckoMobile(34) }}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + <tr> + <td>Objecte ordinari</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatGeckoMobile("40")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Set.prototype")}}</li> + <li>{{jsxref("WeakMap.prototype")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/classes/constructor/index.html b/files/ca/web/javascript/referencia/classes/constructor/index.html new file mode 100644 index 0000000000..a0bd6b966f --- /dev/null +++ b/files/ca/web/javascript/referencia/classes/constructor/index.html @@ -0,0 +1,129 @@ +--- +title: constructor +slug: Web/JavaScript/Referencia/Classes/constructor +translation_of: Web/JavaScript/Reference/Classes/constructor +--- +<div>{{jsSidebar("Classes")}}</div> + +<h2 id="Resum">Resum</h2> + +<p>El mètode <code>constructor</code> és un mètode especial per crear i inicialitzar un objecte creat amb una <code>class</code>.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox">constructor([arguments]) { ... }</pre> + +<h2 id="Descripció">Descripció</h2> + +<p>Només hi pot haver un mètode especial am el nom "constructor" en una classe. Es llançarà un {{jsxref("SyntaxError")}}, si la classe conté més d'un cas d'un mètode <code>constructor</code>.</p> + +<p>Un constructor pot utilitzar la paraula clau <code>super</code> per cridar el constructor de la classe pare.</p> + +<h2 id="Exemples">Exemples</h2> + +<p>Aquest fragment de codi es pren de <a href="https://github.com/GoogleChrome/samples/blob/gh-pages/classes-es6/index.html">mostra de classes</a> (<a href="https://googlechrome.github.io/samples/classes-es6/index.html">demostració en viu</a>).</p> + +<pre class="brush: js">class Square extends Polygon { + constructor(length) { + // Aquí es crida el constructor del pare de la classe amb les longituts + // proveïdes per l'amplada i l'alçada del polígon + super(length, length); + // Nota: En classes derivades, s'ha de cridar super() abans + // d'utilitzar 'this'. Obviar això causarà un error de referència. + this.name = 'Square'; + } + + get area() { + return this.height * this.width; + } + + set area(value) { + this.area = value; + } +}</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-static-semantics-constructormethod', 'Constructor Method')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definició inicial.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatChrome(42.0)}}</td> + <td> + <p>Disponible només al canal Nightly (desde febrer del 2015)</p> + </td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>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>{{CompatUnknown}}</td> + <td>{{CompatChrome(42.0)}}</td> + <td>Disponible només al canal Nightly (desde febrer del 2015)</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h3 id="Notes_específiques_per_Firefox">Notes específiques per Firefox</h3> + +<ul> + <li>Els constructors estàndards encara no s'han implementat ({{bug(1105463)}})</li> +</ul> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/super">super()</a></li> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/class">expressió </a><a href="/en-US/docs/Web/JavaScript/Reference/Operators/class"><code>class</code> </a></li> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Statements/class">declaració </a><a href="/en-US/docs/Web/JavaScript/Reference/Statements/class"><code>class</code> </a></li> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Classes">Classes</a></li> +</ul> diff --git a/files/ca/web/javascript/referencia/classes/index.html b/files/ca/web/javascript/referencia/classes/index.html new file mode 100644 index 0000000000..23daf7e1ff --- /dev/null +++ b/files/ca/web/javascript/referencia/classes/index.html @@ -0,0 +1,382 @@ +--- +title: Classes +slug: Web/JavaScript/Referencia/Classes +tags: + - Classes + - ECMAScript 2015 + - Experimental + - Expérimental(2) + - JavaScript + - NeedsContent + - NeedsTranslation + - Reference + - Référence(2) + - TopicStub +translation_of: Web/JavaScript/Reference/Classes +--- +<div>{{JsSidebar("Classes")}}</div> + +<p>JavaScript classes, introduced in ECMAScript 2015, are primarily syntactical sugar over JavaScript's existing prototype-based inheritance. The class syntax <strong>does not</strong> introduce a new object-oriented inheritance model to JavaScript.</p> + +<h2 id="Defining_classes">Defining classes</h2> + +<p>Classes are in fact "special <a href="/en-US/docs/Web/JavaScript/Reference/Functions">functions</a>", and just as you can define <a href="/en-US/docs/Web/JavaScript/Reference/Operators/function">function expressions</a> and <a href="/en-US/docs/Web/JavaScript/Reference/Statements/function">function declarations</a>, the class syntax has two components: <a href="/en-US/docs/Web/JavaScript/Reference/Operators/class">class expressions</a> and <a href="/en-US/docs/Web/JavaScript/Reference/Statements/class">class declarations</a>.</p> + +<h3 id="Class_declarations">Class declarations</h3> + +<p>One way to define a class is using a <strong>class declaration</strong>. To declare a class, you use the <code>class</code> keyword with the name of the class ("Rectangle" here).</p> + +<pre class="brush: js">class Rectangle { + constructor(height, width) { + this.height = height; + this.width = width; + } +}</pre> + +<h4 id="Hoisting">Hoisting</h4> + +<p>An important difference between <strong>function declarations</strong> and <strong>class declarations</strong> is that function declarations are {{Glossary("Hoisting", "hoisted")}} and class declarations are not. You first need to declare your class and then access it, otherwise code like the following will throw a {{jsxref("ReferenceError")}}:</p> + +<pre class="brush: js example-bad">var p = new Rectangle(); // ReferenceError + +class Rectangle {} +</pre> + +<h3 id="Class_expressions">Class expressions</h3> + +<p>A <strong>class expression</strong> is another way to define a class. Class expressions can be named or unnamed. The name given to a named class expression is local to the class's body. (it can be retrieved through the class's (not an instance's) <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/name">.name</a> property, though)</p> + +<pre class="brush: js">// unnamed +var Rectangle = class { + constructor(height, width) { + this.height = height; + this.width = width; + } +}; +console.log(Rectangle.name); +// output: "Rectangle" + +// named +var Rectangle = class Rectangle2 { + constructor(height, width) { + this.height = height; + this.width = width; + } +}; +console.log(Rectangle.name); +// output: "Rectangle2" +</pre> + +<p><strong>Note:</strong> Class <strong>expressions</strong> also suffer from the same hoisting issues mentioned for Class <strong>declarations</strong>.</p> + +<h2 id="Class_body_and_method_definitions">Class body and method definitions</h2> + +<p>The body of a class is the part that is in curly brackets <code>{}</code>. This is where you define class members, such as methods or constructor.</p> + +<h3 id="Strict_mode">Strict mode</h3> + +<p>The bodies of <em>class declarations</em> and <em>class expressions</em> are executed in <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Strict_mode">strict mode</a> i.e. constructor, static and prototype methods, getter and setter functions are executed in strict mode.</p> + +<h3 id="Constructor">Constructor</h3> + +<p>The <code><a href="/en-US/docs/Web/JavaScript/Reference/Classes/constructor">constructor</a></code> method is a special method for creating and initializing an object created with a <code>class</code>. There can only be one special method with the name "constructor" in a class. A {{jsxref("SyntaxError")}} will be thrown if the class contains more than one occurrence of a <code>constructor</code> method.</p> + +<p>A constructor can use the <code>super</code> keyword to call the constructor of the super class.</p> + +<h3 id="Prototype_methods">Prototype methods</h3> + +<p>See also <a href="/en-US/docs/Web/JavaScript/Reference/Functions/Method_definitions">method definitions</a>.</p> + +<pre class="brush: js">class Rectangle { + constructor(height, width) { + this.height = height; + this.width = width; + } + // Getter + get area() { + return this.calcArea(); + } + // Method + calcArea() { + return this.height * this.width; + } +} + +const square = new Rectangle(10, 10); + +console.log(square.area); // 100</pre> + +<h3 id="Static_methods">Static methods</h3> + +<p>The <code><a href="/en-US/docs/Web/JavaScript/Reference/Classes/static">static</a></code> keyword defines a static method for a class. Static methods are called without <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Introduction_to_Object-Oriented_JavaScript#The_object_(class_instance)" title='An example of class instance is "var john = new Person();"'>instantiating </a>their class and <strong>cannot </strong>be called through a class instance. Static methods are often used to create utility functions for an application.</p> + +<pre class="brush: js">class Point { + constructor(x, y) { + this.x = x; + this.y = y; + } + + static distance(a, b) { + const dx = a.x - b.x; + const dy = a.y - b.y; + + return Math.hypot(dx, dy); + } +} + +const p1 = new Point(5, 5); +const p2 = new Point(10, 10); + +console.log(Point.distance(p1, p2)); // 7.0710678118654755</pre> + +<h3 id="Boxing_with_prototype_and_static_methods">Boxing with prototype and static methods</h3> + +<p>When a static or prototype method is called without a value for <em>this</em>, the <em>this</em> value will be <font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: rgba(220, 220, 220, 0.498039);">undefined</span></font> inside the method. This behavior will be the same even if the <code>"use strict"</code> directive isn't present, because code within the <code>class</code> syntax is always executed in strict mode.</p> + +<pre class="brush: js">class Animal { + speak() { + return this; + } + static eat() { + return this; + } +} + +let obj = new Animal(); +obj.speak(); // Animal {} +let speak = obj.speak; +speak(); // undefined + +Animal.eat() // class Animal +let eat = Animal.eat; +eat(); // undefined</pre> + +<p>If the above is written using traditional function–based syntax, then autoboxing in method calls will happen in non–strict mode based on the initial <em>this</em> value. If the inital value is <code>undefined</code>, <em>this</em> will be set to the global object.</p> + +<p>Autoboxing will not happen in strict mode, the <em>this</em> value remains as passed.</p> + +<pre class="brush: js">function Animal() { } + +Animal.prototype.speak = function() { + return this; +} + +Animal.eat = function() { + return this; +} + +let obj = new Animal(); +let speak = obj.speak; +speak(); // global object + +let eat = Animal.eat; +eat(); // global object +</pre> + +<h3 id="Instance_properties">Instance properties</h3> + +<p>Instance properties must be defined inside of class methods:</p> + +<pre class="brush: js">class Rectangle { + constructor(height, width) { + this.height = height; + this.width = width; + } +}</pre> + +<p>Static class-side properties and prototype data properties must be defined outside of the ClassBody declaration:</p> + +<pre class="brush: js">Rectangle.staticWidth = 20; +Rectangle.prototype.prototypeWidth = 25; +</pre> + +<p> </p> + +<h2 id="Sub_classing_with_extends">Sub classing with <code>extends</code></h2> + +<p>The <code><a href="/en-US/docs/Web/JavaScript/Reference/Classes/extends">extends</a></code> keyword is used in <em>class declarations</em> or <em>class expressions</em> to create a class as a child of another class.</p> + +<pre class="brush: js">class Animal { + constructor(name) { + this.name = name; + } + + speak() { + console.log(this.name + ' makes a noise.'); + } +} + +class Dog extends Animal { + speak() { + console.log(this.name + ' barks.'); + } +} + +var d = new Dog('Mitzie'); +d.speak(); // Mitzie barks. +</pre> + +<p>If there is a constructor present in subclass, it needs to first call super() before using "this".</p> + +<p>One may also extend traditional function-based "classes":</p> + +<pre class="brush: js">function Animal (name) { + this.name = name; +} + +Animal.prototype.speak = function () { + console.log(this.name + ' makes a noise.'); +} + +class Dog extends Animal { + speak() { + console.log(this.name + ' barks.'); + } +} + +var d = new Dog('Mitzie'); +d.speak(); // Mitzie barks. +</pre> + +<p>Note that classes cannot extend regular (non-constructible) objects. If you want to inherit from a regular object, you can instead use {{jsxref("Object.setPrototypeOf()")}}:</p> + +<pre class="brush: js">var Animal = { + speak() { + console.log(this.name + ' makes a noise.'); + } +}; + +class Dog { + constructor(name) { + this.name = name; + } +} + +// If you do not do this you will get a TypeError when you invoke speak +Object.setPrototypeOf(Dog.prototype, Animal); + +var d = new Dog('Mitzie'); +d.speak(); // Mitzie makes a noise. +</pre> + +<h2 id="Species">Species</h2> + +<p>You might want to return {{jsxref("Array")}} objects in your derived array class <code>MyArray</code>. The species pattern lets you override default constructors.</p> + +<p>For example, when using methods such as {{jsxref("Array.map", "map()")}} that returns the default constructor, you want these methods to return a parent <code>Array</code> object, instead of the <code>MyArray</code> object. The {{jsxref("Symbol.species")}} symbol lets you do this:</p> + +<pre class="brush: js">class MyArray extends Array { + // Overwrite species to the parent Array constructor + static get [Symbol.species]() { return Array; } +} + +var a = new MyArray(1,2,3); +var mapped = a.map(x => x * x); + +console.log(mapped instanceof MyArray); // false +console.log(mapped instanceof Array); // true +</pre> + +<h2 id="Super_class_calls_with_super">Super class calls with <code>super</code></h2> + +<p>The <code><a href="/en-US/docs/Web/JavaScript/Reference/Operators/super">super</a></code> keyword is used to call corresponding methods of super class.</p> + +<pre class="brush: js">class Cat { + constructor(name) { + this.name = name; + } + + speak() { + console.log(this.name + ' makes a noise.'); + } +} + +class Lion extends Cat { + speak() { + super.speak(); + console.log(this.name + ' roars.'); + } +} + +var l = new Lion('Fuzzy'); +l.speak(); +// Fuzzy makes a noise. +// Fuzzy roars. + +</pre> + +<h2 id="Mix-ins">Mix-ins</h2> + +<p>Abstract subclasses or <em>mix-ins</em> are templates for classes. An ECMAScript class can only have a single superclass, so multiple inheritance from tooling classes, for example, is not possible. The functionality must be provided by the superclass.</p> + +<p>A function with a superclass as input and a subclass extending that superclass as output can be used to implement mix-ins in ECMAScript:</p> + +<pre class="brush: js">var calculatorMixin = Base => class extends Base { + calc() { } +}; + +var randomizerMixin = Base => class extends Base { + randomize() { } +}; +</pre> + +<p>A class that uses these mix-ins can then be written like this:</p> + +<pre class="brush: js">class Foo { } +class Bar extends calculatorMixin(randomizerMixin(Foo)) { }</pre> + +<h2 id="Specifications">Specifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-class-definitions', 'Class definitions')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ES2016', '#sec-class-definitions', 'Class definitions')}}</td> + <td>{{Spec2('ES2016')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES2017', '#sec-class-definitions', 'Class definitions')}}</td> + <td>{{Spec2('ES2017')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-class-definitions', 'Class definitions')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + + + +<p>{{Compat("javascript.classes")}}</p> + +<h2 id="Running_in_Scratchpad">Running in Scratchpad</h2> + +<p>A class can't be redefined. If you're playing with code in Scratchpad (Firefox menu Tools > Web Developer > Scratchpad) and you 'Run' a definition of a class with the same name twice, you'll get a confusing SyntaxError: redeclaration of let <class-name>.</p> + +<p>To re-run a definition, use Scratchpad's menu Execute > Reload and Run.<br> + Please vote for bug <a href="https://bugzilla.mozilla.org/show_bug.cgi?id=1428672">#1428672</a>.</p> + +<h2 id="See_also">See also</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Functions">Functions</a></li> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Statements/class"><code>class</code> declaration</a></li> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/class"><code>class</code> expression</a></li> + <li>{{jsxref("Operators/super", "super")}}</li> + <li><a href="https://hacks.mozilla.org/2015/07/es6-in-depth-classes/">Blog post: "ES6 In Depth: Classes"</a></li> + <li><a href="https://github.com/tc39/proposal-class-fields">Fields and public/private class properties proposal (stage 3)</a></li> +</ul> diff --git a/files/ca/web/javascript/referencia/classes/static/index.html b/files/ca/web/javascript/referencia/classes/static/index.html new file mode 100644 index 0000000000..3255dc1552 --- /dev/null +++ b/files/ca/web/javascript/referencia/classes/static/index.html @@ -0,0 +1,116 @@ +--- +title: static +slug: Web/JavaScript/Referencia/Classes/static +translation_of: Web/JavaScript/Reference/Classes/static +--- +<div>{{jsSidebar("Classes")}}</div> + +<p>La paraula clau <strong>static</strong> defineix un mètode estàtic per a una classe.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox">static methodName() { ... }</pre> + +<h2 id="Descripció">Descripció</h2> + +<p><u>Els mètodes estàtics es criden sense realitzar una instantània de la seva classe o instantiating their class nor are they callable when the class is instantiated</u>. Els mètodes estàtics s'utilitzen sovint per crear funcions d'utilitat per una aplicació.</p> + +<h2 id="Exemples">Exemples</h2> + +<p>L'exemple següent mostra diverses coses. Mostra com un mètode estàtic és implementat en una classe i que una classe amb un membre estàtic pot tenir subclasses. Finalment, mostra com es pot i com no es pot cridar un mètode estàtic.</p> + +<pre class="brush: js">class Tripple { + static tripple(n) { + n = n | 1; + return n * 3; + } +} + +class BiggerTripple extends Tripple { + static tripple(n) { + return super.tripple(n) * super.tripple(n); + } +} + +console.log(Tripple.tripple()); +console.log(Tripple.tripple(6)); +console.log(BiggerTripple.tripple(3)); +var tp = new Tripple(); +console.log(tp.tripple()); //Logs 'tp.tripple is not a function'.</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-class-definitions', 'Class definitions')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definició inicial.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatChrome(42.0)}}</td> + <td>Disponible només en el canal Nightly (desde febrer del 2015)</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>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>{{CompatUnknown}}</td> + <td>{{CompatChrome(42.0)}}</td> + <td>Disponible només en el canal Nightly (desde febrer del 2015)</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/class">expressió </a><a href="/en-US/docs/Web/JavaScript/Reference/Operators/class"><code>class</code> </a></li> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Statements/class">declaració </a><a href="/en-US/docs/Web/JavaScript/Reference/Statements/class"><code>class</code> </a></li> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Classes">Classes</a></li> +</ul> diff --git a/files/ca/web/javascript/referencia/index.html b/files/ca/web/javascript/referencia/index.html new file mode 100644 index 0000000000..f524504ab2 --- /dev/null +++ b/files/ca/web/javascript/referencia/index.html @@ -0,0 +1,46 @@ +--- +title: Glossari de JavaScript +slug: Web/JavaScript/Referencia +translation_of: Web/JavaScript/Reference +--- +<div>{{JsSidebar}}</div> + +<p>Aquesta part de la secció de JavaScript a l'MDN serveix com a glossari de informació sobre el llenguatge JavaScript. Podeu llegir més <a href="/ca/docs/Web/JavaScript/Reference/About">sobre aquest glossari</a>.</p> + +<h2 id="Objectes_Globals">Objectes Globals</h2> + +<p>Aquest capítol documenta tots els <a href="/ca/docs/Web/JavaScript/Reference/Global_Objects">objectes standard de JavaScript</a>, així com els seus mètodes i propietats.</p> + +<p>{{page('/ca/docs/Web/JavaScript/Reference/Global_Objects', 'Objectes standard (per categoria)')}}</p> + +<h2 id="Sentències">Sentències</h2> + +<p>Aquest capítol documenta totes les <a href="/ca/docs/Web/JavaScript/Reference/Statements">sentències i declaracions disponibles a JavaScript</a>.</p> + +<p>{{page('/ca/docs/Web/JavaScript/Reference/Statements', 'Instruccions i declaracions disponibles (per categoria)')}}</p> + +<h2 id="Expressions_i_operadors">Expressions i operadors</h2> + +<p>Aquest capítol documenta totes les <a href="/ca/docs/Web/JavaScript/Reference/Operators">expressions i els operadors soportats per JavaScript</a>.</p> + +<div>{{page('/ca/docs/Web/JavaScript/Reference/Operators', 'Expressions i operadors (per categoria)')}}</div> + +<h2 id="Funcions">Funcions</h2> + +<p>Aquest capítol documenta com treballar amb <a href="/ca/docs/Web/JavaScript/Reference/Functions">funcions de JavaScript</a>.</p> + +<ul> + <li><a href="/ca/docs/Web/JavaScript/Reference/Functions/arguments"><code>arguments</code></a></li> + <li><a href="/ca/docs/Web/JavaScript/Reference/Functions/Arrow_functions">Functions fletxa</a></li> + <li><a href="/ca/docs/Web/JavaScript/Reference/Functions/Default_parameters">Paràmetres per defecte</a></li> + <li><a href="/ca/docs/Web/JavaScript/Reference/Functions/rest_parameters">Parametres Rest</a></li> +</ul> + +<h2 id="Pàgines_de_glossari_adicionals">Pàgines de glossari adicionals</h2> + +<ul> + <li><a href="/ca/docs/Web/JavaScript/Reference/Lexical_grammar">Gramàtica lèxica</a></li> + <li><a href="/ca/docs/Web/JavaScript/Data_structures">Tipus i estructures de dades</a></li> + <li><a href="/ca/docs/Web/JavaScript/Reference/Strict_mode">Mode estricte</a></li> + <li><a href="/ca/docs/Web/JavaScript/Reference/Deprecated_and_obsolete_features">Característiques en desús</a></li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/array/entries/index.html b/files/ca/web/javascript/referencia/objectes_globals/array/entries/index.html new file mode 100644 index 0000000000..8b67c06038 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/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/referencia/objectes_globals/array/every/index.html b/files/ca/web/javascript/referencia/objectes_globals/array/every/index.html new file mode 100644 index 0000000000..ad707b4990 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/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/referencia/objectes_globals/array/fill/index.html b/files/ca/web/javascript/referencia/objectes_globals/array/fill/index.html new file mode 100644 index 0000000000..e1952a8407 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/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/referencia/objectes_globals/array/filter/index.html b/files/ca/web/javascript/referencia/objectes_globals/array/filter/index.html new file mode 100644 index 0000000000..c1bfec77f3 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/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/referencia/objectes_globals/array/find/index.html b/files/ca/web/javascript/referencia/objectes_globals/array/find/index.html new file mode 100644 index 0000000000..8ee7742c09 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/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/referencia/objectes_globals/array/findindex/index.html b/files/ca/web/javascript/referencia/objectes_globals/array/findindex/index.html new file mode 100644 index 0000000000..5b089bdb98 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/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/referencia/objectes_globals/array/foreach/index.html b/files/ca/web/javascript/referencia/objectes_globals/array/foreach/index.html new file mode 100644 index 0000000000..4d391346eb --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/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/referencia/objectes_globals/array/includes/index.html b/files/ca/web/javascript/referencia/objectes_globals/array/includes/index.html new file mode 100644 index 0000000000..9f64b0e117 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/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/referencia/objectes_globals/array/index.html b/files/ca/web/javascript/referencia/objectes_globals/array/index.html new file mode 100644 index 0000000000..da7c400799 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/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/referencia/objectes_globals/array/indexof/index.html b/files/ca/web/javascript/referencia/objectes_globals/array/indexof/index.html new file mode 100644 index 0000000000..939571a0c8 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/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/referencia/objectes_globals/array/isarray/index.html b/files/ca/web/javascript/referencia/objectes_globals/array/isarray/index.html new file mode 100644 index 0000000000..6393dde86f --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/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/referencia/objectes_globals/array/join/index.html b/files/ca/web/javascript/referencia/objectes_globals/array/join/index.html new file mode 100644 index 0000000000..8d76b4474a --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/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/referencia/objectes_globals/array/keys/index.html b/files/ca/web/javascript/referencia/objectes_globals/array/keys/index.html new file mode 100644 index 0000000000..7d9df8e1f5 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/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/referencia/objectes_globals/array/lastindexof/index.html b/files/ca/web/javascript/referencia/objectes_globals/array/lastindexof/index.html new file mode 100644 index 0000000000..038aa614e5 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/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/referencia/objectes_globals/array/length/index.html b/files/ca/web/javascript/referencia/objectes_globals/array/length/index.html new file mode 100644 index 0000000000..a4954565ff --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/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/referencia/objectes_globals/array/map/index.html b/files/ca/web/javascript/referencia/objectes_globals/array/map/index.html new file mode 100644 index 0000000000..6f0dc1a0d4 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/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/referencia/objectes_globals/array/observe/index.html b/files/ca/web/javascript/referencia/objectes_globals/array/observe/index.html new file mode 100644 index 0000000000..0214800297 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/array/observe/index.html @@ -0,0 +1,128 @@ +--- +title: Array.observe() +slug: Web/JavaScript/Referencia/Objectes_globals/Array/observe +translation_of: Archive/Web/JavaScript/Array.observe +--- +<div>{{JSRef}}</div> + +<p>El mètode <strong><code>Array.observe()</code></strong>s'utilitza per observar canvis en Arrays de forma asíncrona, de forma similar a que {{jsxref("Object.observe()")}} ho fa en objectes. Proporciona una corrent de canvis en l'ordre d'aparició. Es equivalent a la crida de <code>Object.observe()</code> <u>amb la llista de tipus acceptar </u><code>["add", "update", "delete", "splice"]</code>.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code>Array.observe(<var>arr</var>, <var>callback</var>)</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>arr</code></dt> + <dd>L'array que s'ha d'observar.</dd> + <dt><code>callback</code></dt> + <dd>La funció es crida cada cop que es realitzen canvis, amb el següent argument: + <dl> + <dt><code>changes</code></dt> + <dd>Un array d'objectes cadascun dels quals representa un canvi. Les propietats d'aquests objectes de canvis són: + <ul> + <li><strong><code>name</code></strong>: El nom de la propietat que s'ha canviat.</li> + <li><strong><code>object</code></strong>: L'array canviat després que s'hagués produït el canvi.</li> + <li><strong><code>type</code></strong>: Una cadena que indica el tipus de canvi que s'ha portat a cap. Un de <code>"add"</code>, <code>"update"</code>, <code>"delete"</code>, o <code>"splice"</code>.</li> + <li><strong><code>oldValue</code></strong>: Únicament pel tipus <code>"update"</code> i <code>"delete"</code>. El valor abans del canvi.</li> + <li><strong><code>index</code></strong>: Únicament pel tipus <code>"splice"</code>. L'índex en el qual s'ha produït el canvi.</li> + <li><strong><code>removed</code></strong>: Únicament pel tipus <code>"splice</code>. Un array dels elements eliminats.</li> + <li><strong><code>addedCount</code></strong>: Únicament pel tipus<code>"splice"</code>. EL nombre d'elements afegits.</li> + </ul> + </dd> + </dl> + </dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>La funció <code>callback</code> es crida cada cop que es realitza un canvi en <code>arr</code>, amb un array de tots els canvis tal i com han succeït.</p> + +<div class="note"> +<p>Els canvis fets a través de mètodes d'Array, com ara <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/pop"><code>Array.prototype.pop()</code></a>seràn contats com a canvis de <code>"splice"</code>. Canvis d'assignació d'índexs que no canvien la llargària de l'array poden contar-se com a canvis <code>"update"</code>.</p> +</div> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Iniciar_diferents_tipus_de_canvis">Iniciar diferents tipus de canvis</h3> + +<pre class="brush: js">var arr = ['a', 'b', 'c']; + +Array.observe(arr, function(changes) { + console.log(changes); +}); + +arr[1] = 'B'; +// [{type: 'update', object: <arr>, name: '1', oldValue: 'b'}] + +arr[3] = 'd'; +// [{type: 'splice', object: <arr>, index: 3, removed: [], addedCount: 1}] + +arr.splice(1, 2, 'beta', 'gamma', 'delta'); +// [{type: 'splice', object: <arr>, index: 1, removed: ['B', 'c', 'd'], addedCount: 3}] +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<p><a href="https://github.com/arv/ecmascript-object-observe">Strawman proposal for ECMAScript 7</a>.</p> + +<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("36")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome per Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatNo}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li><a href="//stackoverflow.com/q/29269057/778272">Under what condition would Array.observe's “add” event trigger?</a></li> + <li>{{jsxref("Array.unobserve()")}} {{experimental_inline}}</li> + <li>{{jsxref("Object.observe()")}} {{experimental_inline}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/array/of/index.html b/files/ca/web/javascript/referencia/objectes_globals/array/of/index.html new file mode 100644 index 0000000000..efe2d96abd --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/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/referencia/objectes_globals/array/pop/index.html b/files/ca/web/javascript/referencia/objectes_globals/array/pop/index.html new file mode 100644 index 0000000000..7d2ee3189f --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/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/referencia/objectes_globals/array/prototype/index.html b/files/ca/web/javascript/referencia/objectes_globals/array/prototype/index.html new file mode 100644 index 0000000000..35ebf53933 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/array/prototype/index.html @@ -0,0 +1,203 @@ +--- +title: Array.prototype +slug: Web/JavaScript/Referencia/Objectes_globals/Array/prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Array/prototype +--- +<div>{{JSRef}}</div> + +<p>La propietat <strong><code>Array.prototype</code></strong> representa el prototipus del constructor {{jsxref("Array")}}.</p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Description" name="Description">Descripció</h2> + +<p>Les instàncies de {{jsxref("Array")}} hereten de <code>Array.prototype</code>. Com tots els constructors, és possible modificar l'objecte prototipus del constructor per a afectar a totes les instàncies de {{jsxref("Array")}}.</p> + +<p>Fet poc conegut: <code>Array.prototype</code> és ell mateix un {{jsxref("Array")}}:</p> + +<pre class="brush: js">Array.isArray(Array.prototype); // true +</pre> + +<h2 id="Properties" name="Properties">Propietats</h2> + +<dl> + <dt><code>Array.prototype.constructor</code></dt> + <dd>Especifica la funció que ha creat el prototipus de l'objecte.</dd> + <dt>{{jsxref("Array.prototype.length")}}</dt> + <dd>Reflecteix el nombre d'elements d'un array.</dd> +</dl> + +<h2 id="Methods" name="Methods">Mètodes</h2> + +<h3 id="Mutator_methods" name="Mutator_methods">Mètodes Mutadors</h3> + +<p>Els mètodes següents modifiquen l'array:</p> + +<dl> + <dt>{{jsxref("Array.prototype.copyWithin()")}} {{experimental_inline}}</dt> + <dd>Copia una seqüència d'elements de l'array dins l'array.</dd> + <dt>{{jsxref("Array.prototype.fill()")}} {{experimental_inline}}</dt> + <dd>Omple tots els elements d'un array d'una posició inicial a una posició final amb un valor estàtic.</dd> + <dt>{{jsxref("Array.prototype.pop()")}}</dt> + <dd>Elimina l'últim element d'un array i retorna aquest element.</dd> + <dt>{{jsxref("Array.prototype.push()")}}</dt> + <dd>Afegeix un o més elements al final de l'array i retorna el nou tamany de l'array.</dd> + <dt>{{jsxref("Array.prototype.reverse()")}}</dt> + <dd>Capgira l'ordre dels elements d'un array a l'array mateix (no crea cap array nou) — el primer element esdevé l'últim, l'últim esdevé el primer, etcètera.</dd> + <dt>{{jsxref("Array.prototype.shift()")}}</dt> + <dd>Elimina el primer element d'un array i retorna aquest element.</dd> + <dt>{{jsxref("Array.prototype.sort()")}}</dt> + <dd>Ordena els elements d'un array a l'array mateix i retorna l'array.</dd> + <dt>{{jsxref("Array.prototype.splice()")}}</dt> + <dd>Afegeix i/o elimina elements d'un array.</dd> + <dt>{{jsxref("Array.prototype.unshift()")}}</dt> + <dd>Afegeix un o més elements al pricipi d'un array i retorna el nou tamany de l'array.</dd> +</dl> + +<h3 id="Accessor_methods" name="Accessor_methods">Mètodes d'accés</h3> + +<p>Aquests mètodes no modifiquen l'array sino que retornen algun tipus de representació de l'array.</p> + +<dl> + <dt>{{jsxref("Array.prototype.concat()")}}</dt> + <dd>Retorna un nou array format per la unió de l'array actual amb altres arrays o valors.</dd> + <dt>{{jsxref("Array.prototype.includes()")}} {{experimental_inline}}</dt> + <dd>Determina si un array inclou un element en concret, retornant <code>true</code> en cas afirmatiu i <code>false</code> en cas contrari.</dd> + <dt>{{jsxref("Array.prototype.join()")}}</dt> + <dd>Uneix tots els elements d'un array en un string.</dd> + <dt>{{jsxref("Array.prototype.slice()")}}</dt> + <dd>Extrau una secció d'un array i la retorna en forma de nou array.</dd> + <dt>{{jsxref("Array.prototype.toSource()")}} {{non-standard_inline}}</dt> + <dd>Retorna un literal d'array que representa l'array especificat; es pot emprar aquest valor per a crear un nou array. Sobreescriu el mètode {{jsxref("Object.prototype.toSource()")}}.</dd> + <dt>{{jsxref("Array.prototype.toString()")}}</dt> + <dd>Retorna un string que representa l'array i els seus elements. Sobreescriu el mètode {{jsxref("Object.prototype.toString()")}}.</dd> + <dt>{{jsxref("Array.prototype.toLocaleString()")}}</dt> + <dd>Retorna un string localitzat que representa l'array i els seus elements. Sobreescriu el mètode {{jsxref("Object.prototype.toLocaleString()")}}.</dd> + <dt>{{jsxref("Array.prototype.indexOf()")}}</dt> + <dd>Retorna la primera posició de l'array en la que es troba un element igual al valor especificat, o bé -1 si no es troba l'element dins l'array.</dd> + <dt>{{jsxref("Array.prototype.lastIndexOf()")}}</dt> + <dd>Retorna la última posició de l'array en la que es troba un element igual al valor especificat, o bé -1 si no es troba l'element dins l'array.</dd> +</dl> + +<h3 id="Iteration_methods" name="Iteration_methods">Mètodes d'iteració</h3> + +<p>Alguns mètodes accepten com a arguments funcions que es cridaran al processar l'array. Quan es criden aquests mètodes, s'emmagatzema el valor de <code>length</code> de l'array i qualsevol element afegit després a dins de la funció no serà visitat per la mateixa. Altres canvis a l'array (com ara canviar un valor o bé eliminar un element) poden afectar els resultats de l'operació si el mètode visita els elements que han canviat. Tot i que el comportament específic d'aquests mètodes en aquests casos està ben definit no es recomana recolzar-se en ell ja que pot confondre a altres programadors que llegeixin el vostre codi. En comptes de modificar l'array copieu-lo i modifiqueu la copia.</p> + +<dl> + <dt>{{jsxref("Array.prototype.forEach()")}}</dt> + <dd>Crida una funció per a cada element de l'array.</dd> + <dt>{{jsxref("Array.prototype.entries()")}} {{experimental_inline}}</dt> + <dd>Retorna un nou objecte <code>Array Iterator</code> que conté parells clau-valor per a cada posició de l'array.</dd> + <dt>{{jsxref("Array.prototype.every()")}}</dt> + <dd>Retorna <code>true</code> si tots els elements de l'array satisfan la funció proporcionada.</dd> + <dt>{{jsxref("Array.prototype.some()")}}</dt> + <dd>Retorna <code>true</code> si al menys un dels elements de l'array satisfà la funció proporcionada.</dd> + <dt>{{jsxref("Array.prototype.filter()")}}</dt> + <dd>Crea un nou array que conté tots eles elements de l'array des d'on es crida que facin que la funció que actua de filtre retorni <code>true</code>.</dd> + <dt>{{jsxref("Array.prototype.find()")}} {{experimental_inline}}</dt> + <dd>Retorna el valor trobat a l'array, si un element de l'array satisfà la funció proporcionada. En cas contrari retorna <code>undefined</code>.</dd> + <dt>{{jsxref("Array.prototype.findIndex()")}} {{experimental_inline}}</dt> + <dd>Retorna la posició on es troba l'element de l'array que satifcaci la funció proporcionada. Retorna <code>-1</code> si cap element la satisfà.</dd> + <dt>{{jsxref("Array.prototype.keys()")}} {{experimental_inline}}</dt> + <dd>Retorna un nou <code>Array Iterator</code> que conté les claus per a cada posició de l'array.</dd> + <dt>{{jsxref("Array.prototype.map()")}}</dt> + <dd>Crea un nou array a partir dels resultats de cridar a la funció proporcionada per a cada element de l'array.</dd> + <dt>{{jsxref("Array.prototype.reduce()")}}</dt> + <dd>Executa una funció sobre un acumulador i cada valor de l'array (aplicats d'esquerra a dreta) amb l'objectiu de redudir els valors a un sol valor.</dd> + <dt>{{jsxref("Array.prototype.reduceRight()")}}</dt> + <dd>Executa una funció sobre un acumulador i cada valor de l'array (aplicats de dreta a esquerra) amb l'objectiu de redudir els valors a un sol valor.</dd> + <dt>{{jsxref("Array.prototype.values()")}} {{experimental_inline}}</dt> + <dd>Retorna un nou objecte <code>Array Iterator</code> que conté els valors de cada posició de l'array.</dd> + <dt>{{jsxref("Array.prototype.@@iterator()", "Array.prototype[@@iterator]()")}} {{experimental_inline}}</dt> + <dd>Retorna un nou objecte <code>Array Iterator</code> que conté els valors per a cada posició de l'array.</dd> +</dl> + +<h3 id="Generic_methods" name="Generic_methods">Mètodes genèrics</h3> + +<p>Molts dels mètodes de l'objecte Array de JavaScript estan dissenyats per a ser aplicats de manera genèrica a qualsevol objecte que tingui la propietat <code>length</code> i que disposin la seva informació en forma de noms de propietats numèrices (com ara <code>array[5]</code> per a accedir a l'element desat a la posició 5). Alguns mètodes, com ara {{jsxref("Array.join", "join")}}, només llegeixen la propietat <code>length</code> i les altes propietats numèriques. D'altres mètodes, com ara {{jsxref("Array.reverse", "reverse")}}, necessiten que tant les propietats numèriques com la propietat <code>length</code> siguin mutables; això implica que aquests mètodes no es poden fer servir sobre objectes com ara {{jsxref("String")}}, on la seva propietat <code>length</code> així com les propietats numèriques no es poden modificar.</p> + +<h2 id="Specificacions">Specificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificacions</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definició inicial.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.4.3.1', 'Array.prototype')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-array.prototype', 'Array.prototype')}}</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>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li>{{jsxref("Array")}}</li> + <li>{{jsxref("Function.prototype")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/array/push/index.html b/files/ca/web/javascript/referencia/objectes_globals/array/push/index.html new file mode 100644 index 0000000000..5770e5a10c --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/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/referencia/objectes_globals/array/reduce/index.html b/files/ca/web/javascript/referencia/objectes_globals/array/reduce/index.html new file mode 100644 index 0000000000..fa6253fd0c --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/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/referencia/objectes_globals/array/reverse/index.html b/files/ca/web/javascript/referencia/objectes_globals/array/reverse/index.html new file mode 100644 index 0000000000..2528cabdc5 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/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/referencia/objectes_globals/array/shift/index.html b/files/ca/web/javascript/referencia/objectes_globals/array/shift/index.html new file mode 100644 index 0000000000..7b5fa1b330 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/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/referencia/objectes_globals/array/slice/index.html b/files/ca/web/javascript/referencia/objectes_globals/array/slice/index.html new file mode 100644 index 0000000000..d181f94a65 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/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/referencia/objectes_globals/array/some/index.html b/files/ca/web/javascript/referencia/objectes_globals/array/some/index.html new file mode 100644 index 0000000000..7abc1ed76d --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/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/referencia/objectes_globals/array/splice/index.html b/files/ca/web/javascript/referencia/objectes_globals/array/splice/index.html new file mode 100644 index 0000000000..c1abada8d9 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/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> diff --git a/files/ca/web/javascript/referencia/objectes_globals/boolean/index.html b/files/ca/web/javascript/referencia/objectes_globals/boolean/index.html new file mode 100644 index 0000000000..83f2597df9 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/boolean/index.html @@ -0,0 +1,196 @@ +--- +title: Boolean +slug: Web/JavaScript/Referencia/Objectes_globals/Boolean +translation_of: Web/JavaScript/Reference/Global_Objects/Boolean +--- +<div>{{JSRef("Global_Objects", "Boolean")}}</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>L'objecte <strong><code>Boolean</code></strong> és un objecte que embolcalla valors booleans.</p> + +<h2 id="Syntax" name="Syntax">Constructor</h2> + +<pre class="syntaxbox"><code>new Boolean([<var>valors</var>])</code></pre> + +<h3 id="Parameters" name="Parameters">Paràmetres</h3> + +<dl> + <dt><code>valors</code></dt> + <dd>Opcional. El valor inicial de l'objecte <code>Boolean</code>.</dd> +</dl> + +<h2 id="Description" name="Description">Descripció</h2> + +<p>El valor passat com a primer paràmetre es converteix a un valor booleà, en cas necesari. Si és omés o si és <code>0</code>, <code>-0</code>, {{jsxref("Global_Objects/null", "null")}}, <code>false</code>, {{jsxref("Global_Objects/NaN", "NaN")}}, {{jsxref("Global_Objects/undefined", "undefined")}}, o la cadena de caràcters buida (<code>""</code>), l'objecte tindrà el valor inicial <code>false</code>. Tots els altres valors, incloent qualsevol objecte o la cadena de caràcters <code>"false"</code>, crea un objecte amb el valor inicial de <code>true</code>.</p> + +<p>No confoneu els valors <code>Boolean</code> primitius <code>true</code> i <code>false</code> amb els valors <code>true</code> i <code>false</code> de l'objecte <code>Boolean</code>.</p> + +<p>Qualsevol objecte el valor del qual no sigui {{jsxref("Global_Objects/undefined", "undefined")}} o {{jsxref("Global_Objects/null", "null")}}, incloent un objecte de tipus <code>Boolean</code> el valor del qual sigui <code>false</code>, evalua a <code>true</code> quan es passa a una sentència condicional. Per exemple, la condició en la següent sentència {{jsxref("Statements/if...else", "if")}} evalua a <code>true</code>:</p> + +<pre class="brush: js">x = new Boolean(false); +if (x) { + // aquest codi s'executarà +} +</pre> + +<p>Aquest comportament no s'aplica a les primitives de tipus booleà. Per exemple, la condició en la següent sentència {{jsxref("Statements/if...else", "if")}} evalua a <code>false</code>:</p> + +<pre class="brush: js">x = false; +if (x) { + // aquest codi no s'executarà +} +</pre> + +<p>No creeu una instància de <code>Boolean</code> per a convertir un valor no booleà a un valor booleà. En comptes d'això utilitzeu <code>Boolean</code> com una funció per a realitzar aquesta tasca:</p> + +<pre class="brush: js">x = Boolean(expression); // utilitzar preferentment +x = new Boolean(expression); // no ho utilitzeu +</pre> + +<p>Si s'especifica qualsevol objecte, inclòs un objecte <code>Boolean</code> el valor del qual sigui false, com a valor inicial per a un objecte <code>Boolean</code>, el nou objecte <code>Boolean</code> tindrà un valor de <code>true</code>.</p> + +<pre class="brush: js">myFalse = new Boolean(false); // valor inicial false +g = new Boolean(myFalse); // valor inicial true +myString = new String('Hello'); // objecte de tipus String +s = new Boolean(myString); // valor inicial true +</pre> + +<p>No utilitzeu un objecte <code>Boolean</code> quan podríeu utilitzar un valor primitiu booleà.</p> + +<h2 id="Properties" name="Properties">Propietats</h2> + +<dl> + <dt><code>Boolean.length</code></dt> + <dd>La propietat Length retorna el valor de 1.</dd> + <dt>{{jsxref("Boolean.prototype")}}</dt> + <dd>Representa el prototip pel constructor <code>Boolean</code>.</dd> +</dl> + +<p>{{jsOverrides("Function", "Properties", "prototype")}}</p> + +<h2 id="Methods" name="Methods">Mètodes</h2> + +<p>L'objecte <code>Boolean</code> no té mètodes propis. Hereta, però, alguns mètodes a través de la cadena de prototipus:</p> + +<div>{{jsOverrides("Function", "Methods")}}</div> + +<h2 id="Boolean_instances" name="Boolean_instances"><code>Instàncies de Boolean</code></h2> + +<p>Totes les instàncies de <code>Boolean</code> hereten de {{jsxref("Boolean.prototype")}}. Com tots els constructors, el prototipus de l'objecte dicta les propietats i mètodes que heretaran les instàncies.</p> + +<h3 id="Propietats">Propietats</h3> + +<div>{{page('/ca/docs/Web/JavaScript/Reference/Global_Objects/Boolean/prototype', 'Properties')}}</div> + +<h3 id="Mètodes">Mètodes</h3> + +<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean/prototype', 'Methods')}}</div> + +<h2 id="Examples" name="Examples">Exemples</h2> + +<h3 id="Example:_Creating_Boolean_objects_with_an_initial_value_of_false" name="Example:_Creating_Boolean_objects_with_an_initial_value_of_false">Exemple: Crear objectes <code>Boolean</code> amb un valor inicial de<code> false</code></h3> + +<pre class="brush: js">var bNoParam = new Boolean(); +var bZero = new Boolean(0); +var bNull = new Boolean(null); +var bEmptyString = new Boolean(''); +var bfalse = new Boolean(false); +</pre> + +<h3 id="Example:_Creating_Boolean_objects_with_an_initial_value_of_true" name="Example:_Creating_Boolean_objects_with_an_initial_value_of_true">Exemple: Crear objectes <code>Boolean amb un valor inicial de</code> <code>true</code></h3> + +<pre class="brush: js">var btrue = new Boolean(true); +var btrueString = new Boolean('true'); +var bfalseString = new Boolean('false'); +var bSuLin = new Boolean('Su Lin'); +var bArrayProto = new Boolean([]); +var bObjProto = new Boolean({}); +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>ECMAScript 1a Edició.</td> + <td>Standard</td> + <td>Definició inicial. Implementat a JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.6', 'Boolean')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-boolean-objects', 'Boolean')}}</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>{{CompatIE("6.0")}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li>{{jsxref("Boolean.prototype")}}</li> + <li>{{Glossary("Boolean")}}</li> + <li><a href="http://en.wikipedia.org/wiki/Boolean_data_type">El tipus de dades booleà (Wikipedia)</a></li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/boolean/prototype/index.html b/files/ca/web/javascript/referencia/objectes_globals/boolean/prototype/index.html new file mode 100644 index 0000000000..b203f57c40 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/boolean/prototype/index.html @@ -0,0 +1,117 @@ +--- +title: Boolean.prototype +slug: Web/JavaScript/Referencia/Objectes_globals/Boolean/prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Boolean +--- +<div>{{JSRef("Global_Objects", "Boolean")}}</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>La propietat <strong><code>Boolean.prototype</code></strong> representa el prototipus pel constructor {{jsxref("Global_Objects/Boolean", "Boolean")}}.</p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Description" name="Description">Descripció</h2> + +<p>Les instàncies de {{jsxref("Global_Objects/Boolean", "Boolean")}} hereten de<code> Boolean.prototype</code>. Es pot emprar l'objecte prototipus del constructor per a afegir noves propietats o mètodes a totes les instàncies de {{jsxref("Global_Objects/Boolean", "Boolean")}}.</p> + +<h2 id="Propietats">Propietats</h2> + +<dl> + <dt><code>Boolean.prototype.constructor</code></dt> + <dd>Retorna la funció que ha creat la instància del prototipus. Aquesta funció és {{jsxref("Global_Objects/Boolean", "Boolean")}} per defecte.</dd> +</dl> + +<div>{{jsOverrides("Object", "properties", "constructor")}}</div> + +<h2 id="Mètodes">Mètodes</h2> + +<dl> + <dt>{{jsxref("Boolean.prototype.toSource()")}} {{non-standard_inline}}</dt> + <dd>Retorna una cadena de caràcters que conté el codi fond de l'objecte {{jsxref("Global_Objects/Boolean", "Boolean")}}; aquesta pot utilitzar-se per a crear un objecte equivalent. Sobreescriu el mètode {{jsxref("Object.prototype.toSource()")}}.</dd> + <dt>{{jsxref("Boolean.prototype.toString()")}}</dt> + <dd>Retorna una cadena de caràcters que valdrà o bé <code>"true"</code> o bé <code>"false"</code>, depenent del valor que l'objecte representi. Sobreescriu el mètode {{jsxref("Object.prototype.toString()")}}.</dd> + <dt>{{jsxref("Boolean.prototype.valueOf()")}}</dt> + <dd>Retorna el valor primitiu de l'objecte {{jsxref("Global_Objects/Boolean", "Boolean")}}. Sobreescriu el mètode {{jsxref("Object.prototype.valueOf()")}}.</dd> +</dl> + +<div>{{jsOverrides("Object", "methods", "toSource", "toString", "valueOf")}}</div> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>ECMAScript 1a Edició.</td> + <td>Standard</td> + <td>Definició inicial. Implementat a JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.6.3.1', 'Boolean.prototype')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-boolean.prototype', 'Boolean.prototype')}}</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 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> diff --git a/files/ca/web/javascript/referencia/objectes_globals/boolean/tosource/index.html b/files/ca/web/javascript/referencia/objectes_globals/boolean/tosource/index.html new file mode 100644 index 0000000000..6b6a1b8b2b --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/boolean/tosource/index.html @@ -0,0 +1,98 @@ +--- +title: Boolean.prototype.toSource() +slug: Web/JavaScript/Referencia/Objectes_globals/Boolean/toSource +translation_of: Web/JavaScript/Reference/Global_Objects/Boolean/toSource +--- +<div>{{JSRef("Objectes_standard", "Boolean")}} {{non-standard_header}}</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>El mètode <code><strong>toSource()</strong></code> retorna una cadena de caràcters que representa el codi font de l'objecte.</p> + +<h2 id="Syntax" name="Syntax">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>booleanObj</var>.toSource() +Boolean.toSource()</code></pre> + +<h3 id="Parameters" name="Parameters">Paràmetres</h3> + +<p>Cap.</p> + +<h2 id="Description" name="Description">Descripció</h2> + +<p>El mètode <code>toSource</code> retorna els valors següents:</p> + +<ul> + <li>Per a objectes {{jsxref("Objectes_standard/Boolean", "Boolean")}} de la implementació de JavaScript, <code>toSource</code> retorna la següent cadena de caràcters indicant que el codi font no està disponible: + + <pre class="brush: js">function Boolean() { + [native code] +} +</pre> + </li> + <li>Per a instàncies de {{jsxref("Objectes_standard/Boolean", "Boolean")}}, <code>toSource</code> retorna una cadena de caràcters que representa el codi font.</li> +</ul> + +<p>Aquest mètode normalment és utilitzat internament per JavaScript i no explícitament al codi.</p> + +<h2 id="Especificacions">Especificacions</h2> + +<p>No forma part de cap standard. Implementat a JavaScript 1.3.</p> + +<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>{{CompatUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_Also" name="See_Also">Vegeu també</h2> + +<ul> + <li>{{jsxref("Object.prototype.toSource()")}} {{non-standard_inline}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/boolean/tostring/index.html b/files/ca/web/javascript/referencia/objectes_globals/boolean/tostring/index.html new file mode 100644 index 0000000000..90da6cba3a --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/boolean/tostring/index.html @@ -0,0 +1,121 @@ +--- +title: Boolean.prototype.toString() +slug: Web/JavaScript/Referencia/Objectes_globals/Boolean/toString +translation_of: Web/JavaScript/Reference/Global_Objects/Boolean/toString +--- +<div>{{JSRef("Global_Objects", "Boolean")}}</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>El mètode <code><strong>toString()</strong></code> retorna una cadena de caràcters que representa l'objecte Boolean.</p> + +<h2 id="Syntax" name="Syntax">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>bool</var>.toString()</code></pre> + +<h3 id="Parameters" name="Parameters">Paràmetres</h3> + +<p>Cap.</p> + +<h2 id="Description" name="Description">Descripció</h2> + +<p>L'objecte {{jsxref("Objectes_standard/Boolean", "Boolean")}} sobreescriu el mètode <code>toString</code> de l'objecte {{jsxref("Objectes_standard/Object", "Object")}}; no hereta {{jsxref("Object.prototype.toString()")}}. Per a objectes de tipus Boolean, el mètode <code>toString</code> retorna una cadena de caràcters que representa l'objecte.</p> + +<p>JavaScript crida el mètode <code>toString</code> de manera automàtica quan aquest ha de ser representat mitjançant text o bé quan un {{jsxref("Objectes_standard/Boolean", "Boolean")}} és referenciat en una concatenació de cadenes de caràcters.</p> + +<p>Per a objectes i valors de tipus {{jsxref("Objectes_standard/Boolean", "Boolean")}}, el mètode <code>toString</code> incorporat retorna la cadena de caràcters "<code>true</code>" o bé "<code>false</code>", depenent del valor de l'objecte booleà.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Exemple_Utilitzar_toString">Exemple: Utilitzar <code>toString</code></h3> + +<p>Al codi següent <code>flag.toString()</code> retorna "<code>true</code>":</p> + +<pre class="brush: js">var flag = new Boolean(true); +var myVar = flag.toString(); +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>ECMAScript 1a Edició. Implementat a JavaScript 1.1</td> + <td>Standard</td> + <td>Definició inicial.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.6.4.2', 'Boolean.prototype.toString')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-boolean.prototype.tostring', 'Boolean.prototype.toString')}}</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 for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li>{{jsxref("Object.prototype.toString()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/boolean/valueof/index.html b/files/ca/web/javascript/referencia/objectes_globals/boolean/valueof/index.html new file mode 100644 index 0000000000..f99fd3c6c0 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/boolean/valueof/index.html @@ -0,0 +1,117 @@ +--- +title: Boolean.prototype.valueOf() +slug: Web/JavaScript/Referencia/Objectes_globals/Boolean/valueOf +translation_of: Web/JavaScript/Reference/Global_Objects/Boolean/valueOf +--- +<div>{{JSRef("Global_Objects", "Boolean")}}</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>El mètode <code><strong>valueOf()</strong></code> retorna el valor primitiu d'un objecte {{jsxref("Objectes_standard/Boolean", "Boolean")}}.</p> + +<h2 id="Syntax" name="Syntax">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>bool</var>.valueOf()</code></pre> + +<h3 id="Parameters" name="Parameters">Paràmetres</h3> + +<p>Cap.</p> + +<h2 id="Description" name="Description">Descripció</h2> + +<p>El mètode <code>valueOf</code> pertanyent a {{jsxref("Objectes_standard/Boolean", "Boolean")}} retorna el valor primitiu d'un objecte o literal {{jsxref("Objectes_standard/Boolean", "Boolean")}} com a tipus de dada Boolean.</p> + +<p>Aquest mètode normalment és utilitzat internament per JavaScript i no explícitament als scripts.</p> + +<h2 id="Examples" name="Examples">Exemples</h2> + +<h3 id="Example:_Using_valueOf" name="Example:_Using_valueOf">Exemple: Utilitzar <code>valueOf</code></h3> + +<pre class="brush: js">x = new Boolean(); +myVar = x.valueOf(); // assigna false a myVar +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>ECMAScript 1a Edició.</td> + <td>Standard</td> + <td>Definició inicial. Implementat a JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.6.4.3', 'Boolean.prototype.valueOf')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-boolean.prototype.valueof', 'Boolean.prototype.valueOf')}}</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 for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li>{{jsxref("Object.prototype.valueOf()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/date/getdate/index.html b/files/ca/web/javascript/referencia/objectes_globals/date/getdate/index.html new file mode 100644 index 0000000000..16808aaae0 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/date/getdate/index.html @@ -0,0 +1,119 @@ +--- +title: Date.prototype.getDate() +slug: Web/JavaScript/Referencia/Objectes_globals/Date/getDate +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getDate +--- +<div>{{JSRef}}</div> + +<p>El mètode <strong><code>getDate()</code></strong> retorna el dia del mes per a la data especificada segons l'hora local.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>objecteData</var>.getDate()</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<p>Cap.</p> + +<h3 id="Valor_retornat">Valor retornat</h3> + +<p>El valor retornat per <code>getDate()</code> és un nombre sencer entre 1 i 31.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_getDate()">Utilitzar <code>getDate()</code></h3> + +<p>La segona sentència de l'exemple de sota assigna el valor 25 a la variable <code>dia</code>, basant-se en el valor de l'objecte {{jsxref("Date")}} <code>nadal95</code>.</p> + +<pre class="brush: js">var nadal95 = new Date('December 25, 1995 23:15:30'); +var dia = nadal95.getDate(); + +console.log(dia); // 25 +</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-date.prototype.getdate', 'Date.prototype.getDate')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.14', 'Date.prototype.getDate')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definició inicial. Implementat a JavaScript 1.1.</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>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("Date.prototype.getUTCDate()")}}</li> + <li>{{jsxref("Date.prototype.getUTCDay()")}}</li> + <li>{{jsxref("Date.prototype.setDate()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/date/getday/index.html b/files/ca/web/javascript/referencia/objectes_globals/date/getday/index.html new file mode 100644 index 0000000000..244562c167 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/date/getday/index.html @@ -0,0 +1,121 @@ +--- +title: Date.prototype.getDay() +slug: Web/JavaScript/Referencia/Objectes_globals/Date/getDay +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getDay +--- +<div>{{JSRef("Global_Objects", "Date")}}</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>El mètode <strong><code>getDay()</code></strong> retorna el dia de la setmana per a la data especificada, en temps local on 0 (zero) representa el Diumenge.</p> + +<h2 id="Syntax" name="Syntax">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getDay()</code></pre> + +<h3 id="Parameters" name="Parameters">Paràmetres</h3> + +<p>Cap.</p> + +<h3 id="Returns" name="Returns">Retorna</h3> + +<p>El valor retornat per <code>getDay()</code> és un nombre sencer que correspon al dia de la setmana tal i com es mostra a continuació: 0 és Diumenge, 1 és Dilluns, 2 és Dimarts, etcètera.</p> + +<h2 id="Examples" name="Examples">Exemples</h2> + +<h3 id="Example:_Using_getDay" name="Example:_Using_getDay">Exemple: Utilitzar <code>getDay()</code></h3> + +<p>La segona sentència que trobareu a continuació asigna el valor 1 a la variable <code>diaSetmana</code>, basat en el valor de l'objecte {{jsxref("Global_Objects/Date", "Date")}}<code> nadal95</code>, que està inicialitzat amb la data d 25 de Desembre de 1995, és un Dilluns.</p> + +<pre class="brush: js">var nadal95 = new Date('December 25, 1995 23:15:30'); +var diaSetmana = nadal95.getDay(); + +console.log(diaSetmana); // 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>ECMAScript 1a Edició.</td> + <td>Standard</td> + <td>Definició inicial. Implementat a JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.16', 'Date.prototype.getDay')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.getday', 'Date.prototype.getDay')}}</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 for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCDate()")}}</li> + <li>{{jsxref("Date.prototype.getUTCDay()")}}</li> + <li>{{jsxref("Date.prototype.setDate()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/date/getfullyear/index.html b/files/ca/web/javascript/referencia/objectes_globals/date/getfullyear/index.html new file mode 100644 index 0000000000..94f14f4332 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/date/getfullyear/index.html @@ -0,0 +1,121 @@ +--- +title: Date.prototype.getFullYear() +slug: Web/JavaScript/Referencia/Objectes_globals/Date/getFullYear +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getFullYear +--- +<div>{{JSRef("Global_Objects", "Date")}}</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>El mètode <strong><code>getFullYear()</code></strong> retorna l'any de la data especificada, en temps local.</p> + +<p>Utilitzeu aquest mètode en comptes de {{jsxref("Date.prototype.getYear()", "getYear()")}}.</p> + +<h2 id="Syntax" name="Syntax">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getFullYear()</code></pre> + +<h3 id="Parameters" name="Parameters">Paràmetres</h3> + +<p>Cap.</p> + +<h3 id="Returns" name="Returns">Retorna</h3> + +<p>El valor retornat per <code>getFullYear()</code> és un nombre absolut. Per a dates entre els anys 1000 i 9999, <code>getFullYear()</code> retorna un nombre de 4 dígits (1995, per exemple). Utilitzeu aquesta funció per a assegurar-vos d'obtindre un any compatible amb l'efecte 2000.</p> + +<h2 id="Examples" name="Examples">Exemples</h2> + +<h3 id="Example:_Using_getFullYear" name="Example:_Using_getFullYear">Exemple: Utilitzar <code>getFullYear()</code></h3> + +<p>L'exemple següent assigna el valor de 4 dígits de l'any actual a la variable <code>any</code>.</p> + +<pre class="brush: js">var avui = new Date(); +var any = avui.getFullYear(); +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>ECMAScript 1a Edició.</td> + <td>Standard</td> + <td>Definició inicial. Implementat a JavaScript 1.3.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.10', 'Date.prototype.getFullYear')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.getfullyear', 'Date.prototype.getFullYear')}}</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 for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCFullYear()")}}</li> + <li>{{jsxref("Date.prototype.setFullYear()")}}</li> + <li>{{jsxref("Date.prototype.getYear()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/date/gethours/index.html b/files/ca/web/javascript/referencia/objectes_globals/date/gethours/index.html new file mode 100644 index 0000000000..3848e96339 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/date/gethours/index.html @@ -0,0 +1,120 @@ +--- +title: Date.prototype.getHours() +slug: Web/JavaScript/Referencia/Objectes_globals/Date/getHours +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getHours +--- +<div>{{JSRef("Global_Objects", "Date")}}</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>El mètode <strong><code>getHours()</code></strong> retorna l'hora per a la data especificada, en temps local.</p> + +<h2 id="Syntax" name="Syntax">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getHours()</code></pre> + +<h3 id="Parameters" name="Parameters">Paràmetres</h3> + +<p>Cap.</p> + +<h3 id="Returns" name="Returns">Retorna</h3> + +<p>El valor retornat per <code>getHours()</code> és un nombre sencer entre 0 i 23.</p> + +<h2 id="Examples" name="Examples">Exemples</h2> + +<h3 id="Example:_Using_getHours" name="Example:_Using_getHours">Exemple: Utilitzar <code>getHours()</code></h3> + +<p>La segona sentència que trobareu a continuació assigna el valor 23 a la variable <code>hora</code>, basant-se en l'objecte {{jsxref("Global_Objects/Date", "Date")}} <code>nadal95</code>.</p> + +<pre class="brush: js">var nadal95 = new Date('December 25, 1995 23:15:30'); +var hora = nadal95.getHours(); + +console.log(hora); // 23 +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>ECMAScript 1a Edició.</td> + <td>Standard</td> + <td>Definició inicial. Implementat a JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.18', 'Date.prototype.getHours')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.gethours', 'Date.prototype.getHours')}}</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 for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCHours()")}}</li> + <li>{{jsxref("Date.prototype.setHours()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/date/getmilliseconds/index.html b/files/ca/web/javascript/referencia/objectes_globals/date/getmilliseconds/index.html new file mode 100644 index 0000000000..d438cf8cad --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/date/getmilliseconds/index.html @@ -0,0 +1,118 @@ +--- +title: Date.prototype.getMilliseconds() +slug: Web/JavaScript/Referencia/Objectes_globals/Date/getMilliseconds +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getMilliseconds +--- +<div>{{JSRef("Global_Objects", "Date")}}</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>El mètode <strong><code>getMilliseconds()</code></strong> retorna els milisegons de la data especificada d'acord a l'hora local.</p> + +<h2 id="Syntax" name="Syntax">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getMilliseconds()</code></pre> + +<h3 id="Parameters" name="Parameters">Paràmetres</h3> + +<p>Cap.</p> + +<h3 id="Returns" name="Returns">Retorna</h3> + +<p>El valor retornat per <code>getMilliseconds()</code> és un nombre entre 0 i 999.</p> + +<h2 id="Examples" name="Examples">Exemples</h2> + +<h3 id="Example:_Using_getMilliseconds" name="Example:_Using_getMilliseconds">Exemple: Utilitzar <code>getMilliseconds()</code></h3> + +<p>L'exemple següent assigna la part de milisegons de l'hora actual a la variable <code>milisegons</code>:</p> + +<pre class="brush: js">var avui = new Date(); +var milisegonds = avui.getMilliseconds(); +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>ECMAScript 1a Edició.</td> + <td>Standard</td> + <td>Definició inicial. Implementat a JavaScript 1.3.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.24', 'Date.prototype.getMilliseconds')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.getmilliseconds', 'Date.prototype.getMilliseconds')}}</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 for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCMilliseconds()")}}</li> + <li>{{jsxref("Date.prototype.setMilliseconds()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/date/getminutes/index.html b/files/ca/web/javascript/referencia/objectes_globals/date/getminutes/index.html new file mode 100644 index 0000000000..3ae466d56d --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/date/getminutes/index.html @@ -0,0 +1,120 @@ +--- +title: Date.prototype.getMinutes() +slug: Web/JavaScript/Referencia/Objectes_globals/Date/getMinutes +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getMinutes +--- +<div>{{JSRef("Global_Objects", "Date")}}</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>El mètode <strong><code>getMinutes()</code></strong> retorna els minuts de la data especificada segons el temps local.</p> + +<h2 id="Syntax" name="Syntax">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getMinutes()</code></pre> + +<h3 id="Parameters" name="Parameters">Paràmetres</h3> + +<p>Cap.</p> + +<h3 id="Returns" name="Returns">Retorna</h3> + +<p>El valor retorna per <code>getMinutes()</code> és un nombre sencer entre 0 i 59.</p> + +<h2 id="Examples" name="Examples">Exemples</h2> + +<h3 id="Example:_Using_getMinutes" name="Example:_Using_getMinutes">Exemple: Utilitzar <code>getMinutes()</code></h3> + +<p>La segona sentència de sota assigna el valor 15 a la variable <code>minuts</code>, prenent el valor de l'objecte <code>nadal95</code> de tipus {{jsxref("Global_Objects/Date", "Date")}}.</p> + +<pre class="brush: js">var nadal95 = new Date('December 25, 1995 23:15:30'); +var minuts = nadal95.getMinutes(); + +console.log(minuts); // 15 +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>ECMAScript 1a Edició.</td> + <td>Standard</td> + <td>Definició inicial. Implementat a JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.20', 'Date.prototype.getMinutes')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.getminutes', 'Date.prototype.getMinutes')}}</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 for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCMinutes()")}}</li> + <li>{{jsxref("Date.prototype.setMinutes()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/date/getmonth/index.html b/files/ca/web/javascript/referencia/objectes_globals/date/getmonth/index.html new file mode 100644 index 0000000000..2631ebef9a --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/date/getmonth/index.html @@ -0,0 +1,120 @@ +--- +title: Date.prototype.getMonth() +slug: Web/JavaScript/Referencia/Objectes_globals/Date/getMonth +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getMonth +--- +<div>{{JSRef("Global_Objects", "Date")}}</div> + +<h2 id="Resum">Resum</h2> + +<p>El mètode <strong><code>getMonth()</code></strong> retorna el mes de la data especificada d'acord al temps local, representat per un nombre a partir de zero (on zero indica el primer mes de l'any).</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getMonth()</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<p>Cap.</p> + +<h3 id="Retorna">Retorna</h3> + +<p>El valor retornat per <code>getMonth()</code> és un nombre sencer entre 0 i 11. 0 correspon a gener, 1 a febrer, etcètera.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Example:_Using_getMonth" name="Example:_Using_getMonth">Exemple: Utilitzar <code>getMonth()</code></h3> + +<p>La segona sentència de sota assigna el valor 11 a la variable <code>mes</code>, basada en el valor de l'objecte <code>nadal95</code> de tipus {{jsxref("Global_Objects/Date", "Date")}}.</p> + +<pre class="brush: js">var nadal95 = new Date('December 25, 1995 23:15:30'); +var mes = nadal95.getMonth(); + +console.log(mes); // 11 +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>ECMAScript 1a Edició.</td> + <td>Standard</td> + <td>Definició inicial. Implementat a JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.12', 'Date.prototype.getMonth')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.getmonth', 'Date.prototype.getMonth')}}</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 for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCMonth()")}}</li> + <li>{{jsxref("Date.prototype.setMonth()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/date/getseconds/index.html b/files/ca/web/javascript/referencia/objectes_globals/date/getseconds/index.html new file mode 100644 index 0000000000..790c62e3e9 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/date/getseconds/index.html @@ -0,0 +1,120 @@ +--- +title: Date.prototype.getSeconds() +slug: Web/JavaScript/Referencia/Objectes_globals/Date/getSeconds +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getSeconds +--- +<div>{{JSRef("Global_Objects", "Date")}}</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>El mètode <strong><code>getSeconds()</code></strong> retorna els segons de la data especficada d'acord al temps local.</p> + +<h2 id="Syntax" name="Syntax">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getSeconds()</code></pre> + +<h3 id="Parameters" name="Parameters">Paràmetres</h3> + +<p>Cap.</p> + +<h3 id="Returns" name="Returns">Retorna</h3> + +<p>El valor retornat per <code>getSeconds()</code> és un sencer entre 0 i 59.</p> + +<h2 id="Examples" name="Examples">Exemples</h2> + +<h3 id="Example:_Using_getSeconds" name="Example:_Using_getSeconds">Exemple: Utilitzar <code>getSeconds()</code></h3> + +<p>La segona sentència de sota assigna el valor 30 a la variable <code>segons</code>, basat en el valor de l'objecte <code>nadal95</code>, de tipus {{jsxref("Global_Objects/Date", "Date")}}.</p> + +<pre class="brush: js">var nadal95 = new Date('December 25, 1995 23:15:30'); +var segons = nadal95.getSeconds(); + +console.log(segons); // 30 +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>ECMAScript 1a Edició.</td> + <td>Standard</td> + <td>Definició inicial. Implementat a JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.22', 'Date.prototype.getSeconds')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.getseconds', 'Date.prototype.getSeconds')}}</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 for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCSeconds()")}}</li> + <li>{{jsxref("Date.prototype.setSeconds()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/date/gettime/index.html b/files/ca/web/javascript/referencia/objectes_globals/date/gettime/index.html new file mode 100644 index 0000000000..20c45f31c5 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/date/gettime/index.html @@ -0,0 +1,135 @@ +--- +title: Date.prototype.getTime() +slug: Web/JavaScript/Referencia/Objectes_globals/Date/getTime +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getTime +--- +<div>{{JSRef}}</div> + +<p>El mètode <strong><code>getTime()</code></strong> retorna el valor numèric corresponent a l'hora per a la data especificada, d'acord al temps universal.</p> + +<p>Es pot emprar aquest mètode com a ajuda per a proporcionar una data i hora per a un altre objecte de tipus {{jsxref("Global_Objects/Date", "Date")}}. Aquest mètode és funcionalment equivalnet al mètode {{jsxref("Date.valueof", "valueOf()")}}.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getTime()</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<p>Cap.</p> + +<h3 id="Retorn">Retorn</h3> + +<p>El valor retornat pel mètode <code>getTime()</code> és el nombre de milisegons que han passat des de l'1 de gener de 1970 00:00:00 UTC.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_getTime()_per_a_obtindre_dates">Utilitzar <code>getTime()</code> per a obtindre dates</h3> + +<p>Construïr un objecte date que representi el mateix moment.</p> + +<pre class="brush: js">var aniversari = new Date(1994, 12, 10); +var copia= new Date(); +copia.setTime(aniversari.getTime()); +</pre> + +<h3 id="Mesurar_el_temps_d'execució">Mesurar el temps d'execució</h3> + +<p>Restar dos crides seguides de <code>getTime()</code> en objectes {{jsxref("Date")}} acabats de generar dóne el temps transcorregut entre les dues crides. Això pot ser emprat per a calcular el temps d'execució d'algunes operacions. Vegeu també {{jsxref("Date.now()")}} per a prevenir l'instanciació d'objectes {{jsxref("Date")}} innecesaris.</p> + +<pre class="brush: js">var fi, inici; + +inici= new Date(); +for (var i = 0; i < 1000; i++) { + Math.sqrt(i); +} +fi = new Date(); + +console.log("L'operació ha trigat " + (fi.getTime() - inici.getTime()) + ' ms'); +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>ECMAScript 1a Edició.</td> + <td>Standard</td> + <td>Definició inicial. Implementat a JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.9', 'Date.prototype.getTime')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.gettime', 'Date.prototype.getTime')}}</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 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("Date.prototype.setTime()")}}</li> + <li>{{jsxref("Date.prototype.valueOf()")}}</li> + <li>{{jsxref("Date.now()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/date/gettimezoneoffset/index.html b/files/ca/web/javascript/referencia/objectes_globals/date/gettimezoneoffset/index.html new file mode 100644 index 0000000000..8af4d6e9e8 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/date/gettimezoneoffset/index.html @@ -0,0 +1,109 @@ +--- +title: Date.prototype.getTimezoneOffset() +slug: Web/JavaScript/Referencia/Objectes_globals/Date/getTimezoneOffset +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getTimezoneOffset +--- +<div>{{JSRef("Global_Objects", "Date")}}</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>El mètode <strong><code>getTimezoneOffset()</code></strong> retorna la desviació de la zona horària a l'hora UTC, en minuts, per a la localizació en ús.</p> + +<h2 id="Syntax" name="Syntax">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getTimezoneOffset()</code></pre> + +<h3 id="Parameters" name="Parameters">Paràmetres</h3> + +<p>Cap.</p> + +<h3 id="Returns" name="Returns">Retorn</h3> + +<p>La desviació de la zona horària és la diferència, en minuts, entre UTC i l'hora local. Això comporta que la desviació serà positiva si l'hora local està per darrere de la UTC i negativa si està endevant. Per exemple, si la vostra zona horària és UTC+10 (Australian Eastern Standard Time), el mètode retornarà -600. L'horari d'estalvi d'energia (d'estiu) fa que aquest valor no sigui una constant, per a qualsevol localització.</p> + +<h2 id="Examples" name="Examples">Exemples</h2> + +<h3 id="Example:_Using_getTimezoneOffset" name="Example:_Using_getTimezoneOffset">Exemple: Utilitzar <code>getTimezoneOffset()</code></h3> + +<pre class="brush: js">var x = new Date(); +var currentTimeZoneOffsetInHours = x.getTimezoneOffset() / 60; +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>ECMAScript 1a Edició.</td> + <td>Standard</td> + <td>Definició inicial. Implementat a JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.26', 'Date.prototype.getTimezoneOffset')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.gettimezoneoffset', 'Date.prototype.getTimezoneOffset')}}</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 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> diff --git a/files/ca/web/javascript/referencia/objectes_globals/date/getutcdate/index.html b/files/ca/web/javascript/referencia/objectes_globals/date/getutcdate/index.html new file mode 100644 index 0000000000..ee3a8b881f --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/date/getutcdate/index.html @@ -0,0 +1,119 @@ +--- +title: Date.prototype.getUTCDate() +slug: Web/JavaScript/Referencia/Objectes_globals/Date/getUTCDate +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCDate +--- +<div>{{JSRef("Global_Objects", "Date")}}</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>El mètode <strong><code>getUTCDate()</code></strong>retorna el dia del mes per a la data especificada, segons l'hora universal.</p> + +<h2 id="Syntax" name="Syntax">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getUTCDate()</code></pre> + +<h3 id="Parameters" name="Parameters">Paràmetres</h3> + +<p>Cap.</p> + +<h3 id="Returns" name="Returns">Retorn</h3> + +<p>El valor retornat per <code>getUTCDate()</code> és un nombre sencer entre 1 i 31.</p> + +<h2 id="Examples" name="Examples">Exemples</h2> + +<h3 id="Example:_Using_getUTCDate" name="Example:_Using_getUTCDate">Exemple: Utilitzar <code>getUTCDate()</code></h3> + +<p>L'exemple següent assigna la part del dia de la data actual a la variable <code>dia</code>.</p> + +<pre class="brush: js">var avui = new Date(); +var dia = avui.getUTCDate(); +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>ECMAScript 1a Edició.</td> + <td>Standard</td> + <td>Definició inicial. Implementat a JavaScript 1.3.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.15', 'Date.prototype.getUTCDate')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.getutcdate', 'Date.prototype.getUTCDate')}}</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 for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li>{{jsxref("Date.prototype.getDate()")}}</li> + <li>{{jsxref("Date.prototype.getUTCDay()")}}</li> + <li>{{jsxref("Date.prototype.setUTCDate()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/date/getutcday/index.html b/files/ca/web/javascript/referencia/objectes_globals/date/getutcday/index.html new file mode 100644 index 0000000000..b6f992f9a1 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/date/getutcday/index.html @@ -0,0 +1,119 @@ +--- +title: Date.prototype.getUTCDay() +slug: Web/JavaScript/Referencia/Objectes_globals/Date/getUTCDay +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCDay +--- +<div>{{JSRef("Global_Objects", "Date")}}</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>El mètode <strong><code>getUTCDay()</code></strong> retorna el dia de la setmana de la data especificada segons l'hora universal, on 0 representa Diumenge.</p> + +<h2 id="Syntax" name="Syntax">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getUTCDay()</code></pre> + +<h3 id="Parameters" name="Parameters">Paràmetres</h3> + +<p>Cap.</p> + +<h3 id="Returns" name="Returns">Retorn</h3> + +<p>El valor retornat per <code>getUTCDay()</code> és un nombre sencer que correspón al dia de la setmana: 0 per a Diumenge, 1 per a dilluns, 2 per a Dimarts, etcètera.</p> + +<h2 id="Examples" name="Examples">Exemples</h2> + +<h3 id="Example:_Using_getUTCDay" name="Example:_Using_getUTCDay">Exemple: Utilitzar <code>getUTCDay()</code></h3> + +<p>L'exemple següent assigna el dia de la setmana de la data actual a la variable <code>diaSetmana</code>.</p> + +<pre class="brush: js">var avui = new Date(); +var diaSetmana = avui.getUTCDay(); +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>ECMAScript 1a Edició.</td> + <td>Standard</td> + <td>Definició inicial. Implementat a JavaScript 1.3.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.17', 'Date.prototype.getUTCDay')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.getutcday', 'Date.prototype.getUTCDay')}}</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 for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li>{{jsxref("Date.prototype.getUTCDate()")}}</li> + <li>{{jsxref("Date.prototype.getDay()")}}</li> + <li>{{jsxref("Date.prototype.setUTCDate()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/date/getutcfullyear/index.html b/files/ca/web/javascript/referencia/objectes_globals/date/getutcfullyear/index.html new file mode 100644 index 0000000000..3ca1526e28 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/date/getutcfullyear/index.html @@ -0,0 +1,118 @@ +--- +title: Date.prototype.getUTCFullYear() +slug: Web/JavaScript/Referencia/Objectes_globals/Date/getUTCFullYear +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCFullYear +--- +<div>{{JSRef("Global_Objects", "Date")}}</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>El mètode <strong><code>getUTCFullYear()</code></strong> retorna l'any de la data especificada, segons el temps universal.</p> + +<h2 id="Syntax" name="Syntax">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getUTCFullYear()</code></pre> + +<h3 id="Parameters" name="Parameters">Paràmetres</h3> + +<p>Cap.</p> + +<h3 id="Returns" name="Returns">Retorn</h3> + +<p>El valor retornat per <code>getUTCFullYear()</code> és un nombre absolut que compleix amb any-2000, per exemple, 1995.</p> + +<h2 id="Examples" name="Examples">Exemples</h2> + +<h3 id="Example:_Using_getUTCFullYear" name="Example:_Using_getUTCFullYear">Exemple: Utilitzar <code>getUTCFullYear()</code></h3> + +<p>L'exemple següent assigna el valor de 4 dígits de l'any actual a la variable <code>any</code>.</p> + +<pre class="brush: js">var avui = new Date(); +var any = avui.getUTCFullYear(); +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>ECMAScript 1a Edició.</td> + <td>Standard</td> + <td>Definició inicial. Implementat a JavaScript 1.3.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.11', 'Date.prototype.getUTCFullYear')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.getutcfullyear', 'Date.prototype.getUTCFullYear')}}</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 for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li>{{jsxref("Date.prototype.getFullYear()")}}</li> + <li>{{jsxref("Date.prototype.setFullYear()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/date/getutchours/index.html b/files/ca/web/javascript/referencia/objectes_globals/date/getutchours/index.html new file mode 100644 index 0000000000..f575df92a1 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/date/getutchours/index.html @@ -0,0 +1,118 @@ +--- +title: Date.prototype.getUTCHours() +slug: Web/JavaScript/Referencia/Objectes_globals/Date/getUTCHours +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCHours +--- +<div>{{JSRef("Global_Objects", "Date")}}</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>El mètode <strong><code>getUTCHours()</code></strong> retorna les hores especificades a la data, d'acord l'hora universal.</p> + +<h2 id="Syntax" name="Syntax">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getUTCHours()</code></pre> + +<h3 id="Parameters" name="Parameters">Paràmetres</h3> + +<p>Cap.</p> + +<h3 id="Returns" name="Returns">Retorn</h3> + +<p>El valor retornat per <code>getUTCHours()</code> és un nombre sencer entre 0 i 23.</p> + +<h2 id="Examples" name="Examples">Exemples</h2> + +<h3 id="Example:_Using_getUTCHours" name="Example:_Using_getUTCHours">Exemple: Utilitzar <code>getUTCHours()</code></h3> + +<p>L'exemple següent assigna la part de les hores de la data actual a la variable <code>hora</code>.</p> + +<pre class="brush: js">var avui = new Date(); +var hora = avui.getUTCHours(); +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>ECMAScript 1a Edició.</td> + <td>Standard</td> + <td>Definició inicial. Implementat a JavaScript 1.3.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.19', 'Date.prototype.getUTCHours')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.getutchours', 'Date.prototype.getUTCHours')}}</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 for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li>{{jsxref("Date.prototype.getHours()")}}</li> + <li>{{jsxref("Date.prototype.setUTCHours()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/date/getutcmilliseconds/index.html b/files/ca/web/javascript/referencia/objectes_globals/date/getutcmilliseconds/index.html new file mode 100644 index 0000000000..d09ac5bded --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/date/getutcmilliseconds/index.html @@ -0,0 +1,116 @@ +--- +title: Date.prototype.getUTCMilliseconds() +slug: Web/JavaScript/Referencia/Objectes_globals/Date/getUTCMilliseconds +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCMilliseconds +--- +<div>{{JSRef}}</div> + +<p>El mètode <strong><code>getUTCMilliseconds()</code></strong> retorna els milisegons de la data especificada, d'acord al temps universal.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>objecteData</var>.getUTCMilliseconds()</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<p>Cap.</p> + +<h3 id="Valor_retornat">Valor retornat</h3> + +<p>El valor retorna per <code>getUTCMilliseconds()</code> és un nombre sencer entre 0 i 999.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_getUTCMilliseconds()">Utilitzar <code>getUTCMilliseconds()</code></h3> + +<p>L'exemple següent assigna la porció de milisegons del temps actual a la variable <code>milisegons</code>.</p> + +<pre class="brush: js">var avui = new Date(); +var milisegons = avui.getUTCMilliseconds(); +</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.3.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.25', 'Date.prototype.getUTCMilliseconds')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.getutcmilliseconds', 'Date.prototype.getUTCMilliseconds')}}</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 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("Date.prototype.getMilliseconds()")}}</li> + <li>{{jsxref("Date.prototype.setUTCMilliseconds()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/date/getutcminutes/index.html b/files/ca/web/javascript/referencia/objectes_globals/date/getutcminutes/index.html new file mode 100644 index 0000000000..e18a13c52f --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/date/getutcminutes/index.html @@ -0,0 +1,116 @@ +--- +title: Date.prototype.getUTCMinutes() +slug: Web/JavaScript/Referencia/Objectes_globals/Date/getUTCMinutes +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCMinutes +--- +<div>{{JSRef}}</div> + +<p>El mètode <strong><code>getUTCMinutes()</code></strong> retorna els minuts de la data especificada en temps universal.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>objecteData</var>.getUTCMinutes()</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<p>Cap.</p> + +<h3 id="Valor_a_retornar">Valor a retornar</h3> + +<p>El valor retornat per <code>getUTCMinutes()</code> és un nombre sencer entre 0 i 59.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_getUTCMinutes()">Utilitzar <code>getUTCMinutes()</code></h3> + +<p>L'exemple següent assigna la part de minuts del temps actual a la variable <code>minuts</code>.</p> + +<pre class="brush: js">var avui = new Date(); +var minuts = avui.getUTCMinutes(); +</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.3.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.21', 'Date.prototype.getUTCMinutes')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.getutcminutes', 'Date.prototype.getUTCMinutes')}}</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 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("Date.prototype.getMinutes()")}}</li> + <li>{{jsxref("Date.prototype.setUTCMinutes()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/date/getutcmonth/index.html b/files/ca/web/javascript/referencia/objectes_globals/date/getutcmonth/index.html new file mode 100644 index 0000000000..48ba78349b --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/date/getutcmonth/index.html @@ -0,0 +1,116 @@ +--- +title: Date.prototype.getUTCMonth() +slug: Web/JavaScript/Referencia/Objectes_globals/Date/getUTCMonth +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCMonth +--- +<div>{{JSRef}}</div> + +<p>El mètode <strong><code>getUTCMonth()</code></strong> retorna el mes de la data especificada d'acord al temps universal, com a valor basat en zero (on zero indica el primer mes de l'any.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>objecteData</var>.getUTCMonth()</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<p>Cap.</p> + +<h3 id="Valor_retornat">Valor retornat</h3> + +<p>El valor retornat per <code>getUTCMonth()</code> és un nombre sencer entre 0 i 11 corresponent al mes. 0 per al gener, 1 per al febrer, 2 per al març, etcètera.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_getUTCMonth()">Utilitzar <code>getUTCMonth()</code></h3> + +<p>L'exemple següent assigna la part de la data actual corresponent al mes a la variable <code>mes</code>.</p> + +<pre class="brush: js">var avui = new Date(); +var mes = mes.getUTCMonth(); +</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.3.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.13', 'Date.prototype.getUTCMonth')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.getutcmonth', 'Date.prototype.getUTCMonth')}}</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 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("Date.prototype.getMonth()")}}</li> + <li>{{jsxref("Date.prototype.setUTCMonth()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/date/getutcseconds/index.html b/files/ca/web/javascript/referencia/objectes_globals/date/getutcseconds/index.html new file mode 100644 index 0000000000..1f69ca8199 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/date/getutcseconds/index.html @@ -0,0 +1,118 @@ +--- +title: Date.prototype.getUTCSeconds() +slug: Web/JavaScript/Referencia/Objectes_globals/Date/getUTCSeconds +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCSeconds +--- +<div>{{JSRef("Global_Objects", "Date")}}</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>El mètode<strong> <code>getUTCSeconds()</code></strong> retorna els segons a la data especificada, segons l'hora universal.</p> + +<h2 id="Syntax" name="Syntax">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getUTCSeconds()</code></pre> + +<h3 id="Parameters" name="Parameters">Paràmetres</h3> + +<p>Cap.</p> + +<h3 id="Returns" name="Returns">Retorna</h3> + +<p>El valor retornat per <code>getUTCSeconds()</code> és un nombre sencer entre 0 i 59.</p> + +<h2 id="Examples" name="Examples">Exemples</h2> + +<h3 id="Example:_Using_getUTCSeconds" name="Example:_Using_getUTCSeconds">Exemple: <code>Utilitzar getUTCSeconds()</code></h3> + +<p>L'exemple següent assigna la porció de segons del temps actual a la variable <code>segons</code>.</p> + +<pre class="brush: js">var avui = new Date(); +var segons = avui.getUTCSeconds(); +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>ECMAScript 1a Edició.</td> + <td>Standard</td> + <td>Definició inicial. Implementat a JavaScript 1.3.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.23', 'Date.prototype.getUTCSeconds')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.getutcseconds', 'Date.prototype.getUTCSeconds')}}</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 for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li>{{jsxref("Date.prototype.getSeconds()")}}</li> + <li>{{jsxref("Date.prototype.setUTCSeconds()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/date/getyear/index.html b/files/ca/web/javascript/referencia/objectes_globals/date/getyear/index.html new file mode 100644 index 0000000000..8724b2e03b --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/date/getyear/index.html @@ -0,0 +1,162 @@ +--- +title: Date.prototype.getYear() +slug: Web/JavaScript/Referencia/Objectes_globals/Date/getYear +translation_of: Web/JavaScript/Reference/Global_Objects/Date/getYear +--- +<div>{{JSRef("Global_Objects", "Date")}} {{deprecated_header}}</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>El mètode<strong><code> getYear()</code></strong> retorna l'any de la data especificada segons l'hora local. Com que <code>getYear()</code> no retorna anys sencers ("el problema de l'any 2000"), no s'utilitza més i s'ha substituït pel mètode {{jsxref("Date.prototype.getFullYear", "getFullYear()")}}.</p> + +<h2 id="Syntax" name="Syntax">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.getYear()</code></pre> + +<h3 id="Parameters" name="Parameters">Paràmetres</h3> + +<p>Cap.</p> + +<h3 id="Returns" name="Returns">Retorna</h3> + +<p>El mètode <code>getYear()</code> retorna l'any menys el valor 1900; és a dir:</p> + +<ul> + <li>Per a anys majors o iguals a 2000, el valor retornat per <code>getYear()</code> és 100 o major. Per exemple, si l'any és el 2026, <code>getYear()</code> retorna 126.</li> + <li>Per a anys entre 1900 i 1999 (ambdós inclosos), el valor retornat per <code>getYear()</code> roman entre 0 i 99. Per exemple, per a l'any 1976 <code>getYear()</code> retorna 76.</li> + <li>Per a anys menors que 1900, el valor retornat per <code>getYear()</code> és menor que zero. Per exemple, per a l'any 1800, <code>getYear()</code> retorna -100.</li> +</ul> + +<p>Per a tenir en compte anys abans o deprés del 2000 es recomana utilitzar {{jsxref("Date.prototype.getFullYear", "getFullYear()")}} en comptes de <code>getYear()</code> ja que retorna l'any sencer.</p> + +<h2 id="Backward_compatibility" name="Backward_compatibility">Compatibilitat amb versions anteriors</h2> + +<h3 id="JavaScript_1.2_and_earlier" name="JavaScript_1.2_and_earlier">Comportament en JavaScript 1.2 i anteriors</h3> + +<p>El mètode <code>getYear()</code> retorna o bé un any amb dos dígits o bé un any amb 4 dígits:</p> + +<ul> + <li>Per a anys entre 1900 i 1999 (ambdos inclosos) el valor retornat és l'any menys 1900. Per exemple, per a l'any 1976 el valor retornat és 76.</li> + <li>Per a anys menors que 1900 o majors que 1999 el valor retornat per <code>getYear()</code> és l'any amb 4 dígits. Per exemple, per a l'any 1856 el valor retornat és 1856. Per a l'any 2026 el valor retornat és 2026.</li> +</ul> + +<h2 id="Examples" name="Examples">Exemples</h2> + +<h3 id="Example:_Years_between_1900_and_1999" name="Example:_Years_between_1900_and_1999">Exemple: Anys entre1900 i 1999</h3> + +<p>La segona sentència assigna el valor 95 a la variable <code>any</code>.</p> + +<pre class="brush: js">var nadal = new Date('December 25, 1995 23:15:00'); +var any = nadal.getYear(); // retorna 95 +</pre> + +<h3 id="Example:_Years_above_1999" name="Example:_Years_above_1999">Exemple: Anys majors que 1999</h3> + +<p>La segona sentència assigna el valor 100 a la variable <code>any</code>.</p> + +<pre class="brush: js">var nadal = new Date('December 25, 2000 23:15:00'); +var any = Xmas.getYear(); // retorna 100 +</pre> + +<h3 id="Example:_Years_below_1900" name="Example:_Years_below_1900">Exemple: Anys menors que 1900</h3> + +<p>La segona sentència assigna el valor -100 a la variable <code>any</code>.</p> + +<pre class="brush: js">var nadal = new Date('December 25, 1800 23:15:00'); +var any = nadal.getYear(); // retorna -100 +</pre> + +<h3 id="Example:_Setting_and_getting_a_year_between_1900_and_1999" name="Example:_Setting_and_getting_a_year_between_1900_and_1999">Exemple: Assignar i obtenir un any entre1900 i 1999</h3> + +<p>La segona sentència assigna el valor 95 a la variable <code>any</code>, que representa l'any 1995.</p> + +<pre class="brush: js">var nadal.setYear(95); +var any = nadal.getYear(); // retorna 95 +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>ECMAScript 1a Edició.</td> + <td>Standard</td> + <td>Definició inicial. Implementat a JavaScript 1.3.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-B.2.4', 'Date.prototype.getYear')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Definit a l'annex de compatibilitat (amb caràcter informatiu).</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.getyear', 'Date.prototype.getYear')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definit a l'annex de característiques adicionals per a navegadors web (amb caràcter normatiu).</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>Suport bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li>{{jsxref("Date.prototype.getFullYear()")}}</li> + <li>{{jsxref("Date.prototype.getUTCFullYear()")}}</li> + <li>{{jsxref("Date.prototype.setYear()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/date/index.html b/files/ca/web/javascript/referencia/objectes_globals/date/index.html new file mode 100644 index 0000000000..3fb5a9368d --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/date/index.html @@ -0,0 +1,250 @@ +--- +title: Date +slug: Web/JavaScript/Referencia/Objectes_globals/Date +translation_of: Web/JavaScript/Reference/Global_Objects/Date +--- +<div>{{JSRef("Global_Objects", "Date")}}</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>Crea una instància de tipus <strong><code>Date</code></strong> de JavaScript, que representa un únic moment en el temps. Els objectes de tipus <code>Date</code> es basen en un valor de temps que mesura el nombre de milisegons que han passat des de l'u de gener de 1970 UTC.</p> + +<h2 id="Syntax" name="Syntax">Constructor</h2> + +<pre class="syntaxbox"><code>new Date(); +new Date(<var>valor</var>); +new Date(<var>dataString</var>); +new Date(any, mes[, dia[, hora[, minuts[, segons[, <var>milisegons</var>]]]]]); +</code></pre> + +<div class="note"> +<p><strong>Nota:</strong> Els objectes Date de JavaScript només poden ser instanciats cridant Date com a constructor: Si es crida la funció com una funció normal (és a dir, sense l'operador {{jsxref("Operators/new", "new")}}), aquesta retornarà una string en comptes d'un objecte de tipus Date; al contrari que altres tipus d'objectes JavaScript, els objectes de JavaScript de tipus Date no poden ser representats com a literals.</p> +</div> + +<h3 id="Parameters" name="Parameters">Paràmetres</h3> + +<div class="note"> +<p><strong>Nota:</strong> Quan es crida <code>Date</code> com a constructor amb més d'un argument, si els valors són més grans que el seu rang lògic (per exemple, si es passa 13 com a valor pel mes o 70 com a valor de minuts), <code>Date</code> ajusta el valor adjacent. Per exemple, <code>new Date(2013, 13, 1)</code> és equivalent a <code>new Date(2014, 1, 1)</code>, ambdós creen un objecte de tipus <code>Date</code> que representa <code>2014-02-01</code> (cal destacar que els mesos es comencen a contar des de zero). El mateix s'aplica per a altres valors: <code>new Date(2013, 2, 1, 0, 70)</code> és equivalent a <code>new Date(2013, 2, 1, 1, 10)</code> i ambdós representen <code>2013-03-01T01:10:00</code>.</p> +</div> + +<div class="note"> +<p><strong>Nota:</strong> Quan es crida Date com a constructor amb més d'un argument, els arguments especificats representen l'hora local. Si es pretèn passar valors UTC, utilitzeu <code>new Date({{jsxref("Date.UTC()", "Date.UTC(...)")}})</code> amb aquests arguments.</p> +</div> + +<dl> + <dt><code>valor</code></dt> + <dd>Nombre sencer que representa el nombre de milisegons des de l'1 de gener de 1970 00:00:00 UTC (Època UNIX).</dd> + <dt><code>dataString</code></dt> + <dd>Valor String que representa una data. La String ha d'estar en un format reconegut pel mètode {{jsxref("Date.parse()")}} (<a href="http://tools.ietf.org/html/rfc2822#page-14">Marques de temps RFC 2822 compatibles amb el IETF</a> o bé una <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-15.9.1.15">versió de la ISO8601</a>).</dd> + <dt><code>any</code></dt> + <dd>Valor sencer que representa un any. Els valors des de 0 a 99 representen els anys des de 1900 a 1999. Vegeu l'{{anch("Example:_Two_digit_years_map_to_1900_-_1999", "exemple a continuació")}}.</dd> + <dt><code>mes</code></dt> + <dd>Valor sencer que representa un mes, començant per zero com a gener i acabant amb 11 com a desembre.</dd> + <dt><code>dia</code></dt> + <dd>Opcional. Valor sencer que representa el dia del mes.</dd> + <dt><code>hora</code></dt> + <dd>Opcional. Valor sencer que representa l'hora del dia.</dd> + <dt><code>minut</code></dt> + <dd>Opcional. Valor sencer que representa els minuts d'un segment de temps.</dd> + <dt><code>segon</code></dt> + <dd>Opcional. Valor sencer que representa els segons d'un segment de temps.</dd> + <dt><code>milisegons</code></dt> + <dd>Opcional. Valor sencer que representa els milisegons d'un segment de temps.</dd> +</dl> + +<h2 id="Description" name="Description">Descripció</h2> + +<ul> + <li>Si no es proporciona cap argument, el constructor crea un objecte de JavaScript de tipus <code>Date</code> i l'inicialitza amb l'hora actual proporcionada pel sistema.</li> + <li>Si es proporcionen al menys dos arguments, els arguments no proporcionats es consideren o bé 1 (si no s'especifica el dia) o bé 0 per a tots els altres.</li> + <li>L'hora de JavaScript es basa en els milisegons que han passat des de la mitja nit de l'1 de gener de 1970 UTC. Un dia té 86.400.000 milisegons. El rang de l'objecte de JavaScript <code>Date</code> és de -100.000.000 dies a 100.000.000 dies relatius a l'1 de gener de 1970 UTC.</li> + <li>L'objecte de JavaScript <code>Date</code> proporciona el mateix comportament a totes les plataformes on s'utilitzi. El valor de temps es pot passar entre sistemes per a representar el mateix moment del temps i si s'utilitza per a crear un objecte que contingui l'hora local, aquest objecte representarà l'equivalent al temps local.</li> + <li>Alguns dels mètodes de l'objecte de JavaScript <code>Date</code> soporten temps en UTC (universal) i temps local. UTC, també conegut com a Greenwhich Mean Time (GMT), fa referència al temps marcat pel World Time Standard. El temps local és el temps proporcionat per l'ordinador on s'executa el JavaScript.</li> + <li>Si s'invoca la funció de JavaScript <code>Date</code> com una funció (és a dir, sense l'operador {{jsxref("Operators/new", "new")}}), aquesta retornarà una string representant la data i hora actual.</li> +</ul> + +<h2 id="Properties" name="Properties">Propietats</h2> + +<dl> + <dt>{{jsxref("Date.prototype")}}</dt> + <dd>Permet afegir propietats a l'objecte de JavaScript <code>Date</code>.</dd> + <dt><code>Date.length</code></dt> + <dd>El valor de <code>Date.length</code> és 7. Aquest és el nombre de arguments que el constructor accepta.</dd> +</dl> + +<div>{{jsOverrides("Function", "properties", "prototype")}}</div> + +<h2 id="Methods" name="Methods">Mètodes</h2> + +<dl> + <dt>{{jsxref("Date.now()")}}</dt> + <dd>Retorna el valor numèric corresponent al temps actual - el nombre de milisegons que han passat des de l'1 de gener de 1970 00:00:00 UTC.</dd> + <dt>{{jsxref("Date.parse()")}}</dt> + <dd>Interpreta un string que representa una data i retorna el nombre de milisegons des de l'1 de gener de 1970 00:00:00 UTC.</dd> + <dt>{{jsxref("Date.UTC()")}}</dt> + <dd>Accepta els mateixos paràmetres que el constructor (és a dir, de 2 a 7) i retorna le nombre de milisegons des de l'1 de gener de 1970 00:00:00 UTC.</dd> +</dl> + +<div>{{jsOverrides("Function", "Methods", "now", "parse", "UTC")}}</div> + +<h2 id="Date_instances" name="Date_instances">Instàncies de JavaScript <code>Date</code></h2> + +<p>Totes les instàncies de <code>Date</code> hereten de {{jsxref("Date.prototype")}}. L'objecte prototipus del constructor <code>Date</code> pot ser modificat per a afectar a totes les instàncies de <code>Date</code>.</p> + +<h3 id="Mètodes_de_Date.prototype">Mètodes de Date.prototype</h3> + +<div>{{page('/ca/docs/Web/JavaScript/Reference/Global_Objects/Date/prototype', 'Methods')}}</div> + +<h2 id="Examples" name="Examples">Exemples</h2> + +<h3 id="Example:_Several_ways_to_assign_dates" name="Example:_Several_ways_to_assign_dates">Exemple: Vàries formes de crear un objecte de tipus <code>Date</code></h3> + +<p>Els següents exemples mostren diverses maneres de crear dates a JavaScript:</p> + +<pre class="brush: js">var today = new Date(); +var birthday = new Date('December 17, 1995 03:24:00'); +var birthday = new Date('1995-12-17T03:24:00'); +var birthday = new Date(1995, 11, 17); +var birthday = new Date(1995, 11, 17, 3, 24, 0); +</pre> + +<h3 id="Example:_Two_digit_years_map_to_1900_-_1999" name="Example:_Two_digit_years_map_to_1900_-_1999">Exemple: Dos dígits per representar els anys 1900 a 1999</h3> + +<p>Per a crear i obtindre dates entre els anys 0 i 99 es recomana emprar els mètodes {{jsxref("Date.prototype.setFullYear()")}} i {{jsxref("Date.prototype.getFullYear()")}}.</p> + +<pre class="brush: js">var date = new Date(98, 1); // Sun Feb 01 1998 00:00:00 GMT+0000 (GMT) + +// Deprecated method, 98 maps to 1998 here as well +date.setYear(98); // Sun Feb 01 1998 00:00:00 GMT+0000 (GMT) + +date.setFullYear(98); // Sat Feb 01 0098 00:00:00 GMT+0000 (BST) +</pre> + +<h3 id="Example:_Calculating_elapsed_time" name="Example:_Calculating_elapsed_time">Exemple: Calcular el temps passat</h3> + +<p>Els exemples següents mostren com determinar el temps passat entre dues dates a JavaScript:</p> + +<pre class="brush: js">// utilitzant objectes Date +var start = Date.now(); + +// L'event a cronometra va aquí: +doSomethingForALongTime(); +var end = Date.now(); +var elapsed = end - start; // temps transcorregut en milisegons +</pre> + +<pre class="brush: js">// utilitzant mètodes que formen part del sistema +var start = new Date(); + +// the event to time goes here: +doSomethingForALongTime(); +var end = new Date(); +var elapsed = end.getTime() - start.getTime(); // temps transcorregut en milisegons +</pre> + +<pre class="brush: js">// cronometra una funció i retorna el que retorni +function printElapsedTime(fTest) { + var nStartTime = Date.now(), + vReturn = fTest(), + nEndTime = Date.now(); + + console.log('Temps transcorregut: ' + String(nEndTime - nStartTime) + ' miliseconds'); + return vReturn; +} + +yourFunctionReturn = printElapsedTime(yourFunction); +</pre> + +<div class="note"> +<p><strong>Nota:</strong> En navegadors que suporten la característica de temps en alta resolució de la {{domxref("window.performance", "API d'Alt Rendiment Web", "", 1)}}, {{domxref("Performance.now()")}} pot proporcionar mesures de temps més concises i fiables pel temps transcorregut que {{jsxref("Date.now()")}}.</p> +</div> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>ECMAScript 1a Edició.</td> + <td>Standard</td> + <td>Definició inicial. Implementat a JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9', 'Date')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date-objects', 'Date')}}</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 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> + +<h3 id="Informes_de_compatiblitat_amb_navegadors">Informes de compatiblitat amb navegadors</h3> + +<ul> + <li><a href="https://gist.github.com/2312309">4/2012 punts essencials de Yaffle sobre problemes de compatibilitat amb navegadors dels mètodes <code>toISOString</code>/<code>fromISOString</code>/Native <code>Date.parse</code></a></li> + <li><a href="http://dygraphs.com/date-formats.html">3/14/2012 blog de danvk Comparant FF/IE/Chrome en l'interpretació de dates com a strings</a></li> +</ul> + +<h3 id="Notes_específiques_de_Internet_Explorer">Notes específiques de Internet Explorer</h3> + +<p>Internet Explorer 8 <a href="https://msdn.microsoft.com/en-us//library/ie/ff743760(v=vs.94).aspx">no suporta el format de dates ISO8601</a>.</p> diff --git a/files/ca/web/javascript/referencia/objectes_globals/date/now/index.html b/files/ca/web/javascript/referencia/objectes_globals/date/now/index.html new file mode 100644 index 0000000000..c3ef05fa86 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/date/now/index.html @@ -0,0 +1,126 @@ +--- +title: Date.now() +slug: Web/JavaScript/Referencia/Objectes_globals/Date/now +translation_of: Web/JavaScript/Reference/Global_Objects/Date/now +--- +<div>{{JSRef("Global_Objects", "Date")}}</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>El mètode <strong><code>Date.now()</code></strong> retorna el nombre de milisegons que han passat des de l'1 de gener de 1970 00:00:00 UTC.</p> + +<h2 id="Syntax" name="Syntax">Sintaxi</h2> + +<pre class="syntaxbox"><code>var timeInMs = Date.now();</code></pre> + +<h3 id="Parameters" name="Parameters">Paràmetres</h3> + +<p>Cap.</p> + +<h2 id="Description" name="Description">Descripció</h2> + +<p>El mètode <code>now()</code> retorna el nombre de method returns el nombre de milisegons que han passat des de l'1 de gener de 1970 00:00:00 UTC fins al moment actual representat en un {{jsxref("Global_Objects/Number", "Nombre")}}.</p> + +<p>Com que <code>now()</code> és un mètode estàtic de {{jsxref("Global_Objects/Date", "Date")}}, sempre es crida com a <code>Date.now()</code>.</p> + +<h2 id="Polyfill" name="Polyfill">Polyfill</h2> + +<p>Aquest mètode va ser estandaritzat a la cinquena edició de l'ECMA-262. Els motors que encara no hagin sigut actualitzats per a suportar aquest mètode poden utilitzar el bocí de codi següent per a paliar l'absència d'aquest mètode:</p> + +<pre class="brush: js">if (!Date.now) { + Date.now = function now() { + return new Date().getTime(); + }; +} +</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.9.4.4', 'Date.now')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Definició inicial. Implementat a JavaScript 1.5.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.now', 'Date.now')}}</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ístiques</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("1.9")}}</td> + <td>{{CompatIE("9")}}</td> + <td>{{CompatOpera("10.50")}}</td> + <td>{{CompatSafari("4")}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característiques</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> + +<p>Basat en la <a href="http://kangax.github.com/es5-compat-table/">taula de compatibilitat de Kangax</a>.</p> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{domxref("Performance.now()")}} — proporciona marques de temps amb una resolució submilimètrica per a utilitzar al mesurar el rendiment de pàgines web</li> + <li>{{domxref("console.time()")}} / {{domxref("console.timeEnd()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/date/prototype/index.html b/files/ca/web/javascript/referencia/objectes_globals/date/prototype/index.html new file mode 100644 index 0000000000..3ed17045fb --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/date/prototype/index.html @@ -0,0 +1,221 @@ +--- +title: Date.prototype +slug: Web/JavaScript/Referencia/Objectes_globals/Date/prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Date +--- +<div>{{JSRef("Global_Objects", "Date")}}</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>La propietat <strong><code>Date.prototype</code></strong> representa el prototipus per al constructor {{jsxref("Global_Objects/Date", "Date")}}.</p> + +<div>{{js_property_attributes(0, 0, 1)}}</div> + +<h2 id="Description" name="Description">Descripció</h2> + +<p>Les instàncies de JavaScript de {{jsxref("Global_Objects/Date", "Date")}} hereten de<code> Date.prototype</code>. L'objecte prototipus del constructor pot modificar-se per a afectar a les propietats i mètodes heretats per les instàncies de {{jsxref("Global_Objects/Date", "Date")}}.</p> + +<p>Per a compatibilitat amb càlculs amb milenis (en altres paraules, per a tindre en compte l'any 2000), sempre s'hauria d'especificar l'any sencer, per exemple, 1998, en comptes de 98. Per a ajudar a proveïr l'any sencer JavaScript inclou els mètodes {{jsxref("Date.prototype.getFullYear()", "getFullYear()")}}, {{jsxref("Date.prototype.setFullYear()", "setFullYear()")}}, {{jsxref("Date.prototype.getUTCFullYear()", "getUTCFullYear()")}} i {{jsxref("Date.prototype.setUTCFullYear()", "setUTCFullYear()")}}.</p> + +<h2 id="Properties" name="Properties">Propietats</h2> + +<dl> + <dt><code>Date.prototype.constructor</code></dt> + <dd>Retorna la funció que va crear la instància. És a dir, per defecte el constructor {{jsxref("Global_Objects/Date", "Date")}}.</dd> +</dl> + +<div>{{jsOverrides("Object", "properties", "constructor")}}</div> + +<h2 id="Methods" name="Methods">Mètodes</h2> + +<h3 id="Getter">Getter</h3> + +<dl> + <dt>{{jsxref("Date.prototype.getDate()")}}</dt> + <dd>Retorna el dia del mes (1-31) per a la data especificada, en temps local.</dd> + <dt>{{jsxref("Date.prototype.getDay()")}}</dt> + <dd>Retorna el dia de la setmana (0-6) per a la data especificada, en temps local.</dd> + <dt>{{jsxref("Date.prototype.getFullYear()")}}</dt> + <dd>Retorna l'any (4 digits per a anys de 4 digits) per a la data especificada, en temps local.</dd> + <dt>{{jsxref("Date.prototype.getHours()")}}</dt> + <dd>Retorna l'hora (0-23) per a la data especificada, en temps local.</dd> + <dt>{{jsxref("Date.prototype.getMilliseconds()")}}</dt> + <dd>Retorna els milisegons (0-999) per a la data especificada, en temps local.</dd> + <dt>{{jsxref("Date.prototype.getMinutes()")}}</dt> + <dd>Retorna els minuts (0-59) per a la data especificada, en temps local.</dd> + <dt>{{jsxref("Date.prototype.getMonth()")}}</dt> + <dd>Retorna el mes (0-11) per a la data especificada, en temps local.</dd> + <dt>{{jsxref("Date.prototype.getSeconds()")}}</dt> + <dd>Retorna els segons (0-59) per a la data especificada, en temps local.</dd> + <dt>{{jsxref("Date.prototype.getTime()")}}</dt> + <dd>Retorna un valor numèric per a la data especificada que representa la data especificada com al nombre de milisegons que han passat des de l'1 de gener de 1970, 00:00:00 UTC (negatiu per a dates anteriors).</dd> + <dt>{{jsxref("Date.prototype.getTimezoneOffset()")}}</dt> + <dd>Retorna la diferència d'ús horari en minuts del temps local.</dd> + <dt>{{jsxref("Date.prototype.getUTCDate()")}}</dt> + <dd>Retorna el dia del mes (1-31) per a la data especificada en temps universal (UTC).</dd> + <dt>{{jsxref("Date.prototype.getUTCDay()")}}</dt> + <dd>Retorna el dia de la setmana (0-6) per a la data especificada en temps universal (UTC).</dd> + <dt>{{jsxref("Date.prototype.getUTCFullYear()")}}</dt> + <dd>Retorna l'any (4 digits per a anys de 4 digits) per a la data especificada en temps universal (UTC).</dd> + <dt>{{jsxref("Date.prototype.getUTCHours()")}}</dt> + <dd>Retorna l'hora (0-23) per a la data especificada en temps universal (UTC).</dd> + <dt>{{jsxref("Date.prototype.getUTCMilliseconds()")}}</dt> + <dd>Retorna els milisegons (0-999) per a la data especificada en temps universal (UTC).</dd> + <dt>{{jsxref("Date.prototype.getUTCMinutes()")}}</dt> + <dd>Retorna els minuts (0-59) per a la data especificada en temps universal (UTC).</dd> + <dt>{{jsxref("Date.prototype.getUTCMonth()")}}</dt> + <dd>Retorna el mes (0-11) per a la data especificada en temps universal (UTC).</dd> + <dt>{{jsxref("Date.prototype.getUTCSeconds()")}}</dt> + <dd>Retorna els segons (0-59) per a la data especificada en temps universal (UTC).</dd> + <dt>{{jsxref("Date.prototype.getYear()")}} {{deprecated_inline}}</dt> + <dd>Retorna l'any (normalment 2-3 digits) per a la data especificada, en temps local. En comptes d'aquest mètode, utilitzeu {{jsxref("Date.prototype.getFullYear()", "getFullYear()")}}.</dd> +</dl> + +<h3 id="Setter">Setter</h3> + +<dl> + <dt>{{jsxref("Date.prototype.setDate()")}}</dt> + <dd>Assigna el dia del mes per a la data especificada, en temps local.</dd> + <dt>{{jsxref("Date.prototype.setFullYear()")}}</dt> + <dd>Assigna l'any sencer (és a dir, de 4 digits per a un any amb 4 digits) per a la data especificada, en temps local.</dd> + <dt>{{jsxref("Date.prototype.setHours()")}}</dt> + <dd>Assigna l'hora per a la data especificada, en temps local.</dd> + <dt>{{jsxref("Date.prototype.setMilliseconds()")}}</dt> + <dd>Assigna els milisegons per a la data especificada, en temps local.</dd> + <dt>{{jsxref("Date.prototype.setMinutes()")}}</dt> + <dd>Assigna els minuts per a la data especificada, en temps local.</dd> + <dt>{{jsxref("Date.prototype.setMonth()")}}</dt> + <dd>Assigna el mes per a la data especificada, en temps local.</dd> + <dt>{{jsxref("Date.prototype.setSeconds()")}}</dt> + <dd>Assigna els segons per a la data especificada, en temps local.</dd> + <dt>{{jsxref("Date.prototype.setTime()")}}</dt> + <dd>Assigna la data que representarà la instància de l'objecte {{jsxref("Global_Objects/Date", "Date")}} al temps representat pel nombre de milisegons passats des de l'1 de gener de 1970, 00:00:00 UTC. Permet nombres negatius per a temps anteriors a aquesta data.</dd> + <dt>{{jsxref("Date.prototype.setUTCDate()")}}</dt> + <dd>Assigna el dia del mes per a la data especificada en temps universal (UTC).</dd> + <dt>{{jsxref("Date.prototype.setUTCFullYear()")}}</dt> + <dd>Assigna l'any sencer (és a dir, 4 digits per a anys de 4 digits) per a la data especificada en temps universal (UTC).</dd> + <dt>{{jsxref("Date.prototype.setUTCHours()")}}</dt> + <dd>Assigna l'hora per a la data especificada en temps universal (UTC).</dd> + <dt>{{jsxref("Date.prototype.setUTCMilliseconds()")}}</dt> + <dd>Assigna els milisegons per a la data especificada en temps universal (UTC).</dd> + <dt>{{jsxref("Date.prototype.setUTCMinutes()")}}</dt> + <dd>Assigna els minuts per a la data especificada en temps universal (UTC).</dd> + <dt>{{jsxref("Date.prototype.setUTCMonth()")}}</dt> + <dd>Assigna el mes per a la data especificada en temps universal (UTC).</dd> + <dt>{{jsxref("Date.prototype.setUTCSeconds()")}}</dt> + <dd>Assigna els segons per a la data especificada en temps universal (UTC).</dd> + <dt>{{jsxref("Date.prototype.setYear()")}} {{deprecated_inline}}</dt> + <dd>Assigna l'any (normalment 2-3 digits) per a la data especificada en temps local. Utilitzeu {{jsxref("Date.prototype.setFullYear()", "setFullYear()")}} en comptes d'aquest mètode.</dd> +</dl> + +<h3 id="Getters_amb_conversió">Getters amb conversió</h3> + +<dl> + <dt>{{jsxref("Date.prototype.toDateString()")}}</dt> + <dd>Retorna la part part de data de {{jsxref("Global_Objects/Date", "Date")}} com a string inteligible per humans.</dd> + <dt>{{jsxref("Date.prototype.toISOString()")}}</dt> + <dd>Converteix una data a un string seguint el Format Extés del ISO 8601.</dd> + <dt>{{jsxref("Date.prototype.toJSON()")}}</dt> + <dd>Retorna un string que representa l'objecte {{jsxref("Global_Objects/Date", "Date")}} utilitzant {{jsxref("Date.prototype.toISOString()", "toISOString()")}}. Ideat per a ser usat per {{jsxref("JSON.stringify()")}}.</dd> + <dt>{{jsxref("Date.prototype.toGMTString()")}} {{deprecated_inline}}</dt> + <dd>Retorna un string que representa l'objecte {{jsxref("Global_Objects/Date", "Date")}} basat en la zona horària GMT (UT). Utilitzeu {{jsxref("Date.prototype.toUTCString()", "toUTCString()")}} en comptes d'aquest mètode.</dd> + <dt>{{jsxref("Date.prototype.toLocaleDateString()")}}</dt> + <dd>Retorna un string que representa la part de la data amb temps local, basat en la configuració del sistema.</dd> + <dt>{{jsxref("Date.prototype.toLocaleFormat()")}} {{non-standard_inline}}</dt> + <dd>Converteix una data a string tot utilitzant un format string.</dd> + <dt>{{jsxref("Date.prototype.toLocaleString()")}}</dt> + <dd>Retorna un string que representa la data tenint en compte el temps local. Sobreescriu el mètode {{jsxref("Object.prototype.toLocaleString()")}}.</dd> + <dt>{{jsxref("Date.prototype.toLocaleTimeString()")}}</dt> + <dd>Retorna un string que representa la part de temps de la data local basada en la configuració del sistema.</dd> + <dt>{{jsxref("Date.prototype.toSource()")}} {{non-standard_inline}}</dt> + <dd>Retorna un string que representa el codi font per a un objecte {{jsxref("Global_Objects/Date", "Date")}} equivalent; aquest valor pot emprar-se per a crear un nou objecte. Sobreescriu el mètode {{jsxref("Object.prototype.toSource()")}}.</dd> + <dt>{{jsxref("Date.prototype.toString()")}}</dt> + <dd>Retorna un string que representa l'objecte {{jsxref("Global_Objects/Date", "Date")}} especificat. Sobreescriu el mètode {{jsxref("Object.prototype.toString()")}}.</dd> + <dt>{{jsxref("Date.prototype.toTimeString()")}}</dt> + <dd>Retorna la part de temps de l'objecte {{jsxref("Global_Objects/Date", "Date")}} com a string comprensible per humans.</dd> + <dt>{{jsxref("Date.prototype.toUTCString()")}}</dt> + <dd>Converteix una data a un string utilitzant la zona horària UTC.</dd> + <dt>{{jsxref("Date.prototype.valueOf()")}}</dt> + <dd>Retorna el valor primitiu d'un objecte {{jsxref("Global_Objects/Date", "Date")}}. Sobreescriu el mètode {{jsxref("Object.prototype.valueOf()")}}.</dd> +</dl> + +<div>{{jsOverrides("Object", "methods", "getDate", "getDay", "getFullYear", "getHours", "getMilliseconds", "getMinutes", "getMonth", "getSeconds", "getTime", "getTimezoneOffset", "getUTCDate", "getUTCDay", "getUTCFullYear", "getUTCHours", "getUTCMilliseconds", "getUTCMinutes", "getUTCMonth", "getUTCSeconds", "getYear", "setdate", "setFullYear", "setHours", "setMilliseconds", "setMinutes", "setMontth", "setSeconds", "setTime", "setUTCDate", "setUTCFullYear", "setUTCHours", "setUTCMilliseconds", "setUTCMinutes", "setUTCMonth", "setUTCSeconds", "setYear", "toDateString", "toGMTString", "toLocaleDateString", "toLocaleFormat", "toLocaleString", "toLocaleTimeString", "toSource", "toString", "toTimeString", "toUTCString", "valueOf")}}</div> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>ECMAScript 1a Edició.</td> + <td>Standard</td> + <td>Definició inicial. Implementat a JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5', 'Date.prototype')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-properties-of-the-date-prototype-object', 'Date.prototype')}}</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 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> diff --git a/files/ca/web/javascript/referencia/objectes_globals/date/setdate/index.html b/files/ca/web/javascript/referencia/objectes_globals/date/setdate/index.html new file mode 100644 index 0000000000..746de134fe --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/date/setdate/index.html @@ -0,0 +1,122 @@ +--- +title: Date.prototype.setDate() +slug: Web/JavaScript/Referencia/Objectes_globals/Date/setDate +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setDate +--- +<div>{{JSRef}}</div> + +<p>El mètode <strong><code>setDate()</code></strong> assigna el dia de l'objecte {{jsxref("Date")}} relatiu al principi del mes assignat en aquell moment.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>objecteData</var>.setDate(dia)</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>dia</code></dt> + <dd>Un nombre sencer que representa el dia del mes.</dd> +</dl> + +<h3 id="Valor_retornat">Valor retornat</h3> + +<p>El valor retornat per <code>setDate()</code> és el nombre de milisegons que han passat des de l'ú de gener de 1970 00:00:00 UTC de la data resultant (l'objecte {{jsxref("Date")}} també canvia).</p> + +<h2 id="Descripció">Descripció</h2> + +<p>Si es passa un paràmetre que està fora del rang esperat, el mètode <code>setDate()</code> actualitza els altres paràmetres per a acceptar el nombre. Per exemple, si es passa 0 com a <code>dia</code>, la data representarà l'últim dia del mes anterior.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_setDate()">Utilitzar <code>setDate()</code></h3> + +<pre class="brush: js">var elGranDia = new Date(1962, 6, 7); // 1962-07-07 +elGranDia.setDate(24); // 1962-07-24 +elGranDia.setDate(32); // 1962-08-01 +elGranDia.setDate(22); // 1962-08-22</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.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.36', 'Date.prototype.setDate')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.setdate', 'Date.prototype.setDate')}}</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 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("Date.prototype.getDate()")}}</li> + <li>{{jsxref("Date.prototype.setUTCDate()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/date/setfullyear/index.html b/files/ca/web/javascript/referencia/objectes_globals/date/setfullyear/index.html new file mode 100644 index 0000000000..c29d56ca4e --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/date/setfullyear/index.html @@ -0,0 +1,128 @@ +--- +title: Date.prototype.setFullYear() +slug: Web/JavaScript/Referencia/Objectes_globals/Date/setFullYear +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setFullYear +--- +<div>{{JSRef}}</div> + +<p>El mètode <strong><code>setFullYear()</code></strong> assigna l'any sencerr per a la data especificada, d'acord a l'hora local. Retorna una nova marca de temps.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>objecteData</var>.setFullYear(any[, mes[, dia]])</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>any</code></dt> + <dd>Un nombre sencer que representa el valor numèric de l'any, per exemple, 1995.</dd> + <dt><code>mes</code></dt> + <dd>Un nombre sencer entre 0 i 11 que representa el mes.</dd> + <dt><code>dia</code></dt> + <dd>Opcional. Un nombre sencer entre 1 i 31 que representa el dia del mes.</dd> +</dl> + +<h3 id="Valor_retornat">Valor retornat</h3> + +<p>Una nova marca de temps amb el valor de l'objecte actual.</p> + +<h2 id="Descripció">Descripció</h2> + +<p>Si no s'especifica el paràmetre <code>dia</code> s'utilitza el valor retornat pels mètodes {{jsxref("Date.prototype.getMonth()", "getMonth()")}} i {{jsxref("Date.prototype.getDate()", "getDate()")}}.</p> + +<p>Si es passa un paràmetre que està fora del rang esperat, el mètode <code>UTC()</code> actualitza els altres paràmetres per a acceptar el nombre. Per exemple, si es passa 15 com a <code>mes</code>, l'any serà incrementat en 1 (<code>any + 1</code>), i s'emprarà 3 com a <code>mes</code>.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_setFullYear()">Utilitzar <code>setFullYear()</code></h3> + +<pre class="brush: js">var elGranDia = new Date(); +elGranDia.setFullYear(1997); +</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.3.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.40', 'Date.prototype.setFullYear')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.setfullyear', 'Date.prototype.setFullYear')}}</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 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("Date.prototype.getUTCFullYear()")}}</li> + <li>{{jsxref("Date.prototype.setUTCFullYear()")}}</li> + <li>{{jsxref("Date.prototype.setYear()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/date/sethours/index.html b/files/ca/web/javascript/referencia/objectes_globals/date/sethours/index.html new file mode 100644 index 0000000000..7f660ba344 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/date/sethours/index.html @@ -0,0 +1,129 @@ +--- +title: Date.prototype.setHours() +slug: Web/JavaScript/Referencia/Objectes_globals/Date/setHours +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setHours +--- +<div>{{JSRef}}</div> + +<p>El mètode <strong><code>setHours()</code></strong> assigna l'hora per a una data especificada d'acord a l'hora local, i retorna el nombre de milisegons que han passat des de l'u de gener de 1970 00:00:00 UTC fins al temps representat per la instància de {{jsxref("Date")}} actualitzada.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>objecteData</var>.setHours(hores[, minuts[, segons[, milisegons]]])</code></pre> + +<h3 id="Versions_anteriors_a_JavaScript_1.3">Versions anteriors a JavaScript 1.3</h3> + +<pre class="syntaxbox"><code><var>objecteData</var>.setHours(hores)</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>hores</code></dt> + <dd>Un nombre sencer entre 0 i 23, que representa l'hora.</dd> + <dt><code>minuts</code></dt> + <dd>Opcional. Un nombre sencer entre 0 i 59 que representa els minuts.</dd> + <dt><code>segons</code></dt> + <dd>Opcional. Un nombre sencer entre 0 i 59 que representa els segons.</dd> + <dt><code>milisegons</code></dt> + <dd>Opcional. Un nombre sencer entre 0 i 999 que representa els milisegons.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Si no s'especifiquen els paràmetres <code>minuts</code>, <code>segons</code> i <code>milisegons</code> s'utilitzen els valors retornats per {{jsxref("Date.prototype.getMinutes()", "getMinutes()")}}, {{jsxref("Date.prototype.getSeconds()", "getSeconds()")}} i {{jsxref("Date.prototype.getMilliseconds()", "getMilliseconds()")}}.</p> + +<p>Si es passa un paràmetre que està fora del rang esperat, el mètode <code>setHours()</code> actualitza els altres paràmetres per a acceptar el nombre. Per exemple, si es passa 100 com a <code>segons</code>, els minuts seran incrementats en 1 (<code>minuts + 1</code>), i s'emprarà 40 com a <code>segons</code>.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_setHours()">Utilitzar <code>setHours()</code></h3> + +<pre class="brush:js">var elGranDia = new Date(); +elGranDia.setHours(7); +</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.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.34', 'Date.prototype.setHours')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.sethours', 'Date.prototype.setHours')}}</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 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("Date.prototype.getHours()")}}</li> + <li>{{jsxref("Date.prototype.setUTCHours()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/date/setmilliseconds/index.html b/files/ca/web/javascript/referencia/objectes_globals/date/setmilliseconds/index.html new file mode 100644 index 0000000000..53dc451ad4 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/date/setmilliseconds/index.html @@ -0,0 +1,117 @@ +--- +title: Date.prototype.setMilliseconds() +slug: Web/JavaScript/Referencia/Objectes_globals/Date/setMilliseconds +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setMilliseconds +--- +<div>{{JSRef}}</div> + +<p>El mètode <strong><code>setMilliseconds()</code></strong> assigna els milisegons per a una data especificada d'acord a l'hora local.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>objecteData</var>.setMilliseconds(milisegons)</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>milisegons</code></dt> + <dd>Un nombre sencer entre 0 i 999 que representa els milisegons.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Si es passa un paràmetre que està fora del rang esperat, el mètode <code>setMilliseconds()</code> actualitza els altres paràmetres per a acceptar el nombre. Per exemple, si es passa 1005 com a <code>milisegons</code>, els segonsseran incrementats en 1 (<code>segons + 1</code>), i s'emprarà 5 com a <code>milisegons</code>.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_setMilliseconds()">Utilitzar <code>setMilliseconds()</code></h3> + +<pre class="brush: js">var elGranDia= new Date(); +elGranDia.setMilliseconds(100); +</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">Comenataris</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definició inicial. Implementat a JavaScript 1.3.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.28', 'Date.prototype.setMilliseconds')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.setmilliseconds', 'Date.prototype.setMilliseconds')}}</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 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("Date.prototype.getMilliseconds()")}}</li> + <li>{{jsxref("Date.prototype.setUTCMilliseconds()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/date/setminutes/index.html b/files/ca/web/javascript/referencia/objectes_globals/date/setminutes/index.html new file mode 100644 index 0000000000..7dba61cade --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/date/setminutes/index.html @@ -0,0 +1,127 @@ +--- +title: Date.prototype.setMinutes() +slug: Web/JavaScript/Referencia/Objectes_globals/Date/setMinutes +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setMinutes +--- +<div>{{JSRef}}</div> + +<p>El mètode <strong><code>setMinutes()</code></strong> assigna els minuts a una data especificada, d'acord a l'hora local.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>objecteData</var>.setMinutes(minuts[, segons[, milisegons]])</code></pre> + +<h3 id="Versions_anteriors_a_JavaScript_1.3">Versions anteriors a JavaScript 1.3</h3> + +<pre class="syntaxbox"><code><var>objecteData</var>.setMinutes(minuts)</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>minuts</code></dt> + <dd>Un nombre sencer entre 0 i 59 que representa els minuts.</dd> + <dt><code>segons</code></dt> + <dd>Opcional. Un nombre sencer entre 0 i 59 que representa els segons.</dd> + <dt><code>milisegons</code></dt> + <dd>Opcional. Un nombre sencer entre 0 i 999 que representa els milisegons.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Si no s'especifiquen els paràmetres <code>minuts</code>, <code>segons</code> i <code>milisegons</code> s'utilitzen els valors retornats per {{jsxref("Date.prototype.getSeconds()", "getSeconds()")}} i {{jsxref("Date.prototype.getMilliseconds()", "getMilliseconds()")}}.</p> + +<p>Si es passa un paràmetre que està fora del rang esperat, el mètode <code>setMinutes()</code> actualitza els altres paràmetres per a acceptar el nombre. Per exemple, si es passa 100 com a <code>segons</code>, els minuts seran incrementats en 1 (<code>minuts + 1</code>), i s'emprarà 40 com a <code>segons</code>.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_setMinutes()"><code>Utilitzar setMinutes()</code></h3> + +<pre class="brush: js">var elGranDia = new Date(); +elGranDia.setMinutes(45); +</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.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.32', 'Date.prototype.setMinutes')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.setminutes', 'Date.prototype.setMinutes')}}</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 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("Date.prototype.getMinutes()")}}</li> + <li>{{jsxref("Date.prototype.setUTCMinutes()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/date/setmonth/index.html b/files/ca/web/javascript/referencia/objectes_globals/date/setmonth/index.html new file mode 100644 index 0000000000..a84f51df7c --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/date/setmonth/index.html @@ -0,0 +1,126 @@ +--- +title: Date.prototype.setMonth() +slug: Web/JavaScript/Referencia/Objectes_globals/Date/setMonth +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setMonth +--- +<div>{{JSRef}}</div> + +<p>El mètode <strong><code>setMonth()</code></strong> assigna el mes per a una data especificada d'acord a l'any assignat previament.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>objecteData</var>.setMonth(mes[, dia])</code></pre> + +<h3 id="Versions_anteriors_a_JavaScript_1.3">Versions anteriors a JavaScript 1.3</h3> + +<pre class="syntaxbox"><code><var>objecteData</var>.setMonth(mes)</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>mes</code></dt> + <dd>Un nombre sencer entre 0 i 11 que representa els mesos des de gener fins a desembre</dd> + <dt><code>dia</code></dt> + <dd>Opcional. Un nombre sencer entre 1 i 31 que representa el dia del mes.</dd> + <dd> </dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Si no s'especifica el paràmetre <code>dia</code> s'utilitza el valor retornat pel mètode {{jsxref("Date.prototype.getDate()", "getDate()")}}.</p> + +<p>Si es passa un paràmetre que està fora del rang esperat, el mètode <code>setMonth()</code> actualitza els altres paràmetres per a acceptar el nombre. Per exemple, si es passa 15 com a mes, l'any serà incrementat en 1 (<code>any + 1</code>), i s'emprarà 3 com a mes.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_setMonth()">Utilitzar <code>setMonth()</code></h3> + +<pre class="brush: js">var elGranDia = new Date(); +elGranDia.setMonth(6); +</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.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.38', 'Date.prototype.setMonth')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.setmonth', 'Date.prototype.setMonth')}}</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 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("Date.prototype.getMonth()")}}</li> + <li>{{jsxref("Date.prototype.setUTCMonth()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/date/setseconds/index.html b/files/ca/web/javascript/referencia/objectes_globals/date/setseconds/index.html new file mode 100644 index 0000000000..60ea2c0ae3 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/date/setseconds/index.html @@ -0,0 +1,125 @@ +--- +title: Date.prototype.setSeconds() +slug: Web/JavaScript/Referencia/Objectes_globals/Date/setSeconds +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setSeconds +--- +<div>{{JSRef}}</div> + +<p>El mètode <strong><code>setSeconds()</code></strong> assigna els segons per a una data especificada, en temps local.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>objecteData</var>.setSeconds(segons[, milisegons])</code></pre> + +<h3 id="Versions_anteriors_a_JavaScript_1.3">Versions anteriors a JavaScript 1.3</h3> + +<pre class="syntaxbox"><code><var>objecteData</var>.setSeconds(<var>segons</var>)</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>segons</code></dt> + <dd>Un nombre sencer entre 0 i 59 que representa els segons.</dd> + <dt><code>milisegons</code></dt> + <dd>Opcional. Un nombre sencer entre 0 i 999 que representa els milisegons.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Si no s'especifica el paràmetre <code>milisegons</code> s'utilitza el valor retornat pel mètode {{jsxref("Date.prototype.getMilliseconds()", "getMilliseconds()")}}.</p> + +<p>Si es passa un paràmetre que està fora del rang esperat, el mètode <code>setSeconds()</code> actualitza els altres paràmetres per a acceptar el nombre. Per exemple, si es passa 100 com a <code>segons</code>, els minuts seran incrementats en 1 (<code>minuts + 1</code>), i s'emprarà 40 com a <code>segons</code>.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_setSeconds()"><code>Utilitzar setSeconds()</code></h3> + +<pre class="brush: js">var elGranDia = new Date(); +elGranDia.setSeconds(30); +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificacions</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definició inicial. Implementat a JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.30', 'Date.prototype.setSeconds')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.setseconds', 'Date.prototype.setSeconds')}}</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 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("Date.prototype.getSeconds()")}}</li> + <li>{{jsxref("Date.prototype.setUTCSeconds()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/date/settime/index.html b/files/ca/web/javascript/referencia/objectes_globals/date/settime/index.html new file mode 100644 index 0000000000..9774f3ee4c --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/date/settime/index.html @@ -0,0 +1,118 @@ +--- +title: Date.prototype.setTime() +slug: Web/JavaScript/Referencia/Objectes_globals/Date/setTime +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setTime +--- +<div>{{JSRef}}</div> + +<p>El mètode <strong><code>setTime()</code></strong> configura l'objecte {{jsxref("Date")}} amb un nombre que representa un temps en milisegons que han passat des de la mitjanit de l'ú de gener de 1970, en temps universal.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>objecteData</var>.setTime(temps)</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>temps</code></dt> + <dd>Un nombre sencer que representa el nombre de milisegons que han passat des de l'1 de gener de 1970 00:00:00 UTC.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Utilitzeu el mètode <code>setTime()</code> per a assignar una data i hora a un objecte de tipus {{jsxref("Date")}}.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_setTime()">Utilitzar <code>setTime()</code></h3> + +<pre class="brush: js">var elGranDia = new Date('July 1, 1999'); +var elMateixGranDia = new Date(); +elMateixGranDia.setTime(elGranDia.getTime()); +</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.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.27', 'Date.prototype.setTime')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.settime', 'Date.prototype.setTime')}}</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 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("Date.prototype.getTime()")}}</li> + <li>{{jsxref("Date.prototype.setUTCHours()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/date/setutcdate/index.html b/files/ca/web/javascript/referencia/objectes_globals/date/setutcdate/index.html new file mode 100644 index 0000000000..109178f66a --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/date/setutcdate/index.html @@ -0,0 +1,119 @@ +--- +title: Date.prototype.setUTCDate() +slug: Web/JavaScript/Referencia/Objectes_globals/Date/setUTCDate +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCDate +--- +<div>{{JSRef}}</div> + +<p>El mètode <strong><code>setUTCDate()</code></strong> assigna el dia del mes per a una data especificada, en temps universal.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>objecteData</var>.setUTCDate(dia)</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>dia</code></dt> + <dd>Un nombre sencer de 1 a 31, que representa el dia del mes.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>If a parameter you specify is outside of the expected range, <code>setUTCDate()</code> attempts to update the date information in the {{jsxref("Date")}} object accordingly. For example, if you use 40 for <code>dayValue</code>, and the month stored in the {{jsxref("Date")}} object is June, the day will be changed to 10 and the month will be incremented to July.</p> + +<p>Si es passa un paràmetre que està fora del rang esperat, el mètode <code>setUTCDate()</code> actualitza els altres paràmetres per a acceptar el nombre. Per exemple, si es passa 40 com a <code>dia</code>, i el mes especificat a l'objecte {{jsxref("Date")}} és juny, el dia es canviarà a 10 i el mes serà incrementat a juliol.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_setUTCDate()">Utilitzar <code>setUTCDate()</code></h3> + +<pre class="brush: js">var elGranDia = new Date(); +elGranDia.setUTCDate(20); +</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.3.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.37', 'Date.prototype.setUTCDate')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.setutcdate', 'Date.prototype.setUTCDate')}}</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 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("Date.prototype.getUTCDate()")}}</li> + <li>{{jsxref("Date.prototype.setDate()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/date/setutcfullyear/index.html b/files/ca/web/javascript/referencia/objectes_globals/date/setutcfullyear/index.html new file mode 100644 index 0000000000..55185a431b --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/date/setutcfullyear/index.html @@ -0,0 +1,123 @@ +--- +title: Date.prototype.setUTCFullYear() +slug: Web/JavaScript/Referencia/Objectes_globals/Date/setUTCFullYear +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCFullYear +--- +<div>{{JSRef}}</div> + +<p>El mètode <strong><code>setUTCFullYear()</code></strong> assigna l'any sencer a la data especificada d'acord amb el temps universal.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>objecteData</var>.setUTCFullYear(any[, mes[, dia]])</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>any</code></dt> + <dd>Un nombre sencer que representa el valor numèric de l'any, per exemple, 1995.</dd> + <dt><code>mes</code></dt> + <dd>Un nombre sencer entre 0 i 11 que representa el mes.</dd> + <dt><code>dia</code></dt> + <dd>Opcional. Un nombre sencer entre 1 i 31 que representa el dia del mes. Si s'especifica el paràmetre <code>dia</code>, també s'ha d'especificar el paràmetre <code>mes</code>.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Si no s'especifica els paràmetres <code>mes</code> o <code>dia</code> s'utilitza el valor retornat pels mètodes <a href="https://developer.mozilla.org/ca/docs/Web/JavaScript/Referencia/Objectes_globals/Date/getMonth" title="El mètode getMonth() retorna el mes de la data especificada d'acord al temps local, representat per un nombre a partir de zero (on zero indica el primer mes de l'any)."><code>getMonth()</code></a> i <a class="new" href="https://developer.mozilla.org/ca/docs/Web/JavaScript/Referencia/Objectes_globals/Date/getDate" title="Aquesta pàgina encara no ha estat traduïda. Si us plau considera contribuir-hi!"><code>getDate()</code></a>.</p> + +<p>Si es passa un paràmetre que està fora del rang esperat, el mètode <code>setUTCFullYear()</code> actualitza els altres paràmetres per a acceptar el nombre. Per exemple, si es passa 15 com a <code>mes</code>, l'any serà incrementat en 1 (<code>any + 1</code>), i s'emprarà 3 com a <code>mes</code>.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_setUTCFullYear()">Utilitzar <code>setUTCFullYear()</code></h3> + +<pre class="brush: js">var elGranDia = new Date(); +elGranDia.setUTCFullYear(1997); +</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.3.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.41', 'Date.prototype.setUTCFullYear')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.setutcfullyear', 'Date.prototype.setUTCFullYear')}}</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 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("Date.prototype.getUTCFullYear()")}}</li> + <li>{{jsxref("Date.prototype.setFullYear()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/date/setutchours/index.html b/files/ca/web/javascript/referencia/objectes_globals/date/setutchours/index.html new file mode 100644 index 0000000000..3c75ea903c --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/date/setutchours/index.html @@ -0,0 +1,125 @@ +--- +title: Date.prototype.setUTCHours() +slug: Web/JavaScript/Referencia/Objectes_globals/Date/setUTCHours +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCHours +--- +<div>{{JSRef}}</div> + +<p>El mètode <strong><code>setUTCHours()</code></strong> assigna l'hora per a una data especificada d'acord al temps universal, i retorna el nombre de milisegons que han passat des de l'ú de gener de 1970 00:00:00 UTC fins al temps representat per l'instància {{jsxref("Date")}} actualitzada.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>objecteData</var>.setUTCHours(hores[, minuts[, segons[, milisegons]]])</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>hores</code></dt> + <dd>Un nombre sencer entre 0 i 23, que representa l'hora.</dd> + <dt><code>minuts</code></dt> + <dd>Opcional. Un nombre sencer entre 0 i 59 que representa els minuts.</dd> + <dt><code>segons</code></dt> + <dd>Oppcional. Un nombre sencer entre 0 i 59 que representa els segons. Si s'especifica <code>segons</code> també s'ha d'expecificar <code>minuts</code>.</dd> + <dt><code>milisegons</code></dt> + <dd>Opcional. Un nombre sencer entre 0 i 999 que representa els milisegons. Si s'especifica <code>milisegons</code> també s'han d'especificar <code>minuts</code> i <code>segons</code>.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Si no s'especifica els paràmetres <code>minuts</code>, <code>segons</code> o <code>milisegons</code> s'utilitza el valor retornat pels mètodes {{jsxref("Date.prototype.getUTCMinutes()", "getUTCMinutes()")}}, {{jsxref("Date.prototype.getUTCSeconds()", "getUTCSeconds()")}}, i {{jsxref("Date.prototype.getUTCMilliseconds()", "getUTCMilliseconds()")}}.</p> + +<p>Si es passa un paràmetre que està fora del rang esperat, el mètode <code>setUTCHours()</code> actualitza els altres paràmetres per a acceptar el nombre. Per exemple, si es passa 100 com a <code>segons</code>, els minuts seran incrementats en 1 (<code>minuts + 1</code>), i s'emprarà 40 com a <code>segons</code>.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_setUTCHours()">Utilitzar <code>setUTCHours()</code></h3> + +<pre class="brush: js">var elGranDia = new Date(); +elGranDia.setUTCHours(8); +</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.3.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.35', 'Date.prototype.setUTCHours')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.setutchours', 'Date.prototype.setUTCHours')}}</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 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("Date.prototype.getUTCHours()")}}</li> + <li>{{jsxref("Date.prototype.setHours()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/date/setutcmilliseconds/index.html b/files/ca/web/javascript/referencia/objectes_globals/date/setutcmilliseconds/index.html new file mode 100644 index 0000000000..e3265e247f --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/date/setutcmilliseconds/index.html @@ -0,0 +1,117 @@ +--- +title: Date.prototype.setUTCMilliseconds() +slug: Web/JavaScript/Referencia/Objectes_globals/Date/setUTCMilliseconds +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCMilliseconds +--- +<div>{{JSRef}}</div> + +<p>El mètode <strong><code>setUTCMilliseconds()</code></strong> assigna els milisegons a la data sepecificada d'acord l'hora local.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>objecteData</var>.setUTCMilliseconds(<em>milisegons</em>)</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>milisegons</code></dt> + <dd>Un nombre sencer entre 0 i 999 que representa els milisegons.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Si es passa un paràmetre que està fora del rang esperat, el mètode <code>setUTCMilliseconds()</code> actualitza els altres paràmetres per a acceptar el nombre. Per exemple, si es passa 1100 com a <code>milisegons</code>, els segons seran incrementats en 1 (<code>segons + 1</code>), i s'emprarà 100 com a <code>milisegons</code>.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_setUTCMilliseconds()">Utilitzar <code>setUTCMilliseconds()</code></h3> + +<pre class="brush: js">var elGranDia = new Date(); +elGranDia.setUTCMilliseconds(500); +</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.3.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.29', 'Date.prototype.setUTCMilliseconds')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.setutcmilliseconds', 'Date.prototype.setUTCMilliseconds')}}</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 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("Date.prototype.getUTCMilliseconds()")}}</li> + <li>{{jsxref("Date.prototype.setMilliseconds()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/date/setutcminutes/index.html b/files/ca/web/javascript/referencia/objectes_globals/date/setutcminutes/index.html new file mode 100644 index 0000000000..5551364e52 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/date/setutcminutes/index.html @@ -0,0 +1,123 @@ +--- +title: Date.prototype.setUTCMinutes() +slug: Web/JavaScript/Referencia/Objectes_globals/Date/setUTCMinutes +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCMinutes +--- +<div>{{JSRef}}</div> + +<p>El mètode <strong><code>setUTCMinutes()</code></strong> assigna els minuts per a la data especificada, segons l'hora local.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>objecteData</var>.setUTCMinutes(<em>minuts</em>[, <em>segons</em>[, <em>milisegons</em>]])</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>minuts</code></dt> + <dd>Un nombre sencer entre 0 i 59, que representa els minuts.</dd> + <dt><code>segons</code></dt> + <dd>Oppcional. Un nombre sencer entre 0 i 59 que representa els segons. Si s'especifica <code>segons</code> també s'ha d'expecificar <code>minuts</code>.</dd> + <dt><code>milisegons</code></dt> + <dd>Opcional. Un nombre sencer entre 0 i 999 que representa els milisegons. Si s'especifica <code>milisegons</code> també s'han d'especificar <code>minuts</code> i <code>segons</code>.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Si no s'especifica els paràmetres <code>segons</code> o <code>milisegons</code> s'utilitza el valor retornat pels mètodes {{jsxref("Date.prototype.getUTCSeconds()", "getUTCSeconds()")}} i {{jsxref("Date.prototype.getUTCMilliseconds()", "getUTCMilliseconds()")}}.</p> + +<p>Si es passa un paràmetre que està fora del rang esperat, el mètode <code>setUTCMinutes()</code> actualitza els altres paràmetres per a acceptar el nombre. Per exemple, si es passa 100 com a <code>segons</code>, els minuts seran incrementats en 1 (<code>minuts + 1</code>), i s'emprarà 40 com a <code>segons</code>.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_setUTCMinutes()">Utilitzar <code>setUTCMinutes()</code></h3> + +<pre class="brush: js">var elGranDia = new Date(); +elGranDia.setUTCMinutes(43); +</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.3.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.33', 'Date.prototype.setUTCMinutes')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.setutcminutes', 'Date.prototype.setUTCMinutes')}}</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 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("Date.prototype.getUTCMinutes()")}}</li> + <li>{{jsxref("Date.prototype.setMinutes()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/date/setutcmonth/index.html b/files/ca/web/javascript/referencia/objectes_globals/date/setutcmonth/index.html new file mode 100644 index 0000000000..e06f0fba64 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/date/setutcmonth/index.html @@ -0,0 +1,121 @@ +--- +title: Date.prototype.setUTCMonth() +slug: Web/JavaScript/Referencia/Objectes_globals/Date/setUTCMonth +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCMonth +--- +<div>{{JSRef}}</div> + +<p>El mètode <strong><code>setUTCMonth()</code></strong> assigna el mes per a la data especificada segons el temps universal.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>objecteData</var>.setUTCMonth(mes[, dia])</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>mes</code></dt> + <dd>Un nombre sencer entre 0 i 11 que representa els mesos des de gener fins a desembre</dd> + <dt><code>dia</code></dt> + <dd>Opcional. Un nombre sencer entre 1 i 31 que representa el dia del mes.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Si no s'especifica el paràmetre <code>dia</code> s'utilitza el valor retornat pel mètode.{{jsxref("Date.prototype.getUTCDate()", "getUTCDate()")}}.</p> + +<p>Si es passa un paràmetre que està fora del rang esperat, el mètode <code>setUTCMonth()</code> actualitza els altres paràmetres per a acceptar el nombre. Per exemple, si es passa 15 com a mes, l'any serà incrementat en 1 (<code>any + 1</code>), i s'emprarà 3 com a mes.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_setUTCMonth()">Utilitzar <code>setUTCMonth()</code></h3> + +<pre class="brush: js">var elGranDia = new Date(); +elGranDia.setUTCMonth(11); +</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.3.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.39', 'Date.prototype.setUTCMonth')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.setutcmonth', 'Date.prototype.setUTCMonth')}}</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 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("Date.prototype.getUTCMonth()")}}</li> + <li>{{jsxref("Date.prototype.setMonth()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/date/setutcseconds/index.html b/files/ca/web/javascript/referencia/objectes_globals/date/setutcseconds/index.html new file mode 100644 index 0000000000..66f33a9e1b --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/date/setutcseconds/index.html @@ -0,0 +1,121 @@ +--- +title: Date.prototype.setUTCSeconds() +slug: Web/JavaScript/Referencia/Objectes_globals/Date/setUTCSeconds +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCSeconds +--- +<div>{{JSRef}}</div> + +<p>El mètode <strong><code>setUTCSeconds()</code></strong> assigna els segons a la data especificada, segons el temps universal.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>objecteData</var>.setUTCSeconds(<em>segons</em>[, <em>milisegons</em>])</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>segons</code></dt> + <dd>Un nombre sencer entre 0 i 59 que representa els segons.</dd> + <dt><code>milisegons</code></dt> + <dd>Opcional. Un nombre sencer entre 0 i 999 que representa els milisegons.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Si no s'especifica el paràmetre <code>milisegons</code> s'utilitza el valor retornat pel mètode {{jsxref("Date.prototype.getUTCMilliseconds()", "getUTCMilliseconds()")}}.</p> + +<p>Si es passa un paràmetre que està fora del rang esperat, el mètode <code>setUTCSeconds()</code> actualitza els altres paràmetres per a acceptar el nombre. Per exemple, si es passa 100 com a <code>segons</code>, els minuts seran incrementats en 1 (<code>minuts + 1</code>), i s'emprarà 40 com a <code>segons</code>.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_setUTCSeconds()">Utilitzar <code>setUTCSeconds()</code></h3> + +<pre class="brush: js">var elGranDia = new Date(); +elGranDia.setUTCSeconds(20); +</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.3.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.31', 'Date.prototype.setUTCSeconds')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.setutcseconds', 'Date.prototype.setUTCSeconds')}}</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 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("Date.prototype.getUTCSeconds()")}}</li> + <li>{{jsxref("Date.prototype.setSeconds()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/date/setyear/index.html b/files/ca/web/javascript/referencia/objectes_globals/date/setyear/index.html new file mode 100644 index 0000000000..ead16f2d21 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/date/setyear/index.html @@ -0,0 +1,124 @@ +--- +title: Date.prototype.setYear() +slug: Web/JavaScript/Referencia/Objectes_globals/Date/setYear +translation_of: Web/JavaScript/Reference/Global_Objects/Date/setYear +--- +<div>{{JSRef}} {{deprecated_header}}</div> + +<p>El mètode <strong><code>setYear()</code></strong> assigna l'any per a una data especificada, d'acord a l'hora local. Com que <code>setYear()</code> no utilitza anys complerts ("el problema de l'any 2000"), aquest mètode està en desús i s'ha reemplaçat pel mètode {{jsxref("Date.prototype.setFullYear()", "setFullYear()")}}.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>objecteData</var>.setYear(any)</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>any</code></dt> + <dd>Un nombre sencer.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Si <code>any</code> és un nombre entre 0 i 99 (inclòs), llavors s'assigna <code>1900 + any</code> a <code>objecteData</code>. En cas contrari, s'assigna <code>any</code> a <code>objecteData</code>.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_setYear()">Utilitzar <code>setYear()</code></h3> + +<p>Les dues primeres línies assignen el valor 1996 a l'any. La tercera línia assigna el valor 2000 a l'any.</p> + +<pre class="brush: js">var elGranDia = new Date(); + +elGranDia.setYear(96); +elGranDia.setYear(1996); +elGranDia.setYear(2000); +</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.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-B.2.5', 'Date.prototype.getYear')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Definit a l'annex de compatibilitat (informatiu).</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.setyear', 'Date.prototype.getYear')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definit a l'annex de característiques adicionals per a navegadors web (normatiu).</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>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("Date.prototype.getFullYear()")}}</li> + <li>{{jsxref("Date.prototype.getUTCFullYear()")}}</li> + <li>{{jsxref("Date.prototype.setFullYear()")}}</li> + <li>{{jsxref("Date.prototype.setUTCFullYear()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/date/todatestring/index.html b/files/ca/web/javascript/referencia/objectes_globals/date/todatestring/index.html new file mode 100644 index 0000000000..9548215179 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/date/todatestring/index.html @@ -0,0 +1,115 @@ +--- +title: Date.prototype.toDateString() +slug: Web/JavaScript/Referencia/Objectes_globals/Date/toDateString +translation_of: Web/JavaScript/Reference/Global_Objects/Date/toDateString +--- +<div>{{JSRef}}</div> + +<p>El mètode <strong><code>toDateString()</code></strong> retorna la part de la data d'un objecte {{jsxref("Date")}} en un format entenible per persones en anglés amerià.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>objecteData</var>.toDateString()</code></pre> + +<h2 id="Descripció">Descripció</h2> + +<p>Les instàncies de <a href="https://developer.mozilla.org/ca/docs/Web/JavaScript/Referencia/Objectes_globals/Date" title="Crea una instància de tipus Date de JavaScript, que representa un únic moment en el temps. Els objectes de tipus Date es basen en un valor de temps que mesura el nombre de milisegons que han passat des de l'u de gener de 1970 UTC."><code>Date</code></a> representen un punt específic en el temps. Una crida al mètode <a href="https://developer.mozilla.org/ca/docs/Web/JavaScript/Referencia/Objectes_globals/Date/toString" title="El mètode toString() retorna un string que representa l'objecte Date especificat."><code>toString()</code></a> retornarà la dada en un format entenible per persones, en anglés americà. Al motor <a href="https://developer.mozilla.org/en-US/docs/SpiderMonkey">SpiderMonkey</a>, aquest format consisteix en la part de la data (dia, mes i any) seguida de la part de l'hora (hores, minuts, segons i zona horària). De vegades és convenient obtenir un string només de la part de l'hora; aquesta és la raó de ser del mètode <code>toDateString()</code>.</p> + +<p>El mètode <code>toDateString()</code> resulta especialment útil perquè els motors que compleixen amb el standard <a href="https://developer.mozilla.org/en-US/docs/ECMAScript">ECMA-262</a> poden retornar resultats diferents al string obtingut mitjançant el mètode <a href="https://developer.mozilla.org/ca/docs/Web/JavaScript/Referencia/Objectes_globals/Date/toString" title="El mètode toString() retorna un string que representa l'objecte Date especificat."><code>toString()</code></a> en objectes <a href="https://developer.mozilla.org/ca/docs/Web/JavaScript/Referencia/Objectes_globals/Date" title="Crea una instància de tipus Date de JavaScript, que representa un únic moment en el temps. Els objectes de tipus Date es basen en un valor de temps que mesura el nombre de milisegons que han passat des de l'u de gener de 1970 UTC."><code>Date</code></a>, ja que el format depèn totalment de la implementació; això implica que partir el string per a obtenir només la part de temps pot no produïr un resultat consistent en tots els motors.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Ús_bàsic_de_toDateString()">Ús bàsic de <code>toDateString()</code></h3> + +<pre class="brush: js">var d = new Date(1993, 6, 28, 14, 39, 7); + +console.log(d.toString()); // imprimeix Wed Jul 28 1993 14:39:07 GMT-0600 (PDT) +console.log(d.toDateString()); // imprimeix Wed Jul 28 1993 +</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.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.3', 'Date.prototype.toDateString')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.todatestring', 'Date.prototype.toDateString')}}</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 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("Date.prototype.toLocaleDateString()")}}</li> + <li>{{jsxref("Date.prototype.toTimeString()")}}</li> + <li>{{jsxref("Date.prototype.toString()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/date/togmtstring/index.html b/files/ca/web/javascript/referencia/objectes_globals/date/togmtstring/index.html new file mode 100644 index 0000000000..08e63be739 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/date/togmtstring/index.html @@ -0,0 +1,115 @@ +--- +title: Date.prototype.toGMTString() +slug: Web/JavaScript/Referencia/Objectes_globals/Date/toGMTString +translation_of: Web/JavaScript/Reference/Global_Objects/Date/toGMTString +--- +<div>{{JSRef}} {{deprecated_header}}</div> + +<p>El mètode <strong><code>toGMTString()</code></strong> converteix una data a un string, utilitzant les convencions del Greenwich Mean Time (GMT). El format exacte del valor retornat per <code>toGMTString()</code> és depenent de la plataforma i el navegador, per norma general hauria de representar la data en una forma entenible per persones.</p> + +<div class="note"> +<p><strong>Nota:</strong> <code>toGMTString()</code> està en desús i no es recomana fer-lo servir més. Es mantè només per a compatibilitat amb codi vell que l'utilitzi; en comptes d'aquest mètode utilitzeu {{jsxref("Date.prototype.toUTCString()", "toUTCString()")}}.</p> +</div> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>objecteData</var>.toGMTString()</code></pre> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Exemple_senzill">Exemple senzill</h3> + +<p>En aquest exemple el mètode <code>toGMTString()</code> converteix la data a GMT (UTC) utilitzant el desplaçament de zona horaria donat pel sistema operatiu i retorna un valor string que té aproximadament la forma que trobareu a continuació. El format exacte dependrà de la plataforma.</p> + +<pre class="brush: js">var avui = new Date(); +var str = avui.toGMTString(); // en desús! utilitzeu toUTCString() + +console.log(str); // Mon, 18 Dec 1995 17:28:35 GMT +</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, però ja marcat com a en desús. Implementat a JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-B.2.6', 'Date.prototype.toGMTString')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Definit a l'annex de compatibilitat (informatiu).</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.togmtstring', 'Date.prototype.toGMTString')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definit a l'annex per a característiques adicionals per a navegadors web (normatiu).</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>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("Date.prototype.toLocaleDateString()")}}</li> + <li>{{jsxref("Date.prototype.toTimeString()")}}</li> + <li>{{jsxref("Date.prototype.toUTCString()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/date/toisostring/index.html b/files/ca/web/javascript/referencia/objectes_globals/date/toisostring/index.html new file mode 100644 index 0000000000..759e53225c --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/date/toisostring/index.html @@ -0,0 +1,134 @@ +--- +title: Date.prototype.toISOString() +slug: Web/JavaScript/Referencia/Objectes_globals/Date/toISOString +translation_of: Web/JavaScript/Reference/Global_Objects/Date/toISOString +--- +<div>{{JSRef}}</div> + +<p>El mètode <strong><code>toISOString()</code></strong> retorna una cadena en un format ISO extès<em> simplificat </em>(<a href="http://en.wikipedia.org/wiki/ISO_8601">ISO 8601</a>), el qual sempre té 24 caràcters de llargària: <strong><code>YYYY-MM-DDTHH:mm:ss.sssZ</code></strong>. La zona horària és sempre UTC, tal i com indica el sufix <code>"Z"</code>.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.toISOString()</code></pre> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_toISOString()">Utilitzar <code>toISOString()</code></h3> + +<pre class="brush: js">var today = new Date('05 October 2011 14:48 UTC'); + +console.log(today.toISOString()); // Retorna 2011-10-05T14:48:00.000Z +</pre> + +<p>L'exemple anterior interpreta una cadena no estàndard que pot no ser interpretada correctament per navegadors que no siguin mozilla.</p> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Aquest mètode es va estandaritzar en la 5a edició d'ECMA-262. Els motors que no s'hagin actualitzat per suportar aquest mètode poden evitar al mancança d'aquest mètode utilitzant les següents accions:</p> + +<pre class="brush: js">if (!Date.prototype.toISOString) { + (function() { + + function pad(number) { + if (number < 10) { + return '0' + number; + } + return number; + } + + Date.prototype.toISOString = function() { + return this.getUTCFullYear() + + '-' + pad(this.getUTCMonth() + 1) + + '-' + pad(this.getUTCDate()) + + 'T' + pad(this.getUTCHours()) + + ':' + pad(this.getUTCMinutes()) + + ':' + pad(this.getUTCSeconds()) + + '.' + (this.getUTCMilliseconds() / 1000).toFixed(3).slice(2, 5) + + 'Z'; + }; + + }()); +} +</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.9.5.43', 'Date.prototype.toISOString')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Definició inicial. Implementat en JavaScript 1.8.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.toisostring', 'Date.prototype.toISOString')}}</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>{{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 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("Date.prototype.toLocaleDateString()")}}</li> + <li>{{jsxref("Date.prototype.toTimeString()")}}</li> + <li>{{jsxref("Date.prototype.toUTCString()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/date/tojson/index.html b/files/ca/web/javascript/referencia/objectes_globals/date/tojson/index.html new file mode 100644 index 0000000000..8b583470bf --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/date/tojson/index.html @@ -0,0 +1,108 @@ +--- +title: Date.prototype.toJSON() +slug: Web/JavaScript/Referencia/Objectes_globals/Date/toJSON +translation_of: Web/JavaScript/Reference/Global_Objects/Date/toJSON +--- +<div>{{JSRef}}</div> + +<p>El mètode <strong><code>toJSON()</code></strong> retorna una representació de tipus cadena de l'objecte {{jsxref("Date")}}.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.toJSON()</code></pre> + +<h2 id="Descripció">Descripció</h2> + +<p>Les instàncies {{jsxref("Date")}} referencien a un punt concret en el temps. La crida <code>toJSON()</code> retorna una cadena (usant {{jsxref("Date.prototype.toISOString()", "toISOString()")}}) en representació del valor de l'objecte {{jsxref("Date")}}. Generalment aquest mètode s'utilitza, per defecte, per serialitzar eficaçment objectes {{jsxref("Date")}} durant la serialització {{Glossary("JSON")}}.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_toJSON()">Utilitzar <code>toJSON()</code></h3> + +<pre class="brush:js">var jsonDate = (new Date()).toJSON(); +var backToDate = new Date(jsonDate); + +console.log(jsonDate); //2015-10-26T07:46:36.611Z +</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.9.5.44', 'Date.prototype.toJSON')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Definició inicial. Implementat en JavaScript 1.8.5.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.tojson', 'Date.prototype.toJSON')}}</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("Date.prototype.toLocaleDateString()")}}</li> + <li>{{jsxref("Date.prototype.toTimeString()")}}</li> + <li>{{jsxref("Date.prototype.toUTCString()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/date/tostring/index.html b/files/ca/web/javascript/referencia/objectes_globals/date/tostring/index.html new file mode 100644 index 0000000000..8482fe5298 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/date/tostring/index.html @@ -0,0 +1,142 @@ +--- +title: Date.prototype.toString() +slug: Web/JavaScript/Referencia/Objectes_globals/Date/toString +translation_of: Web/JavaScript/Reference/Global_Objects/Date/toString +--- +<div>{{JSRef}}</div> + +<p>El mètode <strong><code>toString()</code></strong> retorna un string que representa l'objecte {{jsxref("Date")}} especificat.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>objecteDate</var>.toString()</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<p>Cap.</p> + +<h2 id="Descripció">Descripció</h2> + +<p>L'objecte {{jsxref("Date")}} sobreescriu el mètode <code>toString()</code> de l'objecte {{jsxref("Object")}}; no hereta {{jsxref("Object.prototype.toString()")}}. Per a objectes {{jsxref("Date")}}, el mètode <code>toString()</code> retorna un string que representa l'objecte.</p> + +<p>El mètode <code>toString()</code> sempre retorna una representació en forma de string de la data en anglés americà.</p> + +<p>JavaScript cridarà el mètode <code>toString()</code> de manera automàtica quan una data requereix ser representada com a text o bé quan una data formi part d'una concatenació de strings.</p> + +<p>El mètode <code>toString()</code> és genèric. Si <code>this</code> no fa referència a una instància de {{jsxref("Date")}}, retornarà "Invalid Date".</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_toString()">Utilitzar <code>toString()</code></h3> + +<p>L'exemple següent assigna el valor de <code>toString()</code> d'un objecte {{jsxref("Date")}} a <code>myVar</code>:</p> + +<pre class="brush: js">var x = new Date(); +myVar = x.toString(); // assigna un valor a myVar simimlar a: +// Mon Sep 28 1998 14:36:22 GMT-0700 (Pacific Daylight Time) +</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.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.2', 'Date.prototype.toLocaleTimeString')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.tostring', 'Date.prototype.toString')}}</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> + <tr> + <td>Mètode genèric</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatGeckoDesktop("41")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>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> + <tr> + <td>Mètode genèric</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatGeckoMobile("41")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Object.prototype.toString()")}}</li> + <li>{{jsxref("Date.prototype.toDateString()")}}</li> + <li>{{jsxref("Date.prototype.toLocaleString()")}}</li> + <li>{{jsxref("Date.prototype.toTimeString()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/date/totimestring/index.html b/files/ca/web/javascript/referencia/objectes_globals/date/totimestring/index.html new file mode 100644 index 0000000000..aac8de7a85 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/date/totimestring/index.html @@ -0,0 +1,115 @@ +--- +title: Date.prototype.toTimeString() +slug: Web/JavaScript/Referencia/Objectes_globals/Date/toTimeString +translation_of: Web/JavaScript/Reference/Global_Objects/Date/toTimeString +--- +<div>{{JSRef}}</div> + +<p>El mètode <strong><code>toTimeString()</code></strong> retorna la part de temps d'un objecte de tipus {{jsxref("Date")}} formatada de tal forma que és entenible per les persones, utilitzan anglés americà.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>objecteData</var>.toTimeString()</code></pre> + +<h2 id="Descripció">Descripció</h2> + +<p>Les instàncies de {{jsxref("Date")}} representen un punt específic en el temps. Una crida al mètode {{jsxref("Date.prototype.toString()", "toString()")}} retornarà la dada en un format entenible per persones, en anglés americà. Al motor <a href="/en-US/docs/SpiderMonkey">SpiderMonkey</a>, aquest format consisteix en la part de la data (dia, mes i any) seguida de la part de l'hora (hores, minuts, segons i zona horària). De vegades és convenient obtenir un string només de la part de l'hora; aquesta és la raó de ser del mètode <code>toTimeString()</code>.</p> + +<p>El mètode <code>toTimeString()</code> resulta especialment útil perquè els motors que compleixen amb el standard <a href="/en-US/docs/ECMAScript">ECMA-262</a> poden retornar resultats diferents al string obtingut mitjançant el mètode {{jsxref("Date.prototype.toString()", "toString()")}} en objectes {{jsxref("Date")}}, ja que el format depèn totalment de la implementació; això implica que partir el string per a obtenir només la part de temps pot no produïr un resultat consistent en tots els motors.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilització_bàsica_de_toTimeString()">Utilització bàsica de <code>toTimeString()</code></h3> + +<pre class="brush: js">var d = new Date(1993, 6, 28, 14, 39, 7); + +console.log(d.toString()); // escriu Wed Jul 28 1993 14:39:07 GMT-0600 (PDT) +console.log(d.toTimeString()); // escriu 14:39:07 GMT-0600 (PDT) +</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.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.5.4', 'Date.prototype.toTimeString')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.totimestring', 'Date.prototype.toTimeString')}}</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 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("Date.prototype.toLocaleTimeString()")}}</li> + <li>{{jsxref("Date.prototype.toDateString()")}}</li> + <li>{{jsxref("Date.prototype.toString()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/date/utc/index.html b/files/ca/web/javascript/referencia/objectes_globals/date/utc/index.html new file mode 100644 index 0000000000..37bb2bc369 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/date/utc/index.html @@ -0,0 +1,142 @@ +--- +title: Date.UTC() +slug: Web/JavaScript/Referencia/Objectes_globals/Date/UTC +translation_of: Web/JavaScript/Reference/Global_Objects/Date/UTC +--- +<div>{{JSRef}}</div> + +<p>El mètode <strong><code>Date.UTC()</code></strong> accepta els mateixos paràmetres que la forma més llarga del constructor, i retorna en un objecte de tipus {{jsxref("Date")}} el nombre de milisegons que han passat des de l'u de gener de 1970 a les 00:00:00, temps universal.</p> + +<h2 id="Syntax" name="Syntax">Sintaxi</h2> + +<pre class="syntaxbox"><code>Date.UTC(any, mes[, dia[, hora[, minuts[, segons[, <var>milisegons</var>]]]]])</code></pre> + +<h3 id="Parameters" name="Parameters">Paràmetres</h3> + +<dl> + <dt><code>any</code></dt> + <dd>Un any major que 1900.</dd> + <dt><code>mes</code></dt> + <dd>Un nombre sencer entre 0 i 11 que representa el mes.</dd> + <dt><code>dia</code></dt> + <dd>Opcional. Un nombre sencer entre 1 i 31 que representa el dia del mes.</dd> + <dt><code>hora</code></dt> + <dd>Opcional. Un nombre sencer entre 0 i 23 que representa l'hora.</dd> + <dt><code>minuts</code></dt> + <dd>Opcional. Un nombre sencer entre 0 i 59 que representa els minuts.</dd> + <dt><code>segons</code></dt> + <dd>Opcional. Un nombre sencer entre 0 i 59 que representa els segons.</dd> + <dt><code>milisegons</code></dt> + <dd>Opcional. Un nombre sencer entre 0 i 999 que representa els milisegons.</dd> +</dl> + +<h2 id="Description" name="Description">Descripció</h2> + +<p><code>UTC()</code> accepta una data en forma de paràmetres separats per comes i retorna el nombre de milisegons que han passat entre l'u de gener de 1970 a les 00:00:00 en temps universal, i el temps especificat pels paràmetres.</p> + +<p>L'any ha de ser especificat plenament; per exemple, 1998. Si s'especifica un any entre 0 i 99, el mètode el converteix a un any del segle 20 (<code>1900 + any</code>); per exemple, si s'especifica 95, s'emprarà l'any 1995.</p> + +<p>El mètode <code>UTC()</code> es diferencia del constructor {{jsxref("Date")}} en dues coses.</p> + +<ul> + <li><code>Date.UTC()</code> utilitza el temps universal en comptes del temps local.</li> + <li><code>Date.UTC()</code> retorna el temps com a nombre en comptes de crear un objecte de tipus {{jsxref("Date")}}.</li> +</ul> + +<p>Si es passa un paràmetre que està fora del rang esperat, el mètode <code>UTC()</code> actualitza els altres paràmetres per a acceptar el nombre. Per exemple, si es passa 15 com a mes, l'any serà incrementat en 1 (<code>any + 1</code>), i s'emprarà 3 com a mes.</p> + +<p>Com que <code>UTC()</code> és un mètode estàtic de {{jsxref("Date")}}, sempre es crida com a <code>Date.UTC()</code> en comptes de com un mètode d'una instància de {{jsxref("Date")}}.</p> + +<h2 id="Examples" name="Examples">Exemples</h2> + +<h3 id="Example:_Using_Date.UTC" name="Example:_Using_Date.UTC">Utilitzar <code>Date.UTC()</code></h3> + +<p>La instrucció següent crea un objecte {{jsxref("Date")}} utilitzant temps UTC en comptes del temps local:</p> + +<pre class="brush:js">var dataUTC = new Date(Date.UTC(96, 11, 1, 0, 0, 0)); +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.utc', 'Date.UTC')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.9.4.3', 'Date.UTC')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definició inicial. Implementat a JavaScript 1.0.</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ísica</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ísica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li>{{jsxref("Date.parse()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/date/valueof/index.html b/files/ca/web/javascript/referencia/objectes_globals/date/valueof/index.html new file mode 100644 index 0000000000..6c5f810ead --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/date/valueof/index.html @@ -0,0 +1,118 @@ +--- +title: Date.prototype.valueOf() +slug: Web/JavaScript/Referencia/Objectes_globals/Date/valueOf +translation_of: Web/JavaScript/Reference/Global_Objects/Date/valueOf +--- +<div>{{JSRef}}</div> + +<p>El mètode<strong> <code>valueOf()</code></strong> retorna el valor primitiu d'un objecte de tipus {{jsxref("Date")}}.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>dateObj</var>.valueOf()</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<p>Cap.</p> + +<h2 id="Descripció">Descripció</h2> + +<p>El mètode <code>valueOf()</code> retorna el valor primitiu d'un objecte de tipus {{jsxref("Date")}} en forma de nombre, el nombre de milisegons des de la mitjanit de l'ú de gener de 1970 UTC.</p> + +<p>Aquest mètode és funcionalment equivalent al mètode {{jsxref("Date.prototype.getTime()")}}.</p> + +<p>Aquest mètode és tot sovint emprat internament per JavaScript i no explícitament en codi.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_valueOf()"><code>Utilitzar valueOf()</code></h3> + +<pre class="brush: js">var x = new Date(56, 6, 17); +var myVar = x.valueOf(); // assigna -424713600000 a myVar +</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.9.5.8', 'Date.prototype.valueOf')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-date.prototype.valueof', 'Date.prototype.valueOf')}}</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 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("Object.prototype.valueOf()")}}</li> + <li>{{jsxref("Date.prototype.getTime()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/error/columnnumber/index.html b/files/ca/web/javascript/referencia/objectes_globals/error/columnnumber/index.html new file mode 100644 index 0000000000..377c797cd3 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/error/columnnumber/index.html @@ -0,0 +1,83 @@ +--- +title: Error.prototype.columnNumber +slug: Web/JavaScript/Referencia/Objectes_globals/Error/columnNumber +translation_of: Web/JavaScript/Reference/Global_Objects/Error/columnNumber +--- +<div>{{JSRef("Global_Objects", "Error", "EvalError,InternalError,RangeError,ReferenceError,SyntaxError,TypeError,URIError")}} {{non-standard_header}}</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>La propietat <code><strong>columnNumber</strong></code> conté el nombre de la columna dins la línia del fitxer on s'ha produit l'error.</p> + +<h2 id="Examples" name="Examples">Exemples</h2> + +<h3 id="Example:_Throwing_a_custom_error" name="Example:_Throwing_a_custom_error">Exemple: Utilitzar <code>columnNumber</code></h3> + +<pre class="brush: js">var e = new Error('Error interpretant les dades'); +throw e; +console.log(e.columnNumber) // 0 +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<p>No forma part de cap especificació. No és standard.</p> + +<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>{{CompatNo}}</td> + <td>{{CompatVersionUnknown}}</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 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>{{CompatVersionUnknown}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li>{{jsxref("Error.prototype.stack")}} {{non-standard_inline}}</li> + <li>{{jsxref("Error.prototype.lineNumber")}} {{non-standard_inline}}</li> + <li>{{jsxref("Error.prototype.fileName")}} {{non-standard_inline}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/error/filename/index.html b/files/ca/web/javascript/referencia/objectes_globals/error/filename/index.html new file mode 100644 index 0000000000..dcca532f86 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/error/filename/index.html @@ -0,0 +1,87 @@ +--- +title: Error.prototype.fileName +slug: Web/JavaScript/Referencia/Objectes_globals/Error/fileName +translation_of: Web/JavaScript/Reference/Global_Objects/Error/fileName +--- +<div>{{JSRef("Global_Objects", "Error", "EvalError,InternalError,RangeError,ReferenceError,SyntaxError,TypeError,URIError")}} {{non-standard_header}}</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>La propietat <code><strong>fileName</strong></code> conté la ruta al fitxer que ha provocat aquest error.</p> + +<h2 id="Description" name="Description">Descripció</h2> + +<p>Aquesta propietat no standard conté la ruta al fitxer que ha provocat l'error. Si es crida des d'un contexte de depuració, com ara des de Firefox Developer Tools, retorna "debugger eval code".</p> + +<h2 id="Examples" name="Examples">Exemples</h2> + +<h3 id="Example:_Throwing_a_custom_error" name="Example:_Throwing_a_custom_error">Exemple: Utilitzar <code>fileName</code></h3> + +<pre class="brush: js">var e = new Error('Dades no tractades'); +throw e; +// e.fileName podria contrindre quelcom semblant a "file:///C:/example.html" +</pre> + +<h2 id="Especificacions.">Especificacions.</h2> + +<p>No format part de cap especificació. No és standard.</p> + +<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>{{CompatNo}}</td> + <td>{{CompatVersionUnknown}}</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 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>{{CompatVersionUnknown}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li>{{jsxref("Error.prototype.stack")}} {{non-standard_inline}}</li> + <li>{{jsxref("Error.prototype.columnNumber")}} {{non-standard_inline}}</li> + <li>{{jsxref("Error.prototype.lineNumber")}} {{non-standard_inline}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/error/index.html b/files/ca/web/javascript/referencia/objectes_globals/error/index.html new file mode 100644 index 0000000000..2e1592edc5 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/error/index.html @@ -0,0 +1,224 @@ +--- +title: Error +slug: Web/JavaScript/Referencia/Objectes_globals/Error +translation_of: Web/JavaScript/Reference/Global_Objects/Error +--- +<div>{{JSRef}}</div> + +<h2 id="Resum">Resum</h2> + +<p>El constructor <strong><code>Error</code></strong> crea un objecte que representa un error. Quan succeeix un error en temps d'execució JavaScript llença una instància de tipus <code>Error</code>. L'objecte <code>Error</code> també es pot emprar com a objecte base per a excepcions definides per l'usuari. Vegeu més abaix per a tipus d'errors standard que forment part del nucli.</p> + +<h2 id="Syntax" name="Syntax">Sintaxi</h2> + +<pre class="syntaxbox">new Error([missatge[, fitxer[, numeroLinia]]])</pre> + +<h3 id="Parameters" name="Parameters">Paràmetres</h3> + +<dl> + <dt><code>missatge</code></dt> + <dd>Opcional. Descripció entenible per persones de l'error.</dd> + <dt><code>fitxer</code> {{non-standard_inline}}</dt> + <dd>Opcional. El valor de la propietat <code>fitxer</code> a l'objecte <code>Error</code> creat. Per defecte pren el valor del nom del fitxer que conté el codi que ha cridat el constructor <code>Error()</code>.</dd> + <dt><code>numeroLinia</code> {{non-standard_inline}}</dt> + <dd>Opcional. El valor de la propietat <font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: rgba(220, 220, 220, 0.5);">numeroLinia</span></font> de l'objecte <code>Error</code> creat. Per defecte rep el valor del número de línia que conté la invocació al constructor <code>Error()</code>.</dd> +</dl> + +<h2 id="Description" name="Description">Descripció</h2> + +<p>Els errors en temps d'execució esdevenen objectes <code>Error</code> nous que són creats i llençats.</p> + +<p>Aquesta pàgina documenta l'ús de l'objecte <code>Error</code> en si mateix, així com el seu ús com funció constructora. Per a un llistat de les propietats i mètodes heretats per les instàncies de <code>Error</code>, vegeu {{jsxref("Error.prototype")}}.</p> + +<h3 id="Error_types" name="Error_types">Tipus d'errors</h3> + +<p>A més del construtor genèric <code>Error</code> hi ha altres sis constructors d'errors que formen part del nucli de JavaScript. Per a excepcions al cantó del client vegeu <a href="/en-US/docs/Web/JavaScript/Guide/Statements#Exception_Handling_Statements">Sentències manegadores d'excepcions</a>.</p> + +<dl> + <dt>{{jsxref("Global_Objects/EvalError", "EvalError")}}</dt> + <dd>Crea una instància que representa un error que succeeix a l'emprar la funció global {{jsxref("Global_Objects/eval", "eval()")}}.</dd> + <dt>{{jsxref("Global_Objects/InternalError", "InternalError")}} {{non-standard_inline}}</dt> + <dd>Crea una instància que representa un error que succeeix quan es llença un error intern des del motor de JavaScript. Per exemple: "massa recursivitat".</dd> + <dt>{{jsxref("Global_Objects/RangeError", "RangeError")}}</dt> + <dd>Crea una instància que representa un error que succeeix quan una variable numèrica o paràmetre està fora del seu rang vàlid.</dd> + <dt>{{jsxref("Global_Objects/ReferenceError", "ReferenceError")}}</dt> + <dd>Crea una instància que representa un error que succeeix quan es deixa de referenciar una referència invàlida.</dd> + <dt>{{jsxref("Global_Objects/SyntaxError", "SyntaxError")}}</dt> + <dd>Crea una instància que representa un error de sintaxi que succeeix a l'interpretar codi dins {{jsxref("Global_Objects/eval", "eval()")}}.</dd> + <dt>{{jsxref("Global_Objects/TypeError", "TypeError")}}</dt> + <dd>Crea una instància que representa un error que succeeix quan una variable o paràmetre és d'un tipus no vàlid.</dd> + <dt>{{jsxref("Global_Objects/URIError", "URIError")}}</dt> + <dd>Crea un error que representa un error que succeeix quan {{jsxref("Global_Objects/encodeURI", "encodeURI()")}} o {{jsxref("Global_Objects/decodeURI", "decodeURl()")}} reben paràmetres invàlids.</dd> +</dl> + +<h2 id="Properties" name="Properties">Propietats</h2> + +<dl> + <dt>{{jsxref("Error.prototype")}}</dt> + <dd>Permet afegir propietats a instàncies <code>Error</code>.</dd> +</dl> + +<h2 id="Methods" name="Methods">Mètodes</h2> + +<p>L'objecte global Error no contè mètodes propis. Tot i així, hereta alguns mètodes a través de la cadena de prototipus.</p> + +<h2 id="Error_instances" name="Error_instances"><code>Instàncies Error</code></h2> + +<div>{{page('ca/docs/JavaScript/Reference/Global_Objects/Error/prototype', 'Descripció')}}</div> + +<h3 id="Propietats">Propietats</h3> + +<div>{{page('ca/docs/JavaScript/Reference/Global_Objects/Error/prototype', 'Propietats')}}</div> + +<h3 id="Mètodes">Mètodes</h3> + +<div>{{page('ca/docs/JavaScript/Reference/Global_Objects/Error/prototype', 'Mètodes')}}</div> + +<h2 id="Examples" name="Examples">Exemples</h2> + +<h3 id="Example:_Throwing_a_generic_error" name="Example:_Throwing_a_generic_error">Exemple: Llençar un error genèric</h3> + +<p>Normalment hom crea un objecte Error amb la intenció de llençar-lo tot emprant la paraula clau {{jsxref("Statements/throw", "throw")}}. Els errors es poden manegar utilitzant la construcció {{jsxref("Statements/try...catch", "try...catch")}}:</p> + +<pre class="brush: js">try { + throw new Error('Oooops!'); +} catch (e) { + alert(e.name + ': ' + e.message); +} +</pre> + +<h3 id="Example:_Handling_a_specific_error" name="Example:_Handling_a_specific_error">Exemple: Manegar un error específic</h3> + +<p><span class="comment">this should probably be removed</span>Es pot escollir fer-se càrrec només de tipus d'errors específics comparant el tipus d'error amb la propietat {{jsxref("Object.prototype.constructor", "constructor")}} de l'error o bé, si s'està escrivint el codi per a motors JavaScript moderns, mitjançant la paraula clau {{jsxref("Operators/instanceof", "instanceof")}}:</p> + +<pre class="brush: js">try { + foo.bar(); +} catch (e) { + if (e instanceof EvalError) { + alert(e.name + ': ' + e.message); + } else if (e instanceof RangeError) { + alert(e.name + ': ' + e.message); + } + // ... etc +} +</pre> + +<h3 id="Exemple_Tipus_d'errors_personalitzats">Exemple: Tipus d'errors personalitzats</h3> + +<p>És possible definir tipus d'errors propis derivats de Error, llençar-los mitjançant <code>throw new MyError()</code> i utilitzar <code>instanceof MyError</code> per a comprovarel tipus d'error al manegador d'excepcions. A sota trobareu la forma més comuna de fer això.</p> + +<div class="warning"> +<p>Advertim que la instància <code>MyError</code> llençada reportarà <code>lineNumber</code> i <code>fileName</code> invàlids, com a mínim a Firefox.</p> +</div> + +<p>Vegeu també <a href="http://stackoverflow.com/questions/1382107/whats-a-good-way-to-extend-error-in-javascript">la discussió a StackOverflow "Quina és una bona forma d'extrendre Error a JavaScript?"</a>.</p> + +<pre class="brush: js">// Crea un nou objecte, que hereta del prototipus constructor Error. +function MyError(message) { + this.name = 'MyError'; + this.message = message || 'Missatge per defecte'; +} +MyError.prototype = Object.create(Error.prototype); +MyError.prototype.constructor = MyError; + +try { + throw new MyError(); +} catch (e) { + console.log(e.name); // 'MyError' + console.log(e.message); // 'Missatge per defecte' +} + +try { + throw new MyError('custom message'); +} catch (e) { + console.log(e.name); // 'MyError' + console.log(e.message); // 'Missatge per defecte' +} +</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.11', 'Error')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-error-objects', 'Error')}}</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 for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li>{{jsxref("Error.prototype")}}</li> + <li>{{jsxref("Statements/throw", "throw")}}</li> + <li>{{jsxref("Statements/try...catch", "try...catch")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/error/linenumber/index.html b/files/ca/web/javascript/referencia/objectes_globals/error/linenumber/index.html new file mode 100644 index 0000000000..7b85f29c19 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/error/linenumber/index.html @@ -0,0 +1,94 @@ +--- +title: Error.prototype.lineNumber +slug: Web/JavaScript/Referencia/Objectes_globals/Error/lineNumber +translation_of: Web/JavaScript/Reference/Global_Objects/Error/lineNumber +--- +<div>{{JSRef("Global_Objects", "Error", "EvalError,InternalError,RangeError,ReferenceError,SyntaxError,TypeError,URIError")}} {{non-standard_header}}</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>La propietat <code><strong>lineNumber</strong></code> conté el nombre de la línia del fitxer que ha llençat aquest erro.</p> + +<h2 id="Examples" name="Examples">Exemples</h2> + +<h3 id="Example:_Throwing_a_custom_error" name="Example:_Throwing_a_custom_error">Exemple: Utilitzar <code>lineNumber</code></h3> + +<pre class="brush: js">var e = new Error('No he pogut interpretar l\'entrada'); +throw e; +console.log(e.lineNumber) // 2 +</pre> + +<h3 id="Example:_Alternative_example_using_error_event" name="Example:_Alternative_example_using_error_event">Exemple: Exemple alternatiu usant l'event <code>error</code></h3> + +<pre class="brush: js">window.addEventListener('error', function(e) { + console.log(e.lineno); // 5 +}); +var e = new Error('No he pogut interpretar l\'entrada'); +throw e; +</pre> + +<p>Això és standard i suportat per Chrome, Firefox i provablement altres.</p> + +<h2 id="Especificacions">Especificacions</h2> + +<p>No forma part de cap especificació. No és standard.</p> + +<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>On <code>error</code> object in handled errors</td> + <td>{{CompatVersionUnknown}}</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 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>{{CompatVersionUnknown}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li>{{jsxref("Error.prototype.stack")}} {{non-standard_inline}}</li> + <li>{{jsxref("Error.prototype.columnNumber")}} {{non-standard_inline}}</li> + <li>{{jsxref("Error.prototype.fileName")}} {{non-standard_inline}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/error/message/index.html b/files/ca/web/javascript/referencia/objectes_globals/error/message/index.html new file mode 100644 index 0000000000..4aa07268fa --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/error/message/index.html @@ -0,0 +1,110 @@ +--- +title: Error.prototype.message +slug: Web/JavaScript/Referencia/Objectes_globals/Error/message +translation_of: Web/JavaScript/Reference/Global_Objects/Error/message +--- +<div>{{JSRef("Global_Objects", "Error", "EvalError,InternalError,RangeError,ReferenceError,SyntaxError,TypeError,URIError")}}</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>La propietat <code><strong>message</strong></code> és una descripció en un format amigable pels humans de l'error.</p> + +<h2 id="Description" name="Description">Descripció</h2> + +<p>Aquesta propietat conté una breu descripció de l'error sempre i quan estigui disponible o hagi sigut assignada. <a href="/ca/docs/Mozilla/Projects/SpiderMonkey">SpiderMonkey</a> fa un ús extensiu de la propietat <code>message</code> per a excepcions. El mètode {{jsxref("Error.prototype.toString()")}} utilitza la propietat <code>message</code> combinada amb la propietat {{jsxref("Error.prototype.name", "name")}} per a crear una representació de l'error.</p> + +<p>Per defecte la propietat <code>message</code> és un string buit, però aquest comportament pot ser sobreescrit per una instàcia simplement passant un missatge com a primer argument del {{jsxref("Error", "constructor Error")}}.</p> + +<h2 id="Examples" name="Examples">Exemples</h2> + +<h3 id="Example:_Throwing_a_custom_error" name="Example:_Throwing_a_custom_error">Exemple: Llençar un error personalitzat</h3> + +<pre class="brush: js">var e = new Error('No he pogut interpretar l\'entrada'); // e.message valdrà 'No he pogut interpretar l\'entrada' +throw e; +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>ECMAScript 1a Edició.</td> + <td>Standard</td> + <td>Definició inicial.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.11.4.3', 'Error.prototype.message')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-error.prototype.message', 'Error.prototype.message')}}</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 for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li>{{jsxref("Error.prototype.name")}}</li> + <li>{{jsxref("Error.prototype.toString()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/error/name/index.html b/files/ca/web/javascript/referencia/objectes_globals/error/name/index.html new file mode 100644 index 0000000000..995ecafd5f --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/error/name/index.html @@ -0,0 +1,111 @@ +--- +title: Error.prototype.name +slug: Web/JavaScript/Referencia/Objectes_globals/Error/name +translation_of: Web/JavaScript/Reference/Global_Objects/Error/name +--- +<div>{{JSRef("Global_Objects", "Error", "EvalError,InternalError,RangeError,ReferenceError,SyntaxError,TypeError,URIError")}}</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>La propietat <code><strong>name</strong></code> representa un nom per al tipus de error. El valor que rep inicialment aquesta propietat és "Error".</p> + +<h2 id="Description" name="Description">Descripció</h2> + +<p>Per defecte, les instàncies de {{jsxref("Error")}} reben el nom "Error". El mètode <a class="new" href="https://developer.mozilla.org/ca/docs/Web/JavaScript/Referencia/Objectes_standard/Error/toString" title="Aquesta pàgina encara no ha estat traduïda. Si us plau consideri contribuir-hi!"><code>Error.prototype.toString()</code></a> utilitza la propietat <code>name</code> combinada amb la propietat <a class="new" href="https://developer.mozilla.org/ca/docs/Web/JavaScript/Referencia/Objectes_standard/Error/message" title="Aquesta pàgina encara no ha estat traduïda. Si us plau consideri contribuir-hi!"><code>message</code></a> per a crear una representació de l'error.</p> + +<h2 id="Examples" name="Examples">Exemples</h2> + +<h3 id="Example:_Throwing_a_custom_error" name="Example:_Throwing_a_custom_error">Exemple: Llençar un error personalitzat</h3> + +<pre class="brush: js">var e = new Error('Entrada no vàlida'); // e.name is 'Error' + +e.name = 'ParseError'; +throw e; +// e.toString() would return 'ParseError: Entrada no vàlida' +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>ECMAScript 1a Edició.</td> + <td>Standard</td> + <td>Definició inicial.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.11.4.2', 'Error.prototype.name')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-error.prototype.name', 'Error.prototype.name')}}</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 for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li>{{jsxref("Error.prototype.message")}}</li> + <li>{{jsxref("Error.prototype.toString()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/error/prototype/index.html b/files/ca/web/javascript/referencia/objectes_globals/error/prototype/index.html new file mode 100644 index 0000000000..a4dee42923 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/error/prototype/index.html @@ -0,0 +1,150 @@ +--- +title: Error.prototype +slug: Web/JavaScript/Referencia/Objectes_globals/Error/prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Error +--- +<div>{{JSRef("Global_Objects", "Error", "EvalError,InternalError,RangeError,ReferenceError,SyntaxError,TypeError,URIError")}}</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>La propietat <code><strong>Error.prototype</strong></code> representa el prototipus per al constructor {{jsxref("Global_Objects/Error", "Error")}}.</p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Description" name="Description">Descripció</h2> + +<p>Totes les instàncies de {{jsxref("Global_Objects/Error", "Error")}} i les instàncies de {{jsxref("Global_Objects/Error", "non-generic errors", "#Error_types", 1)}} heretèn de <code>Error.prototype</code>. Com totes les funcions constructores, es pot utilitzar el prototipus del constructor per a afegir propietats o mètodes a totes les instànces creades amb aquest constructor.</p> + +<h2 id="Properties" name="Properties">Propietats</h2> + +<h3 id="Standard_properties" name="Standard_properties">Propietats standard</h3> + +<dl> + <dt><code>Error.prototype.constructor</code></dt> + <dd>Especifica la funció que ha creat la instància del prototipus.</dd> + <dt>{{jsxref("Error.prototype.message")}}</dt> + <dd>Missatge d'error.</dd> + <dt>{{jsxref("Error.prototype.name")}}</dt> + <dd>Nom de l'error.</dd> +</dl> + +<h3 id="Vendor-specific_extensions" name="Vendor-specific_extensions">Extensions específiques del venedor</h3> + +<div>{{non-standard_header}}</div> + +<h4 id="Microsoft" name="Microsoft">Microsoft</h4> + +<dl> + <dt>{{jsxref("Error.prototype.description")}}</dt> + <dd>Descripció de l'error. Similar a {{jsxref("Error.prototype.message", "message")}}.</dd> + <dt>{{jsxref("Error.prototype.number")}}</dt> + <dd>Nombre de l'error.</dd> +</dl> + +<h4 id="Mozilla" name="Mozilla">Mozilla</h4> + +<dl> + <dt>{{jsxref("Error.prototype.fileName")}}</dt> + <dd>Ruta al fitxer que ha llençat l'error.</dd> + <dt>{{jsxref("Error.prototype.lineNumber")}}</dt> + <dd>Línia del fitxer que ha llençat l'error.</dd> + <dt>{{jsxref("Error.prototype.columnNumber")}}</dt> + <dd>Nombre de columna de la línia que ha llençat l'error.</dd> + <dt>{{jsxref("Error.prototype.stack")}}</dt> + <dd>Conté la traça de l'error.</dd> +</dl> + +<h2 id="Methods" name="Methods">Mètodes</h2> + +<dl> + <dt>{{jsxref("Error.prototype.toSource()")}} {{non-standard_inline}}</dt> + <dd>Retorna un string que conté el codi font de l'objecte {{jsxref("Global_Objects/Error", "Error")}} especificat; es pot emprar aquest valor per a crear un objecte nou. Sobreescriu el mètode {{jsxref("Object.prototype.toSource()")}}.</dd> + <dt>{{jsxref("Error.prototype.toString()")}}</dt> + <dd>Retorna un string que representa l'objecte especificat. Sobreescriu el mètode {{jsxref("Object.prototype.toString()")}}.</dd> +</dl> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>ECMAScript 1a Edició.</td> + <td>Standard</td> + <td>Definició inicial. Implementat a JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.11.3.1', 'Error')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-error.prototype', 'Error')}}</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 for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li>{{jsxref("Error")}}</li> + <li>{{jsxref("Object.prototype")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/error/stack/index.html b/files/ca/web/javascript/referencia/objectes_globals/error/stack/index.html new file mode 100644 index 0000000000..aa41949423 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/error/stack/index.html @@ -0,0 +1,161 @@ +--- +title: Error.prototype.stack +slug: Web/JavaScript/Referencia/Objectes_globals/Error/Stack +translation_of: Web/JavaScript/Reference/Global_Objects/Error/Stack +--- +<div>{{JSRef("Global_Objects", "Error", "EvalError,InternalError,RangeError,ReferenceError,SyntaxError,TypeError,URIError")}} {{non-standard_header}}</div> + +<h2 id="Resum">Resum</h2> + +<p>La propietat no standard <strong><code>stack</code></strong> dels objectes {{jsxref("Error")}} ofereix una traça de quines funcions han estat cridades, en quin ordre, des de quina línia i fitxer, i amb quins arguments. La stack, en forma de string, va de les crides més recent a les més antigues, fins a arribar a la crida original del context global.</p> + +<h2 id="Descripció">Descripció</h2> + +<p>Cada pas estarà separat per una nova línia, on la primera part de cada línia és el nom de la funció (si no es tracta d'una crida des del context global), seguit per pel símbol arroba (@), la ruta del fitxer (excepte quan la funció és la funció constructora de l'error mentre s'està llençant l'error), un punt i coma, i, si hi ha una ruta de fitxer, el nombre de línia. Fixeu-vos que l'objecte {{jsxref("Error")}} també disposa de les propietats <code>filename</code>, <code>lineNumber</code> i <code>columnNumber</code> de l'error llençat (però no de la traça).</p> + +<p>Cal remarcar que aquest és el format utilitzat per Firefox. No hi ha un formateig standard. Tot i així, Safari 6+ i Opera 12- utilitzen un format molt similar. Els navegadors que utilitzen el motor de JavaScript V8 (com ara Chrome, Opera 15+ i el navegador de Android), així com IE10+, d'altra banda, utilitzen un format diferent (vegeu el document de la MSDN <a class="external" href="http://msdn.microsoft.com/en-us/library/windows/apps/hh699850.aspx">error.stack</a>).</p> + +<p><strong>Valors dels arguments a la pila</strong>: Abans del ({{bug("744842")}}) de Firefox 14, el nom de la funció anava seguit dels valors dels arguments convertits a string entre parèntesi immediatament abans de l'arroba (@). Un objecte (o un array, etc) apareixeria en la forma convertida <code>"[object Object]"</code>, i en conseqüència no podria ser evaluada de nou en objectes. Si que es poden obtenir els valors escalars (tot i que resulta més senzill utilitzar <code>arguments.callee.caller.arguments</code>, així com es pot trobar el nom de la funció a <code>arguments.callee.caller.name</code>). <code>"undefined"</code> apareix com a <code>"(void 0)"</code>. Cal tenir en compte que si s'han passat arguments de tipus string que continguin caracters com ara <code>"@"</code>, <code>"("</code>, <code>")"</code> (o bé noms de fitxers), resulta força complicat utiltizar-los per a trencar la línia en les diferents parts que la composen. Degut a això, a partir de Firefox 14 això deixa de ser un problema.</p> + +<h2 id="Exemple">Exemple</h2> + +<p>El següent codi HTML mostra l'ús de la propietat <code>stack</code>.</p> + +<pre class="brush: html"><!DOCTYPE HTML> +<meta charset="UTF-8"> +<title>Exemple de pila de traça</title> +<body> +<script> +function trace() { + try { + throw new Error('myError'); + } + catch(e) { + alert(e.stack); + } +} +function b() { + trace(); +} +function a() { + b(3, 4, '\n\n', undefined, {}); +} +a('primera crida, primerArgument'); +</script> +</pre> + +<p>Assumint que el codi resideix al fitxer <code>C:\exemple.html</code> en un sistema de fitxers de Windows, aquest generarà un missatge d'alerta amb el text següent:</p> + +<p>A partir de Firefox 30 contindrà el nombre de la columna ({{bug("762556")}}):</p> + +<pre><samp>trace@file:///C:/exemple.html:9:17 +b@file:///C:/exemple.html:16:13 +a@file:///C:/exemple.html:19:13 +@file:///C:/exemple.html:21:9</samp></pre> + +<p>Firefox 14 a Firefox 29:</p> + +<pre><samp>trace@file:///C:/exemple.html:9 +b@file:///C:/exemple.html:16 +a@file:///C:/exemple.html:19 +@file:///C:/exemple.html:21</samp></pre> + +<p>Per contra, Firefox 13 i versions prèvies produian el següent text:</p> + +<pre><samp>Error("myError")@:0 +trace()@file:///C:/exemple.html:9 +b(3,4,"\n\n",(void 0),[object Object])@file:///C:/exemple.html:16 +a("primera crida, primerArgument")@file:///C:/exemple.html:19 +@file:///C:/exemple.html:21</samp></pre> + +<h3 id="Pila_de_codi_evaluat">Pila de codi evaluat</h3> + +<p>A partir de Firefox 30 {{geckoRelease("30")}}, la pila d'error pertanyent a codi dins de crides a <code>Function()</code> i <code>eval()</code> conté informació més detallada sobre la línia i la columna que ha produït l'error dins aquestes crides. Les crides a funcions s'indiquen amb <code>"> Function"</code> i les crides a eval amb <code>"> eval"</code>. Vegeu {{bug("332176")}}.</p> + +<pre class="brush: js">try { + new Function('throw new Error()')(); +} catch (e) { + console.log(e.stack); +} + +// anonymous@file:///C:/exemple.html line 7 > Function:1:1 +// @file:///C:/example.html:7:6 + + +try { + eval("eval('FAIL')"); +} catch (x) { + console.log(x.stack); +} + +// @file:///C:/exemple.html line 7 > eval line 1 > eval:1:1 +// @file:///C:/exemple.html line 7 > eval:1:1 +// @file:///C:/exemple.html:7:6 +</pre> + +<p>També podeu utilitzar la directiva <code>//# sourceURL</code> per a donar nom a codi eval. Vegeu també <a href="/en-US/docs/Tools/Debugger/How_to/Debug_eval_sources">Depurar codi eval</a> als documents de <a href="/en-US/docs/Tools/Debugger">Depurar</a> així com en aquesta <a href="http://fitzgeraldnick.com/weblog/59/">entrada d'un bloc</a>.</p> + +<h2 id="Especificacions">Especificacions</h2> + +<p>No forma part de cap especificació. No és standard.</p> + +<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("10")}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatSafari("6")}}</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>Android 4 (potser Android 3, però en cap cas Android 2)</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatSafari("6")}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li><a href="/en-US/docs/Components.stack">Components.stack</a></li> + <li>Projectes externs: <a class="link-https" href="https://github.com/csnover/TraceKit/">TraceKit</a> i<a class="link-https" href="https://github.com/eriwen/javascript-stacktrace">javascript-stacktrace</a></li> + <li>MSDN: documents <a class="external" href="http://msdn.microsoft.com/en-us/library/windows/apps/hh699850.aspx" title="http://msdn.microsoft.com/en-us/library/windows/apps/hh699850.aspx">error.stack</a></li> + <li><a href="https://code.google.com/p/v8/wiki/JavaScriptStackTraceApi">Un cop d'ull a la API de traça de pila del motor JavaScript V8</a></li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/error/tosource/index.html b/files/ca/web/javascript/referencia/objectes_globals/error/tosource/index.html new file mode 100644 index 0000000000..c766aa312b --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/error/tosource/index.html @@ -0,0 +1,91 @@ +--- +title: Error.prototype.toSource() +slug: Web/JavaScript/Referencia/Objectes_globals/Error/toSource +translation_of: Web/JavaScript/Reference/Global_Objects/Error/toSource +--- +<div>{{JSRef}} {{non-standard_header}}</div> + +<p>El mètode <code><strong>toSource()</strong></code> reotrna codi capaç de generar el mateix error en case de ser evaluat.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>e</var>.toSource()</code></pre> + +<h2 id="Descripció">Descripció</h2> + +<p>La crida al mètode <code>toSource</code> d'una instància d'{{jsxref("Error")}}(incloent <em><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error#Error_types">NativeErrors</a></em>) retorna un string que conté el codi font de l'error. Aquest string pot ser evaluat per a crear un objecte (aproximadament) igual. Per defecte la string contenint el codi font segueix l'estructura del construtor {{jsxref("Error")}}. Per exemple:</p> + +<pre class="brush: js">(new<em>name</em>(<em>message</em> ,<em>fileName</em>,<em>lineNumber</em>)) +</pre> + +<p>on aquests atributs corresponen a les propietats de la instància de l'error, respectivament.</p> + +<div class="note"> +<p><strong>Advertència:</strong> Cal tenir en compte que les propietats utilitzades pel mètode <code>toSource</code> a l'hora de crear l'string són mutables i per tant poden no representar de forma acurada la funció utilitzada per a crear la instància de l'error, el nom del fitxer o el nombre de la línia on l'error real ha tingut lloc.</p> +</div> + +<h2 id="Especificacions">Especificacions</h2> + +<p>No forma part de cap standard. Implementat a JavaScript 1.3.</p> + +<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>{{CompatUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Error.prototype.fileName")}}</li> + <li>{{jsxref("Error.prototype.lineNumber")}}</li> + <li>{{jsxref("Error.prototype.message")}}</li> + <li>{{jsxref("Error.prototype.name")}}</li> + <li>{{jsxref("Object.prototype.toSource()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/error/tostring/index.html b/files/ca/web/javascript/referencia/objectes_globals/error/tostring/index.html new file mode 100644 index 0000000000..79fd20f77f --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/error/tostring/index.html @@ -0,0 +1,146 @@ +--- +title: Error.prototype.toString() +slug: Web/JavaScript/Referencia/Objectes_globals/Error/toString +translation_of: Web/JavaScript/Reference/Global_Objects/Error/toString +--- +<div>{{JSRef("Global_Objects", "Error", "EvalError,InternalError,RangeError,ReferenceError,SyntaxError,TypeError,URIError")}}</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>El mètode <code><strong>toString()</strong></code> retorna un string que representa l'error especificat per l'objecte {{jsxref("Error")}}.</p> + +<h2 id="Syntax" name="Syntax">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>e</var>.toString()</code></pre> + +<h2 id="Description" name="Description">Descripció</h2> + +<p>L'objecte {{jsxref("Error")}} sobreescriu el mètode {{jsxref("Object.prototype.toString()")}} heretat per tots els objectes. La seva semàntica és la següent (suposant que {{jsxref("Object")}} i {{jsxref("String")}} tenen els seus valors originals):</p> + +<pre class="brush: js">Error.prototype.toString = function() { + 'use strict'; + + var obj = Object(this); + if (obj !== this) { + throw new TypeError(); + } + + var name = this.name; + name = (name === undefined) ? 'Error' : String(name); + + var msg = this.message; + msg = (msg === undefined) ? '' : String(msg); + + if (name === '') { + return msg; + } + if (msg === '') { + return name; + } + + return name + ': ' + msg; +}; +</pre> + +<h2 id="Examples" name="Examples">Exemples</h2> + +<pre class="brush: js">var e = new Error('fatal error'); +print(e.toString()); // 'Error: fatal error' + +e.name = undefined; +print(e.toString()); // 'Error: fatal error' + +e.name = ''; +print(e.toString()); // 'fatal error' + +e.message = undefined; +print(e.toString()); // 'Error' + +e.name = 'hello'; +print(e.toString()); // 'hello' +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>ECMAScript 1a Edició.</td> + <td>Standard</td> + <td>Definició inicial. Implementat a JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.11.4.4', 'Error.prototype.toString')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-error.prototype.tostring', 'Error.prototype.toString')}}</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 for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li>{{jsxref("Error.prototype.toSource()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/index.html b/files/ca/web/javascript/referencia/objectes_globals/index.html new file mode 100644 index 0000000000..60bd0333f7 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/index.html @@ -0,0 +1,167 @@ +--- +title: Objectes Standard +slug: Web/JavaScript/Referencia/Objectes_globals +translation_of: Web/JavaScript/Reference/Global_Objects +--- +<div> +<div>{{jsSidebar("Objects")}}</div> +</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>Aquest capítol llista tots els objectes que Javascript proporciona per defecte, així com els seus mètodes i propietats.</p> + +<div class="onlyinclude"> +<p>És important no confondre el terme "objectes globals" (també anomenats objectes <em>standard</em> o <em>built-in</em>) amb <em>objecte global</em>. En aquesta pàgina <em>objecte global</em> es refereix a <em>objectes en l'àmbit global</em> (però només si no s'utilitza el mode estricte de ECMAScript 5! En qualsevol altre cas retorna <code>undefined</code>). Es pot accedir a l'<em>objecte global</em> en si mateix mitjançant l'operador {{jsxref("Referencia/Objectes_standard/this", "this")}} en l'àmbit global. De fet l'àmbit global <em>consisteix </em>en les propietats de l'objecte global (propietats heredades incloses, si s'escau).</p> + +<p>Altres objectes en l'àmbit global són o bé <a href="/ca/docs/Web/JavaScript/Guide/Working_with_Objects#Creating_new_objects">creats per l'script de l'usuari</a> o bé proporcionats per l'aplicació del <em>host</em>. Els objectes proporcionats pel <em>host </em>disponibles en els àmbits del navegador estan documentats a la <a href="/ca/docs/Web/API/Reference">referència de la API</a>.</p> + +<h2 id="Objectes_standard_(per_categoria)">Objectes standard (per categoria)</h2> + +<h3 id="Propietats_de_valor">Propietats de valor</h3> + +<p>Propietats globals que retornen un valor simple.</p> + +<ul> + <li>{{jsxref("Infinity")}}</li> + <li>{{jsxref("NaN")}}</li> + <li>{{jsxref("undefined")}}</li> + <li>El literal {{jsxref("null")}}</li> +</ul> + +<h3 id="Funcions_globals">Funcions globals</h3> + +<p>Funcions globals que retornen el resultat d'una rutina específica.</p> + +<ul> + <li>{{jsxref("eval", "eval()")}}</li> + <li>{{jsxref("uneval", "uneval()")}} {{non-standard_inline()}}</li> + <li>{{jsxref("isFinite", "isFinite()")}}</li> + <li>{{jsxref("isNaN", "isNaN()")}}</li> + <li>{{jsxref("parseFloat", "parseFloat()")}}</li> + <li>{{jsxref("parseInt", "parseInt()")}}</li> + <li>{{jsxref("decodeURI", "decodeURI()")}}</li> + <li>{{jsxref("decodeURIComponent", "decodeURIComponent()")}}</li> + <li>{{jsxref("encodeURI", "encodeURI()")}}</li> + <li>{{jsxref("encodeURIComponent", "encodeURIComponent()")}}</li> + <li>{{jsxref("escape", "escape()")}} {{deprecated_inline()}}</li> + <li>{{jsxref("unescape", "unescape()")}} {{deprecated_inline()}}</li> +</ul> + +<h3 id="Objectes_fonamentals">Objectes fonamentals</h3> + +<p>Objectes generals del llenguatge, funcions i errors.</p> + +<ul> + <li>{{jsxref("Object")}}</li> + <li>{{jsxref("Function")}}</li> + <li>{{jsxref("Boolean")}}</li> + <li>{{jsxref("Symbol")}} {{experimental_inline()}}</li> + <li>{{jsxref("Error")}}</li> + <li>{{jsxref("EvalError")}}</li> + <li>{{jsxref("InternalError")}}</li> + <li>{{jsxref("RangeError")}}</li> + <li>{{jsxref("ReferenceError")}}</li> + <li>{{jsxref("SyntaxError")}}</li> + <li>{{jsxref("TypeError")}}</li> + <li>{{jsxref("URIError")}}</li> +</ul> + +<h3 id="Nombres_i_dates">Nombres i dates</h3> + +<p>Objectes que emmagatzemen nombres, dades i càlculs matemàtics.</p> + +<ul> + <li>{{jsxref("Number")}}</li> + <li>{{jsxref("Math")}}</li> + <li>{{jsxref("Date")}}</li> +</ul> + +<h3 id="Processament_de_text">Processament de text</h3> + +<p>Objectes per manipular text.</p> + +<ul> + <li>{{jsxref("String")}}</li> + <li>{{jsxref("RegExp")}}</li> +</ul> + +<h3 id="Col·leccions_indexades">Col·leccions indexades</h3> + +<p>Col·leccions ordenades per un índex. Objectes de tipus array.</p> + +<ul> + <li>{{jsxref("Array")}}</li> + <li>{{jsxref("Int8Array")}}</li> + <li>{{jsxref("Uint8Array")}}</li> + <li>{{jsxref("Uint8ClampedArray")}}</li> + <li>{{jsxref("Int16Array")}}</li> + <li>{{jsxref("Uint16Array")}}</li> + <li>{{jsxref("Int32Array")}}</li> + <li>{{jsxref("Uint32Array")}}</li> + <li>{{jsxref("Float32Array")}}</li> + <li>{{jsxref("Float64Array")}}</li> +</ul> + +<h3 id="Diccionaris_(mapes)">Diccionaris (mapes)</h3> + +<p>Col·leccions d'objectes de tipus diccionari (també coneguts com a mapes o col·leccions d'entrades clau-valor). Els elements són iterables per ordre d'inserció.</p> + +<ul> + <li>{{jsxref("Map")}} {{experimental_inline()}}</li> + <li>{{jsxref("Set")}} {{experimental_inline()}}</li> + <li>{{jsxref("WeakMap")}} {{experimental_inline()}}</li> + <li>{{jsxref("WeakSet")}} {{experimental_inline()}}</li> +</ul> + +<h3 id="Dades_estructurades">Dades estructurades</h3> + +<p>Buffers de dades i <strong>J</strong>ava<strong>S</strong>cript <strong>O</strong>bject <strong>N</strong>otation.</p> + +<ul> + <li>{{jsxref("ArrayBuffer")}}</li> + <li>{{jsxref("DataView")}}</li> + <li>{{jsxref("JSON")}}</li> +</ul> + +<h3 id="Objectes_d'abstracció_de_control">Objectes d'abstracció de control</h3> + +<ul> + <li>{{jsxref("Promise")}} {{experimental_inline()}}</li> +</ul> + +<h3 id="Reflexió">Reflexió</h3> + +<ul> + <li>{{jsxref("Reflect")}} {{experimental_inline()}}</li> + <li>{{jsxref("Proxy")}} {{experimental_inline()}}</li> +</ul> + +<h3 id="Internacionalització">Internacionalització</h3> + +<p>Adicions al nucli de ECMAScript per a funcionalitats sensibles a l'idioma.</p> + +<ul> + <li>{{jsxref("Intl")}}</li> + <li>{{jsxref("Collator", "Intl.Collator")}}</li> + <li>{{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}}</li> + <li>{{jsxref("NumberFormat", "Intl.NumberFormat")}}</li> +</ul> + +<h3 id="Objectes_no-standard">Objectes no-standard</h3> + +<ul> + <li>{{jsxref("Generator")}} {{non-standard_inline()}}</li> + <li>{{jsxref("Iterator")}} {{non-standard_inline()}}</li> + <li>{{jsxref("ParallelArray")}} {{non-standard_inline()}}</li> + <li>{{jsxref("StopIteration")}} {{non-standard_inline()}}</li> +</ul> + +<h3 id="Altres">Altres</h3> + +<ul> + <li><code><a href="/ca/docs/Web/JavaScript/Reference/Functions/arguments">arguments</a></code></li> +</ul> +</div> + +<p> </p> diff --git a/files/ca/web/javascript/referencia/objectes_globals/infinity/index.html b/files/ca/web/javascript/referencia/objectes_globals/infinity/index.html new file mode 100644 index 0000000000..409609bfd2 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/infinity/index.html @@ -0,0 +1,114 @@ +--- +title: Infinity +slug: Web/JavaScript/Referencia/Objectes_globals/Infinity +translation_of: Web/JavaScript/Reference/Global_Objects/Infinity +--- +<div> +<div> +<div>{{jsSidebar("Objects")}}</div> +</div> +</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>La propietat global <code><strong>Infinity</strong></code> és un valor numèric que representa l'infinit.</p> + +<p>{{js_property_attributes(0,0,0)}}</p> + +<h2 id="Syntax" name="Syntax">Sintaxi</h2> + +<pre class="syntaxbox"><code>Infinity </code></pre> + +<h2 id="Description" name="Description">Descripció</h2> + +<p><code>Infinity</code> és una propietat de l'<em>objecte global</em>, és a dir, és una variable dins l'àmbit global.</p> + +<p>El valor inical de <code>Infinity</code> és {{jsxref("Number.POSITIVE_INFINITY")}}. El valor <code>Infinity</code> (infinit positiu) és major que qualsevol altre nombre. Aquest valor es comporta matemàticament com l'infinit; per exemple, qualsevol nombre positiu multiplicat per<code> Infinity</code> dóna com a resultat <code>Infinity</code>, qualsevol valor dividit per <code>Infinity</code> dóna 0.</p> + +<p>Tal i com la especificació ECMAScript 5 defineix, <code>Infinity</code> no pot ser sobreescrit (implementat a JavaScript 1.8.5 / Firefox 4).</p> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificacions</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>ECMAScript 1a Edició.</td> + <td>Standard</td> + <td>Definició inicial. Implementat a JavaScript 1.3</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.1.1.2', 'Infinity')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-value-properties-of-the-global-object-infinity', 'Infinity')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{ CompatibilityTable() }}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li>{{jsxref("Number.NEGATIVE_INFINITY")}}</li> + <li>{{jsxref("Number.POSITIVE_INFINITY")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/json/index.html b/files/ca/web/javascript/referencia/objectes_globals/json/index.html new file mode 100644 index 0000000000..efc86409e6 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/json/index.html @@ -0,0 +1,242 @@ +--- +title: JSON +slug: Web/JavaScript/Referencia/Objectes_globals/JSON +translation_of: Web/JavaScript/Reference/Global_Objects/JSON +--- +<div>{{JSRef("Global_Objects", "JSON")}}</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>L'objecte <strong><code>JSON</code></strong> conté mètodes per a interpretar <a class="external" href="http://json.org/">JavaScript Object Notation</a> ({{glossary("JSON")}}) i convertir valors a JSON. Aquest objecte no pot ser cridat o construit, i a banda dels seus dos mètodes no té cap més funcionalitat o interès.</p> + +<p>and converting values to JSON. It can't be called or constructed, and aside from its two method properties it has no interesting functionality of its own.</p> + +<h2 id="Description" name="Description">Descripció</h2> + +<h3 id="JavaScript_Object_Notation" name="JavaScript_Object_Notation">JavaScript Object Notation</h3> + +<p>JSON és una sintaxi que permet serialitzar objectes, arrays, nombres, strings, booleans i {{jsxref("null")}}. Està basada en la sintaxi de JavaScript però és diferent: algunes parts de JavaScript no són convertibles a JSON i algunes de JSON no ho són a JavaScript. Vegeu també <a href="http://timelessrepo.com/json-isnt-a-javascript-subset">JSON: El subconjunt de JavaScript que no ho és</a>.</p> + +<table> + <caption>Diferències entre JavaScript i JSON</caption> + <thead> + <tr> + <th scope="col">Tipus a JavaScript</th> + <th scope="col">Diferències a JSON</th> + </tr> + </thead> + <tbody> + <tr> + <td>Objectes i Arrays</td> + <td>Els noms de les propietats han de estar embolcallats per cometes dobles; les cometes simples estan prohibides</td> + </tr> + <tr> + <td>Nombres</td> + <td>No són permesos zeros a l'esquerra; els nombres decimals separent la part sencera amb un punt i han de tindre al menys un digit decimal.</td> + </tr> + <tr> + <td>Strings</td> + <td> + <p>Només es pot escapar un grup limitat de caràcters; alguns caràcters de control no són permesos; el separador de línies Unicode (<a href="http://unicode-table.com/en/2028/">U+2028</a>) i el separador de paràgrafs (<a href="http://unicode-table.com/en/2029/">U+2029</a>) són permesos; les strings han d'estar embolcallades per cometes dobles. Vegeu l'exemple següent on {{jsxref("JSON.parse()")}} funciona correctament i es llença un {{jsxref("SyntaxError")}} a l'avaluar el codi com a JavaScript:</p> + + <pre class="brush: js"> +var code = '"\u2028\u2029"'; +JSON.parse(code); // funciona correctament +eval(code); // falla +</pre> + </td> + </tr> + </tbody> +</table> + +<p>La sintaxi completa de JSON és la següent:</p> + +<pre><var>JSON</var> = <strong>null</strong> + <em>o</em> <strong>true</strong> <em>o</em> <strong>false</strong> + <em>o</em> <var>JSONNumber</var> + <em>o</em> <var>JSONString</var> + <em>o</em> <var>JSONObject</var> + <em>o</em> <var>JSONArray</var> + +<var>JSONNumber</var> = <strong>-</strong> <var>PositiveNumber</var> + <em>o</em> <var>PositiveNumber</var> +<var>PositiveNumber</var> = DecimalNumber + <em>o</em> <var>DecimalNumber</var> <strong>.</strong> <var>Digits</var> + <em>o</em> <var>DecimalNumber</var> <strong>.</strong> <var>Digits</var> <var>ExponentPart</var> + <em>o</em> <var>DecimalNumber</var> <var>ExponentPart</var> +<var>DecimalNumber</var> = <strong>0</strong> + <em>o</em> <var>OneToNine</var> <var>Digits</var> +<var>ExponentPart</var> = <strong>e</strong> <var>Exponent</var> + <em>o</em> <strong>E</strong> <var>Exponent</var> +<var>Exponent</var> = <var>Digits</var> + <em>o</em> <strong>+</strong> <var>Digits</var> + <em>o</em> <strong>-</strong> <var>Digits</var> +<var>Digits</var> = <var>Digit</var> + <em>o</em> <var>Digits</var> <var>Digit</var> +<var>Digit</var> = <strong>0</strong> through <strong>9</strong> +<var>OneToNine</var> = <strong>1</strong> through <strong>9</strong> + +<var>JSONString</var> = <strong>""</strong> + <em>o</em> <strong>"</strong> <var>StringCharacters</var> <strong>"</strong> +<var>StringCharacters</var> = <var>StringCharacter</var> + <em>o</em> <var>StringCharacters</var> <var>StringCharacter</var> +<var>StringCharacter</var> = qualsevol caràcter excepte + <strong>"</strong> <em>o</em> <strong>\</strong> <em>o</em> U+0000 fins a U+001F + <em>o</em> <var>EscapeSequence</var> +<var>EscapeSequence</var> = <strong>\"</strong> <em>o</em> <strong>\/</strong> <em>o</em> <strong>\\</strong> <em>o</em> <strong>\b</strong> <em>o</em> <strong>\f</strong> <em>o</em> <strong>\n</strong> <em>o</em> <strong>\r</strong> <em>o</em> <strong>\t</strong> + <em>o</em> <strong>\u</strong> <var>HexDigit</var> <var>HexDigit</var> <var>HexDigit</var> <var>HexDigit</var> +<var>HexDigit</var> = <strong>0</strong> fins a <strong>9</strong> + <em>o</em> <strong>A</strong> fins a <strong>F</strong> + <em>o</em> <strong>a</strong> fins a <strong>f</strong> + +<var>JSONObject</var> = <strong>{</strong> <strong>}</strong> + <em>o</em> <strong>{</strong> <var>Members</var> <strong>}</strong> +<var>Members</var> = <var>JSONString</var> <strong>:</strong> <var>JSON</var> + <em>o</em> <var>Members</var> <strong>,</strong> <var>JSONString</var> <strong>:</strong> <var>JSON</var> + +<var>JSONArray</var> = <strong>[</strong> <strong>]</strong> + <em>o</em> <strong>[</strong> <var>ArrayElements</var> <strong>]</strong> +<var>ArrayElements</var> = <var>JSON</var> + <em>o</em> <var>ArrayElements</var> <strong>,</strong> <var>JSON</var> +</pre> + +<p>Pot haver-hi espais en blanc sense significat a qualsevol lloc excepte dins un<code><var> JSONNumber</var></code> (el nombres no poden contenir espais) o <code><var>JSONString</var></code> (on s'interpreta com el caràcter corrsponen dins l'string, o causaria un error). Els caràcters tabulador (<a href="http://unicode-table.com/en/0009/">U+0009</a>), retorn de carro (<a href="http://unicode-table.com/en/000D/">U+000D</a>), nova línia (<a href="http://unicode-table.com/en/000A/">U+000A</a>), i l'espai (<a href="http://unicode-table.com/en/0020/">U+0020</a>) són els únics caràcters d'espai en blanc acceptats.</p> + +<h2 id="Methods" name="Methods">Mètodes</h2> + +<dl> + <dt>{{jsxref("JSON.parse()")}}</dt> + <dd>Interpreta una string com a JSON, opcionalment transforma el valor produït i les seves propietats, i retorna el valor.</dd> + <dt>{{jsxref("JSON.stringify()")}}</dt> + <dd>Retorna un JSON string corresponent al valor especificat, opcionalment només inclou determinades propietats o reemplaça el valor de propietats tal i com defineixi l'usuari.</dd> +</dl> + +<h2 id="Polyfill" name="Polyfill">Polyfill</h2> + +<p>L'objecte <code>JSON</code> no és suportat a navegadors antics. Aquest problema pot solventar-se insertant el codi següent al principi dels scripts, permetent l'ús de l'objecte <code>JSON</code> en implementacions on no hi ha suport natiu (com ara Internet Explorer 6).</p> + +<p>El següent algorisme emula l'objecte <code>JSON</code> natiu:</p> + +<pre class="brush: js">if (!window.JSON) { + window.JSON = { + parse: function(sJSON) { return eval('(' + sJSON + ')'); }, + stringify: (function () { + var toString = Object.prototype.toString; + var isArray = Array.isArray || function (a) { return toString.call(a) === '[object Array]'; }; + var escMap = {'"': '\\"', '\\': '\\\\', '\b': '\\b', '\f': '\\f', '\n': '\\n', '\r': '\\r', '\t': '\\t'}; + var escFunc = function (m) { return escMap[m] || '\\u' + (m.charCodeAt(0) + 0x10000).toString(16).substr(1); }; + var escRE = /[\\"\u0000-\u001F\u2028\u2029]/g; + return function stringify(value) { + if (value == null) { + return 'null'; + } else if (typeof value === 'number') { + return isFinite(value) ? value.toString() : 'null'; + } else if (typeof value === 'boolean') { + return value.toString(); + } else if (typeof value === 'object') { + if (typeof value.toJSON === 'function') { + return stringify(value.toJSON()); + } else if (isArray(value)) { + var res = '['; + for (var i = 0; i < value.length; i++) + res += (i ? ', ' : '') + stringify(value[i]); + return res + ']'; + } else if (toString.call(value) === '[object Object]') { + var tmp = []; + for (var k in value) { + if (value.hasOwnProperty(k)) + tmp.push(stringify(k) + ': ' + stringify(value[k])); + } + return '{' + tmp.join(', ') + '}'; + } + } + return '"' + value.toString().replace(escRE, escFunc) + '"'; + }; + })() + }; +} +</pre> + +<p>Dos <a class="external" href="http://remysharp.com/2010/10/08/what-is-a-polyfill/">polyfills</a> complexos coneguts per a l'objecte <code>JSON</code> són <a class="link-https" href="https://github.com/douglascrockford/JSON-js">JSON2</a> i <a class="external" href="http://bestiejs.github.com/json3">JSON3</a>.</p> + +<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.12', 'JSON')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-json-object', 'JSON')}}</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.9.1")}}</td> + <td>{{CompatIE("8.0")}}</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>{{CompatGeckoMobile("1.0")}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<p>Basat en la <a class="external" href="http://kangax.github.com/es5-compat-table/">taula de compatibilitat de Kangax</a>.</p> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li>{{jsxref("Date.prototype.toJSON()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/map/clear/index.html b/files/ca/web/javascript/referencia/objectes_globals/map/clear/index.html new file mode 100644 index 0000000000..f29cc93eef --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/map/clear/index.html @@ -0,0 +1,104 @@ +--- +title: Map.prototype.clear() +slug: Web/JavaScript/Referencia/Objectes_globals/Map/clear +translation_of: Web/JavaScript/Reference/Global_Objects/Map/clear +--- +<div>{{JSRef}}</div> + +<p>El mètode <code><strong>clear()</strong></code> esborra tots els elements d'un objecte de tipus <code>Map</code>.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><em>myMap</em>.clear();</code></pre> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_el_mètode_clear">Utilitzar el mètode <code>clear</code></h3> + +<pre class="brush: js">var myMap = new Map(); +myMap.set("bar", "baz"); +myMap.set(1, "foo"); + +myMap.size; // 2 +myMap.has("bar"); // true + +myMap.clear(); + +myMap.size; // 0 +myMap.has("bar") // 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('ES6', '#sec-map.prototype.clear', 'Map.prototype.clear')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definició inicial.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>38</td> + <td>{{CompatGeckoDesktop("19.0")}}</td> + <td>11</td> + <td>25</td> + <td>7.1</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatNo}}</td> + <td>38</td> + <td>{{CompatGeckoMobile("19.0")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Map")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/map/delete/index.html b/files/ca/web/javascript/referencia/objectes_globals/map/delete/index.html new file mode 100644 index 0000000000..01c1b2cf28 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/map/delete/index.html @@ -0,0 +1,109 @@ +--- +title: Map.prototype.delete() +slug: Web/JavaScript/Referencia/Objectes_globals/Map/delete +translation_of: Web/JavaScript/Reference/Global_Objects/Map/delete +--- +<div>{{JSRef}}</div> + +<p>El mètode <code><strong>delete()</strong></code> elimina l'element especificat de l'objecte <code>Map.</code></p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="brush: js">myMap.delete(clau);</pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt>clau</dt> + <dd>Necessari. La clau de l'element a eliminar de l'objecte <code>Map.</code></dd> +</dl> + +<h3 id="valor_Return">valor Return</h3> + +<p>Retorna <code>true</code> si un element de l'objecte <code>Map </code>s'ha eleminat amb èxit.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_el_mètode_delete">Utilitzar el mètode <code>delete</code></h3> + +<pre class="brush: js">var myMap = new Map(); +myMap.set("bar", "foo"); + +myMap.delete("bar"); // Retorna true. Eliminat satisfactòriament. +myMap.has("bar"); // Retorna false. L'element "bar" ja no és present. +</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-map.prototype.delete', 'Map.prototype.delete')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definició inicial.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>38</td> + <td>{{CompatGeckoDesktop("13.0")}}</td> + <td>11</td> + <td>25</td> + <td>7.1</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome 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>38</td> + <td>{{CompatGeckoMobile("13.0")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Map")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/map/entries/index.html b/files/ca/web/javascript/referencia/objectes_globals/map/entries/index.html new file mode 100644 index 0000000000..d5f6942695 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/map/entries/index.html @@ -0,0 +1,104 @@ +--- +title: Map.prototype.entries() +slug: Web/JavaScript/Referencia/Objectes_globals/Map/entries +translation_of: Web/JavaScript/Reference/Global_Objects/Map/entries +--- +<div>{{JSRef}}</div> + +<p>El mètode <code><strong>entries()</strong></code>retorna un nou objecte <code><strong>Iterator</strong></code> que conté la parella <code>[clau, valor]</code> per cadascun dels elements de l'objecte <code>Map</code> en l'ordre d'inserció.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><em>myMap</em>.entries()</code></pre> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_entries()">Utilitzar <code>entries()</code></h3> + +<pre class="brush:js">var myMap = new Map(); +myMap.set("0", "foo"); +myMap.set(1, "bar"); +myMap.set({}, "baz"); + +var mapIter = myMap.entries(); + +console.log(mapIter.next().value); // ["0", "foo"] +console.log(mapIter.next().value); // [1, "bar"] +console.log(mapIter.next().value); // [Object, "baz"] +</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-map.prototype.entries', 'Map.prototype.entries')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definició inicial.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>38</td> + <td>{{ CompatGeckoDesktop("20") }}</td> + <td>{{CompatNo}}</td> + <td>25</td> + <td>7.1</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome 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>38</td> + <td>{{CompatGeckoMobile("20")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Map.prototype.keys()")}}</li> + <li>{{jsxref("Map.prototype.values()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/map/foreach/index.html b/files/ca/web/javascript/referencia/objectes_globals/map/foreach/index.html new file mode 100644 index 0000000000..7097bbee3d --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/map/foreach/index.html @@ -0,0 +1,136 @@ +--- +title: Map.prototype.forEach() +slug: Web/JavaScript/Referencia/Objectes_globals/Map/forEach +translation_of: Web/JavaScript/Reference/Global_Objects/Map/forEach +--- +<div>{{JSRef}}</div> + +<p>El mètode <code><strong>forEach()</strong></code> executa la funció proporcionada un cop epr cada parell clau/valor dins l'objecte <code>Map</code>, seguint l'ordre en el que han estat inserits.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><em>myMap</em>.forEach(<em>callback</em>[, <em>thisArg</em>])</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>callback</code></dt> + <dd>Funció a executar per a cada element.</dd> + <dt><code>thisArg</code></dt> + <dd>Valor a utilitzar com a <code>this</code> mentre s'estigui executant executing <code>callback</code>.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>El mètode <code>forEach</code> executa la funció <code>callback</code> proporcionada un cop per a cada clau que existeixi dins el mapa. No s'invocarà la funció per a claus que hagin estat esborrades. Tanmateix si que s'executarà per a valors amb clau present però que el seu valor sigui <code>undefined</code>.</p> + +<p><code>callback</code> s'invocarà amb <strong>tres</strong><strong> arguments</strong>:</p> + +<ul> + <li>el <strong>valor de l'element</strong></li> + <li>la <strong>clau de l'element</strong></li> + <li>l'<strong>objecte </strong><strong><code>Map</code> que s'està recorrent</strong></li> +</ul> + +<p>Si es proporciona el paràmetre <code>thisArg</code> a la crida de <code>forEach</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="https://developer.mozilla.org/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>Cada valor serà visitat un cop, a no ser que hagi estat eliminat o tornar a afegir abans que el mètode <code>forEach</code> acabi. No s'invocarà <code>callback</code> per a valors eliminats abans de ser visitats. Si que es visitaran, però, valors nous afegits abans <code>forEach</code> no hagi acabat.</p> + +<p><code>forEach</code> executa la funció <code>callback</code> un cop per cada element de l'objecte <code>Map</code>; no retorna cap valor.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Mostrar_els_continguts_d'un_objecte_Map">Mostrar els continguts d'un objecte <code>Map</code></h3> + +<p>El codi següent mostra una línia per cada element d'un objecte <code>Map</code>:</p> + +<pre class="brush:js">function logMapElements(value, key, map) { + console.log("m[" + key + "] = " + value); +} +Map([["foo", 3], ["bar", {}], ["baz", undefined]]).forEach(logMapElements); +// mostra: +// "m[foo] = 3" +// "m[bar] = [object Object]" +// "m[baz] = 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-map.prototype.foreach', 'Map.prototype.forEach')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definició inicial.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-map.prototype.foreach', 'Map.prototype.forEach')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>38</td> + <td>{{CompatGeckoDesktop("25.0")}}</td> + <td>11</td> + <td>25</td> + <td>7.1</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatNo}}</td> + <td>38</td> + <td>{{CompatGeckoMobile("25.0")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Array.prototype.forEach()")}}</li> + <li>{{jsxref("Set.prototype.forEach()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/map/get/index.html b/files/ca/web/javascript/referencia/objectes_globals/map/get/index.html new file mode 100644 index 0000000000..ec345df059 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/map/get/index.html @@ -0,0 +1,116 @@ +--- +title: Map.prototype.get() +slug: Web/JavaScript/Referencia/Objectes_globals/Map/get +translation_of: Web/JavaScript/Reference/Global_Objects/Map/get +--- +<div>{{JSRef}}</div> + +<p>El mètode <code><strong>get()</strong></code> retorna l'element especifciat d'un objecte <code>Map</code>.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><em>myMap</em>.get(clau);</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt>clau</dt> + <dd>Obligatori. La clau de l'element a retorna de l'objecte <code>Map</code>.</dd> +</dl> + +<h3 id="Valor_a_retornar">Valor a retornar</h3> + +<p>Retorna l'element associat a la clau especificada o bé <code>undefined</code> si no s'ha pogut trobar la clau dins l'objecte <code>Map</code>.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_el_mètode_get">Utilitzar el mètode <code>get</code></h3> + +<pre class="brush: js">var myMap = new Map(); +myMap.set("bar", "foo"); + +myMap.get("bar"); // Retorna "foo". +myMap.get("baz"); // Retorna 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-map.prototype.get', 'Map.prototype.get')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definició inicial.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-map.prototype.get', 'Map.prototype.get')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>38</td> + <td>{{CompatGeckoDesktop("13.0")}}</td> + <td>11</td> + <td>25</td> + <td>7.1</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatNo}}</td> + <td>38</td> + <td>{{CompatGeckoMobile("13.0")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Map")}}</li> + <li>{{jsxref("Map.prototype.set()")}}</li> + <li>{{jsxref("Map.prototype.has()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/map/has/index.html b/files/ca/web/javascript/referencia/objectes_globals/map/has/index.html new file mode 100644 index 0000000000..d0ce1bec54 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/map/has/index.html @@ -0,0 +1,114 @@ +--- +title: Map.prototype.has() +slug: Web/JavaScript/Referencia/Objectes_globals/Map/has +translation_of: Web/JavaScript/Reference/Global_Objects/Map/has +--- +<div>{{JSRef}}</div> + +<p>El mètode <code><strong>has()</strong></code> retorna un booleà que indica si existeix un element amb la clau especificada o no.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><em>myMap</em>.has(clau);</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt>clau</dt> + <dd>Obligatori. La clau de l'element que es comprovarà si existeix o no dins l'objecte <code>Map</code>.</dd> +</dl> + +<h3 id="Valor_retornat">Valor retornat</h3> + +<dl> + <dt>Booleà</dt> + <dd>Retorna <code>true</code> si existeix un element amb la clau proporcionada dins l'objecte <code>Map</code>; retorna <code>false</code> en qualsevol altre cas.</dd> +</dl> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_el_mètode_has">Utilitzar el mètode <code>has</code></h3> + +<pre class="brush: js">var myMap = new Map(); +myMap.set("bar", "foo"); + +myMap.has("bar"); // retorn true +myMap.has("baz"); // retorn 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('ES6', '#sec-map.prototype.has', 'Map.prototype.has')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definició inicial.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>38</td> + <td>{{CompatGeckoDesktop("13.0")}}</td> + <td>11</td> + <td>25</td> + <td>7.1</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatNo}}</td> + <td>38</td> + <td>{{CompatGeckoMobile("13.0")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Map")}}</li> + <li>{{jsxref("Map.prototype.set()")}}</li> + <li>{{jsxref("Map.prototype.get()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/map/index.html b/files/ca/web/javascript/referencia/objectes_globals/map/index.html new file mode 100644 index 0000000000..8e2bb647bd --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/map/index.html @@ -0,0 +1,385 @@ +--- +title: Map +slug: Web/JavaScript/Referencia/Objectes_globals/Map +translation_of: Web/JavaScript/Reference/Global_Objects/Map +--- +<div>{{JSRef("Global_Objects", "Map")}}</div> + +<h2 id="Resum">Resum</h2> + +<p>L'objecte <strong><code>Map</code></strong> és un simple mapa de parelles clau/valor. Qualsevol valor (tant objectes com {{Glossary("Primitive", "primitive values")}}) poden fer-se servir tant com a clau com a valor.</p> + +<h2 id="Syntax" name="Syntax">Sintaxi</h2> + +<pre class="syntaxbox"><code>new Map([iterable]) +</code></pre> + +<h3 id="Parameters" name="Parameters">Paràmetres</h3> + +<dl> + <dt><code>iterable</code></dt> + <dd>Iterable és un Array o un altre objecte iterable els quals els seus elements són parelles clau/valor (Arrays de 2 elements). Cada parella clau/valor serà afegida al nou mapa. nul és tracta com a indefinit.</dd> +</dl> + +<h2 id="Description" name="Description">Descripció</h2> + +<p>Un objecte Map pot iterar els seus elements en ordre d'inserció - un bucle <code>for..of</code> retornarà un array de <code>[key, value]</code> per cada iteració.</p> + +<h3 id="Igualtat_de_claus">Igualtat de claus</h3> + +<p>La igualtat de claus es basa en l'algorisme "mateix valor": <code>NaN</code> es considera igual a <code>NaN</code> (tot i que <code>NaN !== NaN</code>) i tots els altres valors es consideren iguals d'acord amb la semàntica de l'operador <code>===</code>. En versions anteriors a l'esborrany de l'ECMAScript 6 <code>-0</code> i <code>+0</code> es consideraven diferents (tot i que <code>-0 === +0</code>), aquest comportament s'ha canviat en versions posteriors i ha sigut adaptat al {{geckoRelease("29")}} ({{bug("952870")}}) i una <a href="https://code.google.com/p/v8/issues/detail?id=3069">versió diària de Chrome</a>.</p> + +<h3 id="Comparació_d'objectes_amb_mapes">Comparació d'objectes amb mapes</h3> + +<p>Els {{jsxref("Object", "Objects")}} son similars als <code>Maps</code> en el sentit que tots dos permeten assignar valors a claus, obtenir aquests valors, esborrar claus i detectar si una clau té un valor assignat o no. Degut a això, històricament s'han fet anar <code>Objects</code> com a <code>Maps</code>; tot i això existeixen diferències importants entre <code>Objects</code> i <code>Maps</code> que fan que l'ús de <code>Map</code> sigui millor.</p> + +<ul> + <li>Un <code>Object</code> té un prototipus, això implica que hi haurà algunes claus definides inicialment. Aquest problem es pot adreçar utilitzant <code>map = Object.create(null)</code>.</li> + <li>Les claus d'un <code>Object</code> són {{jsxref("String", "Strings")}}, mentre que les claus d'un <code>Map</code> poden ser de qualsevol tipus.</li> + <li>És fàcil obtindre el tamany d'un <code>Map</code> mentre que el tamany d'un <code>Object</code> ha de ser calculat manualment.</li> +</ul> + +<p>Utilitzeu mapes en comptes d'objejctes quan les claus no se sàpiguin en temps d'execució, o bé quan totes les claus o els valors siguin del mateix tipus.</p> + +<p>Utilitzeu objectes quan hi hagi una lògica que operi els elements individualment.</p> + +<h2 id="Properties" name="Properties">Propietats</h2> + +<dl> + <dt><code>Map.length</code></dt> + <dd>El valor de la propietat <code>length</code> és 1.</dd> + <dt>{{jsxref("Map.prototype")}}</dt> + <dd>Representa el prototipus pel constructor <code>Map</code>. Permet afegir propietats a tots els objectes de tipus <code>Map</code>.</dd> +</dl> + +<h2 id="Boolean_instances" name="Boolean_instances">Instàncies de <code>Map</code></h2> + +<p>Totes les instàncies de <code>Map</code> hereten de {{jsxref("Map.prototype")}}.</p> + +<h3 id="Propietats">Propietats</h3> + +<p>{{page('ca/Web/JavaScript/Reference/Global_Objects/Map/prototype','Propietats')}}</p> + +<h3 id="Mètodes">Mètodes</h3> + +<p>{{page('ca/Web/JavaScript/Reference/Global_Objects/Map/prototype','Mètodes')}}</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Exemple_Utilitzar_l'objecte_Map">Exemple: Utilitzar l'objecte <code>Map</code></h3> + +<pre class="brush: js">var myMap = new Map(); + +var keyObj = {}, + keyFunc = function () {}, + keyString = "a string"; + +// preparar els valors +myMap.set(keyString, "valor associat a amb 'un string'"); +myMap.set(keyObj, "valor associat amb keyObj"); +myMap.set(keyFunc, "valor associat amb with keyFunc"); + +myMap.size; // 3 + +// obtenir els valors +myMap.get(keyString); // "valor associat amb 'un string'" +myMap.get(keyObj); // "valor associat amb keyObj" +myMap.get(keyFunc); // "valor associat amb keyFunc" + +myMap.get("a string"); // "valor associat amb 'un string'" + // com que keyString === 'un string' +myMap.get({}); // undefined, perquè keyObj !== {} +myMap.get(function() {}) // undefined, perquè keyFunc !== function () {} +</pre> + +<h3 id="Exemple_Utilitzar_NaN_com_a_claus_en_un_Map">Exemple: Utilitzar <code>NaN</code> com a claus en un <code>Map</code></h3> + +<p><code>NaN</code> també pot emprar-se com a clau. Tot i que <code>NaN</code> no és igual a si mateix (<code>NaN !== NaN</code> és cert), l'exemple següent funciona perquè els <code>NaN</code>s són indistinguibles entre ells:</p> + +<pre class="brush: js">var myMap = new Map(); +myMap.set(NaN, "no un nombre"); + +myMap.get(NaN); // "no un nombre" + +var altreNaN = Number("foo"); +myMap.get(altreNaN); // "no un nombre" +</pre> + +<h3 id="Exemple_Iterar_Maps_amb_for..of">Exemple: Iterar <code>Maps</code> amb <code>for..of</code></h3> + +<p>Els mapes es poden iterar fent servir un bucle <code>for..of</code> :</p> + +<pre class="brush: js">var myMap = new Map(); +myMap.set(0, "zero"); +myMap.set(1, "un"); +for (var [key, value] of myMap) { + alert(key + " = " + value); +} +// Mostrarà 2 alertes; el primer amb "0 = zero" i el segon amb "1 = one" + +for (var key of myMap.keys()) { + alert(key); +} +// Mostrarà 2 alertes; el primer amb "0" i el segon amb "1" + +for (var value of myMap.values()) { + alert(value); +} +// Mostrarà 2 alertes; el primer amb "zero" i el segon amb "un" + +for (var [key, value] of myMap.entries()) { + alert(key + " = " + value); +} +// Mostrarà 2 alertes; el primer amb "0 = zero" i el segon amb "1 = un" + +myMap.forEach(function(value, key) { + alert(key + " = " + value); +}, myMap) +// Mostrarà 2 alertes; el primer amb "0 = zero" i el segon amb "1 = un" +</pre> + +<h3 id="Exemple_Relació_amb_els_objectes_Array">Exemple: Relació amb els objectes <code>Array</code></h3> + +<pre class="brush: js">var kvArray = [["clau1", "valor1"], ["clau2", "valor2"]]; + +// Utilitzeu el constructor de Map normal per a transformar un Array 2D clau-valor en un mapa +var myMap = new Map(kvArray); + +myMap.get("valor1"); // retorna "valor1" + +// Utilitzeu l'operador spread per a transformar un mapa en un Array 2D clau-valor. +alert(uneval([...myMap])); // Mostrarà exactament el mateix Array que kvArray + +// O bé utilitzeu l'operador spread a l'iterador de les claus o els valor per a obtenir +// un array de només les claus o els valors +alert(uneval([...myMap.keys()])); // Mostrarà ["clau1", "clau2"] +</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-map-objects', 'Map')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definició inicial.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{ CompatibilityTable() }}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td> + <p>{{ CompatChrome(31) }} <a href="#chrome-specific-note-1">[1]</a><br> + {{ CompatChrome(38) }}</p> + </td> + <td>{{ CompatGeckoDesktop("13") }}</td> + <td>11</td> + <td>25</td> + <td>7.1</td> + </tr> + <tr> + <td>Argument del constructor: <code>new Map(iterable)</code></td> + <td>{{ CompatChrome(38) }}</td> + <td>{{ CompatGeckoDesktop("13") }}</td> + <td>{{ CompatNo() }}</td> + <td>25</td> + <td>{{ CompatNo() }}</td> + </tr> + <tr> + <td>iterable</td> + <td>{{ CompatChrome(38) }}</td> + <td>{{ CompatGeckoDesktop("17") }}</td> + <td>{{ CompatNo() }}</td> + <td>25</td> + <td>7.1</td> + </tr> + <tr> + <td><code>Map.clear()</code></td> + <td>{{ CompatChrome(31) }} <a href="#chrome-specific-note-1">[1]</a><br> + {{ CompatChrome(38) }}</td> + <td>{{CompatGeckoDesktop("19")}}</td> + <td>11</td> + <td>25</td> + <td>7.1</td> + </tr> + <tr> + <td><code>Map.keys(), Map.values(), Map.entries()</code></td> + <td>{{ CompatChrome(37) }} <a href="#chrome-specific-note-1">[1]</a><br> + {{ CompatChrome(38) }}</td> + <td>{{CompatGeckoDesktop("20")}}</td> + <td>{{ CompatNo() }}</td> + <td>25</td> + <td>7.1</td> + </tr> + <tr> + <td><code>Map.forEach()</code></td> + <td>{{ CompatChrome(36) }} <a href="#chrome-specific-note-1">[1]</a><br> + {{ CompatChrome(38) }}</td> + <td>{{CompatGeckoDesktop("25")}}</td> + <td>11</td> + <td>25</td> + <td>7.1</td> + </tr> + <tr> + <td>Igualtat de claus per a -0 i 0</td> + <td>{{ CompatChrome(34) }} <a href="#chrome-specific-note-1">[1]</a><br> + {{ CompatChrome(38) }}</td> + <td>{{CompatGeckoDesktop("29")}}</td> + <td>{{ CompatNo() }}</td> + <td>25</td> + <td>{{ CompatNo() }}</td> + </tr> + <tr> + <td>Argument del constructor: <code>new Map(null)</code></td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{CompatGeckoDesktop("37")}}</td> + <td>{{ CompatUnknown() }}</td> + <td>{{ CompatUnknown() }}</td> + <td>{{ CompatUnknown() }}</td> + </tr> + <tr> + <td>Monkey-patched <code>set()</code> al Constructor</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{CompatGeckoDesktop("37")}}</td> + <td>{{ CompatUnknown() }}</td> + <td>{{ CompatUnknown() }}</td> + <td>{{ CompatUnknown() }}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome per Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Basic support</td> + <td>{{ CompatNo() }}</td> + <td>{{ CompatChrome(31) }} <a href="#chrome-specific-note-1">[1]</a><br> + {{ CompatChrome(38) }}</td> + <td>{{ CompatGeckoMobile("13") }}</td> + <td>{{ CompatNo() }}</td> + <td>{{ CompatNo() }}</td> + <td>iOS 8</td> + </tr> + <tr> + <td>Argument del constructor: <code>new Map(iterable)</code></td> + <td>{{ CompatNo() }}</td> + <td>{{ CompatChrome(38) }}</td> + <td>{{ CompatGeckoMobile("13") }}</td> + <td>{{ CompatNo() }}</td> + <td>{{ CompatNo() }}</td> + <td>{{ CompatNo }}</td> + </tr> + <tr> + <td>iterable</td> + <td>{{ CompatNo() }}</td> + <td>{{ CompatNo() }}</td> + <td>{{ CompatGeckoMobile("17") }}</td> + <td>{{ CompatNo() }}</td> + <td>{{ CompatNo() }}</td> + <td>iOS 8</td> + </tr> + <tr> + <td><code>Map.clear()</code></td> + <td>{{ CompatNo() }}</td> + <td>{{ CompatChrome(31) }} <a href="#chrome-specific-note-1">[1]</a><br> + {{ CompatChrome(38) }}</td> + <td>{{CompatGeckoMobile("19")}}</td> + <td>{{ CompatNo() }}</td> + <td>{{ CompatNo() }}</td> + <td>iOS 8</td> + </tr> + <tr> + <td><code>Map.keys(), Map.values(), Map.entries()</code></td> + <td>{{ CompatNo() }}</td> + <td>{{ CompatChrome(37) }} <a href="#chrome-specific-note-1">[1]</a><br> + {{ CompatChrome(38) }}</td> + <td>{{CompatGeckoMobile("20")}}</td> + <td>{{ CompatNo() }}</td> + <td>{{ CompatNo() }}</td> + <td>iOS 8</td> + </tr> + <tr> + <td><code>Map.forEach()</code></td> + <td>{{ CompatNo() }}</td> + <td>{{ CompatChrome(36) }} <a href="#chrome-specific-note-1">[1]</a><br> + {{ CompatChrome(38) }}</td> + <td>{{CompatGeckoMobile("25")}}</td> + <td>{{ CompatNo() }}</td> + <td>{{ CompatNo() }}</td> + <td>iOS 8</td> + </tr> + <tr> + <td>Igualtat per a -0 i 0</td> + <td>{{ CompatNo() }}</td> + <td>{{ CompatChrome(34) }} <a href="#chrome-specific-note-1">[1]</a><br> + {{ CompatChrome(38) }}</td> + <td>{{CompatGeckoMobile("29")}}</td> + <td>{{ CompatNo() }}</td> + <td>{{ CompatNo() }}</td> + <td>{{ CompatNo() }}</td> + </tr> + <tr> + <td>Argument del constructor: <code>new Map(null)</code></td> + <td>{{ CompatUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{CompatGeckoMobile("37")}}</td> + <td>{{ CompatUnknown() }}</td> + <td>{{ CompatUnknown() }}</td> + <td>{{ CompatUnknown() }}</td> + </tr> + <tr> + <td>Monkey-patched <code>set()</code> al Constructor</td> + <td>{{ CompatUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{CompatGeckoMobile("37")}}</td> + <td>{{ CompatUnknown() }}</td> + <td>{{ CompatUnknown() }}</td> + <td>{{ CompatUnknown() }}</td> + </tr> + </tbody> +</table> +</div> + +<p><a name="chrome-specific-note-1">[1]</a> The feature is available behind a preference. In <code>chrome://flags</code>, activate the entry “Enable Experimental JavaScript”.</p> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li><a class="link-https" href="https://bugzilla.mozilla.org/show_bug.cgi?id=697479">Bug a Map i Set a Mozilla</a></li> + <li><a class="external" href="http://wiki.ecmascript.org/doku.php?id=harmony:simple_maps_and_sets">Proposta de ECMAScript Harmony</a></li> + <li>{{jsxref("Set")}}</li> + <li>{{jsxref("WeakMap")}}</li> + <li>{{jsxref("WeakSet")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/map/keys/index.html b/files/ca/web/javascript/referencia/objectes_globals/map/keys/index.html new file mode 100644 index 0000000000..47c975a891 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/map/keys/index.html @@ -0,0 +1,104 @@ +--- +title: Map.prototype.keys() +slug: Web/JavaScript/Referencia/Objectes_globals/Map/keys +translation_of: Web/JavaScript/Reference/Global_Objects/Map/keys +--- +<div>{{JSRef}}</div> + +<p>El mètode <code><strong>keys()</strong></code> retorna un nou objecte <code><strong>Iterator</strong></code> que conté les claus per cadascún dels elements de l'objecte <code>Map</code> en l'ordre d'insersió.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><em>myMap</em>.keys()</code></pre> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_keys()">Utilitzar <code>keys()</code></h3> + +<pre class="brush:js">var myMap = new Map(); +myMap.set("0", "foo"); +myMap.set(1, "bar"); +myMap.set({}, "baz"); + +var mapIter = myMap.keys(); + +console.log(mapIter.next().value); // "0" +console.log(mapIter.next().value); // 1 +console.log(mapIter.next().value); // Objecte +</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-map.prototype.keys', 'Map.prototype.keys')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definició inicial.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>38</td> + <td>{{CompatGeckoDesktop("20")}}</td> + <td>{{CompatNo}}</td> + <td>25</td> + <td>7.1</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome 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>38</td> + <td>{{CompatGeckoMobile("20") }}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Map.prototype.entries()")}}</li> + <li>{{jsxref("Map.prototype.values()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/map/prototype/index.html b/files/ca/web/javascript/referencia/objectes_globals/map/prototype/index.html new file mode 100644 index 0000000000..86d4a18c50 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/map/prototype/index.html @@ -0,0 +1,125 @@ +--- +title: Map.prototype +slug: Web/JavaScript/Referencia/Objectes_globals/Map/prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Map +--- +<div>{{JSRef}}</div> + +<p>La propietat <code><strong>Map</strong></code><strong><code>.prototype</code></strong> representa el prototipus per al constructor de {{jsxref("Map")}}.</p> + +<div>{{js_property_attributes(0,0,0)}}</div> + +<h2 id="Descripció">Descripció</h2> + +<p>Les instàncies de {{jsxref("Map")}} hereten de {{jsxref("Map.prototype")}}. Es pot utilitzar el prototipus de l'objecte constructor per a afegir propietats o mètodes a totes les instàncies de <code>Map</code>.</p> + +<h2 id="Propietats">Propietats</h2> + +<dl> + <dt><code>Map.prototype.constructor</code></dt> + <dd>Retorna la funció que ha creat el una instància del prototipus. Per defecte és la funció {{jsxref("Map")}}.</dd> + <dt>{{jsxref("Map.prototype.size")}}</dt> + <dd>Retorna el nombre de parells clau-valor que conté l'objecte <code>Map</code>.</dd> +</dl> + +<h2 id="Mètodes">Mètodes</h2> + +<dl> + <dt>{{jsxref("Map.prototype.clear()")}}</dt> + <dd>Elimina tots els parells clau-valor de l'objecte <code>Map</code>.</dd> + <dt>{{jsxref("Map.delete", "Map.prototype.delete(clau)")}}</dt> + <dd>Elimina el valor associat a la clau especificada i retorna el valor que el mètode <code>Map.prototype.has(valor)</code> hagués retornat abans d'eliminar-lo. <code>Map.prototype.has(clau)</code> retornarà <code>false</code> després de cridar aquest mètode.</dd> + <dt>{{jsxref("Map.prototype.entries()")}}</dt> + <dd>Retorna un nou objecte <code>Iterator</code> que conté<strong> un array de <code>[clau, valor]</code></strong> per a cada element dins l'objecte <code>Map</code>, en estricte ordre d'inserció.</dd> + <dt>{{jsxref("Map.forEach", "Map.prototype.forEach(callbackFn[, thisArg])")}}</dt> + <dd>Crida <code>callbackFn</code> per a cada parell clau-valor present a l'objecte <code>Map</code>, recorreguts per ordre d'inserció. Si es proporciona el paràmetre <code>thisArg</code>, aquest s'utilitzarà com a valor de <em>this</em> per a cada crida a <code>callbackFn</code>.</dd> + <dt>{{jsxref("Map.get", "Map.prototype.get(clau)")}}</dt> + <dd>Retorna el valor associat a la clau, o bé <code>undefined</code> si aquesta clau no té cap valor associat.</dd> + <dt>{{jsxref("Map.has", "Map.prototype.has(clau)")}}</dt> + <dd>Retorna un booleà que especifica si la clau té un valor associat en aquest objecte <code>Map</code> o no.</dd> + <dt>{{jsxref("Map.prototype.keys()")}}</dt> + <dd>Retorna un nou objecte <code>Iterator</code> que conté les <strong>claus</strong> de cada element de l'objecte <code>Map</code>, en ordre d'inserció.</dd> + <dt>{{jsxref("Map.set", "Map.prototype.set(clau, valor)")}}</dt> + <dd>Assigna <code>valor</code> a la <code>clau</code> a l'objecte <code>Map</code>. Retorna l'objecte <code>Map</code>.</dd> + <dt>{{jsxref("Map.prototype.values()")}}</dt> + <dd>Retorna un nou objecte <code>Iterator</code> que conté els <code>valors</code> de cada element de l'objecte <code>Map</code>, en ordre d'inserció.</dd> + <dt>{{jsxref("Map.@@iterator", "Map.prototype[@@iterator]()")}}</dt> + <dd>Retorna un nou objecte <code>Iterator</code> que conté <strong>un array de <code>[clau, valor]</code></strong> per a cada element de l'objecte <code>Map</code>, en ordre d'inserció.</dd> +</dl> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-map.prototype', 'Map.prototype')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definició inicial.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>38</td> + <td>{{ CompatGeckoDesktop("13") }}</td> + <td>11</td> + <td>25</td> + <td>7.1</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatNo}}</td> + <td>38</td> + <td>{{CompatGeckoMobile("13")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td> + <p>8</p> + </td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Set.prototype")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/map/set/index.html b/files/ca/web/javascript/referencia/objectes_globals/map/set/index.html new file mode 100644 index 0000000000..3b77060831 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/map/set/index.html @@ -0,0 +1,122 @@ +--- +title: Map.prototype.set() +slug: Web/JavaScript/Referencia/Objectes_globals/Map/set +translation_of: Web/JavaScript/Reference/Global_Objects/Map/set +--- +<div>{{JSRef}}</div> + +<p>El mètode <code><strong>set()</strong></code> afegeig un nou element amb la <code>clau</code> i el <code>valor</code> especificats a un objecte de tipus <code>Map</code>.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><em>myMap</em>.set(clau, valor);</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt>clau</dt> + <dd>Obligatori. La clau de l'element a afegir a l'objecte <code>Map</code>.</dd> + <dt>valor</dt> + <dd>Obligatori. El valor de l'element a afegir a l'objecte <code>Map</code>.</dd> +</dl> + +<h3 id="Valor_retornat">Valor retornat</h3> + +<p>L'objecte <code>Map</code>.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_el_mètode_set">Utilitzar el mètode <code>set</code></h3> + +<pre class="brush: js">var myMap = new Map(); + +// Afegim nous elements al mapa +myMap.set("bar", "foo"); +myMap.set(1, "foobar"); + +// Actualitzem un element amb una clau ja existent al mapa +myMap.set("bar", "fuuu"); +</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-map.prototype.set', 'Map.prototype.set')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definició inicial.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>38</td> + <td>{{CompatGeckoDesktop("13.0")}}</td> + <td>11</td> + <td>25</td> + <td>7.1</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatNo}}</td> + <td>38</td> + <td>{{CompatGeckoMobile("13.0")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Notes_sobre_compatibilitat">Notes sobre compatibilitat</h2> + +<ul> + <li>Abans del Firefox 33 {{geckoRelease("33")}}, <code>Map.prototype.set</code> retornava <code>undefined</code> i en conseqüència no permitia la crida encadenada. Aquest problema va ser solucionat ({{bug(1031632)}}). Aquest comportament també es pot observar al Chrome/v8 (<a href="https://code.google.com/p/v8/issues/detail?id=3410">problema</a>).</li> +</ul> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Map")}}</li> + <li>{{jsxref("Map.prototype.get()")}}</li> + <li>{{jsxref("Map.prototype.has()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/map/size/index.html b/files/ca/web/javascript/referencia/objectes_globals/map/size/index.html new file mode 100644 index 0000000000..aa70c7d84b --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/map/size/index.html @@ -0,0 +1,105 @@ +--- +title: Map.prototype.size +slug: Web/JavaScript/Referencia/Objectes_globals/Map/size +translation_of: Web/JavaScript/Reference/Global_Objects/Map/size +--- +<div>{{JSRef}}</div> + +<p>La propietat d'accés <code><strong>size</strong></code> retorna el número d'elements en un objecte {{jsxref("Map")}}.</p> + +<h2 id="Descripció">Descripció</h2> + +<p>El valor de <code>size</code> és un nombre sencer que representa quantes entrades té l'objecte <code>Map.</code> Una funció d'accés establerta per <code>size</code> és <code>undefined</code>; aquesta propietat no es pot canviar.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_size">Utilitzar <code>size</code></h3> + +<pre class="brush:js">var myMap = new Map(); +myMap.set("a", "alpha"); +myMap.set("b", "beta"); +myMap.set("g", "gamma"); + +myMap.size // 3 +</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-get-map.prototype.size', 'Map.prototype.size')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definició inicial.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</td> + <td>38</td> + <td>{{ CompatGeckoDesktop("19") }}</td> + <td>{{ CompatIE("11") }}</td> + <td>25</td> + <td>7.1</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</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>Basic support</td> + <td>{{CompatNo}}</td> + <td>38</td> + <td>{{CompatGeckoMobile("19")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Notes_específiques_de_Gecko">Notes específiques de Gecko</h2> + +<ul> + <li>A partir de Gecko 13 {{geckoRelease("13")}} fins Gecko 18 {{geckoRelease("18")}} la propietat size era implementada com un mètode <strong><code>Map.prototype.size()</code></strong>, aquesta s'ha canviat a una propietat en versions posteriors conforme l'especificació d'ECMAScript 6 ({{bug("807001")}}).</li> +</ul> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Map")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/map/values/index.html b/files/ca/web/javascript/referencia/objectes_globals/map/values/index.html new file mode 100644 index 0000000000..f1b23be7e7 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/map/values/index.html @@ -0,0 +1,103 @@ +--- +title: Map.prototype.values() +slug: Web/JavaScript/Referencia/Objectes_globals/Map/values +translation_of: Web/JavaScript/Reference/Global_Objects/Map/values +--- +<div>{{JSRef}}</div> + +<p>El mètode <code><strong>values()</strong></code> retorna un nou objecte <strong><a href="/en-US/docs/Web/JavaScript/Guide/Iterators_and_Generators">Iterator</a></strong> que conté els valor per cadascún dels elements de l'objecte <code>Map</code> en l'ordre d'inserció.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><em>myMap</em>.values()</code></pre> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_values()">Utilitzar <code>values()</code></h3> + +<pre class="brush:js">var myMap = new Map(); +myMap.set("0", "foo"); +myMap.set(1, "bar"); +myMap.set({}, "baz"); + +var mapIter = myMap.values(); + +console.log(mapIter.next().value); // "foo" +console.log(mapIter.next().value); // "bar" +console.log(mapIter.next().value); // "baz"</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-map.prototype.values', 'Map.prototype.values')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definició inicial.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>38</td> + <td>{{ CompatGeckoDesktop("20") }}</td> + <td>{{CompatNo}}</td> + <td>25</td> + <td>7.1</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome 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>38</td> + <td>{{ CompatGeckoMobile("20") }}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Map.prototype.entries()")}}</li> + <li>{{jsxref("Map.prototype.keys()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/math/abs/index.html b/files/ca/web/javascript/referencia/objectes_globals/math/abs/index.html new file mode 100644 index 0000000000..34d3e5beb9 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/math/abs/index.html @@ -0,0 +1,129 @@ +--- +title: Math.abs() +slug: Web/JavaScript/Referencia/Objectes_globals/Math/abs +translation_of: Web/JavaScript/Reference/Global_Objects/Math/abs +--- +<div>{{JSRef("Global_Objects", "Math")}}</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>La funció <strong><code>Math.abs()</code></strong> retorna el valor absolut d'un nombre. És a dir:</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.abs</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mrow><mo stretchy="false">|</mo><mi>x</mi><mo stretchy="false">|</mo></mrow><mo>=</mo><mrow><mo>{</mo><mtable columnalign="left left"><mtr><mtd><mi>x</mi></mtd><mtd><mtext>if</mtext><mspace width="1em"></mspace><mi>x</mi><mo>></mo><mn>0</mn></mtd></mtr><mtr><mtd><mi>0</mi></mtd><mtd><mtext>if</mtext><mspace width="1em"></mspace><mi>x</mi><mo>=</mo><mn>0</mn></mtd></mtr><mtr><mtd><mo>-</mo><mi>x</mi></mtd><mtd><mtext>if</mtext><mspace width="1em"></mspace><mi>x</mi><mo><</mo><mn>0</mn></mtd></mtr></mtable></mrow></mrow><annotation encoding="TeX">{\mathtt{\operatorname{Math.abs}(x)}} = {|x|} = \begin{cases} x & \text{if} \quad x \geq 0 \\ -x & \text{if} \quad x < 0 \end{cases} </annotation></semantics></math></p> + +<h2 id="Syntax" name="Syntax">Sintaxi</h2> + +<pre class="syntaxbox"><code>Math.abs(<var>x</var>)</code></pre> + +<h3 id="Parameters" name="Parameters">Paràmetres</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Un nombre.</dd> +</dl> + +<h2 id="Description" name="Description">Descripció</h2> + +<p>Degut a que <code>abs()</code> és un mètode estàtic de <code>Math</code>, sempre s'utilitza com a <code>Math.abs()</code>, en comptes de com a mètode d'una instància de <code>Math</code> (<code>Math</code> no és un constructor).</p> + +<h2 id="Examples" name="Examples">Exemples</h2> + +<h3 id="Example:_Math.abs_behavior" name="Example:_Math.abs_behavior">Exemple: Comportament de <code>Math.abs()</code></h3> + +<p>Si li passem una string no numèric o bé una variable {{jsxref("undefined")}}/buida retorna {{jsxref("NaN")}}. Passar {{jsxref("null")}} retorna 0.</p> + +<pre class="brush: js">Math.abs('-1'); // 1 +Math.abs(-2); // 2 +Math.abs(null); // 0 +Math.abs('string'); // NaN +Math.abs(); // NaN +</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>ECMAScript 1a Edició.</td> + <td>Standard</td> + <td>Definició inicial. Implementat a JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.1', 'Math.abs')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.abs', 'Math.abs')}}</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>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li>{{jsxref("Math.ceil()")}}</li> + <li>{{jsxref("Math.floor()")}}</li> + <li>{{jsxref("Math.round()")}}</li> + <li>{{jsxref("Math.sign()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.trunc()")}} {{experimental_inline}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/math/acos/index.html b/files/ca/web/javascript/referencia/objectes_globals/math/acos/index.html new file mode 100644 index 0000000000..fdf781a4e2 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/math/acos/index.html @@ -0,0 +1,131 @@ +--- +title: Math.acos() +slug: Web/JavaScript/Referencia/Objectes_globals/Math/acos +translation_of: Web/JavaScript/Reference/Global_Objects/Math/acos +--- +<div>{{JSRef("Global_Objects", "Math")}}</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>La funció <strong><code>Math.acos()</code></strong> retorna l'arccosinus (mesurat en radians) d'un nombre, és a dir:<math display="block"><semantics><mrow><mo></mo><mi>x</mi><mo>∊</mo><mo stretchy="false">[</mo><mrow><mo>-</mo><mn>1</mn></mrow><mo>;</mo><mn>1</mn><mo stretchy="false">]</mo><mo>,</mo><mspace width="thickmathspace"></mspace><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.acos</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">arccos</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext> l'únic </mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mo>∊</mo><mo stretchy="false">[</mo><mn>0</mn><mo>;</mo><mi>π</mi><mo stretchy="false">]</mo><mspace width="thinmathspace"></mspace><mtext>tal que</mtext><mspace width="thickmathspace"></mspace><mo lspace="0em" rspace="0em">cos</mo><mo stretchy="false">(</mo><mi>y</mi><mo stretchy="false">)</mo><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x \in [{-1};1],\;\mathtt{\operatorname{Math.acos}(x)} = \arccos(x) = \text{ the unique } \; y \in [0; \pi] \, \text{such that} \; \cos(y) = x</annotation></semantics></math></p> + +<h2 id="Syntax" name="Syntax">Sintaxi</h2> + +<pre class="syntaxbox"><code>Math.acos(<var>x</var>)</code></pre> + +<h3 id="Parameters" name="Parameters">Paràmetres</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Un nombre.</dd> +</dl> + +<h2 id="Description" name="Description">Descripció</h2> + +<p>El mètode <code>Math.acos()</code> retorna un valor numèric entre 0 i π radians per a <code>x</code> entre -1 i 1. Si el valor de <code>x</code> està fora d'aquest rang, retorna {{jsxref("NaN")}}.</p> + +<p>Degut a que <code>acos()</code> és un mètode estàtic de <code>Math</code>, sempre s'utilitza com a <code>Math.acos()</code>, en comptes de com a mètode d'una instància de <code>Math</code> (<code>Math</code> no és un constructor).</p> + +<h2 id="Examples" name="Examples">Exemples</h2> + +<h3 id="Example:_Using_Math.acos" name="Example:_Using_Math.acos">Exemple: Utilitzar <code>Math.acos()</code></h3> + +<pre class="brush: js">Math.acos(-2); // NaN +Math.acos(-1); // 3.141592653589793 +Math.acos(0); // 1.5707963267948966 +Math.acos(0.5); // 1.0471975511965979 +Math.acos(1); // 0 +Math.acos(2); // NaN +</pre> + +<p>Per a valors menors que -1 o majors que 1, <code>Math.acos()</code> retorna {{jsxref("NaN")}}.</p> + +<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>ECMAScript 1a Edició.</td> + <td>Standard</td> + <td>Definició inicial. Implementat a JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.2', 'Math.acos')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.acos', 'Math.acos')}}</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>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li>{{jsxref("Math.asin()")}}</li> + <li>{{jsxref("Math.atan()")}}</li> + <li>{{jsxref("Math.atan2()")}}</li> + <li>{{jsxref("Math.cos()")}}</li> + <li>{{jsxref("Math.sin()")}}</li> + <li>{{jsxref("Math.tan()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/math/acosh/index.html b/files/ca/web/javascript/referencia/objectes_globals/math/acosh/index.html new file mode 100644 index 0000000000..edfe1dd8c0 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/math/acosh/index.html @@ -0,0 +1,126 @@ +--- +title: Math.acosh() +slug: Web/JavaScript/Referencia/Objectes_globals/Math/acosh +translation_of: Web/JavaScript/Reference/Global_Objects/Math/acosh +--- +<div>{{JSRef}}</div> + +<p>La funció <strong><code>Math.acosh()</code></strong> retorna l'accosinus hiperbòlic d'un nombre, és a dir</p> + +<p><math display="block"><semantics><mrow><mo>∀</mo><mi>x</mi><mo>≥</mo><mn>1</mn><mo>,</mo><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.acosh</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="thinmathspace">arcosh</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext> l'única </mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mo>≥</mo><mn>0</mn><mspace width="thickmathspace"></mspace><mtext>tal que</mtext><mspace width="thickmathspace"></mspace><mo lspace="0em" rspace="0em">cosh</mo><mo stretchy="false">(</mo><mi>y</mi><mo stretchy="false">)</mo><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x \geq 1, \mathtt{\operatorname{Math.acosh}(x)} = \operatorname{arcosh}(x) = \text{ the unique } \; y \geq 0 \; \text{such that} \; \cosh(y) = x</annotation></semantics></math></p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code>Math.acosh(<var>x</var>)</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Un nombre.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Com que que <code>acosh()</code> és un mètode estàtic de <code>Math</code>, sempre s'utilitza com a <code>Math.acosh()</code>, en comptes de com a mètode d'una instància de <code>Math</code> (<code>Math</code> no és un constructor).</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_Math.acosh()">Utilitzar <code>Math.acosh()</code></h3> + +<pre class="brush: js">Math.acosh(-1); // NaN +Math.acosh(0); // NaN +Math.acosh(0.5) // NaN +Math.acosh(1); // 0 +Math.acosh(2); // 1.3169578969248166 +</pre> + +<p><code>Math.acosh()</code> retorna {{jsxref("NaN")}} per a valors menors que 1.</p> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Per a tot <math><semantics><mrow><mi>x</mi><mo>≥</mo><mn>1</mn></mrow><annotation encoding="TeX">x \geq 1</annotation></semantics></math>, tenim que <math><semantics><mrow><mo lspace="0em" rspace="thinmathspace">arcosh</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mo lspace="0em" rspace="0em">ln</mo><mrow><mo>(</mo><mrow><mi>x</mi><mo>+</mo><msqrt><mrow><msup><mi>x</mi><mn>2</mn></msup><mo>-</mo><mn>1</mn></mrow></msqrt></mrow><mo>)</mo></mrow></mrow><annotation encoding="TeX">\operatorname {arcosh} (x) = \ln \left(x + \sqrt{x^{2} - 1} \right)</annotation></semantics></math> i, per tant, es pot emular mitjançant la funció següent:</p> + +<pre class="brush: js">Math.acosh = Math.acosh || function(x) { + return Math.log(x + Math.sqrt(x * x - 1)); +}; +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificacions</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.acosh', 'Math.acosh')}}</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("38")}}</td> + <td>{{CompatGeckoDesktop("25")}}</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("25")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Math.asinh()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.atanh()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.cosh()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.sinh()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.tanh()")}} {{experimental_inline}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/math/asin/index.html b/files/ca/web/javascript/referencia/objectes_globals/math/asin/index.html new file mode 100644 index 0000000000..81288af5b6 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/math/asin/index.html @@ -0,0 +1,133 @@ +--- +title: Math.asin() +slug: Web/JavaScript/Referencia/Objectes_globals/Math/asin +translation_of: Web/JavaScript/Reference/Global_Objects/Math/asin +--- +<div>{{JSRef("Global_Objects", "Math")}}</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>La funció <strong><code>Math.asin()</code></strong> retorna l'arcsinus (en radians) d'un nombre, és a dir:</p> + +<p><math display="block"><semantics><mrow><mo>∀</mo><mi>x</mi><mo>∊</mo><mo stretchy="false">[</mo><mrow><mo>-</mo><mn>1</mn></mrow><mo>;</mo><mn>1</mn><mo stretchy="false">]</mo><mo>,</mo><mspace width="thickmathspace"></mspace><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.asin</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">arcsin</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext> l'únic </mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mo>∊</mo><mrow><mo>[</mo><mrow><mo>-</mo><mfrac><mi>π</mi><mn>2</mn></mfrac><mo>;</mo><mfrac><mi>π</mi><mn>2</mn></mfrac></mrow><mo>]</mo></mrow><mspace width="thinmathspace"></mspace><mtext>tal que </mtext><mo lspace="0em" rspace="0em">sin</mo><mo stretchy="false">(</mo><mi>y</mi><mo stretchy="false">)</mo><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x \in [{-1};1],\;\mathtt{\operatorname{Math.asin}(x)} = \arcsin(x) = \text{ the unique } \; y \in \left[-\frac{\pi}{2}; \frac{\pi}{2}\right] \, \text{such that} \; \sin(y) = x</annotation></semantics></math></p> + +<h2 id="Syntax" name="Syntax">Sintaxi</h2> + +<pre class="syntaxbox"><code>Math.asin(<var>x</var>)</code></pre> + +<h3 id="Parameters" name="Parameters">Paràmetres</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Un nombre.</dd> +</dl> + +<h2 id="Description" name="Description">Descripció</h2> + +<p>El mètode <code>Math.asin()</code> retorna un valor numèric entre <math><semantics><mrow><mo>-</mo><mfrac><mi>π</mi><mn>2</mn></mfrac></mrow><annotation encoding="TeX">-\frac{\pi}{2}</annotation></semantics></math> i <math><semantics><mfrac><mi>π</mi><mn>2</mn></mfrac><annotation encoding="TeX">\frac{\pi}{2}</annotation></semantics></math> radians per a <code>x</code> entre -1 i 1. Si el valor de <code>x</code> està fora d'aquest rang la funció retorna {{jsxref("NaN")}}.</p> + +<p>Degut a que <code>asin()</code> és un mètode estàtic de <code>Math</code>, sempre s'utilitza com a <code>Math.asin()</code>, en comptes de com a mètode d'una instància de <code>Math</code> (<code>Math</code> no és un constructor).</p> + +<h2 id="Examples" name="Examples">Exemples</h2> + +<h3 id="Example:_Using_Math.asin" name="Example:_Using_Math.asin">Exemple: Ús de <code>Math.asin()</code></h3> + +<pre class="brush: js">Math.asin(-2); // NaN +Math.asin(-1); // -1.5707963267948966 (-pi/2) +Math.asin(0); // 0 +Math.asin(0.5); // 0.5235987755982989 +Math.asin(1); // 1.570796326794897 (pi/2) +Math.asin(2); // NaN +</pre> + +<p>Per a valors menors que -1 o majors que 1, <code>Math.asin()</code> retorna {{jsxref("NaN")}}.</p> + +<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>ECMAScript 1a Edició.</td> + <td>Standard</td> + <td>Definició inicial. Implementat a JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.3', 'Math.asin')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.asin', 'Math.asin')}}</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>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li>{{jsxref("Math.acos()")}}</li> + <li>{{jsxref("Math.atan()")}}</li> + <li>{{jsxref("Math.atan2()")}}</li> + <li>{{jsxref("Math.cos()")}}</li> + <li>{{jsxref("Math.sin()")}}</li> + <li>{{jsxref("Math.tan()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/math/asinh/index.html b/files/ca/web/javascript/referencia/objectes_globals/math/asinh/index.html new file mode 100644 index 0000000000..9a249bb202 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/math/asinh/index.html @@ -0,0 +1,125 @@ +--- +title: Math.asinh() +slug: Web/JavaScript/Referencia/Objectes_globals/Math/asinh +translation_of: Web/JavaScript/Reference/Global_Objects/Math/asinh +--- +<div>{{JSRef}}</div> + +<p>La funció <strong><code>Math.asinh()</code></strong> retorna l'arcsinus hiperbòlic d'un nombre, és a dir</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.asinh</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="thinmathspace">arsinh</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext> l'única </mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mspace width="thickmathspace"></mspace><mtext>tal que</mtext><mspace width="thickmathspace"></mspace><mo lspace="0em" rspace="0em">sinh</mo><mo stretchy="false">(</mo><mi>y</mi><mo stretchy="false">)</mo><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\mathtt{\operatorname{Math.asinh}(x)} = \operatorname{arsinh}(x) = \text{ the unique } \; y \; \text{such that} \; \sinh(y) = x</annotation></semantics></math></p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code>Math.asinh(<var>x</var>)</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Un nombre.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Com que que <code>asinh</code>() és un mètode estàtic de Math, sempre s'utilitza com a Math.<code>asinh</code>(), en comptes de com a mètode d'una instància de Math (Math no és un constructor).</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_Math.asinh()">Utilitzar <code>Math.asinh()</code></h3> + +<pre class="brush: js">Math.asinh(1); // 0.881373587019543 +Math.asinh(0); // 0 +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Tenim que <math><semantics><mrow><mo lspace="0em" rspace="thinmathspace">arsinh</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mo lspace="0em" rspace="0em">ln</mo><mrow><mo>(</mo><mrow><mi>x</mi><mo>+</mo><msqrt><mrow><msup><mi>x</mi><mn>2</mn></msup><mo>+</mo><mn>1</mn></mrow></msqrt></mrow><mo>)</mo></mrow></mrow><annotation encoding="TeX">\operatorname {arsinh} (x) = \ln \left(x + \sqrt{x^{2} + 1} \right)</annotation></semantics></math> amb el que podem emular el comportament amb la funció següent:</p> + +<pre class="brush: js">Math.asinh = Math.asinh || function(x) { + if (x === -Infinity) { + return x; + } else { + return Math.log(x + Math.sqrt(x * x + 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-math.asinh', 'Math.asinh')}}</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("38")}}</td> + <td>{{CompatGeckoDesktop("25")}}</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("25")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Math.acosh()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.atanh()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.cosh()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.sinh()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.tanh()")}} {{experimental_inline}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/math/atan/index.html b/files/ca/web/javascript/referencia/objectes_globals/math/atan/index.html new file mode 100644 index 0000000000..034578fd54 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/math/atan/index.html @@ -0,0 +1,127 @@ +--- +title: Math.atan() +slug: Web/JavaScript/Referencia/Objectes_globals/Math/atan +translation_of: Web/JavaScript/Reference/Global_Objects/Math/atan +--- +<div>{{JSRef("Global_Objects", "Math")}}</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>La funció <strong><code>Math.atan()</code></strong> retorna l'arctangent (en radians) d'un nombre, és a dir:</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.atan</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">arctan</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext> l'unic </mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mo>∊</mo><mrow><mo>[</mo><mrow><mo>-</mo><mfrac><mi>π</mi><mn>2</mn></mfrac><mo>;</mo><mfrac><mi>π</mi><mn>2</mn></mfrac></mrow><mo>]</mo></mrow><mspace width="thinmathspace"></mspace>tal que<mtext></mtext><mspace width="thickmathspace"></mspace><mo lspace="0em" rspace="0em">tan</mo><mo stretchy="false">(</mo><mi>y</mi><mo stretchy="false">)</mo><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\mathtt{\operatorname{Math.atan}(x)} = \arctan(x) = \text{ the unique } \; y \in \left[-\frac{\pi}{2}; \frac{\pi}{2}\right] \, \text{such that} \; \tan(y) = x</annotation></semantics></math></p> + +<h2 id="Syntax" name="Syntax">Sintaxi</h2> + +<pre class="syntaxbox"><code>Math.atan(<var>x</var>)</code></pre> + +<h3 id="Parameters" name="Parameters">Paràmetres</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Un nombre.</dd> +</dl> + +<h2 id="Description" name="Description">Descripció</h2> + +<p>El mètode <code>Math.atan()</code> retorna un valor numèric entre <math><semantics><mrow><mo>-</mo><mfrac><mi>π</mi><mn>2</mn></mfrac></mrow><annotation encoding="TeX">-\frac{\pi}{2}</annotation></semantics></math> i <math><semantics><mfrac><mi>π</mi><mn>2</mn></mfrac><annotation encoding="TeX">\frac{\pi}{2}</annotation></semantics></math> radians.</p> + +<p>Degut a que <code>atan()</code> és un mètode estàtic de <code>Math</code>, sempre s'utilitza com a <code>Math.atan()</code>, en comptes de com a mètode d'una instància de <code>Math</code> (<code>Math</code> no és un constructor).</p> + +<h2 id="Examples" name="Examples">Exemples</h2> + +<h3 id="Example:_Using_Math.atan" name="Example:_Using_Math.atan">Exemple: Utilitzar <code>Math.atan()</code></h3> + +<pre class="brush: js">Math.atan(1); // 0.7853981633974483 +Math.atan(0); // 0 +</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>ECMAScript 1a Edició.</td> + <td>Standard</td> + <td>Definició inicial. Implementat a JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.4', 'Math.atan')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.atan', 'Math.atan')}}</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>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li>{{jsxref("Math.acos()")}}</li> + <li>{{jsxref("Math.asin()")}}</li> + <li>{{jsxref("Math.atan2()")}}</li> + <li>{{jsxref("Math.cos()")}}</li> + <li>{{jsxref("Math.sin()")}}</li> + <li>{{jsxref("Math.tan()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/math/atan2/index.html b/files/ca/web/javascript/referencia/objectes_globals/math/atan2/index.html new file mode 100644 index 0000000000..2816bb40b8 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/math/atan2/index.html @@ -0,0 +1,139 @@ +--- +title: Math.atan2() +slug: Web/JavaScript/Referencia/Objectes_globals/Math/atan2 +translation_of: Web/JavaScript/Reference/Global_Objects/Math/atan2 +--- +<div>{{JSRef}}</div> + +<p>La funció <strong><code>Math.atan2()</code></strong> retorna l'arctangent del quocient dels arguments passats.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code>Math.atan2(<var>y</var>, <var>x</var>)</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>y</code></dt> + <dd>Primer nombre.</dd> + <dt><code>x</code></dt> + <dd>Segon nombre.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>El mètode <code>Math.atan2()</code> retorn aun valor numèric entre -π i π que representa l'angle theta d'un punt <code>(x, y)</code>. Aquest angle es representa en radiants, en sentit contrari a les agulles del rellotge, entre l'eix positiu X i el punt <code>(x, y)</code>. Cal destacar que els arguments d'aquesta funció representen les coordenades del punt, on el primer argument representa la coordenada <code>y</code> i el segon argument representa la coordenada <code>x</code>.</p> + +<p><code>Math.atan2()</code> rep els arguments <code>x</code> i <code>y</code> de forma separada mentre que <code>Math.atan()</code> rep la relació (ratio) entre aquests dos arguments.</p> + +<p>Com que que <code>atan2()</code> és un mètode estàtic de <code>Math</code>, sempre s'utilitza com a <code>Math.atan2()</code>, en comptes de com a mètode d'una instància de <code>Math</code> (<code>Math</code> no és un constructor).</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_Math.atan2()">Utilitzar <code>Math.atan2()</code></h3> + +<pre class="brush: js">Math.atan2(90, 15); // 1.4056476493802699 +Math.atan2(15, 90); // 0.16514867741462683 + +Math.atan2(±0, -0); // ±PI. +Math.atan2(±0, +0); // ±0. +Math.atan2(±0, -x); // ±PI for x > 0. +Math.atan2(±0, x); // ±0 for x > 0. +Math.atan2(-y, ±0); // -PI/2 for y > 0. +Math.atan2(y, ±0); // PI/2 for y > 0. +Math.atan2(±y, -Infinity); // ±PI for finite y > 0. +Math.atan2(±y, +Infinity); // ±0 for finite y > 0. +Math.atan2(±Infinity, x); // ±PI/2 for finite x. +Math.atan2(±Infinity, -Infinity); // ±3*PI/4. +Math.atan2(±Infinity, +Infinity); // ±PI/4. +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definició inicial. Implementat a JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.5', 'Math.atan2')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.atan2', 'Math.atan2')}}</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 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("Math.acos()")}}</li> + <li>{{jsxref("Math.asin()")}}</li> + <li>{{jsxref("Math.atan()")}}</li> + <li>{{jsxref("Math.cos()")}}</li> + <li>{{jsxref("Math.sin()")}}</li> + <li>{{jsxref("Math.tan()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/math/atanh/index.html b/files/ca/web/javascript/referencia/objectes_globals/math/atanh/index.html new file mode 100644 index 0000000000..8a6b7cc2c8 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/math/atanh/index.html @@ -0,0 +1,127 @@ +--- +title: Math.atanh() +slug: Web/JavaScript/Referencia/Objectes_globals/Math/atanh +translation_of: Web/JavaScript/Reference/Global_Objects/Math/atanh +--- +<div>{{JSRef}}</div> + +<p>La funció <strong><code>Math.atanh()</code></strong> retorna l'arctangent hiperbòlica d'un nombre, és a dir</p> + +<p><math display="block"><semantics><mrow><mo>∀</mo><mi>x</mi><mo>∊</mo><mrow><mo>(</mo><mrow><mo>-</mo><mn>1</mn><mo>,</mo><mn>1</mn></mrow><mo>)</mo></mrow><mo>,</mo><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.atanh</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="thinmathspace">arctanh</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext> l'única </mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mspace width="thickmathspace"></mspace><mtext>tal que</mtext><mspace width="thickmathspace"></mspace><mo lspace="0em" rspace="0em">tanh</mo><mo stretchy="false">(</mo><mi>y</mi><mo stretchy="false">)</mo><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x \in \left( -1, 1 \right), \mathtt{\operatorname{Math.atanh}(x)} = \operatorname{arctanh}(x) = \text{ the unique } \; y \; \text{such that} \; \tanh(y) = x</annotation></semantics></math></p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code>Math.atanh(<var>x</var>)</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Un nombre.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Com que que <code>atanh</code>() és un mètode estàtic de Math, sempre s'utilitza com a <code>Math.atanh</code>(), en comptes de com a mètode d'una instància de <code>Math </code>(<code>Math </code>no és un constructor).</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_Math.atanh()">Utilitzar <code>Math.atanh()</code></h3> + +<pre class="brush: js">Math.atanh(-2); // NaN +Math.atanh(-1); // -Infinity +Math.atanh(0); // 0 +Math.atanh(0.5); // 0.5493061443340548 +Math.atanh(1); // Infinity +Math.atanh(2); // NaN +</pre> + +<p>Es retorna {{jsxref("NaN")}} per a valors més grans que 1 o més petits que -1.</p> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Per a <math><semantics><mrow><mrow><mo>|</mo><mi>x</mi><mo>|</mo></mrow><mo><</mo><mn>1</mn></mrow><annotation encoding="TeX">\left|x\right| < 1</annotation></semantics></math>, tenim que <math><semantics><mrow><mo lspace="0em" rspace="thinmathspace">artanh</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mfrac><mn>1</mn><mn>2</mn></mfrac><mo lspace="0em" rspace="0em">ln</mo><mrow><mo>(</mo><mfrac><mrow><mn>1</mn><mo>+</mo><mi>x</mi></mrow><mrow><mn>1</mn><mo>-</mo><mi>x</mi></mrow></mfrac><mo>)</mo></mrow></mrow><annotation encoding="TeX">\operatorname {artanh} (x) = \frac{1}{2}\ln \left( \frac{1 + x}{1 - x} \right)</annotation></semantics></math> , que podem emular amb la funció següent:</p> + +<pre class="brush: js">Math.atanh = Math.atanh || function(x) { + return Math.log((1+x)/(1-x)) / 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-math.atanh', 'Math.atanh')}}</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("38")}}</td> + <td>{{CompatGeckoDesktop("25")}}</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("25")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Math.acosh()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.asinh()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.cosh()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.sinh()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.tanh()")}} {{experimental_inline}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/math/cbrt/index.html b/files/ca/web/javascript/referencia/objectes_globals/math/cbrt/index.html new file mode 100644 index 0000000000..70d6767183 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/math/cbrt/index.html @@ -0,0 +1,122 @@ +--- +title: Math.cbrt() +slug: Web/JavaScript/Referencia/Objectes_globals/Math/cbrt +translation_of: Web/JavaScript/Reference/Global_Objects/Math/cbrt +--- +<div>{{JSRef}}</div> + +<p>La funció <strong><code>Math.cbrt()</code></strong> retorna la rel cúbica d'un nombre, és a dir</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mrow><mi>M</mi><mi>a</mi><mi>t</mi><mi>h</mi><mo>.</mo><mi>c</mi><mi>b</mi><mi>r</mi><mi>t</mi><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mroot><mi>x</mi><mn>3</mn></mroot><mo>=</mo><mtext>la única</mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mspace width="thickmathspace"></mspace><mtext>tal que</mtext><mspace width="thickmathspace"></mspace><msup><mi>y</mi><mn>3</mn></msup><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\mathtt{Math.cbrt(x)} = \sqrt[3]{x} = \text{the unique} \; y \; \text{such that} \; y^3 = x</annotation></semantics></math></p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code>Math.cbrt(<var>x</var>)</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Un nombre.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Degut a que <code>cbrt()</code> és un mètode estàtic de <code>Math</code>, sempre s'utilitza com a <code>Math.cbrt()</code>, en comptes de com a mètode d'una instància de <code>Math</code> (<code>Math</code> no és un constructor).</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_Math.cbrt()">Utilitzar <code>Math.cbrt()</code></h3> + +<pre class="brush: js">Math.cbrt(-1); // -1 +Math.cbrt(0); // 0 +Math.cbrt(1); // 1 + +Math.cbrt(2); // 1.2599210498948734 +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Per a tot <math><semantics><mrow><mi>x</mi><mo>≥</mo><mn>0</mn></mrow><annotation encoding="TeX">x \geq 0</annotation></semantics></math>, tenim que <math><semantics><mrow><mroot><mi>x</mi><mn>3</mn></mroot><mo>=</mo><msup><mi>x</mi><mrow><mn>1</mn><mo>/</mo><mn>3</mn></mrow></msup></mrow><annotation encoding="TeX">\sqrt[3]{x} = x^{1/3}</annotation></semantics></math> , podem llavors emular aquest comportament amb la funció següent:</p> + +<pre class="brush: js">Math.cbrt = Math.cbrt || function(x) { + var y = Math.pow(Math.abs(x), 1/3); + return x < 0 ? -y : y; +}; +</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-math.cbrt', 'Math.cbrt')}}</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("38")}}</td> + <td>{{CompatGeckoDesktop("25")}}</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("25")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Math.pow()")}}</li> + <li>{{jsxref("Math.sqrt()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/math/ceil/index.html b/files/ca/web/javascript/referencia/objectes_globals/math/ceil/index.html new file mode 100644 index 0000000000..a96880eecd --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/math/ceil/index.html @@ -0,0 +1,197 @@ +--- +title: Math.ceil() +slug: Web/JavaScript/Referencia/Objectes_globals/Math/ceil +translation_of: Web/JavaScript/Reference/Global_Objects/Math/ceil +--- +<div>{{JSRef("Global_Objects", "Math")}}</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>La funció <strong><code>Math.ceil()</code></strong> retorna el més petit dels nombres sencers més grans o iguals a un nombre donat.</p> + +<h2 id="Syntax" name="Syntax">Sintaxi</h2> + +<pre class="syntaxbox"><code>Math.ceil(<var>x</var>)</code></pre> + +<h3 id="Parameters" name="Parameters">Paràmetres</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Un nombre.</dd> +</dl> + +<h2 id="Description" name="Description">Descripció</h2> + +<p>Degut a que <code>ceil()</code> és un mètode estàtic de <code>Math</code>, sempre s'utilitza com a <code>Math.ceil()</code>, ren comptes de com a mètode d'una instància de <code>Math</code> (<code>Math</code> no és un constructor).</p> + +<h2 id="Examples" name="Examples">Exemples</h2> + +<h3 id="Example:_Using_Math.ceil" name="Example:_Using_Math.ceil">Exemple: Ús de <code>Math.ceil()</code></h3> + +<p>L'exemple següent mostra l'ús de <code>Math.ceil()</code>.</p> + +<pre class="brush: js">Math.ceil(.95); // 1 +Math.ceil(4); // 4 +Math.ceil(7.004); // 8 +</pre> + +<h3 id="Example:_Decimal_adjustment" name="Example:_Decimal_adjustment">Exemple: Ajust decimal</h3> + +<pre class="brush: js">// Closure +(function() { + /** + * Decimal adjustment of a number. + * + * @param {String} type The type of adjustment. + * @param {Number} value The number. + * @param {Integer} exp The exponent (the 10 logarithm of the adjustment base). + * @returns {Number} The adjusted value. + */ + function decimalAdjust(type, value, exp) { + // If the exp is undefined or zero... + if (typeof exp === 'undefined' || +exp === 0) { + return Math[type](value); + } + value = +value; + exp = +exp; + // If the value is not a number or the exp is not an integer... + if (isNaN(value) || !(typeof exp === 'number' && exp % 1 === 0)) { + return NaN; + } + // Shift + value = value.toString().split('e'); + value = Math[type](+(value[0] + 'e' + (value[1] ? (+value[1] - exp) : -exp))); + // Shift back + value = value.toString().split('e'); + return +(value[0] + 'e' + (value[1] ? (+value[1] + exp) : exp)); + } + + // Decimal round + if (!Math.round10) { + Math.round10 = function(value, exp) { + return decimalAdjust('round', value, exp); + }; + } + // Decimal floor + if (!Math.floor10) { + Math.floor10 = function(value, exp) { + return decimalAdjust('floor', value, exp); + }; + } + // Decimal ceil + if (!Math.ceil10) { + Math.ceil10 = function(value, exp) { + return decimalAdjust('ceil', value, exp); + }; + } +})(); + +// Round +Math.round10(55.55, -1); // 55.6 +Math.round10(55.549, -1); // 55.5 +Math.round10(55, 1); // 60 +Math.round10(54.9, 1); // 50 +Math.round10(-55.55, -1); // -55.5 +Math.round10(-55.551, -1); // -55.6 +Math.round10(-55, 1); // -50 +Math.round10(-55.1, 1); // -60 +// Floor +Math.floor10(55.59, -1); // 55.5 +Math.floor10(59, 1); // 50 +Math.floor10(-55.51, -1); // -55.6 +Math.floor10(-51, 1); // -60 +// Ceil +Math.ceil10(55.51, -1); // 55.6 +Math.ceil10(51, 1); // 60 +Math.ceil10(-55.59, -1); // -55.5 +Math.ceil10(-59, 1); // -50 +</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>ECMAScript 1a Edició.</td> + <td>Standard</td> + <td>Definició inicial. Implementat a JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.6', 'Math.ceil')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.ceil', 'Math.ceil')}}</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>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li>{{jsxref("Math.abs()")}}</li> + <li>{{jsxref("Math.floor()")}}</li> + <li>{{jsxref("Math.round()")}}</li> + <li>{{jsxref("Math.sign()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.trunc()")}} {{experimental_inline}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/math/clz32/index.html b/files/ca/web/javascript/referencia/objectes_globals/math/clz32/index.html new file mode 100644 index 0000000000..5cde08c7a8 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/math/clz32/index.html @@ -0,0 +1,155 @@ +--- +title: Math.clz32() +slug: Web/JavaScript/Referencia/Objectes_globals/Math/clz32 +translation_of: Web/JavaScript/Reference/Global_Objects/Math/clz32 +--- +<div>{{JSRef}}</div> + +<p>La funció <strong><code>Math.clz32()</code></strong> retorna el nombre de zeros a l'esquerra que apareixen en una representació binària de 32 bits per a un nombre.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code>Math.clz32(<var>x</var>)</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Un nombre.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>"<code>clz32</code>" és una abreviació de <code>CountLeadingZeroes32</code>.</p> + +<p>Si <code>x</code> no és un nombre, primer es convertirà a un nombre, i després es convertirà a un nombre sencer de 32 bits sense signe.</p> + +<p>Si el nombre sencer sense signe de 32 bits és <code>0</code>, la funció retornarà <code>32</code> ja que tots els bits són <code>0</code>.</p> + +<p>Aquesta funció és particulament útil per a sistemes que compilin en JavaScript, com ara <a href="/en-US/docs/Emscripten">Emscripten</a>.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_Math.clz32()">Utilitzar <code>Math.clz32()</code></h3> + +<pre class="brush: js">Math.clz32(1); // 31 +Math.clz32(1000); // 22 +Math.clz32(); // 32 + +[NaN, Infinity, -Infinity, 0, -0, null, undefined, 'foo', {}, []].filter( +function(n) { + return Math.clz32(n) !== 32 +}); // [] + +Math.clz32(true); // 31 +Math.clz32(3.5); // 30 +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Aquesta funció polyfill utilitza {{jsxref("Math.imul")}}.</p> + +<pre class="brush: js">Math.clz32 = Math.clz32 || (function () { + 'use strict'; + + var table = [ + 32, 31, 0, 16, 0, 30, 3, 0, 15, 0, 0, 0, 29, 10, 2, 0, + 0, 0, 12, 14, 21, 0, 19, 0, 0, 28, 0, 25, 0, 9, 1, 0, + 17, 0, 4, , 0, 0, 11, 0, 13, 22, 20, 0, 26, 0, 0, 18, + 5, 0, 0, 23, 0, 27, 0, 6, 0, 24, 7, 0, 8, 0, 0, 0] + + // Adaptat d'un algorisme trobat a Hacker's Delight, pàgina 103. + return function (x) { + // Tingueu en compte que les variables no tenen perquè ser les mateixes. + + // 1. On n = ToUint32(x). + var v = Number(x) >>> 0 + + // 2. On p és el nombre de zeros a l'esquerra en la representació binària de 32 bits de n. + v |= v >>> 1 + v |= v >>> 2 + v |= v >>> 4 + v |= v >>> 8 + v |= v >>> 16 + v = table[Math.imul(v, 0x06EB14F9) >>> 26] + + // Retorna p. + return v + } +})(); +</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-math.clz32', 'Math.clz32')}}</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("38")}}</td> + <td>{{CompatGeckoDesktop("31")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatOpera("25")}}</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 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>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Math")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/math/cos/index.html b/files/ca/web/javascript/referencia/objectes_globals/math/cos/index.html new file mode 100644 index 0000000000..0236b38c9c --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/math/cos/index.html @@ -0,0 +1,128 @@ +--- +title: Math.cos() +slug: Web/JavaScript/Referencia/Objectes_globals/Math/cos +translation_of: Web/JavaScript/Reference/Global_Objects/Math/cos +--- +<div>{{JSRef("Global_Objects", "Math")}}</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>La funció <strong><code>Math.cos()</code></strong> retorna el cosinus d'un nombre.</p> + +<h2 id="Syntax" name="Syntax">Sintaxi</h2> + +<pre class="syntaxbox"><code>Math.cos(<var>x</var>)</code></pre> + +<h3 id="Parameters" name="Parameters">Paràmetres</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Un nombre, mesurat en radians.</dd> +</dl> + +<h2 id="Description" name="Description">Descripció</h2> + +<p>El mètode <code>Math.cos()</code> retorna un valor numèric entre -1 i 1, que representa el cosinus d'un angle.</p> + +<p>Degut a que <code>cos()</code> és un mètode estàtic de <code>Math</code>, sempre s'utilitza com a <code>Math.cos()</code>, en comptes de com a mètode d'una instància de <code>Math</code> (<code>Math</code> no és un constructor).</p> + +<h2 id="Examples" name="Examples">Exemples</h2> + +<h3 id="Example:_Using_Math.cos" name="Example:_Using_Math.cos">Exemple: Utilitzar <code>Math.cos()</code></h3> + +<pre class="brush: js">Math.cos(0); // 1 +Math.cos(1); // 0.5403023058681398 + +Math.cos(Math.PI); // -1 +Math.cos(2 * Math.PI); // 1 +</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>ECMAScript 1a Edició.</td> + <td>Standard</td> + <td>Definició inicial. Implementat a JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.7', 'Math.cos')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.cos', 'Math.cos')}}</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>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li>{{jsxref("Math.acos()")}}</li> + <li>{{jsxref("Math.asin()")}}</li> + <li>{{jsxref("Math.atan()")}}</li> + <li>{{jsxref("Math.atan2()")}}</li> + <li>{{jsxref("Math.sin()")}}</li> + <li>{{jsxref("Math.tan()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/math/cosh/index.html b/files/ca/web/javascript/referencia/objectes_globals/math/cosh/index.html new file mode 100644 index 0000000000..00ebc259b9 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/math/cosh/index.html @@ -0,0 +1,130 @@ +--- +title: Math.cosh() +slug: Web/JavaScript/Referencia/Objectes_globals/Math/cosh +translation_of: Web/JavaScript/Reference/Global_Objects/Math/cosh +--- +<div>{{JSRef}}</div> + +<p>La funció <strong><code>Math.cosh()</code></strong> retorna el cosinus hiperbòlic d'un nombre, això es pot expressar utilitzant la {{jsxref("Math.E", "constant e", "", 1)}}:</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mo lspace="0em" rspace="thinmathspace">Math.cosh(x)</mo></mstyle><mo>=</mo><mfrac><mrow><msup><mi>e</mi><mi>x</mi></msup><mo>+</mo><msup><mi>e</mi><mrow><mo>-</mo><mi>x</mi></mrow></msup></mrow><mn>2</mn></mfrac></mrow><annotation encoding="TeX">\mathtt{\operatorname{Math.cosh(x)}} = \frac{e^x + e^{-x}}{2}</annotation></semantics></math></p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code>Math.cosh(<var>x</var>)</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Un nombre.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Com que que <code>cosh()</code> és un mètode estàtic de <code>Math</code>, sempre s'utilitza com a <code>Math.cosh()</code>, en comptes de com a mètode d'una instància de <code>Math </code>(<code>Math</code> no és un constructor).</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_Math.cosh()">Utilitzar <code>Math.cosh()</code></h3> + +<pre class="brush: js">Math.cosh(0); // 1 +Math.cosh(1); // 1.5430806348152437 +Math.cosh(-1); // 1.5430806348152437 +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Aquesta funció es pot emular amb l'ajuda de la funció {{jsxref("Math.exp()")}}:</p> + +<pre class="brush: js">Math.cosh = Math.cosh || function(x) { + return (Math.exp(x) + Math.exp(-x)) / 2; +} +</pre> + +<p>o bé utilitzant només una crida a la funció {{jsxref("Math.exp()")}}:</p> + +<pre class="brush: js">Math.cosh = Math.cosh || function(x) { + var y = Math.exp(x); + return (y + 1 / y) / 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-math.cosh', 'Math.cosh')}}</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("38")}}</td> + <td>{{CompatGeckoDesktop("25")}}</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("25")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Math.acosh()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.asinh()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.atanh()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.sinh()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.tanh()")}} {{experimental_inline}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/math/e/index.html b/files/ca/web/javascript/referencia/objectes_globals/math/e/index.html new file mode 100644 index 0000000000..efe7476396 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/math/e/index.html @@ -0,0 +1,118 @@ +--- +title: Math.E +slug: Web/JavaScript/Referencia/Objectes_globals/Math/E +translation_of: Web/JavaScript/Reference/Global_Objects/Math/E +--- +<div>{{JSRef("Global_Objects", "Math")}}</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>La propietat <strong><code>Math.E</code></strong> representa la base dels logaritmes naturals, e, el seu valor aproximat és de 2.718.</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.E</mi></mstyle><mo>=</mo><mi>e</mi><mo>≈</mo><mn>2.718</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.E}} = e \approx 2.718</annotation></semantics></math></p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Description" name="Description">Descripció</h2> + +<p>Com que <code>E</code> és una propietat estàtica de <code>Math</code>, sempre s'utilitza com<code> Math.E</code> en comptes de com una propietat d'un objecte <code>Math</code> creat (<code>Math</code> no és un constructor).</p> + +<h2 id="Examples" name="Examples">Exemples</h2> + +<h3 id="Example:_Using_Math.E" name="Example:_Using_Math.E">Exemple: Utilitzar <code>Math.E</code></h3> + +<p>La funció que trobareu a continuació retorna e:</p> + +<pre class="brush: js">function getNapier() { + return Math.E; +} + +getNapier(); // 2.718281828459045 +</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>ECMAScript 1a Edició.</td> + <td>Standard</td> + <td>Definició inicial. Implementat en JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.1.1', 'Math.E')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.e', 'Math.E')}}</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>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li>{{jsxref("Math.exp()")}}</li> + <li>{{jsxref("Math.log()")}}</li> + <li>{{jsxref("Math.log1p()")}} {{experimental_inline}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/math/exp/index.html b/files/ca/web/javascript/referencia/objectes_globals/math/exp/index.html new file mode 100644 index 0000000000..c6d6c6c098 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/math/exp/index.html @@ -0,0 +1,123 @@ +--- +title: Math.exp() +slug: Web/JavaScript/Referencia/Objectes_globals/Math/exp +translation_of: Web/JavaScript/Reference/Global_Objects/Math/exp +--- +<div>{{JSRef}}</div> + +<p>La funció <strong><code>Math.exp()</code></strong> retorna <code>e<sup>x</sup></code>, on <code>x</code> és l'argument, i <code>e</code> és {{jsxref("Math.E", "la constant d'Euler", "", 1)}}, la base dels logaritmes naturals.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code>Math.exp(<var>x</var>)</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Un nombre.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Deguat a que <code>exp()</code> és un mètode estàtic de <code>Math</code>, aquest pot emprar-se com a <code>Math.exp()</code>, en comptes de cridar-lo com un mètode d'un objecte de tipus <code>Math</code> (<code>Math</code> no és un constructor).</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_Math.exp()"><code>Utilitzar Math.exp()</code></h3> + +<pre class="brush: js">Math.exp(-1); // 0.36787944117144233 +Math.exp(0); // 1 +Math.exp(1); // 2.718281828459045 +</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.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.8', 'Math.exp')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.exp', 'Math.exp')}}</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 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("Math.E")}}</li> + <li>{{jsxref("Math.expm1()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.log()")}}</li> + <li>{{jsxref("Math.log10()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.log1p()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.log2()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.pow()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/math/expm1/index.html b/files/ca/web/javascript/referencia/objectes_globals/math/expm1/index.html new file mode 100644 index 0000000000..b8055fba45 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/math/expm1/index.html @@ -0,0 +1,122 @@ +--- +title: Math.expm1() +slug: Web/JavaScript/Referencia/Objectes_globals/Math/expm1 +translation_of: Web/JavaScript/Reference/Global_Objects/Math/expm1 +--- +<div>{{JSRef}}</div> + +<p>La funció <strong><code>Math.expm1()</code></strong> retorna <code>e<sup>x</sup> - 1</code>, on <code>x</code> és l'argument i {{jsxref("Math.E", "e", "", 1)}} és la base dels logaritmes naturals.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code>Math.expm1(<var>x</var>)</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Un nombre.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Com que <code>expm1()</code> és un mètode estàtic de <code>Math</code>, sempre s'utilitza com <code>Math.expm1()</code> en comptes de com un mètode d'un objecte <code>Math</code> creat (<code>Math</code> no és un constructor).</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_Math.expm1()">Utilitzar <code>Math.expm1()</code></h3> + +<pre class="brush: js">Math.expm1(-1); // -0.6321205588285577 +Math.expm1(0); // 0 +Math.expm1(1); // 1.718281828459045 +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Aquesta funció pot ser emulada amb l'ajuda de la funció {{jsxref("Math.exp()")}}:</p> + +<pre class="brush: js">Math.expm1 = Math.expm1 || function(x) { + return Math.exp(x) - 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-math.expm1', 'Math.expm1')}}</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("38")}}</td> + <td>{{CompatGeckoDesktop("25")}}</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("25")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Math.E")}}</li> + <li>{{jsxref("Math.exp()")}}</li> + <li>{{jsxref("Math.log()")}}</li> + <li>{{jsxref("Math.log10()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.log1p()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.log2()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.pow()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/math/floor/index.html b/files/ca/web/javascript/referencia/objectes_globals/math/floor/index.html new file mode 100644 index 0000000000..4a83b8d0e8 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/math/floor/index.html @@ -0,0 +1,194 @@ +--- +title: Math.floor() +slug: Web/JavaScript/Referencia/Objectes_globals/Math/floor +translation_of: Web/JavaScript/Reference/Global_Objects/Math/floor +--- +<div>{{JSRef("Global_Objects", "Math")}}</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>La funció <strong><code>Math.floor()</code></strong> retorna el nombre més gran dels nombres més petits o iguals a un nombre donat.</p> + +<h2 id="Syntax" name="Syntax">Sintaxi</h2> + +<pre class="syntaxbox"><code>Math.floor(<var>x</var>)</code></pre> + +<h3 id="Parameters" name="Parameters">Paràmetres</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Un nombre.</dd> +</dl> + +<h2 id="Description" name="Description">Descripció</h2> + +<p>Degut a que <code>floor()</code> és un mètode estàtic de <code>Math</code>, sempre s'utilitza com a <code>Math.floor()</code>, en comptes de com a mètode d'una instància de <code>Math</code> (<code>Math</code> no és un constructor).</p> + +<h2 id="Examples" name="Examples">Exemples</h2> + +<h3 id="Example:_Using_Math.floor" name="Example:_Using_Math.floor">Exemple: Utilitzar <code>Math.floor()</code></h3> + +<pre class="brush: js">Math.floor( 45.95); // 45 +Math.floor(-45.95); // -46 +</pre> + +<h3 id="Example:_Decimal_adjustment" name="Example:_Decimal_adjustment">Exemple: Ajust decimal</h3> + +<pre class="brush: js">// Closure +(function() { + /** + * Ajust decimal d'un nombre. + * + * @param {String} type El tipus d'ajust. + * @param {Number} value El nombre. + * @param {Integer} exp L'exponent (L'algoritme en base 10 de la base d'ajust + * @returns {Number} El valor ajustat. + */ + function decimalAdjust(type, value, exp) { + // Si exp és undefined o zero... + if (typeof exp === 'undefined' || +exp === 0) { + return Math[type](value); + } + value = +value; + exp = +exp; + // Si value no és un nombre o exp no és un nombre sencer... + if (isNaN(value) || !(typeof exp === 'number' && exp % 1 === 0)) { + return NaN; + } + // Desplaçament + value = value.toString().split('e'); + value = Math[type](+(value[0] + 'e' + (value[1] ? (+value[1] - exp) : -exp))); + // Desfer el desplaçament + value = value.toString().split('e'); + return +(value[0] + 'e' + (value[1] ? (+value[1] + exp) : exp)); + } + + // Arrodoniment decimal + if (!Math.round10) { + Math.round10 = function(value, exp) { + return decimalAdjust('round', value, exp); + }; + } + // Arrodoniment decimal a la baixa + if (!Math.floor10) { + Math.floor10 = function(value, exp) { + return decimalAdjust('floor', value, exp); + }; + } + // Arrodoniment decimal a l'alça + if (!Math.ceil10) { + Math.ceil10 = function(value, exp) { + return decimalAdjust('ceil', value, exp); + }; + } +})(); + +// Arrodoniments +Math.round10(55.55, -1); // 55.6 +Math.round10(55.549, -1); // 55.5 +Math.round10(55, 1); // 60 +Math.round10(54.9, 1); // 50 +Math.round10(-55.55, -1); // -55.5 +Math.round10(-55.551, -1); // -55.6 +Math.round10(-55, 1); // -50 +Math.round10(-55.1, 1); // -60 +// Arrodoniments a la baixa +Math.floor10(55.59, -1); // 55.5 +Math.floor10(59, 1); // 50 +Math.floor10(-55.51, -1); // -55.6 +Math.floor10(-51, 1); // -60 +// Arrodoniments a l'alça +Math.ceil10(55.51, -1); // 55.6 +Math.ceil10(51, 1); // 60 +Math.ceil10(-55.59, -1); // -55.5 +Math.ceil10(-59, 1); // -50 +</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>ECMAScript 1a Edició</td> + <td>Standard</td> + <td>Definició inicial. Implementat a JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.9', 'Math.floor')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.floor', 'Math.floor')}}</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>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li>{{jsxref("Math.abs()")}}</li> + <li>{{jsxref("Math.ceil()")}}</li> + <li>{{jsxref("Math.round()")}}</li> + <li>{{jsxref("Math.sign()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.trunc()")}} {{experimental_inline}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/math/fround/index.html b/files/ca/web/javascript/referencia/objectes_globals/math/fround/index.html new file mode 100644 index 0000000000..7411993dbc --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/math/fround/index.html @@ -0,0 +1,118 @@ +--- +title: Math.fround() +slug: Web/JavaScript/Referencia/Objectes_globals/Math/fround +translation_of: Web/JavaScript/Reference/Global_Objects/Math/fround +--- +<div>{{JSRef}}</div> + +<p>La funció <strong><code>Math.fround()</code></strong> retorna la representació en coma flotant de <a class="external" href="https://en.wikipedia.org/wiki/Single-precision_floating-point_format" title="link to the wikipedia page on single-precision floating-point format">precisió simple</a> més propera d'un nombre.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code>Math.fround(<var>x</var>)</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Un nombre.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Com que <code>fround()</code> és un mètode estàtic de <code>Math</code>, sempre s'utilitza com <code>Math.fround()</code> en comptes de com un mètode d'un objecte <code>Math</code> creat (<code>Math</code> no és un constructor).</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_Math.fround()"><code>Utilitzar Math.fround()</code></h3> + +<pre class="brush: js">Math.fround(0); // 0 +Math.fround(1); // 1 +Math.fround(1.337); // 1.3370000123977661 +Math.fround(1.5); // 1.5 +Math.fround(NaN); // NaN +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>El comportament d'aquesta funció pot ser emulat amb la funció següent, si {{jsxref("Float32Array")}} està suportat:</p> + +<pre class="brush: js">Math.fround = Math.fround || function(x) { + return new Float32Array([x])[0]; +}; +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.fround', 'Math.fround')}}</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("38")}}</td> + <td>{{CompatGeckoDesktop("26")}}</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>{{CompatUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Math.round()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/math/hypot/index.html b/files/ca/web/javascript/referencia/objectes_globals/math/hypot/index.html new file mode 100644 index 0000000000..e29bb754f1 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/math/hypot/index.html @@ -0,0 +1,139 @@ +--- +title: Math.hypot() +slug: Web/JavaScript/Referencia/Objectes_globals/Math/hypot +translation_of: Web/JavaScript/Reference/Global_Objects/Math/hypot +--- +<div>{{JSRef}}</div> + +<p>La funció <strong><code>Math.hypot()</code></strong> retorna la rel quadrada de la suma dels quadrats dels seus arguments, és a dir:</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.hypot</mo><mo stretchy="false">(</mo><msub><mi>v</mi><mn>1</mn></msub><mo>,</mo><msub><mi>v</mi><mn>2</mn></msub><mo>,</mo><mo>…</mo><mo>,</mo><msub><mi>v</mi><mi>n</mi></msub><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><msqrt><mrow><munderover><mo>∑</mo><mrow><mi>i</mi><mo>=</mo><mn>1</mn></mrow><mi>n</mi></munderover><msubsup><mi>v</mi><mi>i</mi><mn>2</mn></msubsup></mrow></msqrt><mo>=</mo><msqrt><mrow><msubsup><mi>v</mi><mn>1</mn><mn>2</mn></msubsup><mo>+</mo><msubsup><mi>v</mi><mn>2</mn><mn>2</mn></msubsup><mo>+</mo><mo>…</mo><mo>+</mo><msubsup><mi>v</mi><mi>n</mi><mn>2</mn></msubsup></mrow></msqrt></mrow><annotation encoding="TeX">\mathtt{\operatorname{Math.hypot}(v_1, v_2, \dots, v_n)} = \sqrt{\sum_{i=1}^n v_i^2} = \sqrt{v_1^2 + v_2^2 + \dots + v_n^2}</annotation></semantics></math></p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code>Math.hypot([<var>valor1</var>[, <var>valor2</var>[, ...]]])</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>valor1, valor2, ...</code></dt> + <dd>Nombres.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Com que que <code>hypot()</code> és un mètode estàtic de <code>Math</code>, sempre s'utilitza com a <code>Math.hypot()</code>, en comptes de com a mètode d'una instància de <code>Math</code> (<code>Math</code> no és un constructor).</p> + +<p>Si no es passa cap argument, el resultat és +0.</p> + +<p>Si al menys un dels arguments no pot ser convertit a nombre el resultat és {{jsxref("Global_Objects/NaN", "NaN")}}.</p> + +<p>Quan se li passa només un argument, <code>Math.hypot()</code> retorna el mateix valor que retornaria <code>Math.abs()</code>.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_Math.hypot()">Utilitzar <code>Math.hypot()</code></h3> + +<pre class="brush: js">Math.hypot(3, 4); // 5 +Math.hypot(3, 4, 5); // 7.0710678118654755 +Math.hypot(); // 0 +Math.hypot(NaN); // NaN +Math.hypot(3, 4, 'foo'); // NaN, +'foo' => NaN +Math.hypot(3, 4, '5'); // 7.0710678118654755, +'5' => 5 +Math.hypot(-3); // 3, el mateix que Math.abs(-3) +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Aquest mètode pot emular-se mitjançant la funció següent:</p> + +<pre class="brush: js">Math.hypot = Math.hypot || function() { + var y = 0; + var length = arguments.length; + + for (var i = 0; i < length; i++) { + if (arguments[i] === Infinity || arguments[i] === -Infinity) { + return Infinity; + } + y += arguments[i] * arguments[i]; + } + return Math.sqrt(y); +}; +</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-math.hypot', 'Math.hypot')}}</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("38")}}</td> + <td>{{CompatGeckoDesktop("27")}}</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("27")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Math.abs()")}}</li> + <li>{{jsxref("Math.pow()")}}</li> + <li>{{jsxref("Math.sqrt()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/math/imul/index.html b/files/ca/web/javascript/referencia/objectes_globals/math/imul/index.html new file mode 100644 index 0000000000..53050a9cd6 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/math/imul/index.html @@ -0,0 +1,120 @@ +--- +title: Math.imul() +slug: Web/JavaScript/Referencia/Objectes_globals/Math/imul +translation_of: Web/JavaScript/Reference/Global_Objects/Math/imul +--- +<div>{{JSRef}}</div> + +<p>La funció <strong><code>Math.imul()</code></strong> retorna el resultat de la multiplicació de 32 bits similar a la de C dels dos paràmetres.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code>Math.imul(<var>a</var>, <var>b</var>)</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>a</code></dt> + <dd>Primer nombre.</dd> + <dt><code>b</code></dt> + <dd>Segon nombre.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p><code>Math.imul()</code> permet una multiplicació ràpida de nombres sencers de 32 bits amb una semàtica similar a la de C. Aquesta característica esdevé útil per a projectes com <a href="http://en.wikipedia.org/wiki/Emscripten">Emscripten</a>. Com que <code>imul()</code> és un mètode estàtic de <code>Math</code>, sempre s'utilitza com <code>Math.imul()</code> en comptes de com un mètode d'un objecte <code>Math</code> creat (<code>Math</code> no és un constructor).</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_Math.imul()">Utilitzar <code>Math.imul()</code></h3> + +<pre class="brush: js">Math.imul(2, 4); // 8 +Math.imul(-1, 8); // -8 +Math.imul(-2, -2); // 4 +Math.imul(0xffffffff, 5); // -5 +Math.imul(0xfffffffe, 5); // -10 +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Aquesta funció pot ser emulada mitjançant la següent funció:</p> + +<pre class="brush: js">Math.imul = Math.imul || function(a, b) { + var ah = (a >>> 16) & 0xffff; + var al = a & 0xffff; + var bh = (b >>> 16) & 0xffff; + var bl = b & 0xffff; + // el desplaçament de zero posicions solventa el signe a la part més significativa + // el |0 del final converteix el valor sense signe en un valor amb signe + return ((al * bl) + (((ah * bl + al * bh) << 16) >>> 0)|0); +}; +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.imul', 'Math.imul')}}</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("28")}}</td> + <td>{{CompatGeckoDesktop("20")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatOpera("16")}}</td> + <td>{{CompatSafari("7")}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatGeckoMobile("20")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>7</td> + </tr> + </tbody> +</table> +</div> diff --git a/files/ca/web/javascript/referencia/objectes_globals/math/index.html b/files/ca/web/javascript/referencia/objectes_globals/math/index.html new file mode 100644 index 0000000000..d493f51b40 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/math/index.html @@ -0,0 +1,205 @@ +--- +title: Math +slug: Web/JavaScript/Referencia/Objectes_globals/Math +translation_of: Web/JavaScript/Reference/Global_Objects/Math +--- +<div>{{JSRef("Global_Objects", "Math")}}</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p><strong><code>Math</code></strong> és un objecte proporcionat pel llenguatge que té propietats i mètodes que pretenen ajudar en càlculs matemàtics. L'objecte conté constants i funcions matemàtiques.</p> + +<h2 id="Description" name="Description">Descripció</h2> + +<p>A diferència d'altres objectes globals, <code>Math</code> no és un constructor. Totes les propietats i mètodes de <code>Math</code> són estàtics. Per a utilitzar la constant pi es fa anar <code>Math.PI</code> i la funció sinus es crida <code>Math.sin(x)</code>, on <code>x</code> és l'argument que rebrà el mètode. Les constants tenen la presició d'un nombre real de JavaScript.</p> + +<h2 id="Properties" name="Properties">Propietats</h2> + +<dl> + <dt>{{jsxref("Math.E")}}</dt> + <dd>La constant de Euler (també coneguda com a nombre E) i la base dels logaritmes naturals, el seu valor aproximat és de 2.718.</dd> + <dt>{{jsxref("Math.LN2")}}</dt> + <dd>El logaritme natural de 2, el seu valor aproximat és de 0.693.</dd> + <dt>{{jsxref("Math.LN10")}}</dt> + <dd>El logaritme natural de 10, el seu valor aproximat és de 2.303.</dd> + <dt>{{jsxref("Math.LOG2E")}}</dt> + <dd>El logaritme de E en base 2, el seu valor aproximat és de 1.443.</dd> + <dt>{{jsxref("Math.LOG10E")}}</dt> + <dd>El logaritme de E en base 10, el seu valor aproximat és de 0.434.</dd> + <dt>{{jsxref("Math.PI")}}</dt> + <dd>La proporció entre la circumferència d'un cercle i el seu diàmetre, el seu valor aproximat és de 3.14159.</dd> + <dt>{{jsxref("Math.SQRT1_2")}}</dt> + <dd>La rel quadrada de un mig (1/2); tanmateix 1 dividit per la rel quadrada de 2, el seu valor aproximat és de 0.707.</dd> + <dt>{{jsxref("Math.SQRT2")}}</dt> + <dd>La rel quadrada de 2, el seu valor aproximat és de 1.414.</dd> +</dl> + +<h2 id="Methods" name="Methods">Mètodes</h2> + +<div class="note"> +<p>Fixeu-vos que les funcions (<code>sin()</code>, <code>cos()</code>, <code>tan()</code>, <code>asin()</code>, <code>acos()</code>, <code>atan()</code>, <code>atan2()</code>) reben i retornen angles en radians. Per a convertir radians a graus cal dividir per <code>(Math.PI / 180)</code>, o bé multiplicar si el que es pretèn es transformar graus a radians.</p> +</div> + +<div class="note"> +<p>Cal destacar que la precisió de moltes de les funcions matemàtiques és depenent de la implementació. Això vol dir que el mateix codi pot donar resultats diferent en diferents navegadors, i fins i tot sota el mateix navegador o motor JS si es prova en diferents sistemes operatius or arquitectures.</p> +</div> + +<dl> + <dt>{{jsxref("Global_Objects/Math/abs", "Math.abs(x)")}}</dt> + <dd>Retorna el valor absolut d'un nombre.</dd> + <dt>{{jsxref("Global_Objects/Math/acos", "Math.acos(x)")}}</dt> + <dd>Retorna l'arccosinus d'un nombre.</dd> + <dt>{{jsxref("Global_Objects/Math/acosh", "Math.acosh(x)")}} {{experimental_inline}}</dt> + <dd>Retorna l'arccosinus hiperbòlic d'un nombre.</dd> + <dt>{{jsxref("Global_Objects/Math/asin", "Math.asin(x)")}}</dt> + <dd>Tetorna l'arcsinus d'un nombre.</dd> + <dt>{{jsxref("Global_Objects/Math/asinh", "Math.asinh(x)")}} {{experimental_inline}}</dt> + <dd>Retorna l'arcsinus hiperbòlic d'un nombre.</dd> + <dt>{{jsxref("Global_Objects/Math/atan", "Math.atan(x)")}}</dt> + <dd>Retorna l'arctangent d'un nombre.</dd> + <dt>{{jsxref("Global_Objects/Math/atanh", "Math.atanh(x)")}} {{experimental_inline}}</dt> + <dd>Retorna l'arctangent hiperbòlic d'un nombre.</dd> + <dt>{{jsxref("Global_Objects/Math/atan2", "Math.atan2(y, x)")}}</dt> + <dd>Retorna l'arctangent del cocient dels paràmetres donats.</dd> + <dt>{{jsxref("Global_Objects/Math/cbrt", "Math.cbrt(x)")}} {{experimental_inline}}</dt> + <dd>Retorna la rel cúbica d'un nombre.</dd> + <dt>{{jsxref("Global_Objects/Math/ceil", "Math.ceil(x)")}}</dt> + <dd>Retorna el nombre sencer més petit que és més gran o igual al nombre donat.</dd> + <dt>{{jsxref("Global_Objects/Math/clz32", "Math.clz32(x)")}} {{experimental_inline}}</dt> + <dd>Retorna el nombre de zeros a l'esquerra que el nombre donat tindria si fós emmagatzemat en 32 bits.</dd> + <dt>{{jsxref("Global_Objects/Math/cos", "Math.cos(x)")}}</dt> + <dd>Retorna el cosinus d'un nombre.</dd> + <dt>{{jsxref("Global_Objects/Math/cosh", "Math.cosh(x)")}} {{experimental_inline}}</dt> + <dd>Retorna el cosinus hiperbòlic d'un nombre.</dd> + <dt>{{jsxref("Global_Objects/Math/exp", "Math.exp(x)")}}</dt> + <dd>Retorna E<sup>x</sup>, on <var>x</var> és el paràmetre i E és la constant de Euler (2.718 aproximadament).</dd> + <dt>{{jsxref("Global_Objects/Math/expm1", "Math.expm1(x)")}} {{experimental_inline}}</dt> + <dd>Retorna <code>exp(x) - 1</code>.</dd> + <dt>{{jsxref("Global_Objects/Math/floor", "Math.floor(x)")}}</dt> + <dd>Retorna el nombre sencer més gran que és igual o menor que el nombre donat.</dd> + <dt>{{jsxref("Global_Objects/Math/fround", "Math.fround(x)")}} {{experimental_inline}}</dt> + <dd>Retorna el nombre en coma float de <a href="http://en.wikipedia.org/wiki/Single-precision_floating-point_format" title="link to the wikipedia page on single precision">precisió simple</a> més proper al nombre donat.</dd> + <dt>{{jsxref("Global_Objects/Math/hypot", "Math.hypot([x[, y[, …]]])")}} {{experimental_inline}}</dt> + <dd>Retorna la rel quadrada del quadrat dels dos paràmetres donats.</dd> + <dt>{{jsxref("Global_Objects/Math/imul", "Math.imul(x, y)")}} {{experimental_inline}}</dt> + <dd>Retorna el resultat de multiplicar els dos paràmetres com a nombres sencers de 32 bits.</dd> + <dt>{{jsxref("Global_Objects/Math/log", "Math.log(x)")}}</dt> + <dd>Retorna el logaritme natural (log<sub>e</sub>, també ln) d'un nombre.</dd> + <dt>{{jsxref("Global_Objects/Math/log1p", "Math.log1p(x)")}} {{experimental_inline}}</dt> + <dd>Retorna el logaritme natural de <code>1 + x</code> (log<sub>e</sub>, també ln) del nombre donat.</dd> + <dt>{{jsxref("Global_Objects/Math/log10", "Math.log10(x)")}} {{experimental_inline}}</dt> + <dd>Retorna el logaritme en base 10 d'un nombre.</dd> + <dt>{{jsxref("Global_Objects/Math/log2", "Math.log2(x)")}} {{experimental_inline}}</dt> + <dd>Retorna el logaritme en base 2 d'un nombre.</dd> + <dt>{{jsxref("Global_Objects/Math/max", "Math.max([x[, y[, …]]])")}}</dt> + <dd>Retorna el major de zero o més nombres donats.</dd> + <dt>{{jsxref("Global_Objects/Math/min", "Math.min([x[, y[, …]]])")}}</dt> + <dd>Retorna el menor de zero o més nombres donats.</dd> + <dt>{{jsxref("Global_Objects/Math/pow", "Math.pow(base, exponent)")}}</dt> + <dd>Retorna la base elevada a l'exponent, és a dir, <code>base<sup>exponent</sup></code>.</dd> + <dt>{{jsxref("Global_Objects/Math/random", "Math.random()")}}</dt> + <dd>Retorna un nombre pseudo aleatori comprés entre 0 i 1.</dd> + <dt>{{jsxref("Global_Objects/Math/round", "Math.round(x)")}}</dt> + <dd>Retorna el nombre sencer més proper al nombre donat.</dd> + <dt>{{jsxref("Global_Objects/Math/sign", "Math.sign(x)")}} {{experimental_inline}}</dt> + <dd>Retorna el signe de x, indicant si x és positiu, negatiu o zero.</dd> + <dt>{{jsxref("Global_Objects/Math/sin", "Math.sin(x)")}}</dt> + <dd>Retorna el sinus d'un nombre.</dd> + <dt>{{jsxref("Global_Objects/Math/sinh", "Math.sinh(x)")}} {{experimental_inline}}</dt> + <dd>Retorna el sinus hiperbòlic d'un nombre.</dd> + <dt>{{jsxref("Global_Objects/Math/sqrt", "Math.sqrt(x)")}}</dt> + <dd>Retorna el resultat positiu de la rel quadrada d'un nombre.</dd> + <dt>{{jsxref("Global_Objects/Math/tan", "Math.tan(x)")}}</dt> + <dd>Retorna la tangent d'un nombre.</dd> + <dt>{{jsxref("Global_Objects/Math/tanh", "Math.tanh(x)")}} {{experimental_inline}}</dt> + <dd>Retorna la tangent hiperbòlica d'un nombre.</dd> + <dt><code>Math.toSource()</code> {{non-standard_inline}}</dt> + <dd>Retorna la cadena de caràcters <code>"Math"</code>.</dd> + <dt>{{jsxref("Global_Objects/Math/trunc", "Math.trunc(x)")}} {{experimental_inline}}</dt> + <dd>Retorna la part sencera del nombre donat.</dd> +</dl> + +<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>ECMAScript 1a Edició.</td> + <td>Standard</td> + <td>Definició inicial. Implementada a JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8', 'Math')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math-object', 'Math')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Nous mètodes afegits: {{jsxref("Math.log10()", "log10()")}}, {{jsxref("Math.log2()", "log2()")}}, {{jsxref("Math.log1p()", "log1p()")}}, {{jsxref("Math.expm1()", "expm1()")}}, {{jsxref("Math.cosh()", "cosh()")}}, {{jsxref("Math.sinh()", "sinh()")}}, {{jsxref("Math.tanh()", "tanh()")}}, {{jsxref("Math.acosh()", "acosh()")}}, {{jsxref("Math.asinh()", "asinh()")}}, {{jsxref("Math.atanh()", "atanh()")}}, {{jsxref("Math.hypot()", "hypot()")}}, {{jsxref("Math.trunc()", "trunc()")}}, {{jsxref("Math.sign()", "sign()")}}, {{jsxref("Math.imul()", "imul()")}}, {{jsxref("Math.fround()", "fround()")}}, {{jsxref("Math.cbrt()", "cbrt()")}} i {{jsxref("Math.clz32()", "clz32()")}}.</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>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li>{{jsxref("Global_Objects/Number", "Number")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/math/ln10/index.html b/files/ca/web/javascript/referencia/objectes_globals/math/ln10/index.html new file mode 100644 index 0000000000..42107c85f5 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/math/ln10/index.html @@ -0,0 +1,118 @@ +--- +title: Math.LN10 +slug: Web/JavaScript/Referencia/Objectes_globals/Math/LN10 +translation_of: Web/JavaScript/Reference/Global_Objects/Math/LN10 +--- +<div>{{JSRef("Global_Objects", "Math")}}</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>La propietat <strong><code>Math.LN10</code></strong> representa el logaritme natural de 10, aproximadament 2.302:</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.LN10</mi></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">ln</mo><mo stretchy="false">(</mo><mn>10</mn><mo stretchy="false">)</mo><mo>≈</mo><mn>2.302</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.LN10}} = \ln(10) \approx 2.302</annotation></semantics></math></p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Description" name="Description">Descripció</h2> + +<p>Degut a que <code>LN10</code> és una propietat estàtica de <code>Math</code>, aquesta sempre s'accedeix mitjançant el codi <code>Math.LN10</code>, en comptes de com una propietat d'un objecte <code>Math</code> creat (<code>Math</code> no és un constructor).</p> + +<h2 id="Examples" name="Examples">Exemples</h2> + +<h3 id="Example:_Using_Math.LN10" name="Example:_Using_Math.LN10">Exemple: Utilitzar <code>Math.LN10</code></h3> + +<p>La funció següent retorna el logaritme natural de 10:</p> + +<pre class="brush:js">function getNatLog10() { + return Math.LN10; +} + +getNatLog10(); // 2.302585092994046 +</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>ECMAScript 1a Edició.</td> + <td>Standard</td> + <td>Definició inicial. Implementat a JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.1.2', 'Math.LN10')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.ln10', 'Math.LN10')}}</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ístiques</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ístiques</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li>{{jsxref("Math.exp()")}}</li> + <li>{{jsxref("Math.log()")}}</li> + <li>{{jsxref("Math.log10()")}} {{experimental_inline}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/math/ln2/index.html b/files/ca/web/javascript/referencia/objectes_globals/math/ln2/index.html new file mode 100644 index 0000000000..92cf2693f2 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/math/ln2/index.html @@ -0,0 +1,118 @@ +--- +title: Math.LN2 +slug: Web/JavaScript/Referencia/Objectes_globals/Math/LN2 +translation_of: Web/JavaScript/Reference/Global_Objects/Math/LN2 +--- +<div>{{JSRef("Global_Objects", "Math")}}</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>La propietat <strong><code>Math.LN2</code></strong> representa el logaritme natural de 2, aproximadament 0.693:</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.LN2</mi></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">ln</mo><mo stretchy="false">(</mo><mn>2</mn><mo stretchy="false">)</mo><mo>≈</mo><mn>0.693</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.LN2}} = \ln(2) \approx 0.693</annotation></semantics></math></p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Description" name="Description">Descripció</h2> + +<p>Degut a que <code>LN2</code> és una propietat estàtica de <code>Math</code>, sempre s'accedeix a aquesta mitjançant el codi <code>Math.LN2</code> en comptes d'accedir a la propietat d'un objecte de <code>Math</code> ja creat (<code>Math</code> no és un constructor).</p> + +<h2 id="Examples" name="Examples">Exemples</h2> + +<h3 id="Example:_Using_Math.LN2" name="Example:_Using_Math.LN2">Exemple: Utilitzar <code>Math.LN2</code></h3> + +<p>La següent funció retorna el logaritme natural de 2:</p> + +<pre class="brush:js">function getNatLog2() { + return Math.LN2; +} + +getNatLog2(); // 0.6931471805599453 +</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>ECMAScript 1a Edició.</td> + <td>Standard</td> + <td>Definició inicial. Implementat a JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.1.3', 'Math.LN2')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.ln2', 'Math.LN2')}}</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>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li>{{jsxref("Math.exp()")}}</li> + <li>{{jsxref("Math.log()")}}</li> + <li>{{jsxref("Math.log2()")}} {{experimental_inline}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/math/log/index.html b/files/ca/web/javascript/referencia/objectes_globals/math/log/index.html new file mode 100644 index 0000000000..a3d8467ae5 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/math/log/index.html @@ -0,0 +1,137 @@ +--- +title: Math.log() +slug: Web/JavaScript/Referencia/Objectes_globals/Math/log +translation_of: Web/JavaScript/Reference/Global_Objects/Math/log +--- +<div>{{JSRef}}</div> + +<p>La funció <strong><code>Math.log()</code></strong> retorna el logaritme natural (base {{jsxref("Math.E", "e")}}) d'un nombre, és a dir</p> + +<p><math display="block"><semantics><mrow><mo>∀</mo><mi>x</mi><mo>></mo><mn>0</mn><mo>,</mo><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.log</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">ln</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext>la única</mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mspace width="thickmathspace"></mspace><mtext>tal que</mtext><mspace width="thickmathspace"></mspace><msup><mi>e</mi><mi>y</mi></msup><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x > 0, \mathtt{\operatorname{Math.log}(x)} = \ln(x) = \text{the unique} \; y \; \text{such that} \; e^y = x</annotation></semantics></math></p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code>Math.log(<var>x</var>)</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Un nombre.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Si el valor de <code>x</code> és negatiu, el valor retornat sempre serà {{jsxref("NaN")}}.</p> + +<p>Degut a que <code>log()</code> és un mètode estàtic de <code>Math</code>, sempre s'utilitza com a <code>Math.log()</code>, en comptes de com a mètode d'una instància de <code>Math </code>(<code>Math</code> no és un constructor).</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_Math.log()">Utilitzar <code>Math.log()</code></h3> + +<pre class="brush: js">Math.log(-1); // NaN, fora de rang +Math.log(0); // -Infinit +Math.log(1); // 0 +Math.log(10); // 2.302585092994046 +</pre> + +<h3 id="Utilitzar_Math.log()_amb_una_base_diferent">Utilitzar <code>Math.log()</code> amb una base diferent</h3> + +<p>La funció següent retorna el logaritme de <code>y</code> amb base <code>x</code> (és a dir, <math><semantics><mrow><msub><mo>log</mo><mi>x</mi></msub><mi>y</mi></mrow><annotation encoding="TeX">\log_x y</annotation></semantics></math>):</p> + +<pre class="brush: js">function getBaseLog(x, y) { + return Math.log(y) / Math.log(x); +} +</pre> + +<p>Si es crida <code>getBaseLog(10, 1000)</code> retornarà <code>2.9999999999999996</code> degut a l'arrodoniment de punt flotant, el qual és molt proper a la resposta real: 3.</p> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificacions</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definició inicial. Implementat a JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.10', 'Math.log')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.log', 'Math.log')}}</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 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("Math.exp()")}}</li> + <li>{{jsxref("Math.log1p()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.log10()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.log2()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.pow()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/math/log10/index.html b/files/ca/web/javascript/referencia/objectes_globals/math/log10/index.html new file mode 100644 index 0000000000..1a82f34848 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/math/log10/index.html @@ -0,0 +1,126 @@ +--- +title: Math.log10() +slug: Web/JavaScript/Referencia/Objectes_globals/Math/log10 +translation_of: Web/JavaScript/Reference/Global_Objects/Math/log10 +--- +<div>{{JSRef}}</div> + +<p>La funció <strong><code>Math.log10()</code></strong> retorna el logaritme en base 10 d'un nombre, és a dir</p> + +<p><math display="block"><semantics><mrow><mo>∀</mo><mi>x</mi><mo>></mo><mn>0</mn><mo>,</mo><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.log10</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><msub><mo lspace="0em" rspace="0em">log</mo><mn>10</mn></msub><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=la única</mo><mspace width="thickmathspace"></mspace><mi>y</mi><mspace width="thickmathspace"></mspace><mtext>tal que</mtext><mspace width="thickmathspace"></mspace><msup><mn>10</mn><mi>y</mi></msup><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x > 0, \mathtt{\operatorname{Math.log10}(x)} = \log_10(x) = \text{the unique} \; y \; \text{such that} \; 10^y = x</annotation></semantics></math></p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code>Math.log10(<var>x</var>)</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Un nombre.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Si el valor de <code>x</code> és menor que 0, el valor retornat sempre és {{jsxref("NaN")}}.</p> + +<p>Com que <code>log10()</code> és un mètode estàtic de <code>Math</code>, sempre s'utilitza com <code>Math.log10()</code> en comptes de com un mètode d'un objecte <code>Math</code> creat (<code>Math</code> no és un constructor).</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_Math.log10()">Utilitzar <code>Math.log10()</code></h3> + +<pre class="brush: js">Math.log10(2); // 0.3010299956639812 +Math.log10(1); // 0 +Math.log10(0); // -Infinit +Math.log10(-2); // NaN +Math.log10(100000); // 5 +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Aquesta funció pot ser emulada mitjançant el següent codi:</p> + +<pre class="brush: js">Math.log10 = Math.log10 || function(x) { + return Math.log(x) / Math.LN10; +}; +</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-math.log10', 'Math.log10')}}</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("38")}}</td> + <td>{{CompatGeckoDesktop("25")}}</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("25")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Math.exp()")}}</li> + <li>{{jsxref("Math.log()")}}</li> + <li>{{jsxref("Math.log1p()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.log2()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.pow()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/math/log10e/index.html b/files/ca/web/javascript/referencia/objectes_globals/math/log10e/index.html new file mode 100644 index 0000000000..299c8d12ed --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/math/log10e/index.html @@ -0,0 +1,118 @@ +--- +title: Math.LOG10E +slug: Web/JavaScript/Referencia/Objectes_globals/Math/LOG10E +translation_of: Web/JavaScript/Reference/Global_Objects/Math/LOG10E +--- +<div>{{JSRef("Global_Objects", "Math")}}</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>La propietat <strong><code>Math.LOG10E</code></strong> representa el logaritme en base 10 de e, el valor del qual és aproximadament 0.434:</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.LOG10E</mi></mstyle><mo>=</mo><msub><mo lspace="0em" rspace="0em">log</mo><mn>10</mn></msub><mo stretchy="false">(</mo><mi>e</mi><mo stretchy="false">)</mo><mo>≈</mo><mn>0.434</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.LOG10E}} = \log_10(e) \approx 0.434</annotation></semantics></math></p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Description" name="Description">Descripció</h2> + +<p>Degut a que <code>LOG10E</code> és una propietat estàtica de l'objecte <code>Math</code>, sempre s'obté el seu valor mitjançant <code>Math.LOG10E</code> en comptes d'accedir a la propietat d'un objecte instanciat de <code>Math</code> (<code>Math</code> no és un constructor).</p> + +<h2 id="Examples" name="Examples">Exemples</h2> + +<h3 id="Example:_Using_Math.LOG10E" name="Example:_Using_Math.LOG10E">Exemple: Utilitzar <code>Math.LOG10E</code></h3> + +<p>La funció següent retorna el logaritme en base 10 de e:</p> + +<pre class="brush:js">function getLog10e() { + return Math.LOG10E; +} + +getLog10e(); // 0.4342944819032518 +</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>ECMAScript 1a Edició.</td> + <td>Standard</td> + <td>Definició inicial. Implementat a JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.1.5', 'Math.LOG10E')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.log10e', 'Math.LOG10E')}}</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>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li>{{jsxref("Math.exp()")}}</li> + <li>{{jsxref("Math.log()")}}</li> + <li>{{jsxref("Math.log10()")}} {{experimental_inline}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/math/log1p/index.html b/files/ca/web/javascript/referencia/objectes_globals/math/log1p/index.html new file mode 100644 index 0000000000..1a0eb32cd5 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/math/log1p/index.html @@ -0,0 +1,125 @@ +--- +title: Math.log1p() +slug: Web/JavaScript/Referencia/Objectes_globals/Math/log1p +translation_of: Web/JavaScript/Reference/Global_Objects/Math/log1p +--- +<div>{{JSRef}}</div> + +<p>La funció <strong><code>Math.log1p()</code></strong> retorna el logaritme natural (base {{jsxref("Math.E", "e")}}) de 1 + un nombre, és a dir</p> + +<p><math display="block"><semantics><mrow><mo>∀</mo><mi>x</mi><mo>></mo><mo>-</mo><mn>1</mn><mo>,</mo><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.log1p</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">ln</mo><mo stretchy="false">(</mo><mn>1</mn><mo>+</mo><mi>x</mi><mo stretchy="false">)</mo></mrow><annotation encoding="TeX">\forall x > -1, \mathtt{\operatorname{Math.log1p}(x)} = \ln(1 + x)</annotation></semantics></math></p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code>Math.log1p(<var>x</var>)</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Un nombre.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Si el valor de <code>x</code> és menor que -1, el valor retornat sempre serà {{jsxref("NaN")}}.</p> + +<p>Com que <code>log1p()</code> és un mètode estàtic de <code>Math</code>, sempre s'utilitza com <code>Math.log1p()</code> en comptes de com un mètode d'un objecte <code>Math</code> creat (<code>Math</code> no és un constructor).</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_Math.log1p()">Utilitzar <code>Math.log1p()</code></h3> + +<pre class="brush: js">Math.log1p(1); // 0.6931471805599453 +Math.log1p(0); // 0 +Math.log1p(-1); // -Infinit +Math.log1p(-2); // NaN +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Aquesta funció pot ser emulada mitjançant la funció següent:</p> + +<pre class="brush: js">Math.log1p = Math.log1p || function(x) { + return Math.log(1 + x); +}; +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.log1p', 'Math.log1p')}}</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("38")}}</td> + <td>{{CompatGeckoDesktop("25")}}</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("25")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Math.exp()")}}</li> + <li>{{jsxref("Math.log()")}}</li> + <li>{{jsxref("Math.log10()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.log2()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.pow()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/math/log2/index.html b/files/ca/web/javascript/referencia/objectes_globals/math/log2/index.html new file mode 100644 index 0000000000..0806bd75ff --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/math/log2/index.html @@ -0,0 +1,127 @@ +--- +title: Math.log2() +slug: Web/JavaScript/Referencia/Objectes_globals/Math/log2 +translation_of: Web/JavaScript/Reference/Global_Objects/Math/log2 +--- +<div>{{JSRef}}</div> + +<p>La funció <strong><code>Math.log2()</code></strong> retorna el logaritme en base 2 d'un nombre, és a dir</p> + +<p><math display="block"><semantics><mrow><mo>∀</mo><mi>x</mi><mo>></mo><mn>0</mn><mo>,</mo><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.log2</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><msub><mo lspace="0em" rspace="0em">log</mo><mn>2</mn></msub><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext>la única</mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mspace width="thickmathspace"></mspace><mtext>tal que</mtext><mspace width="thickmathspace"></mspace><msup><mn>2</mn><mi>y</mi></msup><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x > 0, \mathtt{\operatorname{Math.log2}(x)} = \log_2(x) = \text{the unique} \; y \; \text{such that} \; 2^y = x</annotation></semantics></math></p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code>Math.log2(<var>x</var>)</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Un nombre.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Si el valor de <code>x</code> és menor que 0, el valor retornat sempre serà {{jsxref("NaN")}}.</p> + +<p>Com que <code>log2()</code> és un mètode estàtic de <code>Math</code>, sempre s'utilitza com <code>Math.log2()</code> en comptes de com un mètode d'un objecte <code>Math</code> creat (<code>Math</code> no és un constructor).</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_Math.log2()">Utilitzar <code>Math.log2()</code></h3> + +<pre class="brush: js">Math.log2(3); // 1.584962500721156 +Math.log2(2); // 1 +Math.log2(1); // 0 +Math.log2(0); // -Infinit +Math.log2(-2); // NaN +Math.log2(1024); // 10 +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Aquest Polyfill emula la funció <code>Math.log2</code>. Cal destacar que retorna valors imprecisos per a algunes entrades (com ara 1 << 29), embolcalleu-la amb {{jsxref("Math.round()")}} si esteu treballant amb màscares de bits.</p> + +<pre class="brush: js">Math.log2 = Math.log2 || function(x) { + return Math.log(x) / Math.LN2; +}; +</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-math.log2', 'Math.log2')}}</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("38")}}</td> + <td>{{CompatGeckoDesktop("25")}}</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("25")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Math.exp()")}}</li> + <li>{{jsxref("Math.log()")}}</li> + <li>{{jsxref("Math.log10()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.log1p()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.pow()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/math/log2e/index.html b/files/ca/web/javascript/referencia/objectes_globals/math/log2e/index.html new file mode 100644 index 0000000000..2f37ae44c1 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/math/log2e/index.html @@ -0,0 +1,118 @@ +--- +title: Math.LOG2E +slug: Web/JavaScript/Referencia/Objectes_globals/Math/LOG2E +translation_of: Web/JavaScript/Reference/Global_Objects/Math/LOG2E +--- +<div>{{JSRef("Global_Objects", "Math")}}</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>La propietat <strong><code>Math.LOG2E</code></strong> representa el logaritme de e en base 2, el valor del qual és aproximadament 1.442:</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.LOG2E</mi></mstyle><mo>=</mo><msub><mo lspace="0em" rspace="0em">log</mo><mn>2</mn></msub><mo stretchy="false">(</mo><mi>e</mi><mo stretchy="false">)</mo><mo>≈</mo><mn>1.442</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.LOG2E}} = \log_2(e) \approx 1.442</annotation></semantics></math></p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Description" name="Description">Descripció</h2> + +<p>Com que <code>LOG2E</code> és una propietat estàtica de <code>Math</code>, sempre s'utilitza mitjançant la forma <code>Math.LOG2E</code>, en comptes d'accedir a la propietat d'un objecte <code>Math</code> creat (<code>Math</code> no és un constructor).</p> + +<h2 id="Examples" name="Examples">Exemples</h2> + +<h3 id="Example:_Using_Math.LOG2E" name="Example:_Using_Math.LOG2E">Exemple: Utilitzar <code>Math.LOG2E</code></h3> + +<p>La següent funció retorna el logaritme de e en base 2:</p> + +<pre class="brush: js">function getLog2e() { + return Math.LOG2E; +} + +getLog2e(); // 1.4426950408889634 +</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>ECMAScript 1a Edició.</td> + <td>Standard</td> + <td>Definició inicial. Implementat a JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.1.4', 'Math.LOG2E')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.log2e', 'Math.LOG2E')}}</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>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li>{{jsxref("Math.exp()")}}</li> + <li>{{jsxref("Math.log()")}}</li> + <li>{{jsxref("Math.log2()")}} {{experimental_inline}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/math/max/index.html b/files/ca/web/javascript/referencia/objectes_globals/math/max/index.html new file mode 100644 index 0000000000..791b5dfdfe --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/math/max/index.html @@ -0,0 +1,134 @@ +--- +title: Math.max() +slug: Web/JavaScript/Referencia/Objectes_globals/Math/max +translation_of: Web/JavaScript/Reference/Global_Objects/Math/max +--- +<div>{{JSRef}}</div> + +<p>La funció <strong><code>Math.max()</code></strong> retorna el nombre més gran de zero o més nombres.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code>Math.max([<var>valor1</var>[, <var>valor2</var>[, ...]]])</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>valor1, valor2, ...</code></dt> + <dd>Nombres.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Com que <code>max()</code> és un mètode estàtic de <code>Math</code>, sempre s'utilitza com<code> Math.max()</code> en comptes de com un mètode d'un objecte <code>Math</code> creat (<code>Math</code> no és un constructor).</p> + +<p>Si no es proporciona cap argument, el resultat és -{{jsxref("Infinity")}}.</p> + +<p>Si al menys un dels arguments no pot convertir-se a un nombre, el resultat és {{jsxref("NaN")}}.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_Math.max()">Utilitzar <code>Math.max()</code></h3> + +<pre class="brush: js">Math.max(10, 20); // 20 +Math.max(-10, -20); // -10 +Math.max(-10, 20); // 20 +</pre> + +<p>La següent funció utilitza {{jsxref("Function.prototype.apply()")}} per a trobar l'element màxim d'un array numèric. <code>getMaxOfArray([1, 2, 3])</code> és equivalent a <code>Math.max(1, 2, 3)</code>, però <code>getMaxOfArray()</code> pot emprar-se en arrays de qualsevol mida construits programàticament.</p> + +<pre class="brush: js">function getMaxOfArray(numArray) { + return Math.max.apply(null, numArray); +} +</pre> + +<p>O bé amb el nou {{jsxref("Operators/Spread_operator", "operador spread")}}, obtenir el nombre màxim d'un array és molt més simple.</p> + +<pre class="brush: js">var arr = [1, 2, 3]; +var max = Math.max(...arr); +</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.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.11', 'Math.max')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.max', 'Math.max')}}</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 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("Math.min()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/math/min/index.html b/files/ca/web/javascript/referencia/objectes_globals/math/min/index.html new file mode 100644 index 0000000000..909e6ff2ee --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/math/min/index.html @@ -0,0 +1,140 @@ +--- +title: Math.min() +slug: Web/JavaScript/Referencia/Objectes_globals/Math/min +translation_of: Web/JavaScript/Reference/Global_Objects/Math/min +--- +<div>{{JSRef}}</div> + +<p>La funció <strong><code>Math.min()</code></strong> retorna el més petit de zero o més nombres.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code>Math.min([<var>valor1</var>[, <var>valor2</var>[, ...]]])</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>valor1, valor2, ...</code></dt> + <dd>Nombres.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Degut a que <code>min()</code> és un mètode estàtic de <code>Math</code>, sempre s'utilitza com a <code>Math.min()</code>, en comptes de com a mètode d'una instància de <code>Math</code> (<code>Math</code> no és un constructor).</p> + +<p>Si no es proporciona cap argument, el resultat és {{jsxref("Infinity")}}.</p> + +<p>Si al menys un dels arguments no pot ser convertit a nombre, el resultat és {{jsxref("NaN")}}.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_Math.min()">Utilitzar <code>Math.min()</code></h3> + +<p>Aquest codi troba el valor mínim de <code>x</code> i <code>y</code> i l'assigna a <code>z</code>:</p> + +<pre class="brush: js">var x = 10, y = -20; +var z = Math.min(x, y); +</pre> + +<h3 id="Limitar_un_nombre_amb_Math.min()">Limitar un nombre amb <code>Math.min()</code></h3> + +<p>Sovint s'utilitza <code>Math.min()</code> per a limitar un valor de manera que sempre sigui igual o menor que un límit. Per exemple, aquest codi</p> + +<pre class="brush: js">var x = f(foo); + +if (x > limit) { + x = limit; +} +</pre> + +<p>es podria escriure de la següent manera:</p> + +<pre class="brush: js">var x = Math.min(f(foo), limit); +</pre> + +<p>{{jsxref("Math.max()")}} es pot emprar d'una manera similar per a limitar un valor a l'altre límit.</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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definició inicial. Implementat a JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.12', 'Math.min')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.min', 'Math.min')}}</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 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("Math.max()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/math/pi/index.html b/files/ca/web/javascript/referencia/objectes_globals/math/pi/index.html new file mode 100644 index 0000000000..b867c953df --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/math/pi/index.html @@ -0,0 +1,116 @@ +--- +title: Math.PI +slug: Web/JavaScript/Referencia/Objectes_globals/Math/PI +translation_of: Web/JavaScript/Reference/Global_Objects/Math/PI +--- +<div>{{JSRef("Global_Objects", "Math")}}</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>La propietat <strong><code>Math.PI</code></strong> representa el ratio entre la circumferència d'un crecle i el seu diàmetre, el seu valor aproximat és de 3.14159:</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.PI</mi></mstyle><mo>=</mo><mi>π</mi><mo>≈</mo><mn>3.14159</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.PI}} = \pi \approx 3.14159</annotation></semantics></math></p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Description" name="Description">Descripció</h2> + +<p>Com que <code>PI</code> és una propietat estàtica de <code>Math</code>, sempre s'utilitza amb la forma <code>Math.PI</code>, ren comptes de com una propietat d'un objecte <code>Math</code> ja creat (<code>Math</code> on és un constructor).</p> + +<h2 id="Examples" name="Examples">Exemples</h2> + +<h3 id="Example:_Using_Math.PI" name="Example:_Using_Math.PI">Exemple: Utilitzar <code>Math.PI</code></h3> + +<p>La funció següent utilitza <code>Math.PI</code> per a calcular la circumferència d'un cercle a partir del radi que rep.</p> + +<pre class="brush: js">function calculateCircumference(radius) { + return 2 * Math.PI * radius; +} + +calculateCircumference(1); // 6.283185307179586 +</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>ECMAScript 1a Edició.</td> + <td>Standard</td> + <td>Definició inicial. Implementat a JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.1.6', 'Math.PI')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.pi', 'Math.PI')}}</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>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li>{{jsxref("Global_Objects/Math", "Math")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/math/pow/index.html b/files/ca/web/javascript/referencia/objectes_globals/math/pow/index.html new file mode 100644 index 0000000000..efe89000e9 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/math/pow/index.html @@ -0,0 +1,140 @@ +--- +title: Math.pow() +slug: Web/JavaScript/Referencia/Objectes_globals/Math/pow +translation_of: Web/JavaScript/Reference/Global_Objects/Math/pow +--- +<div>{{JSRef}}</div> + +<p>La funció <strong><code>Math.pow()</code></strong> retorna la <code>base</code> elevada a <code>exponent</code>, és a dir, <code>base<sup>exponent</sup></code>.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code>Math.pow(<var>base</var>, <var>exponent</var>)</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>base</code></dt> + <dd>El nombre base.</dd> + <dt><code>exponent</code></dt> + <dd>L'exponent que s'usarà per a elevar la base.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Com que <code>pow()</code> és un mètode estàtic de <code>Math</code>, sempre s'utilitza com <code>Math.pow()</code> en comptes de com un mètode d'un objecte <code>Math </code>creat (<code>Math </code>no és un constructor).</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_Math.pow()">Utilitzar <code>Math.pow()</code></h3> + +<pre class="brush: js">// simple +Math.pow(7, 2); // 49 +Math.pow(7, 3); // 343 +Math.pow(2, 10); // 1024 +// exponents fractionals +Math.pow(4, 0.5); // 2 (rel quadrada de 4) +Math.pow(8, 1/3); // 2 (rel cúbica de 8) +Math.pow(2, 0.5); // 1.412135623730951 (rel quadrada de 2) +Math.pow(2, 1/3); // 1.2599210498948732 (rel cúbica de 2) +// exponents amb signe +Math.pow(7, -2); // 0.02040816326530612 (1/49) +Math.pow(8, -1/3); // 0.5 +// bases amb signe +Math.pow(-7, 2); // 49 (qualsevol nombre elevat al quadrat és positiu) +Math.pow(-7, 3); // -343 (nombres elevats al cub poden ser negatius) +Math.pow(-7, 0.5); // NaN (els nombres negatius no tenen una rel quadrada real) +// degut a rels "parells" i "senars" estan aprox l'una de l'altra +// i a límits en la precisió dels nombres de punt flotant, +// bases negatives amb exponents fraccionals sempre retornen NaN +Math.pow(-7, 1/3); // NaN +</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.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.13', 'Math.pow')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.pow', 'Math.pow')}}</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 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("Math.cbrt()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.exp()")}}</li> + <li>{{jsxref("Math.log()")}}</li> + <li>{{jsxref("Math.sqrt()")}}</li> + <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Exponentiation" title="Arithmetic operators take numerical values (either literals or variables) as their operands and return a single numerical value. The standard arithmetic operators are addition (+), subtraction (-), multiplication (*), and division (/).">Operador Exponencial</a> {{experimental_inline}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/math/random/index.html b/files/ca/web/javascript/referencia/objectes_globals/math/random/index.html new file mode 100644 index 0000000000..d70169efd4 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/math/random/index.html @@ -0,0 +1,126 @@ +--- +title: Math.random() +slug: Web/JavaScript/Referencia/Objectes_globals/Math/random +translation_of: Web/JavaScript/Reference/Global_Objects/Math/random +--- +<div>{{JSRef}}</div> + +<p>La funció <strong><code>Math.random()</code></strong> retorna un nombre decimal de punt flotant pseudo-aleatori que roman dins el rang <code>[0, 1)</code>, és a dir, des de 0 (inclòs) fins a 1 (exclòs), que després pot ser escalat al rang dessitjat. La implementació selecciona la llavor inicial per a l'algoritme generador de nombres aleatoris; aquesta llavor no pot ser resetejada o escollida per l'usuari.</p> + +<div class="note"> +<p><strong>Nota:</strong> <code>Math.random()</code> <strong>no</strong> proporciona nombres aleatoris criptogràficament segurs. No l'utilitzeu per a cap tasca relacionada amb la seguretat. Per a aquest ús utilitzeu la API Web Crypto, i més concretament el mètode {{domxref("RandomSource.getRandomValues()", "window.crypto.getRandomValues()")}}.</p> +</div> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code>Math.random()</code></pre> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_Math.random()">Utilitzar <code>Math.random()</code></h3> + +<p>Cal destacar que com que els nombres a JavaScript són nombres de punt flotant IEEE 754 amb comportament d'arrodoniment al parell més proper, els rangs proclamats per les funcions de sota (a excepció de <code>Math.random()</code>) no són exactes. Si s'escullen límits extremadament grans (2<sup>53</sup> o majors), és possible en casos <em>extremadament</em> rars, obtindre el límit superior que normalment és exclòs.</p> + +<pre class="brush: js">// Retorna un nombre aleatori entre 0 (inclòs) i 1 (exclòs) +function getRandom() { + return Math.random(); +} +</pre> + +<pre class="brush: js">// Retorna un nombre aleatori entre min (inclòs) i max (exclòs) +function getRandomArbitrary(min, max) { + return Math.random() * (max - min) + min; +} +</pre> + +<pre class="brush: js">// Retorna un nombre sencer aleatori entre min (inclòs) i max (exclòs) +// Utilitzar Math.round() proporciona una distribució no uniforme! +function getRandomInt(min, max) { + return Math.floor(Math.random() * (max - min)) + min; +} +</pre> + +<pre class="brush: js">// Returns a random integer between min (included) and max (included) +// Using Math.round() will give you a non-uniform distribution! +function getRandomIntInclusive(min, max) { + return Math.floor(Math.random() * (max - min + 1)) + min; +}</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. JavaScript 1.0 (Només UNIX) / JavaScript 1.1 (Totes les plataformes).</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.14', 'Math.random')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.random', 'Math.random')}}</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 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> diff --git a/files/ca/web/javascript/referencia/objectes_globals/math/round/index.html b/files/ca/web/javascript/referencia/objectes_globals/math/round/index.html new file mode 100644 index 0000000000..2510799381 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/math/round/index.html @@ -0,0 +1,207 @@ +--- +title: Math.round() +slug: Web/JavaScript/Referencia/Objectes_globals/Math/round +translation_of: Web/JavaScript/Reference/Global_Objects/Math/round +--- +<div>{{JSRef}}</div> + +<p>La funció <strong><code>Math.round()</code></strong> retorna el valor d'un nombre arrodonit al nombre sencer més proper.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code>Math.round(<var>x</var>)</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Un nombre.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Si la porció fraccional del nombre és 0.5 o major, l'argument s'arrodoneix al següent nombre sencer més gran. Si la porció fraccional del nombre és menor de 0.5 l'argument és arrodonit al següent nombre sencer més petit.</p> + +<p>Com que <code>round()</code> és un mètode estàtic de <code>Math</code>, sempre s'utilitza com <code>Math.round()</code> en comptes de com un mètode d'un objecte <code>Math </code>creat (<code>Math </code>no és un constructor).</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_Math.round()">Utilitzar <code>Math.round()</code></h3> + +<pre class="brush: js">// Retorna el valor 20 +x = Math.round(20.49); + +// Retorna el valor 21 +x = Math.round(20.5); + +// Retorna el valor -20 +x = Math.round(-20.5); + +// Retorna el valor -21 +x = Math.round(-20.51); + +// Retorna el valor 1 (!) +// Fixeu-vos en l'error d'arrodoniment degut a la poc precisa aritmètica de punt flotant +// Compareu això amb Math.round10(1.005, -2) de l'exemple de sota +x = Math.round(1.005*100)/100; +</pre> + +<h3 id="Arrodoniment_decimal">Arrodoniment decimal</h3> + +<pre class="brush: js">// Closure +(function() { + /** + * Ajustament decimal d'un nombre + * + * @param {String} type El tipus d'ajustament. + * @param {Number} value El nombre. + * @param {Integer} exp L'exponent (el logaritme en base 10 de la base a ajustar). + * @returns {Number} El valor ajustat. + */ + function decimalAdjust(type, value, exp) { + // Si l'exponent és undefined o zero... + if (typeof exp === 'undefined' || +exp === 0) { + return Math[type](value); + } + value = +value; + exp = +exp; + // Si el valor no és un nombre o l'exponent no és un nombre sencer... + if (isNaN(value) || !(typeof exp === 'number' && exp % 1 === 0)) { + return NaN; + } + // Desplaçament + value = value.toString().split('e'); + value = Math[type](+(value[0] + 'e' + (value[1] ? (+value[1] - exp) : -exp))); + // Desfer el desplaçament + value = value.toString().split('e'); + return +(value[0] + 'e' + (value[1] ? (+value[1] + exp) : exp)); + } + + // Arrodoniment decimal + if (!Math.round10) { + Math.round10 = function(value, exp) { + return decimalAdjust('round', value, exp); + }; + } + // Floor decimal + if (!Math.floor10) { + Math.floor10 = function(value, exp) { + return decimalAdjust('floor', value, exp); + }; + } + // Ceiling decimal + if (!Math.ceil10) { + Math.ceil10 = function(value, exp) { + return decimalAdjust('ceil', value, exp); + }; + } +})(); + +// Arrodoniment +Math.round10(55.55, -1); // 55.6 +Math.round10(55.549, -1); // 55.5 +Math.round10(55, 1); // 60 +Math.round10(54.9, 1); // 50 +Math.round10(-55.55, -1); // -55.5 +Math.round10(-55.551, -1); // -55.6 +Math.round10(-55, 1); // -50 +Math.round10(-55.1, 1); // -60 +Math.round10(1.005, -2); // 1.01 -- compareu aquest resultat amb Math.round(1.005*100)/100 de l'exemple de sobre +// Floor +Math.floor10(55.59, -1); // 55.5 +Math.floor10(59, 1); // 50 +Math.floor10(-55.51, -1); // -55.6 +Math.floor10(-51, 1); // -60 +// Ceil +Math.ceil10(55.51, -1); // 55.6 +Math.ceil10(51, 1); // 60 +Math.ceil10(-55.59, -1); // -55.5 +Math.ceil10(-59, 1); // -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. Implementat a JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.15', 'Math.round')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.round', 'Math.round')}}</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 (WebKit)</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>Firefox Mobile (Gecko)</th> + <th>IE Phone</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> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Math.abs()")}}</li> + <li>{{jsxref("Math.ceil()")}}</li> + <li>{{jsxref("Math.floor()")}}</li> + <li>{{jsxref("Math.sign()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.trunc()")}} {{experimental_inline}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/math/sign/index.html b/files/ca/web/javascript/referencia/objectes_globals/math/sign/index.html new file mode 100644 index 0000000000..520ff27dc4 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/math/sign/index.html @@ -0,0 +1,131 @@ +--- +title: Math.sign() +slug: Web/JavaScript/Referencia/Objectes_globals/Math/sign +translation_of: Web/JavaScript/Reference/Global_Objects/Math/sign +--- +<div>{{JSRef}}</div> + +<p>La funció <strong><code>Math.sign()</code></strong> retorna el signe d'un nombre, indicant si el nombre donat és positiu, negatiu o zero.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code>Math.sign(<var>x</var>)</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Un nombre.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Com que <code>sign()</code> és un mètode estàtic de <code>Math</code>, sempre s'utilitza com <code>Math.sign()</code> en comptes de com un mètode d'un objecte <code>Math</code> creat (<code>Math</code> no és un constructor).</p> + +<p>Aquesta funció pot retornar 5 valors diferents,<code> 1</code>, <code>-1</code>, <code>0</code>, <code>-0</code>, <code>NaN</code>, que representen "nombre positiu", "nombre negatiu", "zero positiu", "zero negatiu" i {{jsxref("NaN")}} respectivament.</p> + +<p>L'argument passat a aquesta funció serà convertit al tipus de <code>x</code> implícitament.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_Math.sign()">Utilitzar <code>Math.sign()</code></h3> + +<pre class="brush: js">Math.sign(3); // 1 +Math.sign(-3); // -1 +Math.sign('-3'); // -1 +Math.sign(0); // 0 +Math.sign(-0); // -0 +Math.sign(NaN); // NaN +Math.sign('foo'); // NaN +Math.sign(); // NaN +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<pre class="brush: js">Math.sign = Math.sign || function(x) { + x = +x; // converteix a un nombre + if (x === 0 || isNaN(x)) { + return x; + } + return x > 0 ? 1 : -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-math.sign', 'Math.sign')}}</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("38")}}</td> + <td>{{CompatGeckoDesktop("25")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatOpera("25")}}</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 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")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Math.abs()")}}</li> + <li>{{jsxref("Math.ceil()")}}</li> + <li>{{jsxref("Math.floor()")}}</li> + <li>{{jsxref("Math.round()")}}</li> + <li>{{jsxref("Math.trunc()")}} {{experimental_inline}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/math/sin/index.html b/files/ca/web/javascript/referencia/objectes_globals/math/sin/index.html new file mode 100644 index 0000000000..7f1faf9a98 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/math/sin/index.html @@ -0,0 +1,127 @@ +--- +title: Math.sin() +slug: Web/JavaScript/Referencia/Objectes_globals/Math/sin +translation_of: Web/JavaScript/Reference/Global_Objects/Math/sin +--- +<div>{{JSRef("Global_Objects", "Math")}}</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>La funció <strong><code>Math.sin()</code></strong> retorna el sinus d'un nombre.</p> + +<h2 id="Syntax" name="Syntax">Sintaxi</h2> + +<pre class="syntaxbox"><code>Math.sin(<var>x</var>)</code></pre> + +<h3 id="Parameters" name="Parameters">Paràmetres</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Un nombre (donat en radians).</dd> +</dl> + +<h2 id="Description" name="Description">Descripció</h2> + +<p>El mètode <code>Math.sin()</code> retorna un valor numèric entre -1 i 1, que representa el sinus de l'angle donat en radiants.</p> + +<p>Degut a que <code>sin()</code> és un mètode estàtic de <code>Math</code>, sempre s'utilitza com a <code>Math.sin()</code>, en comptes de com a mètode d'una instància de <code>Math</code> (<code>Math</code> no és un constructor).</p> + +<h2 id="Examples" name="Examples">Exemples</h2> + +<h3 id="Example:_Using_Math.sin" name="Example:_Using_Math.sin">Exemple: Utilitzar <code>Math.sin()</code></h3> + +<pre class="brush: js">Math.sin(0); // 0 +Math.sin(1); // 0.8414709848078965 + +Math.sin(Math.PI / 2); // 1 +</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>ECMAScript 1a Edició.</td> + <td>{{Spec2('ES1')}}</td> + <td>Definició inicial. Implementat a JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.16', 'Math.sin')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.sin', 'Math.sin')}}</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>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li>{{jsxref("Math.acos()")}}</li> + <li>{{jsxref("Math.asin()")}}</li> + <li>{{jsxref("Math.atan()")}}</li> + <li>{{jsxref("Math.atan2()")}}</li> + <li>{{jsxref("Math.cos()")}}</li> + <li>{{jsxref("Math.tan()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/math/sinh/index.html b/files/ca/web/javascript/referencia/objectes_globals/math/sinh/index.html new file mode 100644 index 0000000000..a1cc1f446a --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/math/sinh/index.html @@ -0,0 +1,129 @@ +--- +title: Math.sinh() +slug: Web/JavaScript/Referencia/Objectes_globals/Math/sinh +translation_of: Web/JavaScript/Reference/Global_Objects/Math/sinh +--- +<div>{{JSRef}}</div> + +<p>La funció <strong><code>Math.sinh()</code></strong> retorna el sinus hiperbòlic d'un nombre, que es pot expressar utilitzant la {{jsxref("Math.E", "constant e", "", 1)}}:</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mo lspace="0em" rspace="thinmathspace">Math.sinh(x)</mo></mstyle><mo>=</mo><mfrac><mrow><msup><mi>e</mi><mi>x</mi></msup><mo>-</mo><msup><mi>e</mi><mrow><mo>-</mo><mi>x</mi></mrow></msup></mrow><mn>2</mn></mfrac></mrow><annotation encoding="TeX">\mathtt{\operatorname{Math.sinh(x)}} = \frac{e^x - e^{-x}}{2}</annotation></semantics></math></p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code>Math.sinh(<var>x</var>)</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Un nombre.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Com que que <code>sinh()</code> és un mètode estàtic de <code>Math</code>, sempre s'utilitza com a <code>Math.sinh()</code>, en comptes de com a mètode d'una instància de <code>Math</code> (<code>Math</code> no és un constructor).</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_Math.sinh()">Utilitzar <code>Math.sinh()</code></h3> + +<pre class="brush: js">Math.sinh(0); // 0 +Math.sinh(1); // 1.1752011936438014 +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Aquest comportament es pot emular amb l'ajut de la funció {{jsxref("Math.exp()")}}:</p> + +<pre class="brush: js">Math.sinh = Math.sinh || function(x) { + return (Math.exp(x) - Math.exp(-x)) / 2; +} +</pre> + +<p>O bé utilitzant només una crida a la funció {{jsxref("Math.exp()")}}:</p> + +<pre class="brush: js">Math.sinh = Math.sinh || function(x) { + var y = Math.exp(x); + return (y - 1 / y) / 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-math.sinh', 'Math.sinh')}}</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("38")}}</td> + <td>{{CompatGeckoDesktop("25")}}</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("25")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Math.acosh()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.asinh()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.atanh()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.cosh()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.tanh()")}} {{experimental_inline}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/math/sqrt/index.html b/files/ca/web/javascript/referencia/objectes_globals/math/sqrt/index.html new file mode 100644 index 0000000000..b726db8a31 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/math/sqrt/index.html @@ -0,0 +1,127 @@ +--- +title: Math.sqrt() +slug: Web/JavaScript/Referencia/Objectes_globals/Math/sqrt +translation_of: Web/JavaScript/Reference/Global_Objects/Math/sqrt +--- +<div>{{JSRef}}</div> + +<p>La funció <strong><code>Math.sqrt()</code></strong> retorna la rel quadrada d'un nombre, és a dir</p> + +<p><math display="block"><semantics><mrow><mo>∀</mo><mi>x</mi><mo>≥</mo><mn>0</mn><mo>,</mo><mstyle mathvariant="monospace"><mrow><mi>M</mi><mi>a</mi><mi>t</mi><mi>h</mi><mo>.</mo><mi>s</mi><mi>q</mi><mi>r</mi><mi>t</mi><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><msqrt><mi>x</mi></msqrt><mo>=</mo><mtext>la única</mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mo>≥</mo><mn>0</mn><mspace width="thickmathspace"></mspace><mtext>tal que</mtext><mspace width="thickmathspace"></mspace><msup><mi>y</mi><mn>2</mn></msup><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x \geq 0, \mathtt{Math.sqrt(x)} = \sqrt{x} = \text{the unique} \; y \geq 0 \; \text{such that} \; y^2 = x</annotation></semantics></math></p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code>Math.sqrt(<var>x</var>)</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Un nombre.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Si el valor de <code>x</code> és negatiu, <code>Math.sqrt()</code> retorna {{jsxref("NaN")}}.</p> + +<p>Degut a que <code>sqrt()</code> és un mètode estàtic de <code>Math</code>, sempre s'utilitza com a <code>Math.sqrt()</code>, en comptes de com a mètode d'una instància de <code>Math</code> (<code>Math</code> no és un constructor).</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_Math.sqrt()">Utilitzar <code>Math.sqrt()</code></h3> + +<pre class="brush: js">Math.sqrt(9); // 3 +Math.sqrt(2); // 1.414213562373095 + +Math.sqrt(1); // 1 +Math.sqrt(0); // 0 +Math.sqrt(-1); // NaN +</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.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.17', 'Math.sqrt')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.sqrt', 'Math.sqrt')}}</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 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("Math.cbrt()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.exp()")}}</li> + <li>{{jsxref("Math.log()")}}</li> + <li>{{jsxref("Math.pow()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/math/sqrt1_2/index.html b/files/ca/web/javascript/referencia/objectes_globals/math/sqrt1_2/index.html new file mode 100644 index 0000000000..3d7d3a1370 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/math/sqrt1_2/index.html @@ -0,0 +1,117 @@ +--- +title: Math.SQRT1_2 +slug: Web/JavaScript/Referencia/Objectes_globals/Math/SQRT1_2 +translation_of: Web/JavaScript/Reference/Global_Objects/Math/SQRT1_2 +--- +<div>{{JSRef("Global_Objects", "Math")}}</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>La propietat <strong><code>Math.SQRT1_2</code></strong> representa la rel quadrada de 1/2, que equival aproximadament a 0.707:</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.SQRT1_2</mi></mstyle><mo>=</mo><msqrt><mfrac><mn>1</mn><mn>2</mn></mfrac></msqrt><mo>=</mo><mfrac><mn>1</mn><msqrt><mn>2</mn></msqrt></mfrac><mo>≈</mo><mn>0.707</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.SQRT1_2}} = \sqrt{\frac{1}{2}} = \frac{1}{\sqrt{2}} \approx 0.707</annotation></semantics></math></p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Description" name="Description">Descripció</h2> + +<p>Degut a que <code>SQRT1_2</code> éss una propietat estàtica de <code>Math</code>, sempre s'utilitza com a <code>Math.SQRT1_2</code> en comptes de com a la propietat d'una instància de <code>Math</code> (<code>Math</code> no és un constructor).</p> + +<h2 id="Examples" name="Examples">Exemples</h2> + +<h3 id="Example:_Using_Math.SQRT1_2" name="Example:_Using_Math.SQRT1_2">Exemple: Utilitzar <code>Math.SQRT1_2</code></h3> + +<p>La següent funció retorna 1 dividit per la rel quadrada de 2:</p> + +<pre class="brush:js">function getRoot1_2() { + return Math.SQRT1_2; +} + +getRoot1_2(); // 0.7071067811865476 +</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>ECMAScript 1a Edició.</td> + <td>Standard</td> + <td>Definició inicial. Implementat aJavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.1.7', 'Math.SQRT1_2')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.sqrt1_2', 'Math.SQRT1_2')}}</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>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li>{{jsxref("Math.pow()")}}</li> + <li>{{jsxref("Math.sqrt()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/math/sqrt2/index.html b/files/ca/web/javascript/referencia/objectes_globals/math/sqrt2/index.html new file mode 100644 index 0000000000..3d049f228c --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/math/sqrt2/index.html @@ -0,0 +1,117 @@ +--- +title: Math.SQRT2 +slug: Web/JavaScript/Referencia/Objectes_globals/Math/SQRT2 +translation_of: Web/JavaScript/Reference/Global_Objects/Math/SQRT2 +--- +<div>{{JSRef("Global_Objects", "Math")}}</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>La propietat <strong><code>Math.SQRT2</code></strong> representa la rel quadrada de 2, que és aproximadament 1.414:</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.SQRT2</mi></mstyle><mo>=</mo><msqrt><mn>2</mn></msqrt><mo>≈</mo><mn>1.414</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.SQRT2}} = \sqrt{2} \approx 1.414</annotation></semantics></math></p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Description" name="Description">Descripció</h2> + +<p>Degut a que <code>SQRT2</code> és una propietat estàtica de <code>Math</code>, sempre s'utilitza com a <code>Math.SQRT2</code>, en comptes de com la propietat d'una instància de <code>Math</code> (<code>Math</code> no és un constructor).</p> + +<h2 id="Examples" name="Examples">Exemples</h2> + +<h3 id="Example:_Using_Math.SQRT2" name="Example:_Using_Math.SQRT2">Exemple: Utilitzar <code>Math.SQRT2</code></h3> + +<p>La funció següent retorna la rel quadrada de 2:</p> + +<pre class="brush: js">function getRoot2() { + return Math.SQRT2; +} + +getRoot2(); // 1.4142135623730951 +</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>ECMAScript 1a Edició.</td> + <td>Standard</td> + <td>Definició inicial. Implementat a JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.1.8', 'Math.SQRT2')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.sqrt2', 'Math.SQRT2')}}</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>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li>{{jsxref("Math.pow()")}}</li> + <li>{{jsxref("Math.sqrt()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/math/tan/index.html b/files/ca/web/javascript/referencia/objectes_globals/math/tan/index.html new file mode 100644 index 0000000000..590e1f5fc8 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/math/tan/index.html @@ -0,0 +1,140 @@ +--- +title: Math.tan() +slug: Web/JavaScript/Referencia/Objectes_globals/Math/tan +translation_of: Web/JavaScript/Reference/Global_Objects/Math/tan +--- +<div>{{JSRef("Global_Objects", "Math")}}</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>La funció <strong><code>Math.tan()</code></strong> retorna la tangent d'un nombre.</p> + +<h2 id="Syntax" name="Syntax">Sintaxi</h2> + +<pre class="syntaxbox"><code>Math.tan(<var>x</var>)</code></pre> + +<h3 id="Parameters" name="Parameters">Paràmetres</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Un nombre que representa un angle, mesurat en radians.</dd> +</dl> + +<h2 id="Description" name="Description">Descripció</h2> + +<p>El mètode <code>Math.tan()</code> retorna un valor numèric que representa la tangent d'un angle.</p> + +<p>Degut a que <code>tan()</code> és un mètode estàtic de <code>Math</code>, sempre s'utilitza com a <code>Math.tan()</code>, en comptes de com a mètode d'una instància de <code>Math</code> (<code>Math</code> no és un constructor).</p> + +<h2 id="Examples" name="Examples">Exemples</h2> + +<h3 id="Example:_Using_Math.tan" name="Example:_Using_Math.tan">Exemple: Utilitzar <code>Math.tan()</code></h3> + +<pre class="brush: js">Math.tan(1); // 1.5574077246549023 +</pre> + +<p>Com que la funció <code>Math.tan()</code> accepta radians però sovint és més fàcil treballar amb graus, a funció següent accepta un valor en graus, el converteix a radians i retorna la tangent.</p> + +<pre class="brush: js">function getTanDeg(deg) { + var rad = deg * Math.PI/180; + return Math.tan(rad); +} +</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>ECMAScript 1a Edició.</td> + <td>{{Spec2('ES1')}}</td> + <td>Definició inicial. Implementat a JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.18', 'Math.tan')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.tan', 'Math.tan')}}</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>{{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> + <table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + </tr> + </tbody> + </table> + </th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li>{{jsxref("Math.acos()")}}</li> + <li>{{jsxref("Math.asin()")}}</li> + <li>{{jsxref("Math.atan()")}}</li> + <li>{{jsxref("Math.atan2()")}}</li> + <li>{{jsxref("Math.cos()")}}</li> + <li>{{jsxref("Math.sin()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/math/tanh/index.html b/files/ca/web/javascript/referencia/objectes_globals/math/tanh/index.html new file mode 100644 index 0000000000..ada19d17e0 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/math/tanh/index.html @@ -0,0 +1,142 @@ +--- +title: Math.tanh() +slug: Web/JavaScript/Referencia/Objectes_globals/Math/tanh +translation_of: Web/JavaScript/Reference/Global_Objects/Math/tanh +--- +<div>{{JSRef}}</div> + +<p>La funció <strong><code>Math.tanh()</code></strong> retorna la tangent hiperbòlica d'un nombre, és a dir</p> + +<p><math display="block"><semantics><mrow><mo lspace="0em" rspace="0em">tanh</mo><mi>x</mi><mo>=</mo><mfrac><mrow><mo lspace="0em" rspace="0em">sinh</mo><mi>x</mi></mrow><mrow><mo lspace="0em" rspace="0em">cosh</mo><mi>x</mi></mrow></mfrac><mo>=</mo><mfrac><mrow><msup><mi>e</mi><mi>x</mi></msup><mo>-</mo><msup><mi>e</mi><mrow><mo>-</mo><mi>x</mi></mrow></msup></mrow><mrow><msup><mi>e</mi><mi>x</mi></msup><mo>+</mo><msup><mi>e</mi><mrow><mo>-</mo><mi>x</mi></mrow></msup></mrow></mfrac><mo>=</mo><mfrac><mrow><msup><mi>e</mi><mrow><mn>2</mn><mi>x</mi></mrow></msup><mo>-</mo><mn>1</mn></mrow><mrow><msup><mi>e</mi><mrow><mn>2</mn><mi>x</mi></mrow></msup><mo>+</mo><mn>1</mn></mrow></mfrac></mrow><annotation encoding="TeX">\tanh x = \frac{\sinh x}{\cosh x} = \frac {e^x - e^{-x}} {e^x + e^{-x}} = \frac{e^{2x} - 1}{e^{2x}+1}</annotation></semantics></math></p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code>Math.tanh(<var>x</var>)</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Un nombre.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Com que que <code>tanh()</code> és un mètode estàtic de <code>Math</code>, sempre s'utilitza com a <code>Math.tanh()</code>, en comptes de com a mètode d'una instància de <code>Math</code> (<code>Math</code> no és un constructor).</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_Math.tanh()">Utilitzar <code>Math.tanh()</code></h3> + +<pre class="brush: js">Math.tanh(0); // 0 +Math.tanh(Infinity); // 1 +Math.tanh(1); // 0.7615941559557649 +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Aquest comportament pot emular-se amb l'ajuda de la funció {{jsxref("Math.exp()")}}:</p> + +<pre class="brush: js">Math.tanh = Math.tanh || function(x) { + if (x === Infinity) { + return 1; + } else if (x === -Infinity) { + return -1; + } else { + return (Math.exp(x) - Math.exp(-x)) / (Math.exp(x) + Math.exp(-x)); + } +} +</pre> + +<p>o bé utilitzant només una crida a {{jsxref("Math.exp()")}}:</p> + +<pre class="brush: js">Math.tanh = Math.tanh || function(x) { + if (x === Infinity) { + return 1; + } else if (x === -Infinity) { + return -1; + } else { + var y = Math.exp(2 * x); + return (y - 1) / (y + 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-math.tanh', 'Math.tanh')}}</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("38")}}</td> + <td>{{CompatGeckoDesktop("25")}}</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("25")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Math.acosh()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.asinh()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.atanh()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.cosh()")}} {{experimental_inline}}</li> + <li>{{jsxref("Math.sinh()")}} {{experimental_inline}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/math/trunc/index.html b/files/ca/web/javascript/referencia/objectes_globals/math/trunc/index.html new file mode 100644 index 0000000000..4f76502d69 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/math/trunc/index.html @@ -0,0 +1,129 @@ +--- +title: Math.trunc() +slug: Web/JavaScript/Referencia/Objectes_globals/Math/trunc +translation_of: Web/JavaScript/Reference/Global_Objects/Math/trunc +--- +<div>{{JSRef}}</div> + +<p>La funció <strong><code>Math.trunc()</code></strong> retorna la part integral d'un nombre, tot descartant els dígits decimals.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code>Math.trunc(<var>x</var>)</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Un nombre.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Al contrari que altres mètodes de <code>Math</code> : {{jsxref("Math.floor()")}}, {{jsxref("Math.ceil()")}} and {{jsxref("Math.round()")}}, la forma en la que <code>Math.trunc()</code> funciona és molt simple, simplement trunca el punt i els dígits que queden a la dreta, sense importa si l'argument és un nombre positiu o negatiu.</p> + +<p>Així que, si l'argument és un nombre positiu, <code>Math.trunc()</code> és equivalent a <code>Math.floor()</code>, en cas contrari, <code>Math.trunc()</code> és equivalent a <code>Math.ceil()</code>.</p> + +<p>Cal destacar que l'argument passat a aquest mètode serà convertit a un nombre de forma implícita.</p> + +<p>Com que <code>trunc()</code> és un mètode estàtic de <code>Math</code>, sempre s'utilitza com <code>Math.trunc()</code> en comptes de com un mètode d'un objecte <code>Math</code> creat (<code>Math</code> no és un constructor).</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_Math.trunc()"><code>Utilitzar Math.trunc()</code></h3> + +<pre class="brush: js">Math.trunc(13.37); // 13 +Math.trunc(42.84); // 42 +Math.trunc(0.123); // 0 +Math.trunc(-0.123); // -0 +Math.trunc('-1.123'); // -1 +Math.trunc(NaN); // NaN +Math.trunc('foo'); // NaN +Math.trunc(); // NaN +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<pre class="brush: js">Math.trunc = Math.trunc || function(x) { + return x < 0 ? Math.ceil(x) : Math.floor(x); +} +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.trunc', 'Math.trunc')}}</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("38")}}</td> + <td>{{CompatGeckoDesktop("25")}}</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("25")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Math.abs()")}}</li> + <li>{{jsxref("Math.ceil()")}}</li> + <li>{{jsxref("Math.floor()")}}</li> + <li>{{jsxref("Math.round()")}}</li> + <li>{{jsxref("Math.sign()")}} {{experimental_inline}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/nan/index.html b/files/ca/web/javascript/referencia/objectes_globals/nan/index.html new file mode 100644 index 0000000000..1d6f4a4dc8 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/nan/index.html @@ -0,0 +1,125 @@ +--- +title: NaN +slug: Web/JavaScript/Referencia/Objectes_globals/NaN +translation_of: Web/JavaScript/Reference/Global_Objects/NaN +--- +<div> +<div> +<div>{{jsSidebar("Objects")}}</div> +</div> +</div> + +<h2 id="Resum">Resum</h2> + +<p>La propietat global <code><strong>NaN</strong></code> és un valor que representa Not-A-Number.</p> + +<p>{{js_property_attributes(0,0,0)}}</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code>NaN</code></pre> + +<h2 id="Description" name="Description">Descripció</h2> + +<p><code>NaN</code> és una propietat de l'<em>objecte global</em>.</p> + +<p>El valor inicial de <code>NaN</code> és Not-A-Number — el mateix que el valor de <code>Number.NaN</code>. En navegadors moderns <code>NaN</code> és una propietat no configurable que no pot ser escrita. En cas contrari es recomana no sobreescriure el seu valor.</p> + +<p>L'ús directe de <code>NaN</code> és poc freqüent. Apareix tot sovint però com va valor retornat quan una funció matemàtica falla (<code>Math.sqrt(-1)</code>) o quan s'intenta convertir una cadena de text a nombre sense èxit (<code>parseInt("blabla")</code>).</p> + +<h2 id="Comparant_NaN">Comparant <code>NaN</code></h2> + +<p>L'operador d'igualtat (<code>==</code> i <code>===</code>) no pot ésser emprat per comparar un resultat amb <code>NaN</code>. Es fa necessari l'ús de {{jsxref("Number.isNaN()")}} o bé {{jsxref("Global_Objects/isNaN", "isNaN()")}}.</p> + +<pre class="brush: js">NaN === NaN; // false +Number.NaN === NaN; // false +isNaN(NaN); // true +isNaN(Number.NaN); // true +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>ECMAScript 1a Edició.</td> + <td>Standard</td> + <td>Definició inicial. Implementat a JavaScript 1.3</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.1.1.1', 'NaN')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-value-properties-of-the-global-object-nan', 'NaN')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{ CompatibilityTable() }}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li>{{jsxref("Number.NaN")}}</li> + <li>{{jsxref("Number.isNaN()")}}</li> + <li>{{jsxref("Global_Objects/isNaN", "isNaN()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/null/index.html b/files/ca/web/javascript/referencia/objectes_globals/null/index.html new file mode 100644 index 0000000000..97506ddeb5 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/null/index.html @@ -0,0 +1,125 @@ +--- +title: 'null' +slug: Web/JavaScript/Referencia/Objectes_globals/null +translation_of: Web/JavaScript/Reference/Global_Objects/null +--- +<div> +<div> +<div>{{jsSidebar("Objects")}}</div> +</div> +</div> + +<h2 id="Resum">Resum</h2> + +<p>El valor <code>null</code> és un literal de JavaScript que representa un valor nul o "buit", per exemple, quan no s'ha asignat cap valor previ. És un dels {{Glossary("Primitive", "valors primitius")}} de JavaScript.</p> + +<h2 id="Syntax" name="Syntax">Sintaxi</h2> + +<pre class="syntaxbox"><code>null </code></pre> + +<h2 id="Description" name="Description">Descripció</h2> + +<p>El valor <code>null</code> és un literal (i no una propietat de l'objecte global, com ho és <a href="/ca/docs/Web/JavaScript/Reference/Global_Objects/undefined" title="/en-US/docs/JavaScript/Reference/Global_Objects/undefined"><code>undefined</code></a>). A l'utilitzar les APIs, <code>null</code> s'obté sovint en comptes de l'objecte esperat quan no hi ha cap objecte relevant. Quan es vol comprovar si un valor és null o be undefined és important recordar les <a href="/ca/docs/Web/JavaScript/Reference/Operators/Comparison_Operators">diferències entre els operadors d'igualtat (==) i d'identitat (===)</a> (ja que amb el primer s'aplica una conversió de tipus).</p> + +<pre class="brush: js">// foo no existeix, no està definit i no s'ha inicialitzat mai +> foo +"ReferenceError: foo is not defined" + +// Es sap que foo existeix ara però no té tipus ni cap valor assignat: +> var foo = null; foo +"null" +</pre> + +<h3 id="Diferència_entre_null_i_undefined">Diferència entre <code>null</code> i <code>undefined</code></h3> + +<pre class="brush: js">typeof null // objecte (degut a un bug a ECMAScript, hauria de ser null) +typeof undefined // undefined +null === undefined // false +null == undefined // true +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>ECMAScript 1a Edició.</td> + <td>Standard</td> + <td>Definició inicial.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-4.3.11', 'null value')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-null-value', 'null value')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{ CompatibilityTable() }}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li>{{jsxref("Global_Objects/undefined", "undefined")}}</li> + <li>{{jsxref("Global_Objects/NaN", "NaN")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/number/epsilon/index.html b/files/ca/web/javascript/referencia/objectes_globals/number/epsilon/index.html new file mode 100644 index 0000000000..5e3f602703 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/number/epsilon/index.html @@ -0,0 +1,102 @@ +--- +title: Number.EPSILON +slug: Web/JavaScript/Referencia/Objectes_globals/Number/EPSILON +translation_of: Web/JavaScript/Reference/Global_Objects/Number/EPSILON +--- +<div>{{JSRef("Global_Objects", "Number")}}</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>La propietat <strong><code>Number.EPSILON</code></strong> representa la diferència entre el nombre 1 i el valor més petit major que 1 que pot ser representat com un {{jsxref("Global_Objects/Number", "Number")}}.</p> + +<p>Per tal d'accedir a la propietat no es fa necessari crear un objecte {{jsxref("Global_Objects/Number", "Number")}} ja que és una propietat estàtica i n'hi ha prou amb fer servir <code>Number.EPSILON</code> per a obtindre el valor.</p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Description" name="Description">Descripció</h2> + +<p>La propietat <code>EPSILON</code> té un valor aproximat de <code>2.2204460492503130808472633361816E-16</code>, és a dir, <code>2<sup>-52</sup></code>.</p> + +<h2 id="Examples" name="Examples">Exemples</h2> + +<h3 id="Exemple_Comprovant_l'igualtat">Exemple: Comprovant l'igualtat</h3> + +<pre class="brush: js">x = 0.2; +y = 0.3; +equal = (Math.abs(x - y) < Number.EPSILON); +</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-15.7.3.7', 'Number.EPSILON')}}</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>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoDesktop("25.0")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatVersionUnknown}}</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 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>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li>L'objecte {{jsxref("Global_Objects/Number", "Number")}} al qual pertany.</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/number/index.html b/files/ca/web/javascript/referencia/objectes_globals/number/index.html new file mode 100644 index 0000000000..5f4b7a0bb2 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/number/index.html @@ -0,0 +1,214 @@ +--- +title: Number +slug: Web/JavaScript/Referencia/Objectes_globals/Number +translation_of: Web/JavaScript/Reference/Global_Objects/Number +--- +<div>{{JSRef("Global_Objects", "Number")}}</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>L'objecte de JavaScript <strong><code>Number</code></strong> és un objecte embolcall que permet treballar amb valors numèrics. Un objecte de tipus <code>Number</code> és creat quan es crida el constructor <code>Number()</code>.</p> + +<h2 id="Syntax" name="Syntax">Constructor</h2> + +<pre class="syntaxbox">new Number(valor);</pre> + +<h3 id="Parameters" name="Parameters">Paràmetres</h3> + +<dl> + <dt><code>valor</code></dt> + <dd>El valor numèric de l'objecte que es pretèn crear.</dd> +</dl> + +<h2 id="Description" name="Description">Descripció</h2> + +<p>Els usos pricipals de l'objecte <code>Number</code> són:</p> + +<ul> + <li>Si l'argument dona al constructor no es pot convertir en un nombre aquest retorna {{jsxref("Global_Objects/NaN", "NaN")}}.</li> + <li><code>Number</code> pot ser emprat per a realitzar conversions de tipus sense necesitat de crear un nou objecte.</li> +</ul> + +<h2 id="Properties" name="Properties">Propietats</h2> + +<dl> + <dt>{{jsxref("Number.EPSILON")}} {{experimental_inline}}</dt> + <dd>L'interval més petit entre dos nombres que es pot representar.</dd> + <dt>{{jsxref("Number.MAX_SAFE_INTEGER")}} {{experimental_inline}}</dt> + <dd>El nombre sencer més gran que JavaScript pot representar de forma segura (<code>2<sup>53</sup> - 1</code>).</dd> + <dt>{{jsxref("Number.MAX_VALUE")}}</dt> + <dd>El nombre positiu més gran que pot ésser representat.</dd> + <dt>{{jsxref("Number.MIN_SAFE_INTEGER")}} {{experimental_inline}}</dt> + <dd>El nombre més petit que JavaScript pot representar de forma segura (<code>-(2<sup>53</sup> - 1)</code>).</dd> + <dt>{{jsxref("Number.MIN_VALUE")}}</dt> + <dd>El nombre positiu més petit que pot ésser representat. És a dir, el nombre positiu més proper a zero sense arribar a ser zero.</dd> + <dt>{{jsxref("Number.NaN")}}</dt> + <dd>El valor especial "not a number".</dd> + <dt>{{jsxref("Number.NEGATIVE_INFINITY")}}</dt> + <dd>El valor especial que representa l'infinit negatiu. És retornat quan es produeix un <em>overflow</em>.</dd> + <dt>{{jsxref("Number.POSITIVE_INFINITY")}}</dt> + <dd>El valor especial que representa l'infinit positiu. És retornat quan es produeix un <em>overflow</em>.</dd> + <dt>{{jsxref("Number.prototype")}}</dt> + <dd>Permet l'adició de propietats a l'objecte <code>Number</code>.</dd> +</dl> + +<div>{{jsOverrides("Function", "properties", "MAX_VALUE", "MIN_VALUE", "NaN", "NEGATIVE_INFINITY", "POSITIVE_INFINITY", "protoype")}}</div> + +<h2 id="Methods" name="Methods">Mètodes</h2> + +<dl> + <dt>{{jsxref("Number.isNaN()")}} {{experimental_inline}}</dt> + <dd>Determina si el valor proporcionat és NaN.</dd> + <dt>{{jsxref("Number.isFinite()")}} {{experimental_inline}}</dt> + <dd>Determina si el valor que representa és un valor finit.</dd> + <dt>{{jsxref("Number.isInteger()")}} {{experimental_inline}}</dt> + <dd>Determina si el valor que representa és un nombre i si es tracta d'un nombre sencer.</dd> + <dt>{{jsxref("Number.isSafeInteger()")}} {{experimental_inline}}</dt> + <dd>Determina si el tipus del valor proporcionat així com el valor en sí mateix és un nombre sencer segur (nombre entre <code>-(2<sup>53</sup> - 1)</code> i <code>2<sup>53</sup> - 1</code>).</dd> + <dt><s class="obsoleteElement">{{jsxref("Number.toInteger()")}} {{obsolete_inline}}</s></dt> + <dd><s class="obsoleteElement">Utilitzat per evaluar el valor passat i convertir-lo a sencer (o bé {{jsxref("Global_Objects/Infinity", "Infinity")}}), però s'ha eliminat.</s></dd> + <dt>{{jsxref("Number.parseFloat()")}} {{experimental_inline}}</dt> + <dd>Fa la mateixa funció que el mètode {{jsxref("Global_Objects/parseFloat", "parseFloat")}} de l'objecte global.</dd> + <dt>{{jsxref("Number.parseInt()")}} {{experimental_inline}}</dt> + <dd>Fa la mateixa funció que el mètode {{jsxref("Global_Objects/parseInt", "parseInt")}} de l'objecte global.</dd> +</dl> + +<div>{{jsOverrides("Function", "Methods", "isNaN")}}</div> + +<h2 id="Number_instances" name="Number_instances"><code>Instàncies de Number</code></h2> + +<p>Totes les instàncies de <code>Number</code> hereten de {{jsxref("Number.prototype")}}. L'objecte prototype del constructor <code>Number</code> pot ser modificat per a afectar a totes les instàncies de <code>Number</code>.</p> + +<h3 id="Methods_of_Number_instance" name="Methods_of_Number_instance">Mètodes</h3> + +<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/prototype', 'Methods')}}</div> + +<h2 id="Examples" name="Examples">Exemples</h2> + +<h3 id="Example:_Using_the_Number_object_to_assign_values_to_numeric_variables" name="Example:_Using_the_Number_object_to_assign_values_to_numeric_variables">Exemple: Utilitzar l'objecte <code>Number</code> per a assignar valors numèrics a variables</h3> + +<p>L'exemple que trobareu a continuació utilitza les propietats de l'objecte <code>Number</code> per a assignar valors a diferents variables numèriques:</p> + +<pre class="brush: js">var biggestNum = Number.MAX_VALUE; +var smallestNum = Number.MIN_VALUE; +var infiniteNum = Number.POSITIVE_INFINITY; +var negInfiniteNum = Number.NEGATIVE_INFINITY; +var notANum = Number.NaN; +</pre> + +<h3 id="Example:_Using_Number_to_convert_a_Date_object" name="Example:_Using_Number_to_convert_a_Date_object">Exemple: Rang de sencers de <code>Number</code></h3> + +<p>El següent exemple mostra el valor sencer mínim i màxim que pot ésser representat per un objecte de tipus <code>Number</code> (per a més detalls, referiu-vos a l'standard EcmaScript, capítol <em>8.5 El tipus Number</em>):</p> + +<pre class="brush: js">var biggestInt = 9007199254740992; +var smallestInt = -9007199254740992; +</pre> + +<p>A l'interpretar dades que han sigut serialitzades amb JSON, els valors que queden fora d'aquest rang poden esdevenir corruptes quan l'intèrpret de JSON els forci esdevenir de tipus <code>Number</code>. Una forma d'evitar aquesta limitació és utilitzar una {{jsxref("Global_Objects/String", "String")}} per representar el nombre.</p> + +<h3 id="Example:_Using_Number_to_convert_a_Date_object" name="Example:_Using_Number_to_convert_a_Date_object">Exemple: Utilitzar <code>Number</code> per a convertir un objecte de tipus <code>Date</code></h3> + +<p>L'exemple que trobareu a continuació converteix un objecte de tipus {{jsxref("Global_Objects/Date", "Date")}} a un tipus numèric tot utilitzant <code>Number</code> com una funció:</p> + +<pre class="brush: js">var d = new Date('December 17, 1995 03:24:00'); +print(Number(d)); +</pre> + +<p>Aquest exemple mostrarà "819199440000".</p> + +<h3 id="Exemple_Convertir_cadenes_de_caràcters_numèriques_a_nombres">Exemple: Convertir cadenes de caràcters numèriques a nombres</h3> + +<pre class="brush: js">Number("123") // 123 +Number("") // 0 +Number("0x11") // 17 +Number("0b11") // 3 +Number("0o11") // 9 +Number("foo") // NaN +Number("100a") // NaN +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>ECMAScript 1a Edició.</td> + <td>Standard</td> + <td>Definició inicial. Implementat a JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.7', 'Number')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-number-objects', 'Number')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Afegides nous mètodes i propietats: ({{jsxref("Number.EPSILON", "EPSILON")}}, {{jsxref("Number.isFinite", "isFinite")}}, {{jsxref("Number.isInteger", "isInteger")}}, {{jsxref("Number.isNaN", "isNaN")}}, {{jsxref("Number.parseFloat", "parseFloat")}}, {{jsxref("Number.parseInt", "parseInt")}})</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadores">Compatibilitat amb navegadores</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>Suport bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li>{{jsxref("Global_Objects/NaN", "NaN")}}</li> + <li>L'objecte global {{jsxref("Global_Objects/Math", "Math")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/number/isfinite/index.html b/files/ca/web/javascript/referencia/objectes_globals/number/isfinite/index.html new file mode 100644 index 0000000000..21d9493bf8 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/number/isfinite/index.html @@ -0,0 +1,118 @@ +--- +title: Number.isFinite() +slug: Web/JavaScript/Referencia/Objectes_globals/Number/isFinite +translation_of: Web/JavaScript/Reference/Global_Objects/Number/isFinite +--- +<div>{{JSRef}}</div> + +<p>El mètode <strong><code>Number.isFinite()</code></strong> determina si el valor que se li passa com a argument és un nombre finit o no.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code>Number.isFinite(valor)</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>valor</code></dt> + <dd>El valor que es comprovarà si és finit.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>En comparació amb la funció global {{jsxref("Global_Objects/isFinite", "isFinite()")}}, aquest mètode no converteix el paràmetres a un nombre forçosament. Això implica que només valors de tipus number, que també siguin finits, retornaran <code>true</code>.</p> + +<h2 id="Exemples">Exemples</h2> + +<pre class="brush: js">Number.isFinite(Infinity); // false +Number.isFinite(NaN); // false +Number.isFinite(-Infinity); // false + +Number.isFinite(0); // true +Number.isFinite(2e64); // true + +Number.isFinite('0'); // false, seria true si s'utilitzés la + // funció global isFinite('0') +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<pre class="brush: js">Number.isFinite = Number.isFinite || function(value) { + return typeof value === "number" && isFinite(value); +} +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-number.isfinite', 'Number.isInteger')}}</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("19")}}</td> + <td>{{CompatGeckoDesktop("16")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatOpera("15")}}</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 for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatGeckoMobile("16")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>L'objecte {{jsxref("Global_Objects/Number", "Number")}} al que pertany.</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/number/isinteger/index.html b/files/ca/web/javascript/referencia/objectes_globals/number/isinteger/index.html new file mode 100644 index 0000000000..ee524e91c2 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/number/isinteger/index.html @@ -0,0 +1,118 @@ +--- +title: Number.isInteger() +slug: Web/JavaScript/Referencia/Objectes_globals/Number/isInteger +translation_of: Web/JavaScript/Reference/Global_Objects/Number/isInteger +--- +<div>{{JSRef}}</div> + +<p>El mètode<strong> <code>Number.isInteger()</code></strong> determina si el valor que se li passa és un nombre sencer.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code>Number.isInteger(valor)</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>valor</code></dt> + <dd>El valor que serà comprovat si és sencer o no.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Si el valor passat és un nombre sencer, la funció retornarà <code>true</code>, en cas contrari es retorna <code>false</code>. Si el valor és {{jsxref("Global_Objects/NaN", "NaN")}} o infinit, es retorna <code>false</code>.</p> + +<h2 id="Exemples">Exemples</h2> + +<pre class="brush: js">Number.isInteger(0.1); // false +Number.isInteger(1); // true +Number.isInteger(Math.PI); // false +Number.isInteger(-100000); // true +Number.isInteger(NaN); // false +Number.isInteger(0); // true +Number.isInteger("10"); // false +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<pre class="brush: js">Number.isInteger = Number.isInteger || function(value) { + return typeof value === "number" && + isFinite(value) && + Math.floor(value) === value; +}; +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-number.isinteger', 'Number.isInteger')}}</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>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoDesktop("16")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatVersionUnknown}}</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 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("16")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>L'objecte {{jsxref("Global_Objects/Number", "Number")}} al que pertany.</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/number/isnan/index.html b/files/ca/web/javascript/referencia/objectes_globals/number/isnan/index.html new file mode 100644 index 0000000000..f6ba247306 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/number/isnan/index.html @@ -0,0 +1,129 @@ +--- +title: Number.isNaN() +slug: Web/JavaScript/Referencia/Objectes_globals/Number/isNaN +translation_of: Web/JavaScript/Reference/Global_Objects/Number/isNaN +--- +<div>{{JSRef}}</div> + +<p>El mètode <strong><code>Number.isNaN()</code></strong> determina si el valor passat com a argument és {{jsxref("Global_Objects/NaN", "NaN")}}. És una versió més robusta de la funció global {{jsxref("Global_Objects/isNaN", "isNaN()")}}.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code>Number.isNaN(valor)</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>valor</code></dt> + <dd>El valor que es comprovarà si és {{jsxref("Global_Objects/NaN", "NaN")}}.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Degut als dos operadors d'igualtat, {{jsxref("Operators/Comparison_Operators", "==", "#Equality")}} i {{jsxref("Operators/Comparison_Operators", "===", "#Identity")}}, retornen <code>false</code> quan es comprova si {{jsxref("Global_Objects/NaN", "NaN")}} <em>és</em> {{jsxref("Global_Objects/NaN", "NaN")}}, la funció <code>Number.isNaN()</code> esdevé necesària. Aquesta situació és diferent a totes les altres posibles comparacions a JavaScript.</p> + +<p>En comparació a la funció global {{jsxref("Global_Objects/isNaN", "isNaN()")}} function, <code>Number.isNaN()</code> no sofreix el problema de convertir forçosament el paràmetre donat a un nombre. Això implica que ara és segur passar valors que normalment serien convertits a {{jsxref("Global_Objects/NaN", "NaN")}} però en realitat no tenen el mateix valor que {{jsxref("Global_Objects/NaN", "NaN")}}. Això també implica que només valors de tipus number, que també siguin {{jsxref("Global_Objects/NaN", "NaN")}}, retornaran <code>true</code>.</p> + +<h2 id="Exemples">Exemples</h2> + +<pre class="brush: js">Number.isNaN(NaN); // true +Number.isNaN(Number.NaN); // true +Number.isNaN(0 / 0) // true + +// exemples que esdevindrien true amb la funció global isNaN() +Number.isNaN("NaN"); // false +Number.isNaN(undefined); // false +Number.isNaN({}); // false +Number.isNaN("blabla"); // false + +// Tots els següents retornen false +Number.isNaN(true); +Number.isNaN(null); +Number.isNaN(37); +Number.isNaN("37"); +Number.isNaN("37.37"); +Number.isNaN(""); +Number.isNaN(" "); +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<pre class="brush: js">Number.isNaN = Number.isNaN || function(value) { + return typeof value === "number" && value !== value; +}</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-number.isnan', 'Number.isnan')}}</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("25")}}</td> + <td>{{CompatGeckoDesktop("15")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatVersionUnknown}}</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>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>{{CompatUnknown}}</td> + <td>{{CompatGeckoMobile("15")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>iOS 9+</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Global_Objects/Number", "Number")}}</li> + <li>{{jsxref("Global_Objects/isNaN", "isNaN()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/number/issafeinteger/index.html b/files/ca/web/javascript/referencia/objectes_globals/number/issafeinteger/index.html new file mode 100644 index 0000000000..7570e7289d --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/number/issafeinteger/index.html @@ -0,0 +1,117 @@ +--- +title: Number.isSafeInteger() +slug: Web/JavaScript/Referencia/Objectes_globals/Number/isSafeInteger +translation_of: Web/JavaScript/Reference/Global_Objects/Number/isSafeInteger +--- +<div>{{JSRef}}</div> + +<p>El mètode <strong><code>Number.isSafeInteger()</code></strong> determina si el valor proporcionat és un nombre sencer segur. Un nombre sencer segur és aquell que</p> + +<ul> + <li>pot ser representat de forma exacta per un nombre de doble precisió IEEE-754, i</li> + <li>la seva representació IEEE-754 no pot ser el resultat de arrodonir cap altre nombre sencer per a encabir-lo a la representació IEEE-754.</li> +</ul> + +<p>Per exemple, <code>2<sup>53</sup> - 1</code> és un nombre sencer segur: pot ser representat de forma exacta i cap altre nombre sencer arrodonit coincideix amb ell sota cap mode d'arrodoniment IEEE-754. Per contra, <code>2<sup>53</sup></code> <em>no</em> és un nombre sencer segur: pot ser representat de manera exacta en IEEE-754, però el nombre sencer <code>2<sup>53</sup> + 1</code> no pot ser representat directament en IEEE-754 sino que s'arrodoniria a <code>2<sup>53</sup></code> mitjançant un arrodoniment al sencer més proper i un arrodoniment cap al zero.</p> + +<p>Els nombres sencers segurs consisteixen en tots els nombres sencers des de <code>-(2<sup>53</sup> - 1)</code> inclòs fins a <code>2<sup>53</sup> - 1</code> inclòs.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code>Number.isSafeInteger(valor)</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>valor</code></dt> + <dd>El valor a ser testat com a nombre sencer segur.</dd> +</dl> + +<h2 id="Exemples">Exemples</h2> + +<pre class="brush: js">Number.isSafeInteger(3); // true +Number.isSafeInteger(Math.pow(2, 53)); // false +Number.isSafeInteger(Math.pow(2, 53) - 1); // true +Number.isSafeInteger(NaN); // false +Number.isSafeInteger(Infinity); // false +Number.isSafeInteger('3'); // false +Number.isSafeInteger(3.1); // false +Number.isSafeInteger(3.0); // true +</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-number.issafeinteger', 'Number.isSafeInteger')}}</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>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoDesktop("32")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <td>Característica</td> + <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("32")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>L'objecte {{jsxref("Global_Objects/Number", "Number")}} al que pertany.</li> + <li>{{jsxref("Number.MIN_SAFE_INTEGER")}}</li> + <li>{{jsxref("Number.MAX_SAFE_INTEGER")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/number/max_safe_integer/index.html b/files/ca/web/javascript/referencia/objectes_globals/number/max_safe_integer/index.html new file mode 100644 index 0000000000..02483b41ac --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/number/max_safe_integer/index.html @@ -0,0 +1,100 @@ +--- +title: Number.MAX_SAFE_INTEGER +slug: Web/JavaScript/Referencia/Objectes_globals/Number/MAX_SAFE_INTEGER +translation_of: Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER +--- +<div>{{JSRef("Global_Objects", "Number")}}</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>La constant <strong><code>Number.MAX_SAFE_INTEGER</code></strong> representa el valor màxim que JavaScript pot representar de forma segura (<code>2<sup>53</sup> - 1</code>).</p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Description" name="Description">Descripció</h2> + +<p>La constant <code>MAX_SAFE_INTEGER</code> te un valor de <code>9007199254740991</code>. El raonament darrera d'aquest nombre és que JavaScript utilitza un <a href="http://en.wikipedia.org/wiki/Double_precision_floating-point_format">format de nombres de coma flotant de doble precisió</a>, tal com s'especifica al <a href="http://en.wikipedia.org/wiki/IEEE_floating_point">IEEE 754</a> i en conseqüència només pot representar de forma segura els nombres entre <code>-(2<sup>53</sup> - 1)</code> i <code>2<sup>53</sup> - 1</code>.</p> + +<p>Degut a que <code>MAX_SAFE_INTEGER</code> és una propietat estàtica de {{jsxref("Global_Objects/Number", "Number")}}, sempre s'accedeix de mitjançant <code>Number.MAX_SAFE_INTEGER</code> en comptes de com una propietat d'un objecte {{jsxref("Global_Objects/Number", "Number")}} instanciat.</p> + +<h2 id="Examples" name="Examples">Exemples</h2> + +<pre class="brush: js">Number.MAX_SAFE_INTEGER // 9007199254740991 +Math.pow(2, 53) - 1 // 9007199254740991 +</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-number.max_safe_integer', 'Number.MAX_SAFE_INTEGER')}}</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("34")}}</td> + <td>{{CompatGeckoDesktop("31")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatVersionUnknown}}</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 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("32")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li>{{jsxref("Number.MIN_SAFE_INTEGER")}}</li> + <li>{{jsxref("Number.isSafeInteger()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/number/max_value/index.html b/files/ca/web/javascript/referencia/objectes_globals/number/max_value/index.html new file mode 100644 index 0000000000..453ad01c23 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/number/max_value/index.html @@ -0,0 +1,118 @@ +--- +title: Number.MAX_VALUE +slug: Web/JavaScript/Referencia/Objectes_globals/Number/MAX_VALUE +translation_of: Web/JavaScript/Reference/Global_Objects/Number/MAX_VALUE +--- +<div> +<div>{{JSRef("Global_Objects", "Number")}}</div> +</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>La propietat <strong><code>Number.MAX_VALUE</code></strong> representa el valor numèric màxim representable en JavaScript.</p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Description" name="Description">Descripció</h2> + +<p>La propietat <code>MAX_VALUE</code> té un valor aproximadament de <code>1.79E+308</code>. Els valors més grans que <code>MAX_VALUE</code> són representats com a "<code>Infinity</code>".</p> + +<p>Ja que <code>MAX_VALUE</code> és una propietat estàtica de {{jsxref("Global_Objects/Number", "Number")}}, sempre es fa servir com a <code>Number.MAX_VALUE</code>, en comptes d'una propietat de l'objecte {{jsxref("Global_Objects/Number", "Number")}} que s'ha creat.</p> + +<h2 id="Examples" name="Examples">Exemples</h2> + +<h3 id="Example:_Using_MAX_VALUE" name="Example:_Using_MAX_VALUE">Exemple: Fer servir <code>MAX_VALUE</code></h3> + +<p>El codi següent multiplica dos valors numèrics. Si el resultat és menor o igual a <code>MAX_VALUE</code>, es crida la funció <code>func1</code>; del contrari, es crida la funció <code>func2</code>.</p> + +<pre class="brush: js">if (num1 * num2 <= Number.MAX_VALUE) { + func1(); +} else { + func2(); +} +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>1a edició de ECMAScript.</td> + <td>Estàndard</td> + <td>Definició inicial. Implementat en JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.7.3.2', 'Number.MAX_VALUE')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-number.max_value', 'Number.MAX_VALUE')}}</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 for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Supor bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li>{{jsxref("Number.MIN_VALUE")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/number/min_safe_integer/index.html b/files/ca/web/javascript/referencia/objectes_globals/number/min_safe_integer/index.html new file mode 100644 index 0000000000..861ec666ec --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/number/min_safe_integer/index.html @@ -0,0 +1,100 @@ +--- +title: Number.MIN_SAFE_INTEGER +slug: Web/JavaScript/Referencia/Objectes_globals/Number/MIN_SAFE_INTEGER +translation_of: Web/JavaScript/Reference/Global_Objects/Number/MIN_SAFE_INTEGER +--- +<div>{{JSRef("Global_Objects", "Number")}}</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>La constant <strong><code>Number.MIN_SAFE_INTEGER</code></strong> representa el nombre sencer segur més petit a JavaScript (<code>-(2<sup>53</sup> - 1)</code>).</p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Description" name="Description">Descripció</h2> + +<p>La constant <code>MIN_SAFE_INTEGER</code> te un valor de<code> -9007199254740991</code>. El raonament darrera d'aquest nombre és que JavaScript utilitza un <a href="http://en.wikipedia.org/wiki/Double_precision_floating-point_format">format de nombres de coma flotant de doble precisió</a>, tal com s'especifica al <a href="http://en.wikipedia.org/wiki/IEEE_floating_point">IEEE 754</a> i en conseqüència només pot representar de forma segura els nombres entre <code>-(2<sup>53</sup> - 1)</code> i <code>2<sup>53</sup> - 1</code>.</p> + +<p>Degut a que <code>MIN_SAFE_INTEGER</code> és una propietat estàtica de {{jsxref("Global_Objects/Number", "Number")}}, sempre s'accedeix de mitjançant <code>Number.MIN_SAFE_INTEGER</code> en comptes de com una propietat d'un objecte {{jsxref("Global_Objects/Number", "Number")}} instanciat.</p> + +<h2 id="Examples" name="Examples">Exemples</h2> + +<pre class="brush: js">Number.MIN_SAFE_INTEGER // -9007199254740991 +-(Math.pow(2, 53) - 1) // -9007199254740991 +</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-number.min_safe_integer', 'Number.MIN_SAFE_INTEGER')}}</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("34")}}</td> + <td>{{CompatGeckoDesktop("31")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatVersionUnknown}}</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 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("32")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li>{{jsxref("Number.MAX_SAFE_INTEGER")}}</li> + <li>{{jsxref("Number.isSafeInteger()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/number/min_value/index.html b/files/ca/web/javascript/referencia/objectes_globals/number/min_value/index.html new file mode 100644 index 0000000000..42af185360 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/number/min_value/index.html @@ -0,0 +1,118 @@ +--- +title: Number.MIN_VALUE +slug: Web/JavaScript/Referencia/Objectes_globals/Number/MIN_VALUE +translation_of: Web/JavaScript/Reference/Global_Objects/Number/MIN_VALUE +--- +<div>{{JSRef("Global_Objects", "Number")}}</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>La propietat <strong><code>Number.MIN_VALUE</code></strong> representa el valor numèric positiu més petit representable en JavaScript.</p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Description" name="Description">Descripció</h2> + +<p>La propietat <code>MIN_VALUE</code> és el nombre més proper a 0, però no és el nombre més negatiu que es pot representar en JavaScript.</p> + +<p><code>MIN_VALUE</code> té un valor aproximat de <code>5e-324</code>. Els valors més petits que <code>MIN_VALUE</code> ("underflow values") són convertits a 0.</p> + +<p>Ja que <code>MIN_VALUE</code> és una propietat estàtica de {{jsxref("Global_Objects/Number", "Number")}}, sempre s'usa com a <code>Number.MIN_VALUE</code>, i no com una propietat de l'objecte {{jsxref("Global_Objects/Number", "Number")}} que heu creat.</p> + +<h2 id="Examples" name="Examples">Exemples</h2> + +<h3 id="Example:_Using_MIN_VALUE" name="Example:_Using_MIN_VALUE">Exemple: Fer servir <code>MIN_VALUE</code></h3> + +<p>El codi següent divideix dos valors numèrics. Si el valor és més gran o igual a <code>MIN_VALUE</code>, la funció <code>func1</code> és crida; del contrari, es crida la funció <code>func2</code>.</p> + +<pre class="brush: js">if (num1 / num2 >= Number.MIN_VALUE) { + func1(); +} else { + func2(); +} +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>1a edició de ECMAScript.</td> + <td>Estàndard</td> + <td>Definició inicial. Implementat en JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.7.3.3', 'Number.MIN_VALUE')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-number.min_value', 'Number.MIN_VALUE')}}</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ístca</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li>{{jsxref("Number.MAX_VALUE")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/number/nan/index.html b/files/ca/web/javascript/referencia/objectes_globals/number/nan/index.html new file mode 100644 index 0000000000..7c6f3f1440 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/number/nan/index.html @@ -0,0 +1,100 @@ +--- +title: Number.NaN +slug: Web/JavaScript/Referencia/Objectes_globals/Number/NaN +translation_of: Web/JavaScript/Reference/Global_Objects/Number/NaN +--- +<div>{{JSRef("Global_Objects", "Number")}}</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>La propietat <strong><code>Number.NaN</code></strong> representa Not-A-Number (quelcom que no és un nombre). Equivalent a {{jsxref("Global_Objects/NaN", "NaN")}}.</p> + +<p>No és necesari crear un objecte de tipus {{jsxref("Global_Objects/Number", "Number")}} per a accedir a aquesta propietat estàtica (utilitzeu <code>Number.NaN</code>).</p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>ECMAScript 1a Edició.</td> + <td>Standard</td> + <td>Definició inicial. Implementat a JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.7.3.4', 'Number.NaN')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-number.nan', 'Number.NaN')}}</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 for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li>L'objecte global {{jsxref("Global_Objects/NaN", "NaN")}}.</li> + <li>L'objecte {{jsxref("Global_Objects/Number", "Number")}} al qual pertany.</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/number/negative_infinity/index.html b/files/ca/web/javascript/referencia/objectes_globals/number/negative_infinity/index.html new file mode 100644 index 0000000000..3fb4c1d150 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/number/negative_infinity/index.html @@ -0,0 +1,134 @@ +--- +title: Number.NEGATIVE_INFINITY +slug: Web/JavaScript/Referencia/Objectes_globals/Number/NEGATIVE_INFINITY +translation_of: Web/JavaScript/Reference/Global_Objects/Number/NEGATIVE_INFINITY +--- +<div>{{JSRef("Global_Objects", "Number")}}</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>La propietat <strong><code>Number.NEGATIVE_INFINITY</code></strong> representa el valor infinit negatiu.</p> + +<p>No fa falta crear un objecte {{jsxref("Global_Objects/Number", "Number")}} per accedir a aquesta propietat estàtica (feu servir <code>Number.NEGATIVE_INFINITY</code>).</p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Description" name="Description">Descripció</h2> + +<p>El valor de <code>Number.NEGATIVE_INFINITY</code> és el mateix que el valor negatiu de la propietat de l'objecte global {{jsxref("Global_Objects/Infinity", "Infinity")}}.</p> + +<p>Aquest valor es comporta de forma una mica diferent a l<u>'infinit matemàtic:</u></p> + +<ul> + <li>Qualsevol valor positiu, incloent {{jsxref("Number.POSITIVE_INFINITY", "POSITIVE_INFINITY")}}, multiplicat per <code>NEGATIVE_INFINITY</code> és <code>NEGATIVE_INFINITY</code>.</li> + <li>Qualsevol calor negatiu, incloent <code>NEGATIVE_INFINITY</code>, multiplicat per <code>NEGATIVE_INFINITY</code> és {{jsxref("Number.POSITIVE_INFINITY", "POSITIVE_INFINITY")}}.</li> + <li>Zero multiplicat per <code>NEGATIVE_INFINITY</code> és {{jsxref("Global_Objects/NaN", "NaN")}}.</li> + <li>{{jsxref("Global_Objects/NaN", "NaN")}} multiplicat per <code>NEGATIVE_INFINITY</code> és {{jsxref("Global_Objects/NaN", "NaN")}}.</li> + <li><code>NEGATIVE_INFINITY</code>, dividit per qualsevol valor negatiu excepte <code>NEGATIVE_INFINITY</code>, és {{jsxref("Number.POSITIVE_INFINITY", "POSITIVE_INFINITY")}}.</li> + <li><code>NEGATIVE_INFINITY</code>, dividit per qualsevol valor positiu excepte {{jsxref("Number.POSITIVE_INFINITY", "POSITIVE_INFINITY")}}, és <code>NEGATIVE_INFINITY</code>.</li> + <li><code>NEGATIVE_INFINITY</code>, dividit tant per <code>NEGATIVE_INFINITY</code> com per {{jsxref("Number.POSITIVE_INFINITY", "POSITIVE_INFINITY")}}, és {{jsxref("Global_Objects/NaN", "NaN")}}.</li> + <li>Qualsevol nombre dividit per <code>NEGATIVE_INFINITY</code> és zero.</li> +</ul> + +<p>Es pot fer serivir la propietat <code>Number.NEGATIVE_INFINITY</code> per indicar una condició d'error que retorna un nombre finit en cas d'èxit. Fixeu-vos, però, que {{jsxref("Global_Objects/isFinite", "isFinite")}} seria més apropiat en aquest cas.</p> + +<h2 id="Examples" name="Examples">Exemples</h2> + +<h3 id="Exemple_Fer_servir_NEGATIVE_INFINITY">Exemple: Fer servir <code>NEGATIVE_INFINITY</code></h3> + +<p><u>En l'exemple següent, a la variable <code>smallNumber</code> se li assigna un valor que és més petit que el valor mínim. Quan la delcaració {{jsxref("Statements/if...else", "if")}} s'executa, <code>smallNumber</code> té el valor <code>-Infinity</code>, així <code>smallNumber</code> s'estableix com a un valor més manegable abans de prosseguir.</u></p> + +<pre class="brush: js notranslate">var smallNumber = (-Number.MAX_VALUE) * 2; + +if (smallNumber == Number.NEGATIVE_INFINITY) { + smallNumber = returnFinite(); +} +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>1a edició de ECMAScript.</td> + <td>Estàndard</td> + <td>Definició inicial. Implementat en JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.7.3.5', 'Number.NEGATIVE_INFINITY')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-number.negative_infinity', 'Number.NEGATIVE_INFINITY')}}</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 for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li>{{jsxref("Number.POSITIVE_INFINITY")}}</li> + <li>{{jsxref("Number.isFinite()")}}</li> + <li>{{jsxref("Global_Objects/Infinity", "Infinity")}}</li> + <li>{{jsxref("Global_Objects/isFinite", "isFinite()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/number/parsefloat/index.html b/files/ca/web/javascript/referencia/objectes_globals/number/parsefloat/index.html new file mode 100644 index 0000000000..cd3494b7ac --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/number/parsefloat/index.html @@ -0,0 +1,103 @@ +--- +title: Number.parseFloat() +slug: Web/JavaScript/Referencia/Objectes_globals/Number/parseFloat +translation_of: Web/JavaScript/Reference/Global_Objects/Number/parseFloat +--- +<div>{{JSRef}}</div> + +<p>El mètode <strong><code>Number.parseFloat()</code></strong> interpreta el string passat com a argument i retorna un nombre de punt flotant. Aquest mètode es comporta de la mateixa manera que la funció global {{jsxref("Global_Objects/parseFloat", "parseFloat()")}} i és part del ECMAScript 6 (el seu motiu d'existència és la modularització dels globals).</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code>Number.parseFloat(<var>string</var>)</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>string</code></dt> + <dd>Un string que representa el valor a interpretar.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Vegeu {{jsxref("Global_Objects/parseFloat", "parseFloat()")}} per a més detalls i exemples.</p> + +<h2 id="Polyfill">Polyfill</h2> + +<pre class="brush: js">Number.parseFloat = parseFloat;</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-number.parsefloat', 'Number.parseFloat')}}</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>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoDesktop("25")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatVersionUnknown}}</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 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")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>L'objecte {{jsxref("Number")}} al que pertany.</li> + <li>La funció global {{jsxref("Global_Objects/parseFloat", "parseFloat()")}}.</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/number/parseint/index.html b/files/ca/web/javascript/referencia/objectes_globals/number/parseint/index.html new file mode 100644 index 0000000000..2ef9597d11 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/number/parseint/index.html @@ -0,0 +1,102 @@ +--- +title: Number.parseInt() +slug: Web/JavaScript/Referencia/Objectes_globals/Number/parseInt +translation_of: Web/JavaScript/Reference/Global_Objects/Number/parseInt +--- +<div>{{JSRef}}</div> + +<p>El mètode <strong><code>Number.parseInt()</code></strong> interpreta un argument string i retorna un nombre sencer de la base especificada.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code>Number.parseInt(<var>string</var>[, <var>radix</var>])</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<div>{{page("ca/docs/Web/JavaScript/Reference/Global_Objects/parseInt", "Parameters")}}</div> + +<h2 id="Descripció">Descripció</h2> + +<p>Aquest mètode és exactament la mateixa funció que la funció global {{jsxref("Global_Objects/parseInt", "parseInt()")}}:</p> + +<pre class="brush: js">Number.parseInt === parseInt; // true</pre> + +<p>i és part de l'ECMAScript 6 (el seu propòsit és la modularització de les globals). Vegeu jsxref("Global_Objects/parseInt", "parseInt()")}} per a més detalls i exemples.</p> + +<h2 id="Polyfill">Polyfill</h2> + +<pre class="brush: js">Number.parseInt = parseInt;</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-number.parseint', 'Number.parseInt')}}</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>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoDesktop("25")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatVersionUnknown}}</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>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>{{CompatGeckoDesktop("25")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>L'objecte {{jsxref("Number")}} al que pertany.</li> + <li>La funció global {{jsxref("Global_Objects/parseInt", "parseInt()")}}.</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/number/positive_infinity/index.html b/files/ca/web/javascript/referencia/objectes_globals/number/positive_infinity/index.html new file mode 100644 index 0000000000..234a779fd1 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/number/positive_infinity/index.html @@ -0,0 +1,137 @@ +--- +title: Number.POSITIVE_INFINITY +slug: Web/JavaScript/Referencia/Objectes_globals/Number/POSITIVE_INFINITY +translation_of: Web/JavaScript/Reference/Global_Objects/Number/POSITIVE_INFINITY +--- +<div>{{JSRef}}</div> + +<p>La propietat <strong><code>Number.POSITIVE_INFINITY</code></strong> representa el valor infinit negatiu.</p> + +<p>No fa falta crear un objecte {{jsxref("Global_Objects/Number", "Number")}} per accedir a aquesta propietat estàtica (feu servir <code>Number.POSITIVE_INFINITY</code>).</p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Descripció">Descripció</h2> + +<p>El valor de <code>Number.POSITIVE_INFINITY</code> és el mateix que el valor negatiu de la propietat de l'objecte global {{jsxref("Infinity")}}.</p> + +<p> </p> + +<p>Aquest valor es comporta de forma una mica diferent a l'infinit matemàtic<u>:</u></p> + +<p>Qualsevol valor positiu, incloent <code>POSITIVE_INFINITY</code>, multiplicat per <code>POSITIVE_INFINITY</code> és <code>POSITIVE_INFINITY</code>.</p> + +<ul> + <li>Qualsevol calor negatiu, incloent <code>NEGATIVE_INFINITY</code>, multiplicat per <code>POSITIVE_INFINITY</code> és {{jsxref("Number.<code>NEGATIVE</code>_INFINITY", "POSITIVE_INFINITY")}}.</li> + <li>Zero multiplicat per<code> POSITIVE_INFINITY</code> és {{jsxref("NaN")}}.</li> + <li>{{jsxref("Global_Objects/NaN", "NaN")}} multiplicat per<code>POSITIVE_INFINITY</code> és {{jsxref("NaN")}}.</li> + <li><code>POSITIVE_INFINITY</code>, dividit per quaulsevol valor negatiu execepte {{jsxref("Number.NEGATIVE_INFINITY", "NEGATIVE_INFINITY")}}, és {{jsxref("Number.NEGATIVE_INFINITY", "NEGATIVE_INFINITY")}}.</li> + <li><code>POSITIVE_INFINITY</code>, dividit per un valor positiu a excepció de<code> POSITIVE_INFINITY</code>, és <code>POSITIVE_INFINITY</code>.</li> + <li><code>POSITIVE_INFINITY</code>, dividit per {{jsxref("Number.NEGATIVE_INFINITY", "NEGATIVE_INFINITY")}} o bé per <code>POSITIVE_INFINITY</code>, és {{jsxref("NaN")}}.</li> + <li>Quasevol nombre dividit per<code> POSITIVE_INFINITY</code> és Zero.</li> +</ul> + +<p>Es pot fer serivir la propietat <code>Number.POSITIVE_INFINITY</code> per indicar una condició d'error que retorna un nombre finit en cas d'èxit. Fixeu-vos, però, que {{jsxref("isFinite")}} seria més apropiat en aquest cas.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_POSITIVE_INFINITY">Utilitzar <code>POSITIVE_INFINITY</code></h3> + +<p>In the following example, the variable <code>bigNumber</code> is assigned a value that is larger than the maximum value. When the {{jsxref("Statements/if...else", "if")}} statement executes, <code>bigNumber</code> has the value <code>Infinity</code>, so <code>bigNumber</code> is set to a more manageable value before continuing.</p> + +<p>A l'exemple següent, a la variable <code>nombrePetit</code> se li assigna un valor que és més gran que el valor màxim. Quan la declaració {{jsxref("Statements/if...else", "if")}} s'executa, <code>nombrePetit</code> té el valor <code>Infinity</code>, així <code>nombrePetit</code> s'estableix com a un valor més manegable abans de prosseguir.</p> + +<pre class="brush: js">var nombrePetit = Number.MAX_VALUE * 2; + +if (nombrePetit == Number.POSITIVE_INFINITY) { + nombrePetit= returnFinite(); +} +</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.7.3.6', 'Number.POSITIVE_INFINITY')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-number.positive_infinity', 'Number.POSITIVE_INFINITY')}}</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 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("Number.NEGATIVE_INFINITY")}}</li> + <li>{{jsxref("Number.isFinite()")}}</li> + <li>{{jsxref("Infinity")}}</li> + <li>{{jsxref("Global_Objects/isFinite", "isFinite()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/number/prototype/index.html b/files/ca/web/javascript/referencia/objectes_globals/number/prototype/index.html new file mode 100644 index 0000000000..3e5e679aaf --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/number/prototype/index.html @@ -0,0 +1,125 @@ +--- +title: Number.prototype +slug: Web/JavaScript/Referencia/Objectes_globals/Number/prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Number +--- +<div>{{JSRef}}</div> + +<p>La propietat <strong><code>Number.prototype</code></strong> representa el prototipus per al constructor {{jsxref("Number")}}.</p> + +<div>{{js_property_attributes(0, 0, 0)}}</div> + +<h2 id="Descripció">Descripció</h2> + +<p>Totes les instàncies de {{jsxref("Number")}} hereten de <code>Number.prototype</code>. L'objecte prototipus del constructor de {{jsxref("Number")}} pot ser modificat per a afectar totes les instàncies de {{jsxref( "Number")}}.</p> + +<h2 id="Propietats">Propietats</h2> + +<dl> + <dt><code>Number.prototype.constructor</code></dt> + <dd>Retorna la funció que ha creat la instància d'aquest objecte. Per defecte aquesta és l'objecte {{jsxref("Number")}}.</dd> +</dl> + +<h2 id="Mètodes">Mètodes</h2> + +<dl> + <dt>{{jsxref("Number.prototype.toExponential()")}}</dt> + <dd>Retorna un string que representa el nombre en notació exponencial.</dd> + <dt>{{jsxref("Number.prototype.toFixed()")}}</dt> + <dd>Retorna un string que representa el nombre en notació de punt fixe.</dd> + <dt>{{jsxref("Number.prototype.toLocaleString()")}}</dt> + <dd>Retorna un string amb una representació d'aquest nombbre sensible a la llengua. Sobreescriu el mètode {{jsxref("Object.prototype.toLocaleString()")}}.</dd> + <dt>{{jsxref("Number.prototype.toPrecision()")}}</dt> + <dd>Retorna un string amb una representació de precisió de punt fixe o notació exponencial del nombre.</dd> + <dt>{{jsxref("Number.prototype.toSource()")}} {{non-standard_inline}}</dt> + <dd>Retorna un objecte literal que representa l'objecte {{jsxref("Number")}} especificat; aquest valor pot ser emprat per a crear un nou objecte. Sobreescriu el mètode {{jsxref("Object.prototype.toSource()")}}.</dd> + <dt>{{jsxref("Number.prototype.toString()")}}</dt> + <dd>Retorna un string que representa l'objecte especificat en el radi (base) especificat. Sobreescriu el mètode {{jsxref("Object.prototype.toString()")}}.</dd> + <dt>{{jsxref("Number.prototype.valueOf()")}}</dt> + <dd>Retorna el valor primitiu de l'objecte especificat. Sobreescriu el mètode {{jsxref("Object.prototype.valueOf()")}}.</dd> +</dl> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definició inicial. Implementat a JavaScript 1.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.7.4', 'Number')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-properties-of-the-number-prototype-object', 'Number')}}</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 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("Number")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/number/toexponential/index.html b/files/ca/web/javascript/referencia/objectes_globals/number/toexponential/index.html new file mode 100644 index 0000000000..69ca3478ac --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/number/toexponential/index.html @@ -0,0 +1,136 @@ +--- +title: Number.prototype.toExponential() +slug: Web/JavaScript/Referencia/Objectes_globals/Number/toExponential +translation_of: Web/JavaScript/Reference/Global_Objects/Number/toExponential +--- +<div>{{JSRef}}</div> + +<p>El mètode <strong><code>toExponential()</code></strong> retorna un string que representa l'objecte de tipus <code>Number</code> en notació exponencial.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>numObj</var>.toExponential([dígitsDecimals])</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>dígitsDecimals</code></dt> + <dd>Opcional. Un nombre sencer que indica el nombre de dígits decimals que s'utilitzaran. Si no s'especifica s'utilitzaran per defecte tants dígits decimals com facin falta per a acomodar el nombre.</dd> +</dl> + +<h3 id="Valor_retornat">Valor retornat</h3> + +<p>Un string que representa l'objecte {{jsxref("Number")}} en notació exponencial amb un dígit a l'esquerra del punt decimal, i arrodonit a <code>dígitsDecimals</code> després del punt decimal. Si s'omet el paràmetre <code>fractionDigits</code> s'utilitzaran tants dígits decimals com facin falta per a acomodar el nombre.</p> + +<p>Si s'utilitza el mètode <code>toExponential()</code> en un literal numèric i el literal numèric no té exponent ni punt decimal, deixeu un espai abans del punt que precedeix a la crida del mètode per a evitar que el punt s'interpreti com a punt decimal.</p> + +<p>Si un nombre té més dígits dels que s'especifiquen al paràmetre <code>dígitsDecimals</code> el nombre s'arrodoneix al nombre més proper representable pel nombre de dígits <code>dígitsDecimals</code>. Vegeu la discussió sobre arrodoniment a la descripció del mètode {{jsxref("Number.prototype.toFixed", "toFixed()")}}, que també s'aplica al mètode <code>toExponential()</code>.</p> + +<h3 id="Excepcions_llençades">Excepcions llençades</h3> + +<dl> + <dt>{{jsxref("RangeError")}}</dt> + <dd>Si el valor de <code>dígitsDecimals</code> és massa petit o massa gran. Els valors acceptats estan entre 0 i 20, ambdos inclusius, i no llençaran per tant l'excepció <a class="new" href="https://developer.mozilla.org/ca/docs/Web/JavaScript/Referencia/RangeError" title="Aquesta pàgina encara no ha estat traduïda. Si us plau considera contribuir-hi!"><code>RangeError</code></a>. Les implementacions poden opcionalment donar suport per a valors més grans.</dd> + <dt>{{jsxref("TypeError")}}</dt> + <dd>Si es crida aquest mètode i se li passa un paràmetre que no és de tipus <a href="https://developer.mozilla.org/ca/docs/Web/JavaScript/Referencia/Objectes_globals/Number" title="L'objecte de JavaScript Number és un objecte embolcall que permet treballar amb valors numèrics. Un objecte de tipus Number és creat quan es crida el constructor Number()."><code>Number</code></a>.</dd> +</dl> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_toExponential">Utilitzar <code>toExponential</code></h3> + +<pre class="brush: js">var numObj = 77.1234; + +console.log(numObj.toExponential()); // escriu 7.71234e+1 +console.log(numObj.toExponential(4)); // escriu 7.7123e+1 +console.log(numObj.toExponential(2)); // escriu 7.71e+1 +console.log(77.1234.toExponential()); // escriu 7.71234e+1 +console.log(77 .toExponential()); // escriu 7.7e+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('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Definició inicial. Implementat a 1.5.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.7.4.6', 'Number.prototype.toExponential')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-number.prototype.toexponential', 'Number.prototype.toExponential')}}</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 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("Number.prototype.toFixed()")}}</li> + <li>{{jsxref("Number.prototype.toPrecision()")}}</li> + <li>{{jsxref("Number.prototype.toString()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/number/tofixed/index.html b/files/ca/web/javascript/referencia/objectes_globals/number/tofixed/index.html new file mode 100644 index 0000000000..8df53aafe3 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/number/tofixed/index.html @@ -0,0 +1,135 @@ +--- +title: Number.prototype.toFixed() +slug: Web/JavaScript/Referencia/Objectes_globals/Number/toFixed +translation_of: Web/JavaScript/Reference/Global_Objects/Number/toFixed +--- +<div>{{JSRef}}</div> + +<p>El mètode <strong><code>toFixed()</code></strong> formateja un nombre utilitzant notació de coma fixa.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>numObj</var>.toFixed([<var>dígits</var>])</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>dígits</code></dt> + <dd>Opcional. El nombre de dígits a utilitzar després del punt decimal; aquest paràmetre pot rebre valors entre 0 i 20, ambdós inclusius, i les implementacions poden opcionalment donar suport per a valors més grans. Si s'omet aquest argument s'utilitza un valor de 0 per defecte.</dd> +</dl> + +<h3 id="Valor_retornat">Valor retornat</h3> + +<p>Una representació de <code>numObj</code> en forma de string que no utilitza notació exponencial i té exactament <code>dígits</code> digits després del punt decimal. El nombre s'arrodoneix en cas que sigui necesari, així com la part fraccionaria s'omple amb zeros en cas necesari. Si <code>numObj</code> és major que <code>1e+21</code>, aquest mètode retornarà un string en notació exponencial, proporcionat pel mètode {{jsxref("Number.prototype.toString()")}}.</p> + +<h3 id="Excepcions_llençades">Excepcions llençades</h3> + +<dl> + <dt>{{jsxref("RangeError")}}</dt> + <dd>Si el valor de <code>dígits</code> és massa petit o massa gran. Els valors acceptats estan entre 0 i 20, ambdos inclusius, i no llençaran per tant l'excepció {{jsxref("RangeError")}}. Les implementacions poden opcionalment donar suport per a valors més grans.</dd> + <dt>{{jsxref("TypeError")}}</dt> + <dd>Si es crida aquest mètode i se li passa un paràmetre que no és de tipus {{jsxref( "Number")}}.</dd> +</dl> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_toFixed">Utilitzar <code>toFixed</code></h3> + +<pre class="brush: js">var numObj = 12345.6789; + +numObj.toFixed(); // Retorna '12346': recalquem l'arrodoniment, no hi ha part decimal +numObj.toFixed(1); // Retorna '12345.7': recalquem l'arrodoniment +numObj.toFixed(6); // Retorna '12345.678900': recalquem els zeros afegits +(1.23e+20).toFixed(2); // Retorna '123000000000000000000.00' +(1.23e-10).toFixed(2); // Retorna '0.00' +2.34.toFixed(1); // Retorna '2.3' +-2.34.toFixed(1); // Retorna -2.3 (degut a la precedència d'operadors, nombres literals negatius no retornen un string...) +(-2.34).toFixed(1); // Retorna'-2.3' (...a no ser que s'utilitzin parèntesi) +</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.5.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.7.4.5', 'Number.prototype.toFixed')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-number.prototype.tofixed', 'Number.prototype.toFixed')}}</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 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("Number.prototype.toExponential()")}}</li> + <li>{{jsxref("Number.prototype.toPrecision()")}}</li> + <li>{{jsxref("Number.prototype.toString()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/number/tointeger/index.html b/files/ca/web/javascript/referencia/objectes_globals/number/tointeger/index.html new file mode 100644 index 0000000000..b8fcd39443 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/number/tointeger/index.html @@ -0,0 +1,95 @@ +--- +title: Number.toInteger() +slug: Web/JavaScript/Referencia/Objectes_globals/Number/toInteger +translation_of: Archive/Web/JavaScript/Number.toInteger +--- +<div>{{JSRef}} {{obsolete_header("33")}} {{non-standard_header}}</div> + +<p>El mètode <strong><code>Number.toInteger()</code></strong> evaluava el valor passat com a paràmetre i el convertia en un nombre sencer, aquest mètode, però, ha sigut eliminat.</p> + +<p>Si el valor és {{jsxref("NaN")}}, {{jsxref("null")}} o bé {{jsxref("undefined")}}, es retorna 0. Si el valor és <code>false</code>, es retorna 0 mentre que si el valor és <code>true</code>, es retorna 1.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code>Number.toInteger(<em>nombre</em>)</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>nombre</code></dt> + <dd>El valor a convertir-se en un nombre sencer.</dd> +</dl> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_toInteger">Utilitzar <code>toInteger</code></h3> + +<pre class="brush: js">Number.toInteger(0.1); // 0 +Number.toInteger(1); // 1 +Number.toInteger(Math.PI); // 3 +Number.toInteger(null); // 0 +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<p><code>Number.toInteger()</code> era part de l'esborrany de l'especificació de l'ECMAScript 6, però el 23 d'agost de 2013 es va eliminar a la revisió 17 de l'esborrany.</p> + +<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>{{CompatNo}}</td> + <td>{{CompatNo}} [1]</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 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>{{CompatNo}} [1]</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<p>[1] Aquesta característica va estar suportada des del Firefox 16 al 32.</p> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Number")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/number/toprecision/index.html b/files/ca/web/javascript/referencia/objectes_globals/number/toprecision/index.html new file mode 100644 index 0000000000..0af5875e7f --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/number/toprecision/index.html @@ -0,0 +1,134 @@ +--- +title: Number.prototype.toPrecision() +slug: Web/JavaScript/Referencia/Objectes_globals/Number/toPrecision +translation_of: Web/JavaScript/Reference/Global_Objects/Number/toPrecision +--- +<div>{{JSRef}}</div> + +<p>El mètode <strong><code>toPrecision()</code></strong> retorna un string que representa l'objecte {{jsxref("Number")}} amb la precisió especificada.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>numObj</var>.toPrecision([<em>precisió</em>])</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>precisió</code></dt> + <dd>Opional. Un nombre sencer que indica el nombre de dígits significatius.</dd> +</dl> + +<h3 id="Valor_retornat">Valor retornat</h3> + +<p>Un string que representa un objecte {{jsxref("Number")}} en notació de punt fix o bé en notació exponencial, arrodonit a <code>precisió</code> dígits significatius. Vegeu la discussió sobre arrodoniment a la descripció del mètode {{jsxref("Number.prototype.toFixed()")}}, que també s'aplica a <code>toPrecision()</code>.</p> + +<p>Si s'omet l'argument <code>precisió</code>, es comporta com {{jsxref("Number.prototype.toString()")}}. Si l'argument <code>precisió</code> no és un nombre sencer, aquest s'arrodoneix al nombre sencer més proper.</p> + +<h3 id="Excepcions_llençades">Excepcions llençades</h3> + +<dl> + <dt>{{jsxref("Global_Objects/RangeError", "RangeError")}}</dt> + <dd>Si el valor de precisió no està entre 1 i 100 (ambdós inclusius), es llença un <a class="new" href="https://developer.mozilla.org/ca/docs/Web/JavaScript/Referencia/RangeError" title="Aquesta pàgina encara no ha estat traduïda. Si us plau considera contribuir-hi!"><code>RangeError</code></a>. Les implementacions poden opcionalment donar suport per a valors més grans o petits. ECMA-262 tan sols requereix una precisió de fins a 21 dígits significatius.</dd> +</dl> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_toPrecision">Utilitzar <code>toPrecision</code></h3> + +<pre class="brush: js">var numObj = 5.123456; + +console.log(numObj.toPrecision()); // escriu 5.123456 +console.log(numObj.toPrecision(5)); // escriu 5.1235 +console.log(numObj.toPrecision(2)); // escriu 5.1 +console.log(numObj.toPrecision(1)); // escriu 5 + +// fixeu-vos que la notació exponencial pot retornar-se en algunes circumstàncies +console.log((1234.5).toPrecision(2)); // escriu 1.2e+3 +</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 1.5.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.7.4.7', 'Number.prototype.toPrecision')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-number.prototype.toprecision', 'Number.prototype.toPrecision')}}</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 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("Number.prototype.toFixed()")}}</li> + <li>{{jsxref("Number.prototype.toExponential()")}}</li> + <li>{{jsxref("Number.prototype.toString()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/number/tostring/index.html b/files/ca/web/javascript/referencia/objectes_globals/number/tostring/index.html new file mode 100644 index 0000000000..7381fc97ac --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/number/tostring/index.html @@ -0,0 +1,141 @@ +--- +title: Number.prototype.toString() +slug: Web/JavaScript/Referencia/Objectes_globals/Number/toString +translation_of: Web/JavaScript/Reference/Global_Objects/Number/toString +--- +<div>{{JSRef}}</div> + +<p>El mètode <strong><code>toString()</code></strong> retorna un string que representa l'objecte {{jsxref("Number")}} especificat.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>objecteNum</var>.toString([</code><em>base</em><code>])</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>base</code></dt> + <dd>Opcional. Un nombre sencer entre 2 i 36 que indica la base a utilitzar a l'hora de representar valors numèrics.</dd> +</dl> + +<h3 id="Errors_llençats">Errors llençats</h3> + +<dl> + <dt>{{jsxref("RangeError")}}</dt> + <dd>Si <code>toString()</code> rep una <code>base</code> que no estigui entre 2 i 36, es llença un {{jsxref("RangeError")}}.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>L'objecte {{jsxref("Number")}} sobreescriu el mètode <code>toString()</code> de l'objecte {{jsxref("Object")}}; no hereta {{jsxref("Object.prototype.toString()")}}. Per a objectes {{jsxref( "Number")}}, el mètode <code>toString()</code> retorna una representació en forma de string de l'objecte, utilitzant la base especificada.</p> + +<p>El mètode <code>toString()</code> interpreta el primer argument donat, i intenta retornar una representació en forma de string tot utilitzant la base proporcionada. Per a bases majors que 10, les lletres del alfabet indiquen numerals majors que 9. Per exemple, per a nombres hexadecimals (en base 16), s'utilitzen les lletres de la <code>a</code> a la <code>f</code>.</p> + +<p>Si no s'especifica la <code>base</code>, s'utilitza 10 com a base.</p> + +<p>Si <code>objecteNum</code> és negatiu, es conserva el signe. Això s'aplica fins i tot si la base és 2; el string retornat és la representació binària positiva de <code>objecteNum</code> precedida per un signe <code>-</code>, <strong>no</strong> s'utilitza el complement a dos de <code>objecteNum</code>.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_toString">Utilitzar <code>toString</code></h3> + +<pre class="brush: js">var count = 10; + +console.log(count.toString()); // mostra '10' +console.log((17).toString()); // mostra '17' + +var x = 6; + +console.log(x.toString(2)); // mostra '110' +console.log((254).toString(16)); // mostra 'fe' + +console.log((-10).toString(2)); // mostra '-1010' +console.log((-0xff).toString(2)); // mostra '-11111111' +</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.7.4.2', 'Number.prototype.tostring')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-number.prototype.tostring', 'Number.prototype.tostring')}}</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 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("Number.prototype.toFixed()")}}</li> + <li>{{jsxref("Number.prototype.toExponential()")}}</li> + <li>{{jsxref("Number.prototype.toPrecision()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/parsefloat/index.html b/files/ca/web/javascript/referencia/objectes_globals/parsefloat/index.html new file mode 100644 index 0000000000..570fa6b63f --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/parsefloat/index.html @@ -0,0 +1,166 @@ +--- +title: parseFloat() +slug: Web/JavaScript/Referencia/Objectes_globals/parseFloat +translation_of: Web/JavaScript/Reference/Global_Objects/parseFloat +--- +<div> +<div> +<div>{{jsSidebar("Objects")}}</div> +</div> +</div> + +<p>La funció <code><strong>parseFloat()</strong></code> interpreta un argument de tipus cadena i retorna un nombre decimal amb coma flotant</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox">parseFloat(<em>cadena</em>)</pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>cadena</code></dt> + <dd>Una cadena que representa el valor que es vol interpretar.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p><code>parseFloat</code> és una funció de nivell superior que no està associada a cap objecte.</p> + +<p><code>parseFloat</code> interpreta el seu argument, una cadena, i retorna un nombre decimal amb coma flotant. Si es topa amb un caràcter que no sigui un signe (+ o -), un numeral (0-9), un punt decimal, o un exponent, retorna el valor fins a aquell punt i ignora aquell caràcter i la resta de caràcters que el succeeixen. Es permeten espais inicials i finals.</p> + +<p>Si el primer caràcter no es pot convertir en un nombre, <code>parseFloat</code> retorna <code>NaN</code>.</p> + +<p>Per propòstis aritmètics, el valor de <code>NaN</code> no és un nombre en qualsevol radix. Es pot cridar la funció {{jsxref("isNaN")}} per determinar si el resultat del <code>parseFloat</code> és <code>NaN</code>. Si es passa <code>NaN</code> en operacions aritmètiques, el resultat de l'operació també serà <code>NaN</code>.</p> + +<p><code>parseFloat</code> també pot interpretar i retornar el valor <code>Infinity</code>. Es pot utilitzar la funció {{jsxref("isFinite")}} per determinar si el resultat és un nombre finit i (no <code>Infinity</code>, <code>-Infinity</code>, o <code>NaN</code>).</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="parseFloat_retorna_un_nombre"><code>parseFloat</code> retorna un nombre</h3> + +<p>Tots els exemples següents retornen <strong>3.14</strong></p> + +<pre class="brush:js">parseFloat("3.14"); +parseFloat("314e-2"); +parseFloat("0.0314E+2"); +parseFloat("3.14more non-digit characters"); +</pre> + +<h3 id="parseFloat_retorna_NaN"><code>parseFloat</code> retorna NaN</h3> + +<p>L'exemple següent retorna <code>NaN</code></p> + +<pre class="brush: js">parseFloat("FF2"); +</pre> + +<h3 id="Una_interpretació_més_estricta">Una interpretació més estricta</h3> + +<p>Sovint és útil tenir una forma més estricta d'interpretar els valors flotants, expressions regulars poden ajudar:</p> + +<pre class="brush: js">var filterFloat = function (value) { + if(/^(\-|\+)?([0-9]+(\.[0-9]+)?|Infinity)$/ + .test(value)) + return Number(value); + return NaN; +} + +console.log(filterFloat('421')); // 421 +console.log(filterFloat('-421')); // -421 +console.log(filterFloat('+421')); // 421 +console.log(filterFloat('Infinity')); // Infinity +console.log(filterFloat('1.61803398875')); // 1.61803398875 +console.log(filterFloat('421e+0')); // NaN +console.log(filterFloat('421hop')); // NaN +console.log(filterFloat('hop1.61803398875')); // NaN + +</pre> + +<p>Vegeu que aquest codi és només a mode d'exemple, no accepta nombres vàlids com <code>1.</code> o <code>.5</code>.</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('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definició inicial.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.1.2.3', 'parseFloat')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-parsefloat-string', 'parseFloat')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome per Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Global_Objects/parseInt", "parseInt()")}}</li> + <li>{{jsxref("Number.parseFloat()")}}</li> + <li>{{jsxref("Number.parseInt()")}}</li> + <li>{{jsxref("Global_Objects/isNaN", "isNaN()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/set/add/index.html b/files/ca/web/javascript/referencia/objectes_globals/set/add/index.html new file mode 100644 index 0000000000..b93eaa3efb --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/set/add/index.html @@ -0,0 +1,119 @@ +--- +title: Set.prototype.add() +slug: Web/JavaScript/Referencia/Objectes_globals/Set/add +translation_of: Web/JavaScript/Reference/Global_Objects/Set/add +--- +<div>{{JSRef}}</div> + +<p>El mètode <code><strong>add()</strong></code> afegeix un nou element al final de l'objecte <code>Set</code> amb el <code>valor</code> especificat pel paràmetre.</p> + +<h2 id="Sintax">Sintax</h2> + +<pre class="syntaxbox"><code><em>mySet</em>.add(valor);</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt>valor</dt> + <dd>Obligatori. El valor de l'element que s'afegirà a l'objecte <code>Set</code>.</dd> +</dl> + +<h3 id="Valor_retornat">Valor retornat</h3> + +<p>L'objecte <code>Set</code>.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_el_mètode_add">Utilitzar el mètode <code>add</code></h3> + +<pre class="brush: js">var mySet = new Set(); + +mySet.add(1); +mySet.add(5).add("some text"); // crida en cadena + +console.log(mySet); +// Set [1, 5, "some text"] +</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-set.prototype.add', 'Set.prototype.add')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definició inicial.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>38</td> + <td>{{CompatGeckoDesktop("13.0")}}</td> + <td>11</td> + <td>25</td> + <td>7.1</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatNo}}</td> + <td>38</td> + <td>{{CompatGeckoMobile("13.0")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Notes_específiques_per_al_Firefox">Notes específiques per al Firefox</h2> + +<ul> + <li>En les versions anteriors al Firefox 33 {{geckoRelease("33")}}, <code>Set.prototype.add</code> retornava <code>undefined</code> i per tant no es podien realitzar crides encadenades. Aquest problem ha estat resolt ({{bug(1031632)}}). Aquest comportament també es pot trovar al Chrome/v8 (<a href="https://code.google.com/p/v8/issues/detail?id=3410">problema</a>).</li> +</ul> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Set")}}</li> + <li>{{jsxref("Set.prototype.delete()")}}</li> + <li>{{jsxref("Set.prototype.has()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/set/clear/index.html b/files/ca/web/javascript/referencia/objectes_globals/set/clear/index.html new file mode 100644 index 0000000000..6ef179daaa --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/set/clear/index.html @@ -0,0 +1,105 @@ +--- +title: Set.prototype.clear() +slug: Web/JavaScript/Referencia/Objectes_globals/Set/clear +translation_of: Web/JavaScript/Reference/Global_Objects/Set/clear +--- +<div>{{JSRef}}</div> + +<p>El mètode <code><strong>clear()</strong></code> esborra tots els elements emmagatzemats dins l'objecte <code>Set</code>.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><em>mySet</em>.clear();</code></pre> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_el_mètode_clear">Utilitzar el mètode <code>clear</code></h3> + +<pre class="brush: js">var mySet = new Set(); +mySet.add(1); +mySet.add("foo"); + +mySet.size; // 2 +mySet.has("foo"); // true + +mySet.clear(); + +mySet.size; // 0 +mySet.has("bar") // 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('ES6', '#sec-set.prototype.clear', 'Set.prototype.clear')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definició inicial.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>38</td> + <td>{{CompatGeckoDesktop("19.0")}}</td> + <td>11</td> + <td>25</td> + <td>7.1</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatNo}}</td> + <td>25</td> + <td>{{CompatGeckoMobile("19.0")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Set")}}</li> + <li>{{jsxref("Set.prototype.delete()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/set/delete/index.html b/files/ca/web/javascript/referencia/objectes_globals/set/delete/index.html new file mode 100644 index 0000000000..ea66c1a723 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/set/delete/index.html @@ -0,0 +1,112 @@ +--- +title: Set.prototype.delete() +slug: Web/JavaScript/Referencia/Objectes_globals/Set/delete +translation_of: Web/JavaScript/Reference/Global_Objects/Set/delete +--- +<div>{{JSRef}}</div> + +<p>El mètode <code><strong>delete()</strong></code> esborra l'element especificat emmagatzemat dins l'objecte <code>Set</code>.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><em>mySet</em>.delete(valor);</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt>valor</dt> + <dd>Obligatori. El valor de l'element a eliminar.</dd> +</dl> + +<h3 id="Valor_retornat">Valor retornat</h3> + +<p>Retorna <code>true</code> si s'ha pogut eliminar l'element de l'objecte <code>Set</code>; en cas contrari retorna <code>false</code>.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_el_mètode_delete">Utilitzar el mètode <code>delete</code></h3> + +<pre class="brush: js">var mySet = new Set(); +mySet.add("foo"); + +mySet.delete("bar"); // Retorna false. No s'ha trobat l'element "bar". +mySet.delete("foo"); // Retorna true. S'ha pogut esborrar l'element "foo". + +mySet.has("foo"); // Retorna false. L'element "foo" ja no existeix dins el Set. +</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-set.prototype.delete', 'Set.prototype.delete')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definició inicial.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>38</td> + <td>{{CompatGeckoDesktop("13.0")}}</td> + <td>11</td> + <td>25</td> + <td>7.1</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatNo}}</td> + <td>38</td> + <td>{{CompatGeckoMobile("13.0")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Set")}}</li> + <li>{{jsxref("Set.prototype.clear()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/set/entries/index.html b/files/ca/web/javascript/referencia/objectes_globals/set/entries/index.html new file mode 100644 index 0000000000..848e53ba8d --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/set/entries/index.html @@ -0,0 +1,104 @@ +--- +title: Set.prototype.entries() +slug: Web/JavaScript/Referencia/Objectes_globals/Set/entries +translation_of: Web/JavaScript/Reference/Global_Objects/Set/entries +--- +<div>{{JSRef}}</div> + +<p>El mètode <code><strong>entries()</strong></code> retorna un nou objecte <code>Iterator</code> que conté<strong> un array de <code>[valor, valor]</code></strong> per a cada element emmagatzemat dins l'objecte <code>Set</code>, ordenats per ordre d'inserció. Els elements de l'objecte <code>Set</code> no disposen de claus, a diferència dels objectes <code>Map</code>. Tot i així, per a oferir una API similar a la de l'objecte <code>Map</code> cada <em>entrada</em> té el mateix valor tant com per a la <em>clau</em> com per al <em>valor</em>. És per això que es retorna un array <code>[valor, valor]</code>.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><em>mySet</em>.entries()</code></pre> + +<h2 id="Examples">Examples</h2> + +<h3 id="Using_entries()">Using <code>entries()</code></h3> + +<pre class="brush:js">var mySet = new Set(); +mySet.add("foobar"); +mySet.add(1); +mySet.add("baz"); + +var setIter = mySet.entries(); + +console.log(setIter.next().value); // ["foobar", "foobar"] +console.log(setIter.next().value); // [1, 1] +console.log(setIter.next().value); // ["baz", "baz"] +</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-set.prototype.entries', 'Set.prototype.entries')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definició inicial.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>38</td> + <td>{{ CompatGeckoDesktop("24") }}</td> + <td>{{CompatNo}}</td> + <td>25</td> + <td>7.1</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatNo}}</td> + <td>38</td> + <td>{{ CompatGeckoMobile("24") }}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Set.prototype.keys()")}}</li> + <li>{{jsxref("Set.prototype.values()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/set/has/index.html b/files/ca/web/javascript/referencia/objectes_globals/set/has/index.html new file mode 100644 index 0000000000..ca9027b8a4 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/set/has/index.html @@ -0,0 +1,114 @@ +--- +title: Set.prototype.has() +slug: Web/JavaScript/Referencia/Objectes_globals/Set/has +translation_of: Web/JavaScript/Reference/Global_Objects/Set/has +--- +<div>{{JSRef}}</div> + +<p>El mètode <code><strong>has()</strong></code> retorna un booleà que indica si l'element amb el valor especificat existeix o no dins l'objecte <code>Set</code>.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><em>mySet</em>.has(valor);</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt>valor</dt> + <dd>Obligatori. El valor a comprovar si pertany o no a l'objecte <code>Set</code>.</dd> +</dl> + +<h3 id="Valor_retornat">Valor retornat</h3> + +<dl> + <dt>Booleà</dt> + <dd>Retorna <code>true</code> si existex un element amb el valor especificat dins l'objecte <code>Set</code>; en cas contrari retorna <code>false</code>.</dd> +</dl> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_el_mètode_has">Utilitzar el mètode <code>has</code></h3> + +<pre class="brush: js">var mySet = new Set(); +mySet.add("foo"); + +mySet.has("foo"); // retorna true +mySet.has("bar"); // retorna 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('ES6', '#sec-set.prototype.has', 'Set.prototype.has')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definició inicial.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>38</td> + <td>{{CompatGeckoDesktop("13.0")}}</td> + <td>11</td> + <td>25</td> + <td>7.1</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatNo}}</td> + <td>38</td> + <td>{{CompatGeckoMobile("13.0")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Set")}}</li> + <li>{{jsxref("Set.prototype.add()")}}</li> + <li>{{jsxref("Set.prototype.delete()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/set/index.html b/files/ca/web/javascript/referencia/objectes_globals/set/index.html new file mode 100644 index 0000000000..993d296324 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/set/index.html @@ -0,0 +1,380 @@ +--- +title: Set +slug: Web/JavaScript/Referencia/Objectes_globals/Set +translation_of: Web/JavaScript/Reference/Global_Objects/Set +--- +<div>{{JSRef}}</div> + +<p>L'objecte <strong><code>Set</code></strong> permet emmagatzemar valors <em>únics </em>de qualsevol tipus, ja siguin {{Glossary("Primitive", "valors primitius")}} o bé referències a objectes.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox">new Set([iterable]);</pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt>iterable</dt> + <dd>Si rep un <a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...of">objecte iterable</a>, tots els seus elements seran afegits al nou Set. null serà tractat com a undefined.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Els objectes <code>Set</code> són coleccions de valors, els seus elements poden ser iterats en ordre d'inserció. Un valor només pot aparèixer un cop dins el <code>Set</code>; és únic dins la col·lecció del <code>Set</code>.</p> + +<h3 id="Igualtat_de_valors">Igualtat de valors</h3> + +<p>Degut a que cada valor dins el <code>Set</code> ha de ser únic, la igualtat dels valors serà comprovada i aquesta no es basa en el mateix algoritme que l'emprat per l'operador<code> ===</code>. Concreatement, per a <code>Set</code>s, <code>+0</code> (que és estrictament igual a <code>-0</code>) i <code>-0</code> són valors diferents. Tot i així, aquest comportament s'ha canviat a la última especificació de l'ECMAScript 6. A partir de Gecko 29.0 {{geckoRelease("29")}} ({{bug("952870")}}) i una recent <a href="https://code.google.com/p/v8/issues/detail?id=3069">versió nightly del Chrome</a>, <code>+0</code> i <code>-0</code> són tractats com al mateix valor en objectes <code>Set</code>. Així mateix, <code>NaN</code> i <code>undefined</code> també poden ser emmagatzemats dins un Set. <code>NaN</code> és considerat igual a <code>NaN</code> (tot i que <code>NaN !== NaN</code>).</p> + +<h2 id="Propietats">Propietats</h2> + +<dl> + <dt><code>Set.length</code></dt> + <dd>El valor de la propietat <code>length</code> és 0.</dd> + <dt>{{jsxref("Set.@@species", "get Set[@@species]")}}</dt> + <dd>La funció constructora que s'ha utilitzat per a crear objectes derivats.</dd> + <dt>{{jsxref("Set.prototype")}}</dt> + <dd>Representa el prototipus per al constructor <code>Set</code>. Permet afegir propietats a tots els objectes <code>Set</code>.</dd> +</dl> + +<h2 id="Instàncies_de_Set">Instàncies de <code>Set</code></h2> + +<p>Totes les instàncies de <code>Set</code> hereten de {{jsxref("Set.prototype")}}.</p> + +<h3 id="Propietats_2">Propietats</h3> + +<p>{{page('ca/Web/JavaScript/Reference/Global_Objects/Set/prototype','Propietats')}}</p> + +<h3 id="Mètodes">Mètodes</h3> + +<p>{{page('ca/Web/JavaScript/Reference/Global_Objects/Set/prototype','Mètodes')}}</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_l'objecte_Set">Utilitzar l'objecte <code>Set</code></h3> + +<pre class="brush: js">var mySet = new Set(); + +mySet.add(1); +mySet.add(5); +mySet.add("algun text"); + +mySet.has(1); // true +mySet.has(3); // false, 3 no ha estat afegit al set +mySet.has(5); // true +mySet.has(Math.sqrt(25)); // true +mySet.has("Some Text".toLowerCase()); // true + +mySet.size; // 3 + +mySet.delete(5); // esborra 5 del set +mySet.has(5); // false, 5 ha sigut esborrat + +mySet.size; // 2, acabem d'esborrar un valor +</pre> + +<h3 id="Iterarar_Sets">Iterarar Sets</h3> + +<pre class="brush: js">// iterar els elements d'un set +// imprimeix els elements en l'ordre: 1, "algun text" +for (let item of mySet) console.log(item); + +// imprimeix els elements en l'ordre: 1, "algun text" +for (let item of mySet.keys()) console.log(item); + +// imprimeix els elements en l'ordre: 1, "algun text" +for (let item of mySet.values()) console.log(item); + +// imprimeix els elements en l'ordre: 1, "algun text" +//(key i value són iguals en aquest exemple) +for (let [key, value] of mySet.entries()) console.log(key); + +// converteix el set en un Array (mitjançant <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Array_comprehensions">Array comprehensions</a>) +var myArr = [v for (v of mySet)]; // [1, "algun text"] +// Alternativa (mitjançant <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/from">Array.from</a>) +var myArr = Array.from(mySet); // [1, "algun text"] + +// el codi següent també funcionarà si s'executa dins un document HTML +mySet.add(document.body); +mySet.has(document.querySelector("body")); // true + +// conversió entre Set i Array +mySet2 = new Set([1,2,3,4]); +mySet2.size; // 4 +[...mySet2]; // [1,2,3,4] + +// la intersecció es pot simular via +var intersection = new Set([x for (x of set1) if (set2.has(x))]); + +// Iteració de les entrades del set mitjançant un forEach +mySet.forEach(function(value) { + console.log(value); +}); + +// 1 +// 2 +// 3 +// 4</pre> + +<h3 id="Relació_amb_objectes_Array">Relació amb objectes <code>Array</code></h3> + +<pre class="brush: js">var myArray = ["valor1", "valor2", "valor3"]; + +// Utilitzem el constructor normal del Set per a transformar un Array en un Set +var mySet = new Set(myArray); + +mySet.has("valor1"); // retorna true + +// Utilitzem l'operador spread per a transformar un Set en un Array. +console.log(uneval([...mySet])); // Mostrarà exactament el mateix Array que myArray</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-set-objects', 'Set')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definició inicial.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td> + <p>{{ CompatChrome(38) }} [1]</p> + </td> + <td>{{ CompatGeckoDesktop("13") }}</td> + <td>{{ CompatIE("11") }}</td> + <td>25</td> + <td>7.1</td> + </tr> + <tr> + <td>Argument al constructor: <code>new Set(iterable)</code></td> + <td>{{ CompatChrome(38) }}</td> + <td>{{ CompatGeckoDesktop("13") }}</td> + <td>{{CompatNo}}</td> + <td>25</td> + <td>{{CompatNo}}</td> + </tr> + <tr> + <td>iterable</td> + <td>{{ CompatChrome(38) }}</td> + <td>{{ CompatGeckoDesktop("17") }}</td> + <td>{{CompatNo}}</td> + <td>25</td> + <td>7.1</td> + </tr> + <tr> + <td><code>Set.clear()</code></td> + <td>{{ CompatChrome(38) }}</td> + <td>{{CompatGeckoDesktop("19")}}</td> + <td>{{ CompatIE("11") }}</td> + <td>25</td> + <td>7.1</td> + </tr> + <tr> + <td><code>Set.keys(), Set.values(), Set.entries()</code></td> + <td>{{ CompatChrome(38) }}</td> + <td>{{CompatGeckoDesktop("24")}}</td> + <td>{{CompatNo}}</td> + <td>25</td> + <td>7.1</td> + </tr> + <tr> + <td><code>Set.forEach()</code></td> + <td>{{ CompatChrome(38) }}</td> + <td>{{CompatGeckoDesktop("25")}}</td> + <td>{{ CompatIE("11") }}</td> + <td>25</td> + <td>7.1</td> + </tr> + <tr> + <td>Igualtat de valors per a -0 i 0</td> + <td>{{ CompatChrome(38) }}</td> + <td>{{CompatGeckoDesktop("29")}}</td> + <td>{{CompatNo}}</td> + <td>25</td> + <td>{{CompatNo}}</td> + </tr> + <tr> + <td>Argument del constructor: <code>new Set(null)</code></td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoDesktop("37")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + <tr> + <td>Monkey-patched <code>add()</code> al Constructor</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoDesktop("37")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + <tr> + <td><code>Set[@@species]</code></td> + <td>{{CompatUnknown}}</td> + <td>{{CompatGeckoDesktop("41")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + <tr> + <td><code>Set()</code> sense <code>new</code> llença excepció</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatGeckoDesktop("42")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>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>{{CompatChrome(38)}} [1]</td> + <td>{{ CompatGeckoMobile("13") }}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + <tr> + <td>Argument al constructor: <code>new Set(iterable)</code></td> + <td>{{CompatNo}}</td> + <td>{{CompatChrome(38)}}</td> + <td>{{ CompatGeckoMobile("13") }}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + <tr> + <td>iterable</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{ CompatGeckoMobile("17") }}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + <tr> + <td><code>Set.clear()</code></td> + <td>{{CompatNo}}</td> + <td>{{ CompatChrome(38) }}</td> + <td>{{CompatGeckoMobile("19")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + <tr> + <td><code>Set.keys(), Set.values(), Set.entries()</code></td> + <td>{{CompatNo}}</td> + <td>{{ CompatChrome(38) }}</td> + <td>{{CompatGeckoMobile("24")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + <tr> + <td><code>Set.forEach()</code></td> + <td>{{CompatNo}}</td> + <td>{{ CompatChrome(38) }}</td> + <td>{{CompatGeckoMobile("25")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>8</td> + </tr> + <tr> + <td>Igualtat de valors per a -0 i 0</td> + <td>{{CompatNo}}</td> + <td>{{ CompatChrome(38) }}</td> + <td>{{CompatGeckoMobile("29")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + <tr> + <td>Argument del constructor: <code>new Set(null)</code></td> + <td>{{CompatUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoMobile("37")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + <tr> + <td>Monkey-patched <code>add()</code> al Constructor</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatGeckoMobile("37")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + <tr> + <td><code>Set[@@species]</code></td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatGeckoMobile("41")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + <tr> + <td><code>Set()</code> sense <code>new</code> llença excepció</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatGeckoMobile("42")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<p>[1] La característica estava disponible sota una preferència a partir de Chorem 31. Al <code>chrome://flags</code>, activeu l'entrada “Activa JavaScript Experimental”.</p> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Map")}}</li> + <li>{{jsxref("WeakMap")}}</li> + <li>{{jsxref("WeakSet")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/set/prototype/index.html b/files/ca/web/javascript/referencia/objectes_globals/set/prototype/index.html new file mode 100644 index 0000000000..526a5e15b5 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/set/prototype/index.html @@ -0,0 +1,123 @@ +--- +title: Set.prototype +slug: Web/JavaScript/Referencia/Objectes_globals/Set/prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Set +--- +<div>{{JSRef}}</div> + +<p>La propietat <code><strong>Set</strong></code><strong><code>.prototype</code></strong> representa el prototipus per al constructor de {{jsxref("Set")}}.</p> + +<div>{{js_property_attributes(0,0,0)}}</div> + +<h2 id="Descripció">Descripció</h2> + +<p>Les instàncies de {{jsxref("Set")}} hereten de {{jsxref("Set.prototype")}}. Es pot utilitzar el l'objecte prototipus del constructor per a afegir propietats o mètodes a totes les instàncies de <code>Set</code>.</p> + +<h2 id="Propietats">Propietats</h2> + +<dl> + <dt><code>Set.prototype.constructor</code></dt> + <dd>Retorna la funció que ha creat la instància del prototipus. Per defecte es tracta de la funció {{jsxref("Set")}}.</dd> + <dt>{{jsxref("Set.prototype.size")}}</dt> + <dd>Retorna el nombre de valors emmagatzemats dins l'objecte <code>Set</code>.</dd> +</dl> + +<h2 id="Mètodes">Mètodes</h2> + +<dl> + <dt>{{jsxref("Set.add", "Set.prototype.add(valor)")}}</dt> + <dd>Afegeix un nou element a l'objecte <code>Set</code> amb el valor donat. Retorna l'objecte <code>Set</code>.</dd> + <dt>{{jsxref("Set.prototype.clear()")}}</dt> + <dd>Elimina tots els elements de l'objecte <code>Set</code>.</dd> + <dt>{{jsxref("Set.delete", "Set.prototype.delete(valor)")}}</dt> + <dd>Elimina l'element associat a <code>valor</code> i retorna el que el mètode <code>Set.prototype.has(valor)</code> hagués retornat prèviament a aquesta crida. Després d'aquesta crida <code>Set.prototype.has(valor)</code> retornarà <code>false</code>.</dd> + <dt>{{jsxref("Set.prototype.entries()")}}</dt> + <dd>Retorna un nou objecte <code>Iterator</code> que conté <strong>un array de la forma <code>[valor, valor]</code></strong> per a cada element dins l'objecte <code>Set</code>, en ordre d'inserció. El array retornat manté similitud amb el comportament de l'objecte <code>Map</code>, de forma que cada entrada té el mateix valor per a la seva <em>clau</em> i <em>valor</em>.</dd> + <dt>{{jsxref("Set.forEach", "Set.prototype.forEach(callbackFn[, thisArg])")}}</dt> + <dd>Crida <code>callbackFn</code> per a cada valor present a l'objecte <code>Set</code>, recorreguts per ordre d'inserció. Si es proporciona el paràmetre <code>thisArg</code>, aquest s'utilitzarà com a valor de <em>this</em> per a cada crida a <code>callbackFn</code>.</dd> + <dt>{{jsxref("Set.has", "Set.prototype.has(value)")}}</dt> + <dd>Retorna un booleà que especifica si la clau té un valor associat en aquest objecte <code>Set</code> o no.</dd> + <dt>{{jsxref("Set.prototype.keys()")}}</dt> + <dd>Es tracta de la mateixa funció que la funció <strong><code>values()</code></strong> i retorna un nou objecte <code>Iterator</code> que conté els valors per a cada element de l'objecte <code>Set</code>, en ordre d'inserció.</dd> + <dt>{{jsxref("Set.prototype.values()")}}</dt> + <dd>Retorna un nou objecte <code>Iterator</code> que conté els <strong>valors</strong><strong> </strong>de cada element de l'objecte <code>Set</code>, en ordre d'inserció.</dd> + <dt>{{jsxref("Set.prototype.@@iterator()", "Set.prototype[@@iterator]()")}}</dt> + <dd>Retorna un nou objecte <code>Iterator</code> que conté els <strong>valors</strong><strong> </strong>de cada element de l'objecte <code>Set</code>, en ordre d'inserció.</dd> +</dl> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-set.prototype', 'Set.prototype')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definició inicial.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>38</td> + <td>{{ CompatGeckoDesktop("13") }}</td> + <td>11</td> + <td>25</td> + <td>7.1</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatNo}}</td> + <td>38</td> + <td>{{ CompatGeckoMobile("13") }}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td> + <p>8</p> + </td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Map.prototype")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/set/values/index.html b/files/ca/web/javascript/referencia/objectes_globals/set/values/index.html new file mode 100644 index 0000000000..307fa78113 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/set/values/index.html @@ -0,0 +1,106 @@ +--- +title: Set.prototype.values() +slug: Web/JavaScript/Referencia/Objectes_globals/Set/values +translation_of: Web/JavaScript/Reference/Global_Objects/Set/values +--- +<div>{{JSRef}}</div> + +<p>El mètode <code><strong>values()</strong></code> retorna un nou objecte <code><strong>Iterator</strong></code> que conté els valors per a cada element de l'objecte <code>Set</code> en ordre d'inserció.</p> + +<p>El mètode <strong><code>keys()</code></strong> és un mètode sinònim d'aquest mètode (per a mantindre la similitud amb els objecte {{jsxref("Map")}}); es comporta exactament de la mateixa forma i retorna els <strong>valors</strong> dels elements de l'objecte <code>Set</code>.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><em>mySet</em>.values(); +<code><em>mySet</em>.keys(); +</code></code></pre> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_values()">Utilitzar <code>values()</code></h3> + +<pre class="brush:js">var mySet = new Set(); +mySet.add("foo"); +mySet.add("bar"); +mySet.add("baz"); + +var setIter = mySet.values(); + +console.log(setIter.next().value); // "foo" +console.log(setIter.next().value); // "bar" +console.log(setIter.next().value); // "baz"</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-set.prototype.values', 'Set.prototype.values')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definició inicial.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>38</td> + <td>{{CompatGeckoDesktop("24")}}</td> + <td>{{CompatNo}}</td> + <td>25</td> + <td>7.1</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatNo}}</td> + <td>38</td> + <td>{{ CompatGeckoMobile("24") }}</td> + <td>{{ CompatNo}}</td> + <td>{{ CompatNo}}</td> + <td>8</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Set.prototype.entries()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/string/anchor/index.html b/files/ca/web/javascript/referencia/objectes_globals/string/anchor/index.html new file mode 100644 index 0000000000..15bd4db97b --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/string/anchor/index.html @@ -0,0 +1,118 @@ +--- +title: String.prototype.anchor() +slug: Web/JavaScript/Referencia/Objectes_globals/String/anchor +translation_of: Web/JavaScript/Reference/Global_Objects/String/anchor +--- +<div>{{JSRef}}</div> + +<p>El mètode <strong><code>anchor()</code></strong> un element àncora HTML {{HTMLElement("a")}} que s'utilitza com a HTML un objectiu hypertext.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>str</var>.anchor(<var>nom</var>)</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>nom</code></dt> + <dd>Una cadena que representa l'atribut <code>name</code> attribute of the a tag to be created.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Utilitzar el mètode <code>anchor()</code> per crear i mostrar una àncora en un document mitjançant programació.</p> + +<p>En la sintaxi, la cadena de text representa el text literal que es vol mostrar a l'usuari. La cadena paràmetre <code>name</code> representa l'atribut <code>name</code> de l'element {{HTMLElement("a")}}.</p> + +<p>Les àncores creades amb el mètode <code>anchor()</code> es tornen elements de l'array {{domxref("document.anchors")}}.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_anchor()">Utilitzar<code> anchor()</code></h3> + +<pre class="brush: js">var myString = 'Taula de continguts'; + +document.body.innerHTML = myString.anchor('contents_anchor'); +</pre> + +<p>Mostrarà el següent HTML:</p> + +<pre class="brush: html"><a name="contents_anchor">Taula de continguts</a> +</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-string.prototype.anchor', 'String.prototype.anchor')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definició inicial. Implementat en JavaScript 1.0. Definit en l'Annex B (normative) per característiques addiccionals d'ECMAScript per a navegadors Web.</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.0")}} [1]</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 pdr 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.0")}} [1]</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<p>[1] Des de la versió Gecko 17, les <code>"</code> (cometes) són substituides pel caràcter de referència HTML <code>&quot;</code> en cadenes subministrades pel paràmetre <code>name.</code></p> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("String.prototype.link()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/string/big/index.html b/files/ca/web/javascript/referencia/objectes_globals/string/big/index.html new file mode 100644 index 0000000000..a3b8815f10 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/string/big/index.html @@ -0,0 +1,114 @@ +--- +title: String.prototype.big() +slug: Web/JavaScript/Referencia/Objectes_globals/String/big +translation_of: Web/JavaScript/Reference/Global_Objects/String/big +--- +<div>{{JSRef}} {{deprecated_header}}</div> + +<p>El mètode <strong><code>big()</code></strong> crea un element HTML {{HTMLElement("big")}} que causa que la cadena es mostri en una font de mida gran.</p> + +<div class="note"> +<p><strong>Nota d'ús:</strong> L'element <big> s'ha eliminat de l'<a href="/en-US/docs/Web/Guide/HTML/HTML5">HTML5</a> i no s'hauria de fer servir més. S'aconsella als desenvolupadors web utilitzar les propietats de <a href="/en-US/docs/Web/CSS">CSS.</a></p> +</div> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>str</var>.big()</code></pre> + +<h2 id="Descripció">Descripció</h2> + +<p>El mètode <code>big()</code> incrusta una cadena dins del tag <code><big></code>: <code>"<big>str</big>"</code>.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_big()">Utilitzar <code>big()</code></h3> + +<p>L'exemple següent utilitza mètodes string per canviar la mida d'una cadena:</p> + +<pre class="brush: js">var worldString = 'Hello, world'; + +console.log(worldString.small()); // <small>Hello, world</small> +console.log(worldString.big()); // <big>Hello, world</big> +console.log(worldString.fontsize(7)); // <fontsize=7>Hello, world</fontsize> +</pre> + +<p>Amb l'objecte {{domxref("HTMLElement.style", "element.style")}} es pot obtenir l'atribut <code>style</code> de l'element i manipular-lo més genèricament, per exemple:</p> + +<pre class="brush: js">document.getElementById('yourElemId').style.fontSize = '2em'; +</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-string.prototype.big', 'String.prototype.big')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definició inicial. Implementat en JavaScript 1.0. Definit en l'Annex B (normative) per característiques addicionals ECMAScript per navegadors web.</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.0")}}</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>{{CompatGeckoMobile("1.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("String.prototype.fontsize()")}}</li> + <li>{{jsxref("String.prototype.small()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/string/blink/index.html b/files/ca/web/javascript/referencia/objectes_globals/string/blink/index.html new file mode 100644 index 0000000000..2378325897 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/string/blink/index.html @@ -0,0 +1,110 @@ +--- +title: String.prototype.blink() +slug: Web/JavaScript/Referencia/Objectes_globals/String/blink +translation_of: Web/JavaScript/Reference/Global_Objects/String/blink +--- +<div>{{JSRef}} {{deprecated_header}}</div> + +<p>El mètode <strong><code>blink()</code></strong> crea un elment HTML {{HTMLElement("blink")}} que fa mostrar una cadena de forma intermitent.</p> + +<div class="warning"> +<p><strong>Advertència:</strong> El text que es mostra de forma intermitent és mal vist per varis estàndards d'accessibilitat. L'element <code><blink></code> no és estàndard i és obsolet!</p> +</div> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>str</var>.blink()</code></pre> + +<h2 id="Descripció">Descripció</h2> + +<p>El mètode <code>blink()</code> incrusta una cadena dins l'etiqueta <code><blink></code>: <code>"<blink>cad</blink>"</code>.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_blink()">Utilitzar <code>blink()</code></h3> + +<p>L'exemple següent utilitza mètodes string per canviar el format d'una cadena:</p> + +<pre class="brush: js">var worldString = 'Hello, world'; + +console.log(worldString.blink()); // <blink>Hello, world</blink> +console.log(worldString.bold()); // <b>Hello, world</b> +console.log(worldString.italics()); // <i>Hello, world</i> +console.log(worldString.strike()); // <strike>Hello, world</strike></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-string.prototype.blink', 'String.prototype.blink')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definició inicial. Implementat en JavaScript 1.0. Definit en l'Annex B (normative) per característiques addiccionals d'ECMAScrip per Navegadors Web.</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.0")}}</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>{{CompatGeckoMobile("1.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("String.prototype.bold()")}}</li> + <li>{{jsxref("String.prototype.italics()")}}</li> + <li>{{jsxref("String.prototype.strike()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/string/bold/index.html b/files/ca/web/javascript/referencia/objectes_globals/string/bold/index.html new file mode 100644 index 0000000000..502810bb45 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/string/bold/index.html @@ -0,0 +1,106 @@ +--- +title: String.prototype.bold() +slug: Web/JavaScript/Referencia/Objectes_globals/String/bold +translation_of: Web/JavaScript/Reference/Global_Objects/String/bold +--- +<div>{{JSRef}} {{deprecated_header}}</div> + +<p>El mètode <strong><code>bold()</code></strong> crea un element HTML {{HTMLElement("b")}} que causa que una cadena es mostri amb negreta.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>str</var>.bold()</code></pre> + +<h2 id="Descripció">Descripció</h2> + +<p>El mètode <code>bold()</code> incrusta una cadena en l'etiqueta <code><b></code>: <code>"<b>cad</b>"</code>.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_bold()">Utilitzar <code>bold()</code></h3> + +<p>L'exemple següent utilitza mètodes string per canviar el format d'una cadena:</p> + +<pre class="brush: js">var worldString = 'Hello, world'; + +console.log(worldString.blink()); // <blink>Hello, world</blink> +console.log(worldString.bold()); // <b>Hello, world</b> +console.log(worldString.italics()); // <i>Hello, world</i> +console.log(worldString.strike()); // <strike>Hello, world</strike></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-string.prototype.bold', 'String.prototype.bold')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definició inicial. Implementat en JavaScript 1.0. Definit en l'Annex B (normative) per Característiques addiccionals ECMAScript per navegadors Web.</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.0")}}</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>{{CompatGeckoMobile("1.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("String.prototype.blink()")}}</li> + <li>{{jsxref("String.prototype.italics()")}}</li> + <li>{{jsxref("String.prototype.strike()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/string/charat/index.html b/files/ca/web/javascript/referencia/objectes_globals/string/charat/index.html new file mode 100644 index 0000000000..55a84ab7d0 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/string/charat/index.html @@ -0,0 +1,283 @@ +--- +title: String.prototype.charAt() +slug: Web/JavaScript/Referencia/Objectes_globals/String/charAt +translation_of: Web/JavaScript/Reference/Global_Objects/String/charAt +--- +<div>{{JSRef}}</div> + +<p>El mètode <strong><code>charAt()</code></strong> retorna el caràcter especificat d'una cadena.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>str</var>.charAt(posicio)</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>posicio</code></dt> + <dd>Un nombre sencer entre 0 i la longitud de la cadena menys 1.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Els caràcters d'una cadena reben un nombre per la seva posició d'esquerra a dreta. La posició del primer caràcter és el 0 i la posició de l'últim caràcter d'una cadena anomenada <code>stringName</code> és <code>stringName.length - 1</code>. Si la <code>posicio</code> proporcionada està fora del rang vàlid JavaScript retornarà una cadena buida.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Mostrar_caràcters_de_diferents_posicions_d'una_cadena">Mostrar caràcters de diferents posicions d'una cadena</h3> + +<p>L'exemple següent mostra alguns caràcters a diferents posicions de la cadena <code>"Brave new world"</code>:</p> + +<pre class="brush: js">var anyString = 'Brave new world'; + +console.log("El caràcter a la posició 0 és '" + anyString.charAt(0) + "'"); +console.log("El caràcter a la posició 1 és '" + anyString.charAt(1) + "'"); +console.log("El caràcter a la posició 2 és '" + anyString.charAt(2) + "'"); +console.log("El caràcter a la posició 3 és '" + anyString.charAt(3) + "'"); +console.log("El caràcter a la posició 4 és '" + anyString.charAt(4) + "'"); +console.log("El caràcter a la posició 999 és '" + anyString.charAt(999) + "'"); +</pre> + +<p>Les línies anteriors mostren la sortida següent:</p> + +<pre class="brush: js">El caràcter a la posició 0 és 'B' +El caràcter a la posició 1 és 'r' +El caràcter a la posició 2 és 'a' +El caràcter a la posició 3 és 'v' +El caràcter a la posició 4 és 'e' +El caràcter a la posició 999 és '' +</pre> + +<h3 id="Obtenir_caràcters_sencers">Obtenir caràcters sencers</h3> + +<p>El codi següent garanteix obtenir un caràcter sencer, fins i tot quan la cadena contingui caràcters que no formen part del pla bàsic multilingüístic.</p> + +<pre class="brush: js">var str = 'A \uD87E\uDC04 Z'; // We could also use a non-BMP character directly +for (var i = 0, chr; i < str.length; i++) { + if ((chr = getWholeChar(str, i)) === false) { + continue; + } + // Adapt this line at the top of each loop, passing in the whole string and + // the current iteration and returning a variable to represent the + // individual character + + console.log(chr); +} + +function getWholeChar(str, i) { + var code = str.charCodeAt(i); + + if (Number.isNaN(code)) { + return ''; // Position not found + } + if (code < 0xD800 || code > 0xDFFF) { + return str.charAt(i); + } + + // High surrogate (could change last hex to 0xDB7F to treat high private + // surrogates as single characters) + if (0xD800 <= code && code <= 0xDBFF) { + if (str.length <= (i + 1)) { + throw 'High surrogate without following low surrogate'; + } + var next = str.charCodeAt(i + 1); + if (0xDC00 > next || next > 0xDFFF) { + throw 'High surrogate without following low surrogate'; + } + return str.charAt(i) + str.charAt(i + 1); + } + // Low surrogate (0xDC00 <= code && code <= 0xDFFF) + if (i === 0) { + throw 'Low surrogate without preceding high surrogate'; + } + var prev = str.charCodeAt(i - 1); + + // (could change last hex to 0xDB7F to treat high private + // surrogates as single characters) + if (0xD800 > prev || prev > 0xDBFF) { + throw 'Low surrogate without preceding high surrogate'; + } + // We can pass over low surrogates now as the second component + // in a pair which we have already processed + return false; +} +</pre> + +<p>En l'entorn de l'ECMAScript 2016, que soporta assignació desestructurada, es pot utilitzar el codi següent com a versió alternativa més flexibleenvironment which allows destructured assignment, the following is a more succinct and somewhat more flexible alternative in that it does incrementing for an incrementing variable automatically (if the character warrants it in being a surrogate pair).</p> + +<pre class="brush: js">var str = 'A\uD87E\uDC04Z'; // We could also use a non-BMP character directly +for (var i = 0, chr; i < str.length; i++) { + [chr, i] = getWholeCharAndI(str, i); + // Adapt this line at the top of each loop, passing in the whole string and + // the current iteration and returning an array with the individual character + // and 'i' value (only changed if a surrogate pair) + + console.log(chr); +} + +function getWholeCharAndI(str, i) { + var code = str.charCodeAt(i); + + if (Number.isNaN(code)) { + return ''; // Position not found + } + if (code < 0xD800 || code > 0xDFFF) { + return [str.charAt(i), i]; // Normal character, keeping 'i' the same + } + + // High surrogate (could change last hex to 0xDB7F to treat high private + // surrogates as single characters) + if (0xD800 <= code && code <= 0xDBFF) { + if (str.length <= (i + 1)) { + throw 'High surrogate without following low surrogate'; + } + var next = str.charCodeAt(i + 1); + if (0xDC00 > next || next > 0xDFFF) { + throw 'High surrogate without following low surrogate'; + } + return [str.charAt(i) + str.charAt(i + 1), i + 1]; + } + // Low surrogate (0xDC00 <= code && code <= 0xDFFF) + if (i === 0) { + throw 'Low surrogate without preceding high surrogate'; + } + var prev = str.charCodeAt(i - 1); + + // (could change last hex to 0xDB7F to treat high private surrogates + // as single characters) + if (0xD800 > prev || prev > 0xDBFF) { + throw 'Low surrogate without preceding high surrogate'; + } + // Return the next character instead (and increment) + return [str.charAt(i + 1), i + 1]; +} +</pre> + +<h3 id="Fixing_charAt()_to_support_non-Basic-Multilingual-Plane_(BMP)_characters">Fixing <code>charAt()</code> to support non-Basic-Multilingual-Plane (BMP) characters</h3> + +<p>While the example above may be more frequently useful for those wishing to support non-BMP characters (since it does not require the caller to know where any non-BMP character might appear), in the event that one <em>does</em> wish, in choosing a character by index, to treat the surrogate pairs within a string as the single characters they represent, one can use the following:</p> + +<pre class="brush: js">function fixedCharAt(str, idx) { + var ret = ''; + str += ''; + var end = str.length; + + var surrogatePairs = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g; + while ((surrogatePairs.exec(str)) != null) { + var li = surrogatePairs.lastIndex; + if (li - 2 < idx) { + idx++; + } else { + break; + } + } + + if (idx >= end || idx < 0) { + return ''; + } + + ret += str.charAt(idx); + + if (/[\uD800-\uDBFF]/.test(ret) && /[\uDC00-\uDFFF]/.test(str.charAt(idx + 1))) { + // Go one further, since one of the "characters" is part of a surrogate pair + ret += str.charAt(idx + 1); + } + return ret; +} +</pre> + +<h2 id="Specifications">Specifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.4', 'String.prototype.charAt')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.charat', 'String.prototype.charAt')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.charat', 'String.prototype.charAt')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</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>Feature</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>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also">See also</h2> + +<ul> + <li>{{jsxref("String.prototype.indexOf()")}}</li> + <li>{{jsxref("String.prototype.lastIndexOf()")}}</li> + <li>{{jsxref("String.prototype.charCodeAt()")}}</li> + <li>{{jsxref("String.prototype.codePointAt()")}}</li> + <li>{{jsxref("String.prototype.split()")}}</li> + <li>{{jsxref("String.fromCodePoint()")}}</li> + <li><a href="https://mathiasbynens.be/notes/javascript-unicode">JavaScript has a Unicode problem – Mathias Bynens</a></li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/string/concat/index.html b/files/ca/web/javascript/referencia/objectes_globals/string/concat/index.html new file mode 100644 index 0000000000..87cdda3c5e --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/string/concat/index.html @@ -0,0 +1,125 @@ +--- +title: String.prototype.concat() +slug: Web/JavaScript/Referencia/Objectes_globals/String/concat +translation_of: Web/JavaScript/Reference/Global_Objects/String/concat +--- +<div>{{JSRef}}</div> + +<p>El mètode <strong><code>concat()</code></strong> combina el text de dos o més strings i retorna un nou string.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>str</var>.concat(<var>string2</var>, <var>string3</var>[, ..., <var>stringN</var>])</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>string2...string<em>N</em></code></dt> + <dd>Strings que seran concatenats a aquest string.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>La funció <code>concat()</code> combina el text d'un o més strings i retorna un nou string. Canvis al text d'un string no afecten l'altre string.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_concat()">Utilitzar <code>concat()</code></h3> + +<p>L'exemple següent combina strings en un nou string.</p> + +<pre class="brush: js">var hola = 'Hola, '; +console.log(hola.concat('Kevin', ' tingueu un bon dia.')); + +/* Hola, Kevin tingueu un bon dia. */ +</pre> + +<h2 id="Rendiment">Rendiment</h2> + +<p>Es recomana altament utilitzar els {{jsxref("Operators/Assignment_Operators", "operadors d'assignació", "", 1)}} (<code>+</code>, <code>+=</code>) en comptes del mètode <code>concat()</code>. Vegeu aquest <a href="http://jsperf.com/concat-vs-plus-vs-join">test de rendiment</a>.</p> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>{{SpecName('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Definició inicial. Implementat a JavaScript 1.2.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.6', 'String.prototype.concat')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.concat', 'String.prototype.concat')}}</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 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.concat()")}}</li> + <li>{{jsxref("Operators/Assignment_Operators", "Operadors d'asssignació", "", 1)}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/string/endswith/index.html b/files/ca/web/javascript/referencia/objectes_globals/string/endswith/index.html new file mode 100644 index 0000000000..83a1201549 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/string/endswith/index.html @@ -0,0 +1,133 @@ +--- +title: String.prototype.endsWith() +slug: Web/JavaScript/Referencia/Objectes_globals/String/endsWith +translation_of: Web/JavaScript/Reference/Global_Objects/String/endsWith +--- +<div>{{JSRef}}</div> + +<p>El mètode <strong><code>endsWith()</code></strong> method determina si un string acaba amb els caràcters d'un altre string, retornant <code>true</code> o <code>false</code> depenent d'això.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>str</var>.endsWith(stringAcercar[, posició])</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>stringAcercar</code></dt> + <dd>Els caràcters a cercar al final d'aquest string.</dd> + <dt><code>posició</code></dt> + <dd>Opcional. Cerca dins aquest string considerant <code>posició</code> com la última posició del string; per defecte rep el valor del tamany total del string.</dd> + <dt> </dt> + <dt> </dt> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Aquest mètode us permet determinar si un string acaba en un altre string.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_endsWith()">Utilitzar <code>endsWith()</code></h3> + +<pre class="brush: js">var str = 'To be, or not to be, that is the question.'; + +console.log(str.endsWith('question.')); // true +console.log(str.endsWith('to be')); // false +console.log(str.endsWith('to be', 19)); // true +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Aquest mètode va ser afegit a l'especificació ECMAScript i pot no estar disponible encara a totes les implementacions de JavaScript. No obstant, la funció següent emula el comportament de <code>String.prototype.endsWith()</code>:</p> + +<pre class="brush: js">if (!String.prototype.endsWith) { + String.prototype.endsWith = function(searchString, position) { + var subjectString = this.toString(); + if (typeof position !== 'number' || !isFinite(position) || Math.floor(position) !== position || position > subjectString.length) { + position = subjectString.length; + } + position -= searchString.length; + var lastIndex = subjectString.indexOf(searchString, position); + return lastIndex !== -1 && lastIndex === position; + }; +} +</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-string.prototype.endswith', 'String.prototype.endsWith')}}</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("41")}}</td> + <td>{{CompatGeckoDesktop("17")}}</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 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>{{CompatChrome("36")}}</td> + <td>{{CompatGeckoMobile("17")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("String.prototype.startsWith()")}} {{experimental_inline}}</li> + <li>{{jsxref("String.prototype.contains()")}} {{experimental_inline}}</li> + <li>{{jsxref("String.prototype.indexOf()")}}</li> + <li>{{jsxref("String.prototype.lastIndexOf()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/string/fixed/index.html b/files/ca/web/javascript/referencia/objectes_globals/string/fixed/index.html new file mode 100644 index 0000000000..069ab4243f --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/string/fixed/index.html @@ -0,0 +1,103 @@ +--- +title: String.prototype.fixed() +slug: Web/JavaScript/Referencia/Objectes_globals/String/fixed +translation_of: Web/JavaScript/Reference/Global_Objects/String/fixed +--- +<div>{{JSRef}} {{deprecated_header}}</div> + +<p>El mètode <strong><code>fixed()</code></strong> crea un element HTML {{HTMLElement("tt")}} que fa que una cadena es mostri en una font fixed-pitch.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>str</var>.fixed()</code></pre> + +<h2 id="Descripció">Descripció</h2> + +<p>El mètode <code>fixed()</code> incrusta una cadena en una etiqueta <code><tt></code>: <code>"<tt>cad</tt>"</code>.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_fixed()">Utilitzar <code>fixed()</code></h3> + +<p>L'exemple següent utilitza el mètode <code>fixed</code> per canviar el format d'una cadena:</p> + +<pre class="brush: js">var worldString = 'Hello, world'; +console.log(worldString.fixed()); // "<tt>Hello, world</tt>" +</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-string.prototype.fixed', 'String.prototype.fixed')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definició inicial. Implementat en JavaScript 1.0. Definit en l'Annex B (normative) per Característiques addiccionals d'ECMAScript per Navegadors Web.</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.0")}}</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>{{CompatGeckoMobile("1.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("String.prototype.bold()")}}</li> + <li>{{jsxref("String.prototype.italics()")}}</li> + <li>{{jsxref("String.prototype.strike()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/string/fontcolor/index.html b/files/ca/web/javascript/referencia/objectes_globals/string/fontcolor/index.html new file mode 100644 index 0000000000..be52cd576b --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/string/fontcolor/index.html @@ -0,0 +1,122 @@ +--- +title: String.prototype.fontcolor() +slug: Web/JavaScript/Referencia/Objectes_globals/String/fontcolor +translation_of: Web/JavaScript/Reference/Global_Objects/String/fontcolor +--- +<div>{{JSRef}} {{deprecated_header}}</div> + +<p>El mètode <strong><code>fontcolor()</code></strong> crea un element HTML {{HTMLElement("font")}} que fa que una cadena es mostri amb el color font especificat.</p> + +<div class="note"> +<p><strong>Nota d'ús:</strong> L'element <font> s'ha eleminitat d'<a href="/en-US/docs/Web/Guide/HTML/HTML5">HTML5</a> i no s'ha de fer servir més. Els desenvolupadors web haurien d'utilitzar les propietats de <a href="/en-US/docs/Web/CSS">CSS</a> per aquesta finalitat<a href="/en-US/docs/Web/CSS">.</a></p> +</div> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>str</var>.fontcolor(<var>color</var>)</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>color</code></dt> + <dd>Una cadena que expressa el color com a un triplet RGB hexadecimal o com una cadena literal. Les cadenes literals de noms de colors es troben enllistades en la <a href="/en-US/docs/Web/CSS/color_value">referència de colors de CSS.</a></dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Si expresseu el color com un triplet RGB hexadecimal, heu de fer servir el format <code>rrggbb</code>. Per example, els valors RGB hexadecimals pel color salmó són vermell=FA, verd=80, i blau=72, de forma que el triplet RGB pel color salmó és <code>"FA8072"</code>.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_fontcolor()">Utilitzar <code>fontcolor()</code></h3> + +<p>L'exemple següent utilitza el mètode <code>fontcolor()</code> per canviar el color d'una cadena mitjançant la creació d'una cadena amb l'etiqueta HTML <code><font></code>.</p> + +<pre class="brush: js">var worldString = 'Hola, món'; + +console.log(worldString.fontcolor('red') + ' és vermell en aquesta línia'); +// '<font color="red">Hola, món</font> 's vermell en aquesta línia' + +console.log(worldString.fontcolor('FF00') + ' és vermell en hexadecimal en aquesta línia'); +// '<font color="FF00">Hola, món</font> és vermell en hexadecimal en aquesta línia' +</pre> + +<p>Amb l'objecte {{domxref("HTMLElement.style", "element.style")}} es pot obtenir l'atribut <code>style</code> de l'element i manipular-lo més genèricament, per exemple:</p> + +<pre class="brush: js">document.getElementById('yourElemId').style.color = 'red'; +</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-string.prototype.fontcolor', 'String.prototype.fontcolor')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definició inicial. Implementat en JavaScript 1.0. Definit en l'Annex B (normative) per Característiques addiccionals d'ECMAScript per Navegadors Web.</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.0")}}</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>{{CompatGeckoMobile("1.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("String.prototype.fontsize()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/string/fontsize/index.html b/files/ca/web/javascript/referencia/objectes_globals/string/fontsize/index.html new file mode 100644 index 0000000000..9f30d124aa --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/string/fontsize/index.html @@ -0,0 +1,121 @@ +--- +title: String.prototype.fontsize() +slug: Web/JavaScript/Referencia/Objectes_globals/String/fontsize +translation_of: Web/JavaScript/Reference/Global_Objects/String/fontsize +--- +<div>{{JSRef}} {{deprecated_header}}</div> + +<p>El mètode <strong><code>fontsize()</code></strong> crea un element HTML {{HTMLElement("font")}} que causa que una cadena es mostri en el tamany font especificat.</p> + +<div class="note"> +<p><strong>Nota d'ús:</strong> L'element <font> s'ha eliminat de l'<a href="/en-US/docs/Web/Guide/HTML/HTML5">HTML5</a> i no s'ha de fer servir més. Els desenvolupadors web haurien de fer servir les propietats de <a href="/en-US/docs/Web/CSS">CSS</a> per aquesta finalitat.</p> +</div> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>str</var>.fontsize(<var>mida</var>)</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>mida</code></dt> + <dd>Un nombre sencer entre 1 i 7, una cadena que representi un nombre sencer amb signe entre 1 i 7.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Quan s'especifica la mida com a un nombre sencer, s'estableix la mida de la <code>str</code> a un de les 7 mides definides. Quan s'especifica la <code>mida</code> com una cadena com pot ser "-2", s'adjusta el tamany font de <code>str</code> en relació ambel tamany establert en l'etiqueta {{HTMLElement("basefont")}}.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_fontsize()">Utilitzar <code>fontsize()</code></h3> + +<p>El següent exemple utilitza mètodes string per canviar la mida de la cadena:</p> + +<pre class="brush: js">var worldString = 'Hola, món'; + +console.log(worldString.small()); // <small>Hola, món</small> +console.log(worldString.big()); // <big>Hola, món</big> +console.log(worldString.fontsize(7)); // <font size="7">Hola, món</fontsize> +</pre> + +<p>Amb l'objecte {{domxref("HTMLElement.style", "element.style")}} es pot obtenir el atribut <code>style</code> de l'element i manipular-lo més genèricament, per exemple:</p> + +<pre class="brush: js">document.getElementById('yourElemId').style.fontSize = '0.7em'; +</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-string.prototype.fontsize', 'String.prototype.fontsize')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definició inicial. Implementat en JavaScript 1.0. Definit en l'Annex B (normative) per Característiques Addiccionals d'ECMAScript per Navegadors Web.</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.0")}}</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>{{CompatGeckoMobile("1.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("String.prototype.big()")}}</li> + <li>{{jsxref("String.prototype.small()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/string/fromcharcode/index.html b/files/ca/web/javascript/referencia/objectes_globals/string/fromcharcode/index.html new file mode 100644 index 0000000000..f4e2308bf9 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/string/fromcharcode/index.html @@ -0,0 +1,126 @@ +--- +title: String.fromCharCode() +slug: Web/JavaScript/Referencia/Objectes_globals/String/fromCharCode +translation_of: Web/JavaScript/Reference/Global_Objects/String/fromCharCode +--- +<div>{{JSRef}}</div> + +<p>El mètode estàtic <strong><code>String.fromCharCode()</code></strong> retorna un string creat a partir de la seqüència de valors Unicode especificada.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code>String.fromCharCode(<var>num1</var>[, ...[, <var>numN</var>]])</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>num1, ..., num<em>N</em></code></dt> + <dd>Una seqüència de nombres que són valors Unicode.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Aquest mètode retorna un string i no un objecte de tipus {{jsxref("String")}}.</p> + +<p>Com que <code>fromCharCode()</code> és un mètode estàtic de {{jsxref("String")}}, sempre s'utilitza com <code>String.fromCharCode()</code> en comptes de com un mètode d'un objecte {{jsxref("String")}} creat.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_fromCharCode()">Utilitzar <code>fromCharCode()</code></h3> + +<p>L'exemple següent retorna el string "ABC".</p> + +<pre class="brush: js">String.fromCharCode(65, 66, 67); // "ABC" +</pre> + +<h2 id="Fer_que_funcioni_amb_valors_més_grans">Fer que funcioni amb valors més grans</h2> + +<p>Tot i que la majoria dels valors Unicode es poden representar amb un nombre de 16 bits (tal i com s'esperava mentre s'estava estandaritzant el JavaScript) i es pot emprar <code>fromCharCode()</code> per a retornar un sol caràcter per als valors més comuns (com ara valors UCS-2, que són un subconjunt de l'UTF-16 amb els caràcters més comuns), per a poder manegar TOTS els valors legals Unicode (els quals requereixen fins a 21 bits), l'ús de només <code>fromCharCode()</code> no és adequat ja que els caràcters de valor més alt utilitzen dos nombres "substituts" (de menor valor) per a formar un sol caràcter. Es pot emprar {{jsxref("String.fromCodePoint()")}} (que forma part de l'esborrant de l'ECMAScript 6) per a retornar el parell de nombres citat i, d'aquesta forma, representar de manera adequada aquests caràcters de valor més alt.</p> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificacions</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definició inicial. Implementat a JavaScript 1.2.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.3.2', 'StringfromCharCode')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.fromcharcodes', 'String.fromCharCode')}}</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 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.fromCodePoint()")}}</li> + <li>{{jsxref("String.prototype.charAt()")}}</li> + <li>{{jsxref("String.prototype.charCodeAt()")}}</li> + <li>{{jsxref("String.prototype.codePointAt()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/string/index.html b/files/ca/web/javascript/referencia/objectes_globals/string/index.html new file mode 100644 index 0000000000..136820a54d --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/string/index.html @@ -0,0 +1,340 @@ +--- +title: String +slug: Web/JavaScript/Referencia/Objectes_globals/String +translation_of: Web/JavaScript/Reference/Global_Objects/String +--- +<div>{{JSRef("Global_Objects", "String")}}</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>L'objecte global <strong><code>String</code></strong> és un constructor per a strings, també conegudes com a cadenes de caràcters.</p> + +<h2 id="Syntax" name="Syntax">Sintaxi</h2> + +<p>Els literals de tipus Stringpoden tenir les següents formes:</p> + +<pre class="syntaxbox"><code>'string text' +"string text" +"中文 español English हिन्दी العربية português বাংলা русский 日本語 ਪੰਜਾਬੀ 한국어 </code><span style="color: #222222; font-family: Consolas,'Lucida Console',monospace; font-size: 12px; line-height: normal; white-space: pre-wrap;">தமிழ்</span><code>" +</code></pre> + +<p>A més dels caràcters imprimibles normals, es poden codificar caràcters especials mitjançant la notació d'escapament:</p> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Codi</th> + <th scope="col">Sortida</th> + </tr> + </thead> + <tbody> + <tr> + <td><code>\0</code></td> + <td>el caràcter NUL</td> + </tr> + <tr> + <td><code>\'</code></td> + <td>cometa simple</td> + </tr> + <tr> + <td><code>\"</code></td> + <td>cometa doble</td> + </tr> + <tr> + <td><code>\\</code></td> + <td>barra invertida</td> + </tr> + <tr> + <td><code>\n</code></td> + <td>línia nova</td> + </tr> + <tr> + <td><code>\r</code></td> + <td>retorn de carro</td> + </tr> + <tr> + <td><code>\v</code></td> + <td>barra vertical</td> + </tr> + <tr> + <td><code>\t</code></td> + <td>tabulador</td> + </tr> + <tr> + <td><code>\b</code></td> + <td>esborrar</td> + </tr> + <tr> + <td><code>\f</code></td> + <td>form feed</td> + </tr> + <tr> + <td><code>\uXXXX</code></td> + <td>caràcter amb codificació unicode</td> + </tr> + <tr> + <td><code>\xXX</code></td> + <td>caràcter amb codificació Latin-1</td> + </tr> + </tbody> +</table> + +<p>O bé utilitzant l'objecte global <code>String</code> de forma directa:</p> + +<pre class="syntaxbox"><code>String(quelcom) +new String(quelcom) +</code></pre> + +<h3 id="Parameters" name="Parameters">Paràmetres</h3> + +<dl> + <dt><code>quelcom</code></dt> + <dd>Qualsevol cosa que serà convertida a string.</dd> +</dl> + +<h2 id="Description" name="Description">Descripció</h2> + +<p>Les Strings són útils per a emmagatzemar dades que poden ser representades en forma de texte. Algunes de les operacions més emprades en strings són per a obtindre la seva llargada {{jsxref("String.length", "length")}}, per a concatenar-les mitjançant els <a href="/ca/docs/Web/JavaScript/Reference/Operators/String_Operators">operadors de strings + i +=</a>, per a comprovar l'existència o localització de substrings amb el mètode {{jsxref("String.prototype.indexOf()", "indexOf()")}}, o bé per a extreure substrings amb el mètode {{jsxref("String.prototype.substring()", "substring()")}}.</p> + +<h3 id="Character_access" name="Character_access">Accés als caràcters</h3> + +<p>Hi ha dues formes d'accedir a un caràcter individual emmagatzemat dins un string. El primer és el mètode {{jsxref("String.prototype.charAt()", "charAt()")}}:</p> + +<pre class="brush: js">return 'cat'.charAt(1); // retorna "a" +</pre> + +<p>L'altra forma (introduida a ECMAScript 5) és fer anar l'string com si fós un objecte de tipus array, on els caràcters individuals es corresponen a un índex numèric:</p> + +<pre class="brush: js">return 'cat'[1]; // retorna "a" +</pre> + +<p>Utilitzar la notació de claus per a esborrar o bé assignar un valor a un caràcter no funcionarà. Les propietats involucrades no són de tipus no-escriptura i no són configurables. (Vegeu {{jsxref("Object.defineProperty()")}} per a més informació).</p> + +<h3 id="Comparing_strings" name="Comparing_strings">Comparar strings</h3> + +<p>Els desenvolupadors de C disposen de la funció <code>strcmp()</code> per a comparar strings. A JavaScript senzillament es poden utilitzar els <a href="/ca/docs/Web/JavaScript/Reference/Operators/Comparison_Operators">operadors major-que i menor-que</a></p> + +<pre class="brush: js">var a = 'a'; +var b = 'b'; +if (a < b) { // true + print(a + ' és menor que ' + b); +} else if (a > b) { + print(a + ' és major que ' + b); +} else { + print(a + ' i ' + b + ' són iguals.'); +} +</pre> + +<p>Es pot obtindre un resultat similar mitjançant el mètode {{jsxref("String.prototype.localeCompare()", "localeCompare()")}}, heredat per les instàncies de <code>String</code>.</p> + +<h3 id="Distinció_entre_les_primitives_string_i_els_objectes_String">Distinció entre les primitives string i els objectes <code>String</code></h3> + +<p>Cal recalcar que JavaScript distingeix entre objectes de tipus <code>String</code> i valors primitius de tipus string (El mateix succeeix amb {{jsxref("Global_Objects/Boolean", "Boolean")}} i {{jsxref("Global_Objects/Number", "Numbers")}}</p> + +<p>Els literals de tipus string (englobats en cometes simples o dobles) així com strings retornats per crides a l'objecte <code>String</code> en un contexte no constructor (és a dir, sense utilitzar la paraula clau {{jsxref("Operators/new", "new")}}) són strings primitives. JavaScript automàticament converteix primitives a objectes String, de forma que és posible utilitzar mètodes de l'objecte <code>String</code> en strings primitives. En els contextes on s'ha d'invocar un mètode en una primitiva string o es demana la una propietat, JavaScript automàticament embolcallarà la primitiva string amb un objecte String i cridarà el mètode o la propietat corresponent.</p> + +<pre class="brush: js">var s_prim = 'foo'; +var s_obj = new String(s_prim); + +console.log(typeof s_prim); // Escriu "string" +console.log(typeof s_obj); // Escriu "object" +</pre> + +<p>Les primitives string i els objectes <code>String</code> també donen resultats diferents a l'utilitzar {{jsxref("Global_Objects/eval", "eval()")}}. Les primitives passades a <code>eval</code> són considerades codi font; els objectes <code>String</code> es tracten com qualsevol altre objecte, és a dir, retornan l'objecte. Per exemple:</p> + +<pre class="brush: js">var s1 = '2 + 2'; // crea una primitiva string +var s2 = new String('2 + 2'); // crea un objecte String +console.log(eval(s1)); // escriu el nombre 4 +console.log(eval(s2)); // escriu la string "2 + 2" +</pre> + +<p>És per aquestes raons que el codi pot produïr errors quan trobi objectes <code>String</code> però s'esperès una primitiva string, tot i que de forma general els autors no s'han de preocupar per la distinció.</p> + +<p>Un objecte <code>String</code> sempre es pot convertir en la seva representació primitiva mitjançant el mètode {{jsxref("String.prototype.valueOf()", "valueOf()")}}.</p> + +<pre class="brush: js">console.log(eval(s2.valueOf())); // escriu el nombre 4 +</pre> + +<div class="note"><strong>Nota:</strong> Per a una altra posible enfocament quant a string a JavaScript llegiu l'article sobre <a href="/ca/Add-ons/Code_snippets/StringView"><code>StringView</code> — una representació de strings basada en arrays de tipatge explícit similar a C</a>.</div> + +<h2 id="Properties" name="Properties">Propietats</h2> + +<dl> + <dt>{{jsxref("String.prototype")}}</dt> + <dd>Permet afegir propietats a un objecte <code>String</code>.</dd> +</dl> + +<div>{{jsOverrides("Function", "Properties", "prototype")}}</div> + +<h2 id="Methods" name="Methods">Mètodes</h2> + +<dl> + <dt>{{jsxref("String.fromCharCode()")}}</dt> + <dd>Retorna un string creat a partir de la seqüència de valors Unicode proporcionada.</dd> + <dt>{{jsxref("String.fromCodePoint()")}} {{experimental_inline}}</dt> + <dd>Retorna un string creat a partir de la seqüència de <u><em>code points</em> </u>proporcionada.</dd> + <dt>{{jsxref("String.raw()")}} {{experimental_inline}}</dt> + <dd>Retorna un string creat a partir de l'string proporcionat <u>sense tindre en compte la codificació.</u></dd> +</dl> + +<div>{{jsOverrides("Function", "Methods", "fromCharCode", "fromCodePoint", "raw")}}</div> + +<h2 id="Mètodes_genèrics_de_String"><code>Mètodes genèrics de String</code></h2> + +<p>Els mètodes de les instàncies de <code>String</code> també estan disponibles a Firefox a partir del JavaScript 1.6 (tot i que no formen part de l'standard ECMAScript) a l'objecte <code>String</code>, així es poden aplicar els mètodes de <code>String</code> a qualsevol objecte:</p> + +<pre class="brush: js">var num = 15; +console.log(String.replace(num, /5/, '2')); +</pre> + +<p>{{jsxref("Global_Objects/Array", "Generics", "#Array_generic_methods", 1)}} <u>també estàn disponibles als mètodes de</u> {{jsxref("Global_Objects/Array", "Array")}}.</p> + +<p>A continuació es mostra un <em>shim</em> per a donar suport als navegadors que no ho suporten:</p> + +<pre class="brush: js">/*globals define*/ +// Assumes all supplied String instance methods already present +// (one may use shims for these if not available) +(function() { + 'use strict'; + + var i, + // We could also build the array of methods with the following, but the + // getOwnPropertyNames() method is non-shimable: + // Object.getOwnPropertyNames(String).filter(function(methodName) { + // return typeof String[methodName] === 'function'; + // }); + methods = [ + 'quote', 'substring', 'toLowerCase', 'toUpperCase', 'charAt', + 'charCodeAt', 'indexOf', 'lastIndexOf', 'startsWith', 'endsWith', + 'trim', 'trimLeft', 'trimRight', 'toLocaleLowerCase', + 'toLocaleUpperCase', 'localeCompare', 'match', 'search', + 'replace', 'split', 'substr', 'concat', 'slice' + ], + methodCount = methods.length, + assignStringGeneric = function(methodName) { + var method = String.prototype[methodName]; + String[methodName] = function(arg1) { + return method.apply(arg1, Array.prototype.slice.call(arguments, 1)); + }; + }; + + for (i = 0; i < methodCount; i++) { + assignStringGeneric(methods[i]); + } +}()); +</pre> + +<h2 id="String_instances" name="String_instances"><code>Instàncies de String</code></h2> + +<h3 id="Propietats">Propietats</h3> + +<div>{{page('/ca/docs/Web/JavaScript/Reference/Global_Objects/String/prototype', 'Properties')}}</div> + +<h3 id="Mètodes">Mètodes</h3> + +<h4 id="Methods_unrelated_to_HTML" name="Methods_unrelated_to_HTML">Mètodes no relacionats amb HTML</h4> + +<div>{{page('/ca/docs/Web/JavaScript/Reference/Global_Objects/String/prototype', 'Methods_unrelated_to_HTML')}}</div> + +<h4 id="HTML_wrapper_methods" name="HTML_wrapper_methods">Mètodes d'embolcall de HTML</h4> + +<div>{{page('/ca/docs/Web/JavaScript/Reference/Global_Objects/String/prototype', 'HTML_wrapper_methods')}}</div> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Exemple_Conversió_de_strings">Exemple: Conversió de strings</h3> + +<p>És posible utilitzar <code>String</code> com a una alternativa "més segura" de {{jsxref("String.prototype.toString()","toString()")}}, ja que tot i que normalment també crida el mètode <code>toString()</code> subjacent, també funciona per a {{jsxref("Global_Objects/null", "null")}} i {{jsxref("Global_Objects/undefined", "undefined")}}. Per exemple:</p> + +<pre class="brush: js">var outputStrings = []; +for (var i = 0, n = inputValues.length; i < n; ++i) { + outputStrings.push(String(inputValues[i])); +} +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentari</th> + </tr> + <tr> + <td>ECMAScript 1a Edició</td> + <td>Standard</td> + <td>Definició inicial.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5', 'String')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string-objects', 'String')}}</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("0.2")}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{domxref("DOMString")}}</li> + <li><a href="/ca/Add-ons/Code_snippets/StringView"><code>StringView</code> — una representació de strings basada en arrays de tipatge explícit similar a C</a></li> + <li><a href="/ca/docs/Web/API/DOMString/Binary">Strings binàries</a></li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/string/indexof/index.html b/files/ca/web/javascript/referencia/objectes_globals/string/indexof/index.html new file mode 100644 index 0000000000..9b08b04ded --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/string/indexof/index.html @@ -0,0 +1,190 @@ +--- +title: String.prototype.indexOf() +slug: Web/JavaScript/Referencia/Objectes_globals/String/indexOf +translation_of: Web/JavaScript/Reference/Global_Objects/String/indexOf +--- +<div>{{JSRef}}</div> + +<p>El mètode <code><strong>indexOf()</strong></code> retorna la primera posició dins el {{jsxref("String")}} des del que es crida a la qual es troba el valor proporcionat. Retorna -1 si no es troba el valor donat.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>str</var>.indexOf(valorACercar[, posicioInicial]</code>)</pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>valorACercar</code></dt> + <dd>Un string que representa el valor a cercar.</dd> + <dt><code>posicioInicial</code> {{optional_inline}}</dt> + <dd>La posició a partir de la qual es cercarà dins la cadena. Pot ser qualsevol nombre sencer. El valor per defecte és <code>0</code>, indicant que es cercarà a tota la cadena. Si <code>posicioInicial</code><code> < 0</code> es cercarà a tota la cadena. Si <code>posicioInicial >= str.length</code>, no es cercarà a la cadena i es retornarà <code>-1</code> automàticament. Si <code>valorACercar</code> és una cadena buida es retornarà<code> str.length</code>.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Els caràcters de la cadena s'indexen d'esquerra a dreta. La posició del primer caràcter és <code>0</code>, i la posició de l'últim caràcter d'una cadena amb nom <code>stringName</code> és <code>stringName.length - 1</code>.</p> + +<pre class="brush: js">'Blue Whale'.indexOf('Blue'); // returns 0 +'Blue Whale'.indexOf('Blute'); // returns -1 +'Blue Whale'.indexOf('Whale', 0); // returns 5 +'Blue Whale'.indexOf('Whale', 5); // returns 5 +'Blue Whale'.indexOf('', 9); // returns 9 +'Blue Whale'.indexOf('', 10); // returns 10 +'Blue Whale'.indexOf('', 11); // returns 10 +</pre> + +<h3 id="Distinció_entre_majúscules_i_minúscules">Distinció entre majúscules i minúscules</h3> + +<p>El mètode <code>indexOf()</code> distingeix entre majúscules i minúscules. Per exemple, l'expressió següent retorna -1:</p> + +<pre class="brush: js">'Blue Whale'.indexOf('blue'); // retorna -1 +</pre> + +<h3 id="Comprovar_troballes">Comprovar troballes</h3> + +<p>Cal destacar que '0' no s'evalua a <code>true</code> i que '-1' no s'evalua a <code>false</code>. Tenim llavors que al comprovar si una cadena específica existeix dins una altra, la forma correcta de comprovar-ho seria:</p> + +<pre class="brush: js">'Blue Whale'.indexOf('Blue') !== -1; // true +'Blue Whale'.indexOf('Bloe') !== -1; // false +</pre> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_indexOf()_i_lastIndexOf()">Utilitzar <code>indexOf()</code> i <code>lastIndexOf()</code></h3> + +<p>L'exemple següent utilitza <code>indexOf()</code> i {{jsxref("String.prototype.lastIndexOf()", "lastIndexOf()")}} per a trobar valors dins la cadena <code>"Brave new world"</code>.</p> + +<pre class="brush: js">var anyString = 'Brave new world'; + +console.log('La posicó de la primera w des del principi és ' + anyString.indexOf('w')); +// mostra 8 +console.log('La posició de la primera w des del final és ' + anyString.lastIndexOf('w')); +// mostra 10 + +console.log('La posicó de "new" des del principi és ' + anyString.indexOf('new')); +// mostra 6 +console.log('La posició de "new" des del final és ' + anyString.lastIndexOf('new')); +// mostra 6 +</pre> + +<h3 id="indexOf()_i_distinció_entre_majúscules_i_minúscules"><code>indexOf()</code> i distinció entre majúscules i minúscules</h3> + +<p>L'exemple següent definteix dos variables de tipus cadena. The following example defines two string variables. The variables contain the same string except that the second string contains uppercase letters. The first {{domxref("console.log()")}} method displays 19. But because the <code>indexOf()</code> method is case sensitive, the string <code>"cheddar"</code> is not found in <code>myCapString</code>, so the second <code>console.log()</code> method displays -1.</p> + +<pre class="brush: js">var myString = 'brie, pepper jack, cheddar'; +var myCapString = 'Brie, Pepper Jack, Cheddar'; + +console.log('myString.indexOf("cheddar") is ' + myString.indexOf('cheddar')); +// logs 19 +console.log('myCapString.indexOf("cheddar") is ' + myCapString.indexOf('cheddar')); +// logs -1 +</pre> + +<h3 id="Using_indexOf()_to_count_occurrences_of_a_letter_in_a_string">Using <code>indexOf()</code> to count occurrences of a letter in a string</h3> + +<p>The following example sets <code>count</code> to the number of occurrences of the letter <code>e</code> in the string <code>str</code>:</p> + +<pre class="brush: js">var str = 'To be, or not to be, that is the question.'; +var count = 0; +var pos = str.indexOf('e'); + +while (pos !== -1) { + count++; + pos = str.indexOf('e', pos + 1); +} + +console.log(count); // displays 4 +</pre> + +<h2 id="Specifications">Specifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Specification</th> + <th scope="col">Status</th> + <th scope="col">Comment</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.7', 'String.prototype.indexOf')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.indexof', 'String.prototype.indexOf')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-string.prototype.indexof', 'String.prototype.indexOf')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + +<div>{{CompatibilityTable}}</div> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Feature</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Basic support</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>Feature</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>Basic support</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also">See also</h2> + +<ul> + <li>{{jsxref("String.prototype.charAt()")}}</li> + <li>{{jsxref("String.prototype.lastIndexOf()")}}</li> + <li>{{jsxref("String.prototype.split()")}}</li> + <li>{{jsxref("Array.prototype.indexOf()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/string/italics/index.html b/files/ca/web/javascript/referencia/objectes_globals/string/italics/index.html new file mode 100644 index 0000000000..f38a8f9579 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/string/italics/index.html @@ -0,0 +1,104 @@ +--- +title: String.prototype.italics() +slug: Web/JavaScript/Referencia/Objectes_globals/String/italics +translation_of: Web/JavaScript/Reference/Global_Objects/String/italics +--- +<div>{{JSRef}} {{deprecated_header}}</div> + +<p>El mètode <strong><code>italics()</code></strong> crea un element HTML {{HTMLElement("i")}} que converteix una cadena en format itàlic.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>str</var>.italics()</code></pre> + +<h2 id="Descripció">Descripció</h2> + +<p>El mètode <code>italics()</code> incrusta una cadena en una etiqueta <code><i></code>: <code>"<i>str</i>"</code>.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_italics()">Utilitzar <code>italics()</code></h3> + +<p>L'exemple següent utilitza mètodes string per canviar el format de la cadena:</p> + +<pre class="brush: js">var worldString = 'Hola, món'; console.log(worldString.blink()); // Hello, world +console.log(worldString.bold()); // <strong>Hola, món</strong> +console.log(worldString.italics()); //<em>Hola, món</em> +console.log(worldString.strike()); // <s>Hola, món</s></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-string.prototype.italics', 'String.prototype.italics')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definició inicial. Implemtat en JavaScript 1.0. Definit en l'Annex B (normative) per Caracerístiques Adiccionals d'ECMAScript per navegadors Web.</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.0")}}</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>{{CompatGeckoMobile("1.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("String.prototype.blink()")}}</li> + <li>{{jsxref("String.prototype.bold()")}}</li> + <li>{{jsxref("String.prototype.strike()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/string/length/index.html b/files/ca/web/javascript/referencia/objectes_globals/string/length/index.html new file mode 100644 index 0000000000..63a3114d2d --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/string/length/index.html @@ -0,0 +1,121 @@ +--- +title: String.length +slug: Web/JavaScript/Referencia/Objectes_globals/String/length +translation_of: Web/JavaScript/Reference/Global_Objects/String/length +--- +<div>{{JSRef("Global_Objects", "String")}}</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>La propietat <strong><code>length</code></strong> representa la longitud d'una cadena de caràcters.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>str</var>.length</code></pre> + +<h2 id="Description" name="Description">Descripció</h2> + +<p>Aquesta propietat retorna el nombre d'unitats de codi en un string. {{interwiki("wikipedia", "UTF-16")}}, el format de string utilitzar a JavaScript, utilitza un únic codi de 16 bits per a representar els caràcters més comuns, però necessita dos unitats de codi per a caràcters menys comuns, així que és possible que el valor retornat per <code>length</code> no encaixi amb el nombre de caràcters reals a la cadena de caràcters.</p> + +<p>Per a una cadena buida, <code>length</code> és 0.</p> + +<p>La propietat estàtica <code>String.length</code> retorna el valor 1.</p> + +<h2 id="Examples" name="Examples">Exemples</h2> + +<h3 id="Example:_Basic_usage" name="Example:_Basic_usage">Exemple: Ús bàsic</h3> + +<pre class="brush: js">var x = 'Mozilla'; +var empty = ''; + +console.log('Mozilla té ' + x.length + ' unitats de codi'); +/* "Mozilla té 7 unitats de codi" */ + +console.log('La string buida té una longitud de ' + empty.length); +/* "La string buida té una longitud de 0" */ +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificacions</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>ECMAScript 1a Edició.</td> + <td>Standard</td> + <td>Definició inicial. Implementat a JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.5.1', 'String.prototype.length')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-properties-of-string-instances-length', 'String.prototype.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 for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li><a class="external" href="http://developer.teradata.com/blog/jasonstrimpel/2011/11/javascript-string-length-and-internationalizing-web-applications"><code>String.length</code> a JavaScript i com internacionalitzar Aplicacions Web</a></li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/string/link/index.html b/files/ca/web/javascript/referencia/objectes_globals/string/link/index.html new file mode 100644 index 0000000000..efe1385ddc --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/string/link/index.html @@ -0,0 +1,119 @@ +--- +title: String.prototype.link() +slug: Web/JavaScript/Referencia/Objectes_globals/String/link +translation_of: Web/JavaScript/Reference/Global_Objects/String/link +--- +<div>{{JSRef}}</div> + +<p>El mètode <strong><code>link()</code></strong> crea un element HTML {{HTMLElement("a")}} que causa que una cadena es mostri com un enllaç hipertext a una altra URL.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>str</var>.link(<var>url</var>)</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>url</code></dt> + <dd>Una cadena que especifica l'atribut <code>href</code> de l'etiqueta <code><a>:</code> hauria de ser una URL vàlida (relativa o absoluta), amb qualsevols caràcters escapats <code>&</code> com <code>&amp;</code>, i qualsevol caràcter <code>"</code> escapat com <code>&quot;</code>.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Use the <code>link()</code> method to create an HTML snippet for a hypertext link. The returned string can then be added to the document via {{domxref("document.write()")}} or {{domxref("element.innerHTML")}}.</p> + +<p>Links created with the <code>link()</code> method become elements in the <code>links</code> array of the <code>document</code> object. See {{domxref("document.links")}}.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_link()">Utilitzar <code>link()</code></h3> + +<p>L'exemple següent mostra la paraula "MDN" com a un enllaç hypertext lque retorna a l'usuari a la xarxa de Mozilla Developer.</p> + +<pre class="brush: js">var hotText = 'MDN'; +var URL = 'https://developer.mozilla.org/'; + +console.log('Click to return to ' + hotText.link(URL)); +// Click to return to <a href="https://developer.mozilla.org/">MDN</a> +</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-string.prototype.link', 'String.prototype.link')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definició inicial. Implementat en JavaScript 1.0. Definit en l'Annex B (normative) per Característiques Addiccionals d'ECMAScript per Navegadors Web.</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.0")}}</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>{{CompatGeckoMobile("1.0")}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Notes_específiques_Gecko">Notes específiques Gecko</h2> + +<ul> + <li>Starting Gecko 17.0 {{geckoRelease("17")}} the <code>"</code> (quotation mark) is now automatically replaced by its HTML reference character <code>&quot;</code> in the <code>url</code> parameter.</li> +</ul> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("String.prototype.anchor()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/string/normalize/index.html b/files/ca/web/javascript/referencia/objectes_globals/string/normalize/index.html new file mode 100644 index 0000000000..7a6bcef500 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/string/normalize/index.html @@ -0,0 +1,154 @@ +--- +title: String.prototype.normalize() +slug: Web/JavaScript/Referencia/Objectes_globals/String/normalize +translation_of: Web/JavaScript/Reference/Global_Objects/String/normalize +--- +<div>{{JSRef}}</div> + +<p>El mètode <strong><code>normalize()</code></strong> retorna la Forma Normalitzada en Unicode d'un string donat (si el valor passat no és un string, es convertirà a string primer).</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>str</var>.normalize([<var>forma</var>])</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>forma</code></dt> + <dd>Una de les opcions <code>"NFC"</code>, <code>"NFD"</code>, <code>"NFKC"</code>, o <code>"NFKD"</code>, que determina quina Forma de Normalització Unicode es farà anar. Si s'omet o es passa {{jsxref("undefined")}} com a paràmetre, s'utilitzarà <code>"NFC"</code> per defecte. + <ul> + <li><code>NFC</code> — Normalization Form Canonical Composition.</li> + <li><code>NFD</code> — Normalization Form Canonical Decomposition.</li> + <li><code>NFKC</code> — Normalization Form Compatibility Composition.</li> + <li><code>NFKD</code> — Normalization Form Compatibility Decomposition.</li> + </ul> + </dd> +</dl> + +<h3 id="Errors_llençats">Errors llençats</h3> + +<dl> + <dt>{{jsxref("RangeError")}}</dt> + <dd>Es llença un {{jsxref("RangeError")}} si <code>forma</code> no és un dels valors especificats adalt.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>El mètode <code>normalize()</code> retorna la Forma Normalitzada Unicode d'un string. No afecta el propi valor del string passat sino que en retorna un de nou.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_normalize()">Utilitzar <code>normalize()</code></h3> + +<pre class="brush: js">// String inicial + +// U+1E9B: LLETRA S PETITA DEL LLATÍ AMB UN PUNT A SOBRE +// U+0323: COMBINACIÓ AMB EL PUNT A SOTA +var str = '\u1E9B\u0323'; + + +// Canonically-composed form (NFC) + +// U+1E9B: LLETRA S PETITA DEL LLATÍ AMB UN PUNT A SOBRE +// U+0323: COMBINACIÓ AMB EL PUNT A SOTA +str.normalize('NFC'); // '\u1E9B\u0323' +str.normalize(); // el mateix que a sobre + + +// Canonically-decomposed form (NFD) + +// U+017F: LLETRA S PETITA DEL LLATÍ AMB UN PUNT A SOBRE +// U+0323: COMBINACIÓ AMB EL PUNT A SOTA +// U+0307: COMBINACIÓ AMB EL PUNT A SOBRE +str.normalize('NFD'); // '\u017F\u0323\u0307' + + +// Compatibly-composed (NFKC) + +// U+1E69: LLETRA S PETITA DEL LLATÍ AMB UN PUNT A SOBRE +str.normalize('NFKC'); // '\u1E69' + + +// Compatibly-decomposed (NFKD) + +// U+0073: LLETRA S PETITA DEL LLATÍ +// U+0323: COMBINACIÓ AMB EL PUNT A SOTA +// U+0307: COMBINACIÓ AMB EL PUNT A SOBRE +str.normalize('NFKD'); // '\u0073\u0323\u0307' +</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-string.prototype.normalize', 'String.prototype.normalize')}}</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("34")}}</td> + <td>{{CompatGeckoDesktop("31")}}</td> + <td>{{CompatIE("11")}}</td> + <td>{{CompatVersionUnknown}}</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 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>{{CompatChrome("34")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li><a href="http://www.unicode.org/reports/tr15/">Annex del Standard Unicode #15, Formes Normalitzades del Unicode</a></li> + <li><a href="http://en.wikipedia.org/wiki/Unicode_equivalence">Equivalències al Unicode</a></li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/string/quote/index.html b/files/ca/web/javascript/referencia/objectes_globals/string/quote/index.html new file mode 100644 index 0000000000..f8027d070a --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/string/quote/index.html @@ -0,0 +1,107 @@ +--- +title: String.prototype.quote() +slug: Web/JavaScript/Referencia/Objectes_globals/String/quote +translation_of: Archive/Web/JavaScript/String.quote +--- +<div>{{JSRef}} {{obsolete_header("37")}} {{non-standard_header}}</div> + +<p>El mètode no estàndard <strong><code>quote()</code></strong> retorna una còpia de la cadena, reemplaçant diferents caràcters especials de la cadena amb les seves seqüències d'escapament i embolcalla el resultat amb cometes dobles (<code>"</code>).</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>str</var>.quote()</code></pre> + +<h2 id="Exemples">Exemples</h2> + +<p>A la taula següent, el mètode <code>quote()</code> reemplaça els caràcters especials i embolcalla les cadenes amb cometes dobles. Tingueu en compte que en la tercera on un {{jsxref("Global_Objects/eval", "eval()")}} embolcallat avalua la seqüència d'escapament novament.</p> + +<table class="fullwidth-table"> + <thead> + <tr> + <th class="header" scope="col"><code>str</code></th> + <th class="header" scope="col"><code>str.quote()</code></th> + <th class="header" scope="col"><code>eval(str.quote())</code></th> + </tr> + </thead> + <tbody> + <tr> + <td><code>Hello world!</code></td> + <td><code>"Hello world!"</code></td> + <td><code>Hello world!</code></td> + </tr> + <tr> + <td><code style="white-space: pre;">Hello<br> + world!</code></td> + <td><code>"Hello\n\tworld!"</code></td> + <td><code style="white-space: pre;">Hello<br> + world!</code></td> + </tr> + <tr> + <td><code>" \ — '</code></td> + <td><code>"\" \\ \u2014 '"</code></td> + <td><code>" \ — '</code></td> + </tr> + </tbody> +</table> + +<h2 id="Especificacions">Especificacions</h2> + +<p>No forma part de cap estàndard. Implementant en JavaScript 1.3.</p> + +<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>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome per Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("JSON.stringify()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/string/small/index.html b/files/ca/web/javascript/referencia/objectes_globals/string/small/index.html new file mode 100644 index 0000000000..761797bdda --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/string/small/index.html @@ -0,0 +1,110 @@ +--- +title: String.prototype.small() +slug: Web/JavaScript/Referencia/Objectes_globals/String/small +translation_of: Web/JavaScript/Reference/Global_Objects/String/small +--- +<div>{{JSRef}} {{deprecated_header}}</div> + +<p>El mètode <strong><code>small()</code></strong> crea un element HTML {{HTMLElement("small")}} que causa que una cadena es mostri amb una font petita.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>str</var>.small()</code></pre> + +<h2 id="Descripció">Descripció</h2> + +<p>El mètode <code>small()</code> incrusta una adena en una etiqueta <code><small>:</code> <code>"<small>str</small>"</code>.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_small()">Utilitzar <code>small()</code></h3> + +<p>L'exemple següent utilitza mètodes string per canviar la mida d'una cadena:</p> + +<pre class="brush: js">var worldString = 'Hola, món'; + +console.log(worldString.small()); // <small>Hola, món</small> +console.log(worldString.big()); // <big>Hola, món</big> +console.log(worldString.fontsize(7)); // <font size="7">Hola, món</fontsize> +</pre> + +<p>Amb l'objecte {{domxref("HTMLElement.style", "element.style")}} es pot obtenir l'atribut <code>style</code> d'un element i manipular-lo més genèricament. Per exemple:</p> + +<pre class="brush: js">document.getElementById('yourElemId').style.fontSize = '0.7em'; +</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-string.prototype.small', 'String.prototype.small')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definició inicial. Implementat en JavaScript 1.0. Definit en l'Annex B (normative) per Característiques Addiccionals d'ECMAScript per Navegadors Web.</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.0")}}</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>{{CompatGeckoMobile("1.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("String.prototype.fontsize()")}}</li> + <li>{{jsxref("String.prototype.big()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/string/startswith/index.html b/files/ca/web/javascript/referencia/objectes_globals/string/startswith/index.html new file mode 100644 index 0000000000..ca25398d51 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/string/startswith/index.html @@ -0,0 +1,128 @@ +--- +title: String.prototype.startsWith() +slug: Web/JavaScript/Referencia/Objectes_globals/String/startsWith +translation_of: Web/JavaScript/Reference/Global_Objects/String/startsWith +--- +<div>{{JSRef}}</div> + +<p>El mètode <strong><code>startsWith()</code></strong> determina si un string comença amb els caràcters d'un altre string, retornant <code>true</code> o <code>false</code> depenent d'això.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>str</var>.startsWith(stringAcercar[, posició])</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>stringAcercar</code></dt> + <dd>Els caràcters a cercar al començament d'aquest string.</dd> + <dt><code>posició</code></dt> + <dd>Opcional. La posició dins el string a la qual es començarà a cercar per a trobar <code>stringAcercar</code>; per defecte és 0.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Aquest mètode us permet determinar si un string comença amb un altre string.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_startsWith()">Utilitzar <code>startsWith()</code></h3> + +<pre class="brush: js">var str = 'To be, or not to be, that is the question.'; + +console.log(str.startsWith('To be')); // true +console.log(str.startsWith('not to be')); // false +console.log(str.startsWith('not to be', 10)); // true +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Aquest mètode va ser afegit a l'especificació ECMAScript i pot no estar disponible encara a totes les implementacions de JavaScript. No obstant, la funció següent emula el comportament de <code>String.prototype.startsWith()</code>:</p> + +<pre class="brush: js">if (!String.prototype.startsWith) { + String.prototype.startsWith = function(searchString, position) { + position = position || 0; + return this.indexOf(searchString, position) === position; + }; +} +</pre> + +<p>Trobareu una funció Polyfill més robusta i optimitzada <a href="https://github.com/mathiasbynens/String.prototype.startsWith">al GitHub de Mathias Bynens</a>.</p> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.startswith', 'String.prototype.startsWith')}}</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("41")}}</td> + <td>{{CompatGeckoDesktop("17")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatChrome("41")}}</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 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>{{CompatChrome("36")}}</td> + <td>{{CompatGeckoMobile("17")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("String.prototype.endsWith()")}} {{experimental_inline}}</li> + <li>{{jsxref("String.prototype.includes()")}} {{experimental_inline}}</li> + <li>{{jsxref("String.prototype.indexOf()")}}</li> + <li>{{jsxref("String.prototype.lastIndexOf()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/string/sub/index.html b/files/ca/web/javascript/referencia/objectes_globals/string/sub/index.html new file mode 100644 index 0000000000..0b512d038e --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/string/sub/index.html @@ -0,0 +1,109 @@ +--- +title: String.prototype.sub() +slug: Web/JavaScript/Referencia/Objectes_globals/String/sub +translation_of: Web/JavaScript/Reference/Global_Objects/String/sub +--- +<div>{{JSRef}} {{deprecated_header}}</div> + +<p>El mètode <strong><code>sub()</code></strong> crea un element HTML {{HTMLElement("sub")}} que fa que una cadena es mostri com a subíndex.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>str</var>.sub()</code></pre> + +<h2 id="Descripció">Descripció</h2> + +<p>El mètode <code>sub()</code> incrusta una cadena a una etiqueta <code><sub></code>: <code>"<sub>str</sub>"</code>.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_els_mètodes_sub()_i_sup()">Utilitzar els mètodes <code>sub()</code> i <code>sup()</code></h3> + +<p>El codi següent utiltza els mètodes <code>sub()</code> i {{jsxref("String.prototype.sup()", "sup()")}} per donar format a una cadena:</p> + +<pre class="brush: js">var superText="superíndex"; +var subText="subíndex"; + +console.log("Així es com es veu un " + superText.sup()); +// Així es com es veu un <sup>superíndex</sup>. + +console.log("Així es com es veu un " + subText.sub()); +// Així es com es veu un <sub>subíndex</sub>. +</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-string.prototype.sub', 'String.prototype.sub')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> + <p>Definició inicial. Implementat en JavaScript 1.0. Definit en l'Annex B (normative) per a Característiques Addicicionals d'ECMAScript per Navegadors Web.</p> + </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.0")}}</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>{{CompatGeckoMobile("1.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("String.prototype.sup()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/string/substr/index.html b/files/ca/web/javascript/referencia/objectes_globals/string/substr/index.html new file mode 100644 index 0000000000..5fdb1f03b4 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/string/substr/index.html @@ -0,0 +1,156 @@ +--- +title: String.prototype.substr() +slug: Web/JavaScript/Referencia/Objectes_globals/String/substr +translation_of: Web/JavaScript/Reference/Global_Objects/String/substr +--- +<div>{{JSRef}}</div> + +<p>El mètode <strong><code>substr()</code></strong> retorna els caràcters d'una cadena començant per la posició especificada fins al nombre especificat de caràcters.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>str</var>.substr(<var>començament</var>[, <var>llargària</var>])</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>començament</code></dt> + <dd>Lloc des d'on es comença a extraure els caràcters. Si es dóna un nombre negatiu, se'l tracta com <code>strLength + començament</code> on <code>strLength</code> és la llargària de al cadena (per exemple, si <code>començament</code> és -3 se'l tracta com <code>strLength - 3</code>.)</dd> + <dt><code>llargària</code></dt> + <dd>Opcional. El nombre de caràcter per extraure.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p><code>començament</code> is a character index. L'índex del primer caràcter és 0, i l'índex de l'últim caràcter és 1 menys que la llargària de la cadena. <code>substr()</code> comença extraient caràcters a <code>començament</code> i recull els caràcters <code>llargària</code> (llevat que primer s'arribi al final de la cadena, en aquest cas en retornaria menys).</p> + +<p>Si <code>començament</code> és positivu i més gran o igual que la llargària de la cadena, <code>substr()</code> retornarà una cadena buida.</p> + +<p>SI <code>començament</code> és negatiu, <code>substr()</code> l'utilitza com un índex de caràcter des del final de la cadena. Si <code>començament</code> és negatiu i <code>abs(comença,ent)</code> és més gran que la llargària de la cadena, <code>substr()</code> utilitza 0 com a índex d'inici. Nota: El maneig de valors negatius de l'argument <code>començament</code> no està suportat per Microsoft JScript.</p> + +<p>Si <code>llargària</code> és 0 o negatiu, <code>substr()</code> retorna una cadena buida. Si <code>llargària</code> s'omet, <code>substr()</code> extreu els caràcter fins al final de la cadena.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_substr()">Utilitzar <code>substr()</code></h3> + +<pre class="brush: js">var str = 'abcdefghij'; + +console.log('(1, 2): ' + str.substr(1, 2)); // '(1, 2): bc' +console.log('(-3, 2): ' + str.substr(-3, 2)); // '(-3, 2): hi' +console.log('(-3): ' + str.substr(-3)); // '(-3): hij' +console.log('(1): ' + str.substr(1)); // '(1): bcdefghij' +console.log('(-20, 2): ' + str.substr(-20, 2)); // '(-20, 2): ab' +console.log('(20, 2): ' + str.substr(20, 2)); // '(20, 2): ' +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Microsoft's JScript no suporta valors negatius per l'índex d'inici. Si desitjes utilitzar aquesta característica, pots utilitzar el codi de compatibilitat següent per evitar aquest error:</p> + +<pre class="brush: js">// només s'executa quan la funció substr() està trencada +if ('ab'.substr(-1) != 'b') { + /** + * Obtenir la subcadena d'una cadena + * @param {integer} start on comença la subcadena + * @param {integer} length quants caràcters s'han de retornar + * @return {string} + */ + String.prototype.substr = function(substr) { + return function(start, length) { + // crida el mètode original + return substr.call(this, + // Si ens dóna un començament negatiu, calcular quant es des de l'inici de la cadena + // adjustar el paràmetre start per valor negatiu + start < 0 ? this.length + start : start, + length) + } + }(String.prototype.substr); +} +</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>Definit en l'Annex B de Compatibilitat (informative). Implementat en JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-B.2.3', 'String.prototype.substr')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Definit en l'Annex B de Compatibilitat (informative)</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.substr', 'String.prototype.substr')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definit en l'Annex B (normative) per Característiques addiccionals d'ECMAScript per Navegadors Web</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("String.prototype.slice()")}}</li> + <li>{{jsxref("String.prototype.substring()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/string/sup/index.html b/files/ca/web/javascript/referencia/objectes_globals/string/sup/index.html new file mode 100644 index 0000000000..24b46c88ce --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/string/sup/index.html @@ -0,0 +1,107 @@ +--- +title: String.prototype.sup() +slug: Web/JavaScript/Referencia/Objectes_globals/String/sup +translation_of: Web/JavaScript/Reference/Global_Objects/String/sup +--- +<div>{{JSRef}} {{deprecated_header}}</div> + +<p>El mètode <strong><code>sup()</code></strong> crea un element HTML {{HTMLElement("sup")}} que causa que la cadena es mostri com un superíndex.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>str</var>.sup()</code></pre> + +<h2 id="Descripció">Descripció</h2> + +<p>El mètode <code>sup()</code> incrusta una cadena en l'etiqueta <code><sup></code>:<code>"<sup>str</sup>"</code>.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_els_mètodes_sub()_i_sup()">Utilitzar els mètodes <code>sub()</code> i <code>sup()</code></h3> + +<p>L'exemple següent utilitza els mètodes {{jsxref("String.prototype.sub()", "sub()")}} i <code>sup()</code> per formatejar la cadena:</p> + +<pre class="brush: js">var superText = 'superíndex'; +var subText = 'subíndex'; + +console.log('This is what a ' + superText.sup()); +// "Així es com es veu un <sup>superíndex</sup>." + +console.log('This is what a ' + subText.sub()); +// "Així es com es veu un <sub>subíndex</sub>." +</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-string.prototype.sup', 'String.prototype.sup')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definició inicial. Implementat en JavaScript 1.0. Definit en l'Annex B (normative) per a Característiques Addicicionals d'ECMAScript per Navegadors Web.</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.0")}}</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>{{CompatGeckoMobile("1.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("String.prototype.sub()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/string/tolocalelowercase/index.html b/files/ca/web/javascript/referencia/objectes_globals/string/tolocalelowercase/index.html new file mode 100644 index 0000000000..c138197bc1 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/string/tolocalelowercase/index.html @@ -0,0 +1,110 @@ +--- +title: String.prototype.toLocaleLowerCase() +slug: Web/JavaScript/Referencia/Objectes_globals/String/toLocaleLowerCase +translation_of: Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase +--- +<div>{{JSRef}}</div> + +<p>El mètode<strong> <code>toLocaleLowerCase()</code> </strong>retorna el valor del string que fa la crida convertit a minúscules , tot seguint les directrius locals específiques de conversió a minúscules.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>str</var>.toLocaleLowerCase()</code></pre> + +<h2 id="Descripció">Descripció</h2> + +<p>El mètode<strong> <code>toLocaleLowerCase()</code> </strong>retorna el valor del string que fa la crida convertit a minúscules , tot seguint les directrius locals específiques de conversió a minúscules.El mètode<strong> <code>toLocaleLowerCase()</code> </strong>retorna el valor del string que fa la crida convertit a minúscules , tot seguint les directrius locals específiques de conversió a minúscules. En la majoria dels casos, la crida a aquest mètode produirà un resultat similar a la del mètode {{jsxref("String.prototype.toLowerCase()", "toLowerCase()")}}, però per a algunes localitzacions, com ara el Turc, en les quals el pas de majúscules a minúscules o de minúscules a majúscules no segueix les assignacions per defecte del Unicode, el resultat pot diferir.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_toLocaleLowerCase()">Utilitzar <code>toLocaleLowerCase()</code></h3> + +<pre class="brush: js">console.log('ALFABET'.toLocaleLowerCase()); // 'alfabet' +</pre> + +<h2 id="Especifications">Especifications</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.5.4.17', 'String.prototype.toLocaleLowerCase')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.tolocalelowercase', 'String.prototype.toLocaleLowerCase')}}</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 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.toLocaleUpperCase()")}}</li> + <li>{{jsxref("String.prototype.toLowerCase()")}}</li> + <li>{{jsxref("String.prototype.toUpperCase()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/string/tolocaleuppercase/index.html b/files/ca/web/javascript/referencia/objectes_globals/string/tolocaleuppercase/index.html new file mode 100644 index 0000000000..8f7b2aa716 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/string/tolocaleuppercase/index.html @@ -0,0 +1,110 @@ +--- +title: String.prototype.toLocaleUpperCase() +slug: Web/JavaScript/Referencia/Objectes_globals/String/toLocaleUpperCase +translation_of: Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase +--- +<div>{{JSRef}}</div> + +<p>El mètode <strong><code>toLocaleUpperCase()</code></strong> retorna el valor del string que fa la crida convertit a majúscules, tot seguint les directrius locals específiques de conversió a majúscules.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>str</var>.toLocaleUpperCase()</code></pre> + +<h2 id="Descripció">Descripció</h2> + +<p>El mètode <strong><code>toLocaleUpperCase()</code></strong> retorna el valor del string que fa la crida convertit a majúscules, tot seguint les directrius locals específiques de conversió a majúscules. <code>toLocaleUpperCase()</code> no afecta el valor del string que fa la crida sino que en retorna un de nou. En la majoria dels casos, la crida a aquest mètode produirà un resultat similar a la del mètode {{jsxref("String.prototype.toUpperCase()", "toUpperCase()")}}, però per a algunes localitzacions, com ara el Turc, en les quals el pas de majúscules a minúscules o de minúscules a majúscules no segueix les assignacions per defecte del Unicode, el resultat pot diferir.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_toLocaleUpperCase()">Utilitzar <code>toLocaleUpperCase()</code></h3> + +<pre class="brush: js">console.log('alfabet'.toLocaleUpperCase()); // 'ALFABET' +</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.5.4.19', 'String.prototype.toLocaleUpperCase')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.tolocaleuppercase', 'String.prototype.toLocaleUpperCase')}}</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 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.toLocaleLowerCase()")}}</li> + <li>{{jsxref("String.prototype.toLowerCase()")}}</li> + <li>{{jsxref("String.prototype.toUpperCase()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/string/tolowercase/index.html b/files/ca/web/javascript/referencia/objectes_globals/string/tolowercase/index.html new file mode 100644 index 0000000000..7147d0ea0d --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/string/tolowercase/index.html @@ -0,0 +1,111 @@ +--- +title: String.prototype.toLowerCase() +slug: Web/JavaScript/Referencia/Objectes_globals/String/toLowerCase +translation_of: Web/JavaScript/Reference/Global_Objects/String/toLowerCase +--- +<div>{{JSRef}}</div> + +<p>El mètode <strong><code>toLowerCase()</code></strong> retorna el valor del string que fa la crida convertit a majúscules.<br> + </p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>str</var>.toLowerCase()</code></pre> + +<h2 id="Descripció">Descripció</h2> + +<p>El mètode <code>toLowerCase()</code> retorna el valor del string que fa la crida convertit a majúscules. <code>toLowerCase()</code> no afecta el valor del string que fa la crida sino que en retorna un de nou.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_toLowerCase()"><code>Utilitzar toLowerCase()</code></h3> + +<pre class="brush: js">console.log('ALFABET'.toLowerCase()); // 'alfabet' +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificacions</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definició inicial. Implementat a JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.16', 'String.prototype.toLowerCase')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.tolowercase', 'String.prototype.toLowerCase')}}</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 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.toLocaleLowerCase()")}}</li> + <li>{{jsxref("String.prototype.toLocaleUpperCase()")}}</li> + <li>{{jsxref("String.prototype.toUpperCase()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/string/tostring/index.html b/files/ca/web/javascript/referencia/objectes_globals/string/tostring/index.html new file mode 100644 index 0000000000..11f2555a2f --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/string/tostring/index.html @@ -0,0 +1,113 @@ +--- +title: String.prototype.toString() +slug: Web/JavaScript/Referencia/Objectes_globals/String/toString +translation_of: Web/JavaScript/Reference/Global_Objects/String/toString +--- +<div>{{JSRef}}</div> + +<p>El mètode <strong><code>toString()</code></strong> retorna un string que representa l'objecte especificat.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>str</var>.toString()</code></pre> + +<h2 id="Descripció">Descripció</h2> + +<p>L'objecte {{jsxref("String")}} sobreescriu el mètode <code>toString()</code> de l'objecte {{jsxref("Object")}}; no hereta {{jsxref("Object.prototype.toString()")}}. Per a objectes {{jsxref("String")}}, el mètode <code>toString()</code> retorna un string que representa l'objecte i és el mateix que el que el retornat pel mètode {{jsxref("String.prototype.valueOf()")}}.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_toString()">Utilitzar <code>toString()</code></h3> + +<p>L'exemple següent mostra el valor d'un objecte {{jsxref("String")}}:</p> + +<pre class="brush: js">var x = new String('Hello world'); + +console.log(x.toString()); // mostra 'Hello world' +</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.1.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.2', 'String.prototype.toString')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.tostring', 'String.prototype.toString')}}</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 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("Object.prototype.toSource()")}}</li> + <li>{{jsxref("String.prototype.valueOf()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/string/touppercase/index.html b/files/ca/web/javascript/referencia/objectes_globals/string/touppercase/index.html new file mode 100644 index 0000000000..2a3b4fe56a --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/string/touppercase/index.html @@ -0,0 +1,110 @@ +--- +title: String.prototype.toUpperCase() +slug: Web/JavaScript/Referencia/Objectes_globals/String/toUpperCase +translation_of: Web/JavaScript/Reference/Global_Objects/String/toUpperCase +--- +<div>{{JSRef}}</div> + +<p>El mètode <strong><code>toUpperCase()</code></strong> retorna el valor del string que fa la crida convertit a majúscules.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>str</var>.toUpperCase()</code></pre> + +<h2 id="Descripció">Descripció</h2> + +<p>El mètode <code>toUpperCase()</code> retorna el valor del string que fa la crida convertit a majúscules. <code>toUpperCase()</code> no afecta el valor del string que fa la crida sino que en retorna un de nou.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_toUpperCase()">Utilitzar <code>toUpperCase()</code></h3> + +<pre class="brush: js">console.log('alfabet'.toUpperCase()); // 'ALFABET' +</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.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.5.4.18', 'String.prototype.toUpperCase')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.touppercase', 'String.prototype.toUpperCase')}}</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 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.toLocaleLowerCase()")}}</li> + <li>{{jsxref("String.prototype.toLocaleUpperCase()")}}</li> + <li>{{jsxref("String.prototype.toLowerCase()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/string/trim/index.html b/files/ca/web/javascript/referencia/objectes_globals/string/trim/index.html new file mode 100644 index 0000000000..2dd955ea62 --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/string/trim/index.html @@ -0,0 +1,123 @@ +--- +title: String.prototype.trim() +slug: Web/JavaScript/Referencia/Objectes_globals/String/Trim +translation_of: Web/JavaScript/Reference/Global_Objects/String/Trim +--- +<div>{{JSRef}}</div> + +<p>El mètode <strong><code>trim()</code></strong> elimina els espais en blanc tant a l'inici com al final del string. En aquest contexte, s'entèn com a espais en blanc tots les caràcters que no imprimeixin res (espai, tabulador, espai sense salt de línia, etcètera) així com tots els caràcters terminadors de línia (LF, CR, etc.).</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>str</var>.trim()</code></pre> + +<h2 id="Descripció">Descripció</h2> + +<p>El mètode <code>trim()</code> retorna un string sense espais en blanc tant a l'inici com al final. <code>trim()</code> no afecta el valor del string ja que en retorna un de nou.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_trim()">Utilitzar <code>trim()</code></h3> + +<p>L'exemple següent mostra el string <code>'foo'</code>:</p> + +<pre class="brush: js">var orig = ' foo '; +console.log(orig.trim()); // 'foo' + +// Un altre exemple de .trim() eliminant espais en blanc només d'un cantó. + +var orig = 'foo '; +console.log(orig.trim()); // 'foo' +</pre> + +<h2 id="Polyfill">Polyfill</h2> + +<p>Executar el codi que es mostra a continuació abans d'executar cap altre codi crearà la funció <code>trim()</code> si aquesta no està disponible de forma nativa.</p> + +<pre class="brush: js">if (!String.prototype.trim) { + String.prototype.trim = function () { + return this.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, ''); + }; +} +</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.5.4.20', 'String.prototype.trim')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Definició inicial. Implementat a JavaScript 1.8.1.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-string.prototype.trim', 'String.prototype.trim')}}</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.1")}}</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 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.trimLeft()")}} {{non-standard_inline}}</li> + <li>{{jsxref("String.prototype.trimRight()")}} {{non-standard_inline}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/string/trimleft/index.html b/files/ca/web/javascript/referencia/objectes_globals/string/trimleft/index.html new file mode 100644 index 0000000000..f16a5b89fa --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/string/trimleft/index.html @@ -0,0 +1,94 @@ +--- +title: String.prototype.trimLeft() +slug: Web/JavaScript/Referencia/Objectes_globals/String/TrimLeft +translation_of: Web/JavaScript/Reference/Global_Objects/String/trimStart +--- +<div>{{JSRef}} {{non-standard_header}}</div> + +<p>El mètode <strong><code>trimLeft()</code></strong> elimina els espais en blanc a l'esquerra del string.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>str</var>.trimLeft()</code></pre> + +<h2 id="Descripció">Descripció</h2> + +<p>El mètode <code>trimLeft()</code> retorna un string on els espais en blanc del començament s'han eliminat. <code>trimLeft()</code> no afecta al valor mateix del string sino que en retorna un de nou.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_trimLeft()">Utilitzar <code>trimLeft()</code></h3> + +<p>L'exemple següent mostra el string <code>'foo '</code>:</p> + +<pre class="brush: js; highlight: [5]">var str = ' foo '; + +console.log(str.length); // 8 + +str = str.trimLeft(); +console.log(str.length); // 5 +console.log(str); // 'foo ' +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<p>No és part de cap standard. Implementat a JavaScript 1.8.1.</p> + +<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.1")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("String.prototype.trim()")}}</li> + <li>{{jsxref("String.prototype.trimRight()")}} {{non-standard_inline}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/string/trimright/index.html b/files/ca/web/javascript/referencia/objectes_globals/string/trimright/index.html new file mode 100644 index 0000000000..41ab89e3ca --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/string/trimright/index.html @@ -0,0 +1,94 @@ +--- +title: String.prototype.trimRight() +slug: Web/JavaScript/Referencia/Objectes_globals/String/TrimRight +translation_of: Web/JavaScript/Reference/Global_Objects/String/trimEnd +--- +<div>{{JSRef}} {{non-standard_header}}</div> + +<p>El mètode <strong><code>trimRight()</code></strong> elimina els espais en blanc al final d'un string.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code><var>str</var>.trimRight()</code></pre> + +<h2 id="Descripció">Descripció</h2> + +<p>El mètode <code>trimRight()</code> retorna el string sense espais en blanc al final del mateix. <code>trimRight()</code> no afecta el valor del string sino que en retorna un de nou.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_trimRight()">Utilitzar <code>trimRight()</code></h3> + +<p>L'exemple següent mostra el string <code>' foo'</code>:</p> + +<pre class="brush: js; highlight: [5]">var str = ' foo '; + +console.log(str.length); // 8 + +str = str.trimRight(); +console.log(str.length); // 5 +console.log(str); // ' foo' +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<p>No forma part de cap standard. Implementat a JavaScript 1.8.1.</p> + +<h2 id="Browser_compatibility">Browser compatibility</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.1")}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("String.prototype.trim()")}}</li> + <li>{{jsxref("String.prototype.trimLeft()")}} {{non-standard_inline}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/syntaxerror/index.html b/files/ca/web/javascript/referencia/objectes_globals/syntaxerror/index.html new file mode 100644 index 0000000000..2ad16e006f --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/syntaxerror/index.html @@ -0,0 +1,166 @@ +--- +title: SyntaxError +slug: Web/JavaScript/Referencia/Objectes_globals/SyntaxError +translation_of: Web/JavaScript/Reference/Global_Objects/SyntaxError +--- +<div>{{JSRef}}</div> + +<p>L'objecte <code><strong>SyntaxError</strong></code> representa un error quan s'intenta interpretar un codi sintàcticament no vàlid.</p> + +<h2 id="Descripció">Descripció</h2> + +<p>Es llança un <code>SyntaxError</code> quan el motor JavaScript es troba amb tokens o un token que no s'adequa a la sintaxi del llenguatge quan s'interpreta el codi.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code>new SyntaxError([<var>missatge</var>[, <var>nomFitxer</var>[, <var>numeroLinia</var>]]])</code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>missatge</code></dt> + <dd>Opcional. Descripció llegible per humans de l'error</dd> + <dt><code>nomFitxer</code> {{non-standard_inline}}</dt> + <dd>Opcional. El nom del fitxer que conté el codi que causa l'excepció</dd> + <dt><code>numeroLinia</code> {{non-standard_inline}}</dt> + <dd>Opcional. El número de linia del codi que causa l'excepció</dd> +</dl> + +<h2 id="Propietats">Propietats</h2> + +<dl> + <dt>{{jsxref("SyntaxError.prototype")}}</dt> + <dd>Permet l'addició de propietats a un objecte <code>SyntaxError</code>.</dd> +</dl> + +<h2 id="Mètodes">Mètodes</h2> + +<p>El <code>SyntaxError</code> global no conté cap mètode en si mateix, tanmateix, sí que hereta alguns mètodes a través de la cadena prototipus.</p> + +<h2 id="instànces_de_SyntaxError">instànces de <code>SyntaxError</code></h2> + +<h3 id="Propietats_2">Propietats</h3> + +<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/SyntaxError/prototype', 'Properties')}}</div> + +<h3 id="Mètodes_2">Mètodes</h3> + +<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/SyntaxError/prototype', 'Methods')}}</div> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Capturar_un_SyntaxError">Capturar un <code>SyntaxError</code></h3> + +<pre class="brush: js">try { + eval('hoo bar'); +} catch (e) { + console.log(e instanceof SyntaxError); // true + console.log(e.message); // "missing ; before statement" + console.log(e.name); // "SyntaxError" + console.log(e.fileName); // "Scratchpad/1" + console.log(e.lineNumber); // 1 + console.log(e.columnNumber); // 4 + console.log(e.stack); // "@Scratchpad/1:2:3\n" +} +</pre> + +<h3 id="Crear_un_SyntaxError">Crear un <code>SyntaxError</code></h3> + +<pre class="brush: js">try { + throw new SyntaxError('Hello', 'someFile.js', 10); +} catch (e) { + console.log(e instanceof SyntaxError); // true + console.log(e.message); // "Hello" + console.log(e.name); // "SyntaxError" + console.log(e.fileName); // "someFile.js" + console.log(e.lineNumber); // 10 + console.log(e.columnNumber); // 0 + console.log(e.stack); // "@Scratchpad/2:11:9\n" +} +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>{{SpecName('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Definició inicial.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.11.6.4', 'SyntaxError')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-native-error-types-used-in-this-standard-syntaxerror', 'SyntaxError')}}</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("Error")}}</li> + <li>{{jsxref("SyntaxError.prototype")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/syntaxerror/prototype/index.html b/files/ca/web/javascript/referencia/objectes_globals/syntaxerror/prototype/index.html new file mode 100644 index 0000000000..714990be7b --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/syntaxerror/prototype/index.html @@ -0,0 +1,121 @@ +--- +title: SyntaxError.prototype +slug: Web/JavaScript/Referencia/Objectes_globals/SyntaxError/prototype +translation_of: Web/JavaScript/Reference/Global_Objects/SyntaxError +--- +<div>{{JSRef}}</div> + +<p>La propietat <code><strong>SyntaxError.prototype</strong></code> representa el prototip pel constructor {{jsxref("SyntaxError")}}.</p> + +<h2 id="Descripció">Descripció</h2> + +<p>Totes les instàncies {{jsxref("SyntaxError")}} hereten de <code>SyntaxError.prototype</code>. Es pot utilitzar el prototipus per afegir propietats o mètodes a totes les instàncies.</p> + +<h2 id="Propietats">Propietats</h2> + +<dl> + <dt><code>SyntaxError.prototype.constructor</code></dt> + <dd>Especifica la funció que ha creat el prototip d'una instància.</dd> + <dt>{{jsxref("Error.prototype.message", "SyntaxError.prototype.message")}}</dt> + <dd>Missatge d'error. Tot i que l'ECMA-262 especifica que {{jsxref("SyntaxError")}} hauria de proveir la seva pròpia propietat <code>message,</code> en <a href="/en-US/docs/Mozilla/Projects/SpiderMonkey">SpiderMonkey</a>, hereta {{jsxref("Error.prototype.message")}}.</dd> + <dt>{{jsxref("Error.prototype.name", "SyntaxError.prototype.name")}}</dt> + <dd>Nom de l'herror. Heretat de {{jsxref("Error")}}.</dd> + <dt>{{jsxref("Error.prototype.fileName", "SyntaxError.prototype.fileName")}}</dt> + <dd>Ruta a l'arxiu que llança aquest error. Heretat de {{jsxref("Error")}}.</dd> + <dt>{{jsxref("Error.prototype.lineNumber", "SyntaxError.prototype.lineNumber")}}</dt> + <dd>Número de línia en el fitxa que llança aquest error. Heretat de {{jsxref("Error")}}.</dd> + <dt>{{jsxref("Error.prototype.columnNumber", "SyntaxError.prototype.columnNumber")}}</dt> + <dd>Número de columna en línia que llança aquest error. Heretat de {{jsxref("Error")}}.</dd> + <dt>{{jsxref("Error.prototype.stack", "SyntaxError.prototype.stack")}}</dt> + <dd>Traça de l'error. Heretat de {{jsxref("Error")}}.</dd> +</dl> + +<h2 id="Mètodes">Mètodes</h2> + +<p>Tot i que l'objecte prototip {{jsxref("SyntaxError")}} no conté cap mètode per si mateix, instàncies de{{jsxref("SyntaxError")}} heretes alguns mètodes a través de la cadena prototip.</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('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Definició inicial</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.11.7.6', 'NativeError.prototype')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Definit com a <code><em>NativeError</em>.prototype</code>.</td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-nativeerror.prototype', 'NativeError.prototype')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definit com a <code><em>NativeError</em>.prototype</code>.</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("Error.prototype")}}</li> + <li>{{jsxref("Function.prototype")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/objectes_globals/undefined/index.html b/files/ca/web/javascript/referencia/objectes_globals/undefined/index.html new file mode 100644 index 0000000000..3dd30fbefe --- /dev/null +++ b/files/ca/web/javascript/referencia/objectes_globals/undefined/index.html @@ -0,0 +1,174 @@ +--- +title: undefined +slug: Web/JavaScript/Referencia/Objectes_globals/undefined +translation_of: Web/JavaScript/Reference/Global_Objects/undefined +--- +<div> +<div> +<div>{{jsSidebar("Objects")}}</div> +</div> +</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>El valor de la propietat global <code><strong>undefined</strong></code> representa el valor <code>undefined</code>. És un dels {{Glossary("Primitive", "tipus primitius")}} de JavaScript.</p> + +<p>{{js_property_attributes(0,0,0)}}</p> + +<h2 id="Syntax" name="Syntax">Sintaxi</h2> + +<pre class="syntaxbox"><code>undefined</code></pre> + +<h2 id="Description" name="Description">Descripció</h2> + +<p><code>undefined</code> és una propietat de l'<em>objecte global</em>, és a dir, és una variable dins l'àmbit global.</p> + +<p>Als navegadors moderns (JavaScript 1.8.5 / Firefox 4+), <code>undefined</code> és una propietat no configurable i que no pot ser escrita, tal com denota la especificació ECMAScript 5. Encara que no sigui el cas, és convenient evitar sobreescriure el seu valor.</p> + +<p>Una variable a la que no s'ha assignat cap valor és de tipus <code>undefined</code>. Un mètode o sentència retornarà <code>undefined</code> si la variable que s'evalua no te assignat cap valor. Una funció retornarà <code>undefined</code> si no es {{jsxref("Statements/return", "retorna")}} un valor explícitament.</p> + +<p>Degut a que <code>undefined</code> no és una {{jsxref("Reserved_Words", "paraula reservada")}} es pot emprar com a <a href="/ca/docs/Web/JavaScript/Guide/Values,_variables,_and_literals#Variables">identificador</a> (nom de variable) a qualsvol àmbit que no sigui el global.</p> + +<pre class="brush: js">// mostra "foo string" +(function(){ var undefined = 'foo'; console.log(undefined, typeof undefined); })(); + +// mostra "foo string" +(function(undefined){ console.log(undefined, typeof undefined); })('foo'); +</pre> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Igualtat_estricta_i_undefined">Igualtat estricta i <code>undefined</code></h3> + +<p>Es pot emprar <code>undefined</code> en combinació amb els operadors de igualtat i no-igualtat per determinar si una variable té assignat un valor.</p> + +<pre class="brush: js">var x; +if (x === undefined) { + // sentències que s'executaran +} +else { + // sentències que no s'executaran +} +</pre> + +<div class="note">Nota: En aquest cas s'ha de fer servir l'operador d'igualtat estricta (<code>===</code>) en comptes de l'operador standard d'igualtat (<code>==</code>) ja que <code>x == undefined</code> també comprova si <code>x</code> és <code>null</code>, mentre que l'operador d'igualtat estricta no ho fa. <code>null</code> no és equivalent a <code>undefined</code>. Per més detalls vegeu {{jsxref("Operators/Comparison_Operators", "comparació d'operadors")}}.</div> + +<h3 id="L'operador_Typeof_i_undefined"><code>L'operador Typeof</code> i <code>undefined</code></h3> + +<p>De forma alternativa, es pot emprar {{jsxref("Operators/typeof", "typeof")}}:</p> + +<pre class="brush: js">var x; +if (typeof x === 'undefined') { + // sentències que s'executaran +} +</pre> + +<p>Una raó per utilitzar {{jsxref("Operators/typeof", "typeof")}} és que no provoca un error si la variable no ha estat definida prèviament.</p> + +<pre class="brush: js">// x no ha estat prèviament definida +if (typeof x === 'undefined') { // s'evalua a true sense errors + // sentències que s'executaran +} + +if(x === undefined){ // llença ReferenceError + +} +</pre> + +<p>De totes formes és recomanable evitar l'ús d'aquest tipus de tècniques. JavaScript és un llenguatge amb àmbits estàtics, de manera que per saber si una variable ha estat definida prèviament n'hi ha prou amb comprovar si ha estat definida dins l'àmbit immediat. L'única excepció és l'àmbit global. Aquest, però, està vinculat a l'objecte global, per la qual cosa comprovar si una variable existeix dins l'àmbit global és equivalent a comprovar l'existència d'una propietat dins l'objecte global (emprant l'operador {{jsxref("Operators/in", "in")}}, per exemple).</p> + +<h3 id="L'operador_Void_i_undefined"><code>L'operador Void</code> i <code>undefined</code></h3> + +<p>L'operador {{jsxref("Operators/void", "void")}} és una altra alternativa.</p> + +<pre class="brush: js">var x; +if (x === void 0) { + // sentències que s'executaran +} + +// y no ha estat definida prèviament +if (y === void 0) { + // llença ReferenceError (en oposició a `typeof`) +} +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>ECMAScript 1st Edition.</td> + <td>Standard</td> + <td>Definició inicial. Impementat a JavaScript 1.3</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.1.1.3', 'undefined')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-undefined', 'undefined')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{ CompatibilityTable() }}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + </tbody> +</table> +</div> + +<p> </p> diff --git a/files/ca/web/javascript/referencia/operadors/arithmetic_operators/index.html b/files/ca/web/javascript/referencia/operadors/arithmetic_operators/index.html new file mode 100644 index 0000000000..da169292cd --- /dev/null +++ b/files/ca/web/javascript/referencia/operadors/arithmetic_operators/index.html @@ -0,0 +1,286 @@ +--- +title: Operadors aritmètics +slug: Web/JavaScript/Referencia/Operadors/Arithmetic_Operators +translation_of: Web/JavaScript/Reference/Operators +--- +<div> +<div>{{jsSidebar("Operators")}}</div> +</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p><strong>Els operadors aritmètics</strong> prenen valors numèrics (poden ser tant literals com ser variables) com a operands seus i retornen un valor numèric únic. Els operadors aritmètics estàndards són la suma (+), la resta (-), la multiplicació (*), i la divisió (/).</p> + +<h2 id="Suma_()"><a name="Addition">Suma (+)</a></h2> + +<p>L'operador <em>Suma</em> produeix la suma dels operands numèrics o de la concatenació de cadenes.</p> + +<h3 id="Sintaxi">Sintaxi</h3> + +<pre class="syntaxbox"><strong>Operador:</strong> x + y +</pre> + +<h3 id="Exemples">Exemples</h3> + +<pre class="brush: js">// Nombre + Nombre -> suma +1 + 2 // 3 + +// Booleà + Nombre -> suma +true + 1 // 2 + +// Booleà + Booleà -> suma +false + false // 0 + +// Nombre + String -> concatenació +5 + "foo" // "5foo" + +// String + Booleà -> concatenació +"foo" + false // "foofalse" + +// String + String -> concatenació +"foo" + "bar" // "foobar" +</pre> + +<h2 id="Resta_(-)"><a name="Subtraction">Resta (-)</a></h2> + +<p>L'operador <em>resta</em> produeix la resta de dos operands, produint la seva diferència.</p> + +<h3 id="Sintaxi_2">Sintaxi</h3> + +<pre class="syntaxbox"><strong>Operador:</strong> x - y +</pre> + +<h3 id="Exemples_2">Exemples</h3> + +<pre class="brush: js">5 - 3 // 2 +3 - 5 // -2 +"foo" - 3 // NaN</pre> + +<h2 id="Divisió_()"><a name="Division">Divisió (/)</a></h2> + +<p>L'operador divisió produeix el quocient dels seus operands on el operand de l'esquerra és el dividend, i l'operand de la dreta és el divisor.</p> + +<h3 id="Sintaxi_3">Sintaxi</h3> + +<pre class="syntaxbox"><strong>Operador:</strong> x / y +</pre> + +<h3 id="Exemples_3">Exemples</h3> + +<pre class="brush: js">1 / 2 // retorna 0.5 a JavaScript +1 / 2 // retorna 0 in Java +// (cap dels nombres és explícitament n nombre de coma flotant) + +1.0 / 2.0 // retorna 0.5 a JavaScript i Java + +2.0 / 0 // retorna Infinity a JavaScript +2.0 / 0.0 // també retorna Infinity +2.0 / -0.0 // retorna -Infinity a JavaScript</pre> + +<h2 id="Multiplicació_(*)"><a name="Multiplication">Multiplicació (*)</a></h2> + +<p>L'operador <em>multiplicació</em> produeix el producte dels operands.</p> + +<h3 id="Sintaxi_4">Sintaxi</h3> + +<pre class="syntaxbox"><strong>Operador:</strong> x * y +</pre> + +<h3 id="Exemples_4">Exemples</h3> + +<pre class="brush: js">2 * 2 // 4 +-2 * 2 // -4 +Infinity * 0 // NaN +Infinity * Infinity // Infinity +"foo" * 2 // NaN +</pre> + +<h2 id="Mòdul_()"><a name="Remainder">Mòdul (%)</a></h2> + +<p>L'operador<em> mòdul </em>retorna el mòdul del primer operand amb el segon, això és, <code>var1</code> modulo <code>var2</code> en la sentència prèvia, on <code>var1</code> i <code>var2 </code>són variables. La funció mòdul és la resta entera de dividir <code>var1</code> <code>per var2</code>. <a href="http://wiki.ecmascript.org/doku.php?id=strawman:modulo_operator" title="http://wiki.ecmascript.org/doku.php?id=strawman:modulo_operator">Hi ha una proposta per a implementar un operador mòdul real en una futura versió de l'ECMAScript.</a></p> + +<h3 id="Sintaxi_5">Sintaxi</h3> + +<pre class="syntaxbox"><strong>Operador:</strong> var1 % var2 +</pre> + +<h3 id="Exemples_5">Exemples</h3> + +<pre class="brush: js">12 % 5 // 2 +-1 % 2 // -1 +NaN % 2 // NaN +</pre> + +<h2 id="Increment_()"><a name="Increment">Increment (++)</a></h2> + +<p>L'operador <em>increment</em> incrementa (afegeix un) al seu operand i retorna un valor.</p> + +<ul> + <li>Emprat com a sufix, és a dir, amb l'operador després de l'operand (per exemple: x++), retorna el valor de l'operand abans d'incrementar-lo.</li> + <li>Emprat com a prefix, és a dir, amb l'operador precedint l'operand (per exemple: ++x), retorna el valor de l'operand després d'incrementar-lo.</li> +</ul> + +<h3 id="Sintaxi_6">Sintaxi</h3> + +<pre class="syntaxbox"><strong>Operador:</strong> x++ or ++x +</pre> + +<h3 id="Exemples_6">Exemples</h3> + +<pre class="brush: js">// Sufix +var x = 3; +y = x++; // y = 3, x = 4 + +// Prefix +var a = 2; +b = ++a; // a = 3, b = 3 +</pre> + +<h2 id="Decrement_(--)"><a name="Decrement">Decrement (--)</a></h2> + +<p>L'operador <em>decrement</em> decrementa (resta un) al seu operand i retorna el seu valor.</p> + +<ul> + <li>Emprat com a sufix, és a dir, amb l'operador després de l'operand (per exemple: x--), retorna el valor de l'operand abans de decrementar-lo.</li> + <li>Emprat com a prefix, és a dir, amb l'operador precedint l'operand (per exemple: --x), retorna el valor de l'operand després de decrementar-lo.</li> +</ul> + +<h3 id="Sintaxi_7">Sintaxi</h3> + +<pre class="syntaxbox"><strong>Operador:</strong> x-- or --x +</pre> + +<h3 id="Exemples_7">Exemples</h3> + +<pre class="brush: js">// Sufix +var x = 3; +y = x--; // y = 3, x = 2 + +// Prefix +var a = 2; +b = --a; // a = 1, b = 1 +</pre> + +<h2 id="Negació_unària_(-)"><a name="Unary_negation">Negació unària (-)</a></h2> + +<p>L'operador de negació unària precedeix el seu operand i el nega.</p> + +<h3 id="Sintaxi_8">Sintaxi</h3> + +<pre class="syntaxbox"><strong>Operator:</strong> -x +</pre> + +<h3 id="Exemples_8">Exemples</h3> + +<pre class="brush: js">var x = 3; +y = -x; // y = -3, x = 3 +</pre> + +<h2 id="Operador_unari_de_conversió_a_nombre_()"><a name="Unary_plus">Operador unari de conversió a nombre</a> (+)</h2> + +<p>L'operador unari de conversió a nombre precedeix el seu operand i intenta convertir-lo en un nombre si no ho és ja. Tot i que l'operand de negació unària també pot convertir no-nombres, l'operador de conversió és el mètode més ràpid i recomanat per a convertir quelcom a un nombre ja que no realitza cap altra operació al nombre. Pot convertir cadenes de caràcters representant sencers i nombres en coma flotant, així com els valors <code>true</code>, <code>false</code> i <code>null</code>. Quant a nombres sencers, tant la notació decimal com la hexadecimal (denotada amb el prefixe "0x") estàn suportades. Els nombres negatius també estàn suportats (tot i que no per a hexadecimals). Si no pot interpretar un valor determinat l'operador retornarà<a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/NaN"> NaN</a>.</p> + +<h3 id="Sintaxi_9">Sintaxi</h3> + +<pre class="syntaxbox"><strong>Operador:</strong> +x +</pre> + +<h3 id="Exemples_9">Exemples</h3> + +<pre class="brush: js">+3 // 3 ++"3" // 3 ++true // 1 ++false // 0 ++null // 0 +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>ECMAScript 1st Edition.</td> + <td>Standard</td> + <td>Initial definition.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-11.6', 'Additive operators')}}<br> + {{SpecName('ES5.1', '#sec-11.5', 'Multiplicative operators')}}<br> + {{SpecName('ES5.1', '#sec-11.3', 'Postfix expressions')}}<br> + {{SpecName('ES5.1', '#sec-11.4', 'Unary operators')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-additive-operators', 'Additive operators')}}<br> + {{SpecName('ES6', '#sec-multiplicative-operators', 'Multiplicative operators')}}<br> + {{SpecName('ES6', '#sec-postfix-expressions', 'Postfix expressions')}}<br> + {{SpecName('ES6', '#sec-unary-operators', 'Unary operators')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{ CompatibilityTable() }}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome per Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Assignment_Operators">Operadors d'assignació</a></li> +</ul> diff --git a/files/ca/web/javascript/referencia/operadors/bitwise_operators/index.html b/files/ca/web/javascript/referencia/operadors/bitwise_operators/index.html new file mode 100644 index 0000000000..048a1eddf6 --- /dev/null +++ b/files/ca/web/javascript/referencia/operadors/bitwise_operators/index.html @@ -0,0 +1,718 @@ +--- +title: Operadors de bits +slug: Web/JavaScript/Referencia/Operadors/Bitwise_Operators +translation_of: Web/JavaScript/Reference/Operators +--- +<div>{{jsSidebar("Operators")}}</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p><strong>Els operadors de bits</strong> tracten els seus operands com una seqüència de 32 bits (uns i zeros), en comptes de operar-los com a <a href="/ca/docs/Web/JavaScript/Reference/Global_Objects/Number">nombres</a> decimals, hexadecimals o octals. Per exemple, la representació binària del és nombre decimal nou (9) 1001. Els operadors de bits treballen amb aquesta representació binària però el resultat que retorna l'operació sempre és un nombre standard de JavaScript.</p> + +<p>La taula que trobareu a continuació és un resum dels operadors de bits que es poden trobar a JavaScript:</p> + +<table class="standard-table"> + <tbody> + <tr> + <th>Operador</th> + <th>Ús</th> + <th>Descripció</th> + </tr> + <tr> + <td><a href="#Bitwise_AND">AND binari</a></td> + <td style="white-space: nowrap;"><code>a & b</code></td> + <td> + <p>Retorna un 1 a les posicions on el bit de <code>a</code> i el bit de <code>b</code> són 1 i un 0 en totes les altres.</p> + </td> + </tr> + <tr> + <td><a href="#Bitwise_OR">OR binari</a></td> + <td style="white-space: nowrap;"><code>a | b</code></td> + <td> + <p>Retorna un 1 a les posicions on al menys la posició de <code>a</code> o la de <code>b</code> són 1.</p> + </td> + </tr> + <tr> + <td><a href="#Bitwise_XOR">XOR binari</a></td> + <td style="white-space: nowrap;"><code>a ^ b</code></td> + <td> + <p>Retorna un 1 a cada posició on <code>a</code> és 1 i <code>b</code> és 0 o bé <code>a</code> és 0 i <code>b</code> és 1.</p> + </td> + </tr> + <tr> + <td><a href="#Bitwise_NOT">NOT binari</a></td> + <td style="white-space: nowrap;"><code>~ a</code></td> + <td>Inverteix els bits de l'operand donat.</td> + </tr> + <tr> + <td><a href="#Left_shift">Desplaçament a l'esquerra</a></td> + <td style="white-space: nowrap;"><code>a << b</code></td> + <td>Desplaça els bits de <code>a</code> <code>b</code> posicions a l'esquerra, tot omplint amb zeros les primeres b posicions.</td> + </tr> + <tr> + <td><a href="#Right_shift">Desplaçament a la dreta conservant el signe</a></td> + <td style="white-space: nowrap;"><code>a >> b</code></td> + <td>Desplaça els bits de <code>a</code> <code>b</code> posicions a la dreta, descartant els bits desplaçats fora.</td> + </tr> + <tr> + <td><a href="#Unsigned_right_shift">Desplaçament a la dreta omplint amb zeros</a></td> + <td style="white-space: nowrap;"><code>a >>> b</code></td> + <td>Desplaça els bits de <code>a</code> <code>b</code> posicions a la dreta, descartant els bits desplaçats fora. Els primers <code>b</code> bits s'omplen amb zeros.</td> + </tr> + </tbody> +</table> + +<h2 id="Enters_de_32_bits_amb_signe">Enters de 32 bits amb signe</h2> + +<p>Els operands de totes les operacions de bits es converteixen a enters amb signe de 32 bits utilitzant el format de complement a 2. Això vol dir que la versió negativa d'un nombre (per exemple 5 vs -5) és exactament la mateixa representació binària però amb els bits invertits (operació de bits NOT del nombre, també coneguda com a complement del nombre) més 1. Per exemple, seguidament es mostra la representació binària de 314:</p> + +<pre>00000000000000000000000100111010 +</pre> + +<p>I a continuació <code>~314</code>, és a dir, el complement de <code>314</code>:</p> + +<pre>11111111111111111111111011000101 +</pre> + +<p>Finalment es mostra <code>-314</code>, és a dir, el complement a dos de <code>314</code>:</p> + +<pre>11111111111111111111111011000110 +</pre> + +<p>El complement a dos garanteix que el bit de més a l'esquerra sempre serà un <code>0</code> quan el nombre és positiu i un <code>1</code> quan el nombre sigui negatiu. Aquest bit és doncs anomentat el <em>bit de signe</em> degut a això.</p> + +<p>El nombre <code>0</code> es representa com a l'enter composat íntegrament de zeros a tots els seus bits.</p> + +<pre>0 (base 10) = 00000000000000000000000000000000 (base 2) +</pre> + +<p>El nombre <code>-1</code> és l'enter composats completament per 1s a tots els seus bits.</p> + +<pre>-1 (base 10) = 11111111111111111111111111111111 (base 2) +</pre> + +<p>El nombre <code>-2147483648</code> (representació hexadecimal: <code>-0x80000000</code>) és l'enter composat per zeros a tots els seus bits a excepciò del bit de més a l'esquerra, que és un 1.</p> + +<pre>-2147483648 (base 10) = 10000000000000000000000000000000 (base 2) +</pre> + +<p>El nombre <code>2147483647</code> (representació hexadecimal: <code>0x7fffffff</code>) és el sencer composat per 1 a tots els seus bits a excepció del de més a l'esquerra.</p> + +<pre>2147483647 (base 10) = 01111111111111111111111111111111 (base 2) +</pre> + +<p>Els nombres <code>-2147483648</code> i <code>2147483647</code> són els enters més petit i més gran respectivament que poden ser representats mitjançant un nombre de 32 bits amb signe.</p> + +<h2 id="Operadors_lògics_de_bits">Operadors lògics de bits</h2> + +<p>Conceptualment els operadors lògics de bits funcionen de la següent forma:</p> + +<ul> + <li>Es converteixen els operans a enters de 32 bits amb signe, expressats com una sèrie de bits (zeros i uns).</li> + <li>Cada bit del primer operand s'emparella amb el corresponent bit del segon operand: el primer bit amb el primer bit, el segon amb el segon, etcètera.</li> + <li>L'operador s'aplica per cada parella de bits, tot construint el resultat bit a bit.</li> +</ul> + +<h3 id="(AND_binari)"><a name="Bitwise_AND">& (AND binari)</a></h3> + +<p>Realitza l'operació AND a cada parella de bits. <code>a</code> AND <code>b</code> esdevindrà 1 només si ambdós <code>a</code> i <code>b</code> són 1. La taula de la veritat per a l'operació AND és la següent:</p> + +<table class="standard-table"> + <tbody> + <tr> + <td class="header">a</td> + <td class="header">b</td> + <td class="header">a AND b</td> + </tr> + <tr> + <td>0</td> + <td>0</td> + <td>0</td> + </tr> + <tr> + <td>0</td> + <td>1</td> + <td>0</td> + </tr> + <tr> + <td>1</td> + <td>0</td> + <td>0</td> + </tr> + <tr> + <td>1</td> + <td>1</td> + <td>1</td> + </tr> + </tbody> +</table> + +<pre> 9 (base 10) = 00000000000000000000000000001001 (base 2) + 14 (base 10) = 00000000000000000000000000001110 (base 2) + -------------------------------- +14 & 9 (base 10) = 00000000000000000000000000001000 (base 2) = 8 (base 10) +</pre> + +<p>Realitzar l'operació AND binària de qualsevol nombre amb el zero retornarà zero. Realitzar l'operació AND binària de qualsevol nombre amb -1 retornarà el mateix nombre.</p> + +<h3 id="(OR_binari)"><a name="Bitwise_OR">| (OR binari)</a></h3> + +<p>Realitza la operació OR a cada parella de bits. <code>a</code> OR <code>b</code> retornarà 1 si qualsevol de <code>a</code> o <code>b</code> és 1. La taula de la veritat per a l'operació OR és:</p> + +<table class="standard-table"> + <tbody> + <tr> + <td class="header">a</td> + <td class="header">b</td> + <td class="header">a OR b</td> + </tr> + <tr> + <td>0</td> + <td>0</td> + <td>0</td> + </tr> + <tr> + <td>0</td> + <td>1</td> + <td>1</td> + </tr> + <tr> + <td>1</td> + <td>0</td> + <td>1</td> + </tr> + <tr> + <td>1</td> + <td>1</td> + <td>1</td> + </tr> + </tbody> +</table> + +<pre> 9 (base 10) = 00000000000000000000000000001001 (base 2) + 14 (base 10) = 00000000000000000000000000001110 (base 2) + -------------------------------- +14 | 9 (base 10) = 00000000000000000000000000001111 (base 2) = 15 (base 10) +</pre> + +<p>Realitzar l'operació OR binària de qualsevol nombre x amb 0 retornarà x. Realitzar l'operació OR binària de qualsevol nombre x amb -1 retornarà ~x</p> + +<h3 id="(XOR_binari)"><a name="Bitwise_XOR">^ (XOR binari)</a></h3> + +<p>Realitza la operació XOR a cada parella de bits. <code>a</code> XOR <code>b</code> retorna 1 si <code>a</code> i <code>b</code> són diferents. La taula de la veritat per a l'operació XOR és la següent:</p> + +<table class="standard-table"> + <tbody> + <tr> + <td class="header">a</td> + <td class="header">b</td> + <td class="header">a XOR b</td> + </tr> + <tr> + <td>0</td> + <td>0</td> + <td>0</td> + </tr> + <tr> + <td>0</td> + <td>1</td> + <td>1</td> + </tr> + <tr> + <td>1</td> + <td>0</td> + <td>1</td> + </tr> + <tr> + <td>1</td> + <td>1</td> + <td>0</td> + </tr> + </tbody> +</table> + +<pre> 9 (base 10) = 00000000000000000000000000001001 (base 2) + 14 (base 10) = 00000000000000000000000000001110 (base 2) + -------------------------------- +14 ^ 9 (base 10) = 00000000000000000000000000000111 (base 2) = 7 (base 10) +</pre> + +<p>Realitzar l'operació XOR binària de qualsevol nombre x amb 0 retornarà x. Realitzar l'operació OR binària de qualsevol nombre x amb -1 retornarà ~x.</p> + +<h3 id="(NOT_binari)"><a name="Bitwise_NOT">~ (NOT binari)</a></h3> + +<p>Realitza una operació NOT a cada bit. NOT <code>a</code> retorna el valor invers (també conegut com el complement a 1) de <code>a</code>. La taula de la veritat per a la operació NOT és:</p> + +<table class="standard-table"> + <tbody> + <tr> + <td class="header">a</td> + <td class="header">NOT a</td> + </tr> + <tr> + <td>0</td> + <td>1</td> + </tr> + <tr> + <td>1</td> + <td>0</td> + </tr> + </tbody> +</table> + +<pre> 9 (base 10) = 00000000000000000000000000001001 (base 2) + -------------------------------- +~9 (base 10) = 11111111111111111111111111110110 (base 2) = -10 (base 10) +</pre> + +<p>Realitzar la operació NOT binària a un nombre x qualsevol retorna -(x + 1). Per exemple, ~5 resulta en -6.</p> + +<p>Exemple amb indexOf:</p> + +<pre class="brush: js">var str = 'rawr'; +var searchFor = 'a'; + +// fora alternativa equivalent a if (-1*str.indexOf('a') <= -1) +if (~str.indexOf(searchFor)) { + // searchFor és dins l'string +} else { + // searchFor no està dins l'string +} + +// valors retornats per (~str.indexOf(searchFor)) +// r == -1 +// a == -2 +// w == -3 +</pre> + +<h2 id="Operadors_binaris_de_desplaçament">Operadors binaris de desplaçament</h2> + +<p>Els operadors binaris de desplaçament accepten dos operands: el primer és el valor que serà transformat a enter de 32 bits i al que se li aplicarà el desplaçament. El segon determina el nombre de posicions que es desplaçarà cada bit. La direcció en la que els bits es desplaçaran es determina per l'operador usat.</p> + +<p>Els operadors de desplaçament converteixen els seus operands a enters de 32 bits en ordre <em>big-endian</em> i retornen un valor amb el mateix tipus que l'operand de l'esquerra. L'operand de la dreta hauria de ser menor de 32, però de no ser així només s'utilitzen els primers 5 bits.</p> + +<h3 id="<<_(Desplaçament_a_l'esquerra)"><a name="Left_shift"><< (Desplaçament a l'esquerra)</a></h3> + +<p>Aquest operador desplaça el primer operand un nombre específic de bits cap a l'esquerra. Els bits de l'esquerra sobrants són descartats. Per a omplir les primeres posicions de la dreta s'utilitzen zeros.</p> + +<p>Exemple<code>: 9 << 2</code> resulta en 36:</p> + +<pre> 9 (base 10): 00000000000000000000000000001001 (base 2) + -------------------------------- +9 << 2 (base 10): 00000000000000000000000000100100 (base 2) = 36 (base 10) +</pre> + +<p>Desplaçar a l'esquerra qualsevol nombre <strong>x</strong> <strong>y</strong> bits resulta en <strong>x * 2^y</strong>.</p> + +<h3 id=">>_(Desplaçament_a_la_dreta_preservant_el_signe)"><a name="Right_shift">>> (Desplaçament a la dreta preservant el signe)</a></h3> + +<p>Aquest operador desplaça el primer operand un nombre específic de bits a la dreta. Els bits sobrants es descarten. Els bits de l'esquerra s'inicialitzen amb el valor inicial del primer bit de l'esquerra. Degut a que el bit de més a l'esquerra tindrà el mateix valor que el bit de més a l'esquerra abans de realitzar el desplaçament, el bit de signe no canvia. És degut a aquesta propietat que es diu que aquest operand preserva el signe.</p> + +<p>Per exemple, <code>9 >> 2</code> resulta en 2:</p> + +<pre> 9 (base 10): 00000000000000000000000000001001 (base 2) + -------------------------------- +9 >> 2 (base 10): 00000000000000000000000000000010 (base 2) = 2 (base 10) +</pre> + +<p>De la mateixa manera, <code>-9 >> 2</code> resulta en -3, ja que el signe es preserva:</p> + +<pre> -9 (base 10): 11111111111111111111111111110111 (base 2) + -------------------------------- +-9 >> 2 (base 10): 11111111111111111111111111111101 (base 2) = -3 (base 10) +</pre> + +<h3 id=">>>_(Desplaçament_a_la_dreta_omplint_amb_zeros)"><a name="Unsigned_right_shift">>>> (Desplaçament a la dreta omplint amb zeros)</a></h3> + +<p>Aquest operador desplaça el primer operand un nombre específic de bits cap a la dreta. Els bits sobrants degut al desplaçament són descartats. Els bits de l'esquerra són omplerts utilitzant zeros. Com que el bit de signe sempre acaba sent un zero el resultat sempre és no negatiu.</p> + +<p>Per a nombres no negatius, els operadors de desplaçament a la dreta preservant el signe i omplint amb zeros retornen el mateix resultat. Per exemple, <code>9 >>> 2</code> resulta en 2, tal com <code>9 >> 2</code>:</p> + +<pre> 9 (base 10): 00000000000000000000000000001001 (base 2) + -------------------------------- +9 >>> 2 (base 10): 00000000000000000000000000000010 (base 2) = 2 (base 10) +</pre> + +<p>El resultat varia, però, per a nombres negatius. Per exemple, <code>-9 >>> 2</code> resulta en 1073741821, el qual es diferent de <code>-9 >> 2</code> (que retorna -3):</p> + +<pre> -9 (base 10): 11111111111111111111111111110111 (base 2) + -------------------------------- +-9 >>> 2 (base 10): 00111111111111111111111111111101 (base 2) = 1073741821 (base 10) +</pre> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Exemple_Marques_i_màscares_de_bits">Exemple: Marques i màscares de bits</h3> + +<p>Els operadors lògics de bits s'empren tot sovint per a crear, manipular i llegir seqüències de <em>marques</em>, les quals realitzen uns funció similar a les variables booleanes. El seu avantatge davant les variables booleanes és que les seqüències de marques utilitzen molta menys memòria (per un factor de 32).</p> + +<p>The bitwise logical operators are often used to create, manipulate, and read sequences of <em>flags</em>, which are like binary variables. Variables could be used instead of these sequences, but binary flags take much less memory (by a factor of 32).</p> + +<p>Suposem 4 marques:</p> + +<ul> + <li>Marca A: tenim un problema de formigues</li> + <li>Marca B: tenim un ratpenat</li> + <li>Marca C: tenim un gat</li> + <li>Marca D: tenim un ànec</li> +</ul> + +<p>Aquestes marques són representades per una seqüència de bits: DCBA. Quan una marca està activada, té un valor de 1. Quan una marca no està activa rep un valor de 0. Suposem que una variable anomenada <code>flags</code> (marques en anglès) té el valor binari 0101:</p> + +<pre class="brush: js">var flags = 5; // 0101 en binari +</pre> + +<p>Aquest valor indica:</p> + +<ul> + <li>La marca A està activa, és a dir, és certa (tenim un problema de formigues)</li> + <li>La marca B és falsa (no tenim un murisec)</li> + <li>La marca C és certa (tenim un gat)</li> + <li>La marca D és falsa (no tenim un ànec)</li> +</ul> + +<p>Com que les operacions be bits utilitzen nombres de 32 bits, 0101 és en realitat 00000000000000000000000000000101, però els zeros a l'esquerra es poden obviar ja que no contenen informació útil.</p> + +<p>Una <em>màscara de bits</em> és una seqüència que pot manipular i/o llegir marques. És molt comú definir màscares "primitives" per a cada marca:</p> + +<pre class="brush: js">var FLAG_A = 1; // 0001 +var FLAG_B = 2; // 0010 +var FLAG_C = 4; // 0100 +var FLAG_D = 8; // 1000 +</pre> + +<p>Es fàcil crear noves màscares mitjançant operacions de bits lògiques sobre les màscares primitives. Per exemple, la màscara de bits 1011 es pot crear mitjançant operacions OR sobre FLAG_A, FLAG_B i FLAG_D:</p> + +<pre class="brush: js">var mask = FLAG_A | FLAG_B | FLAG_D; // 0001 | 0010 | 1000 => 1011 +</pre> + +<p>Els valors individuals d'una marca es poden obtindre mitjançant una operació AND de la seqüència de marques amb la màscara primitiva corresponent. La màscara de bits descarta els bits de les marques que no s'escauen. Per exemple, la màscara de bits 0100 es pot emprar per veure si la marca C està activa:</p> + +<pre class="brush: js">// si tenim un gat... +if (flags & FLAG_C) { // 0101 & 0100 => 0100 => true + // ... fer coses +} +</pre> + +<p>Una màscara de bits amb múltiples marques activades funciona com un "or". Per exemple els següents dos blocs de codi són equivalents:</p> + +<pre class="brush: js">// si tenim un ratpenat o un gat... +// (0101 & 0010) || (0101 & 0100) => 0000 || 0100 => true +if ((flags & FLAG_B) || (flags & FLAG_C)) { + // ... fer coses +} +</pre> + +<pre class="brush: js">// si tenim un ratpenat o un gat... +var mask = FLAG_B | FLAG_C; // 0010 | 0100 => 0110 +if (flags & mask) { // 0101 & 0110 => 0100 => true + // ... fer coses +} +</pre> + +<p>Les marques es poden activar mitjançant una operació OR amb la màscara, on cada bit amb el valor 1 activarà la marca corresponent si no està ja activada. Per exemple, la màscara de bits 1100 pot ser emprada per a activar les marques C i D:</p> + +<pre class="brush: js">// si, tenim un gat i un ànec +var mask = FLAG_C | FLAG_D; // 0100 | 1000 => 1100 +flags |= mask; // 0101 | 1100 => 1101 +</pre> + +<p>Les marques es poden desactivar mitjançant una operació AND amb una màscara de bits, on cada bit amb el valor de zero desactivarà la marca corresponent si no està ja desactivada. Aquestes màscares poden generar-se fàcilment mitjançant una operació NOT sobre la màscara primitiva adient. Per exemple, la màscara 1010 pot ser emprada per a desactivar les marques A i C:</p> + +<pre class="brush: js">// no, no tenim un problema amb formigues ni tenim un gat +var mask = ~(FLAG_A | FLAG_C); // ~0101 => 1010 +flags &= mask; // 1101 & 1010 => 1000 +</pre> + +<p>També es podría haver creat la màscara amb <code>~FLAG_A & ~FLAG_C</code> (Llei de De Morgan):</p> + +<pre class="brush: js">// no, no tenim un problema amb formigues ni tenim un gat +var mask = ~FLAG_A & ~FLAG_C; +flags &= mask; // 1101 & 1010 => 1000 +</pre> + +<p>Es pot invertir una màscara (entenem per invertir activar-la si està desactivada i desactivar-la si està activada. És a dir, invertir el seu valor) mitjançant una operació XOR amb una màscara de bits, on cada bit amb el valor 1 invertirà el valor de la marca corresponent. Per exemple, la màscara de bits 0110 pot ser emprada per invertir les marques B i C:</p> + +<pre class="brush: js">// Si no teniem un ratpenat, ara en tenim un +// i si en teniem un, adéu ratpenat +// El mateix amb els gats +var mask = FLAG_B | FLAG_C; +flags = flags ^ mask; // 1100 ^ 0110 => 1010 +</pre> + +<p>Finalment, les marques poden ser invertides mitjançant l'operador NOT:</p> + +<pre class="brush: js">// entrant a l'univers paral·lel +flags = ~flags; // ~1010 => 0101 +</pre> + +<h3 id="Xuletes_per_conversions">Xuletes per conversions</h3> + +<p>Converteix un <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/String" title="/en-US/docs/JavaScript/Reference/Global_Objects/String">String</a></code> binari a un <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number" title="/en-US/docs/JavaScript/Reference/Global_Objects/Number">Number</a></code> decimal:</p> + +<pre class="brush: js">var sBinString = "1011"; +var nMyNumber = parseInt(sBinString, 2); +alert(nMyNumber); // prints 11, i.e. 1011 +</pre> + +<p>Converteix un <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number" title="/en-US/docs/JavaScript/Reference/Global_Objects/Number">Number</a></code> decimal en un <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/String" title="/en-US/docs/JavaScript/Reference/Global_Objects/String">String</a></code> binari:</p> + +<pre class="brush: js">var nMyNumber = 11; +var sBinString = nMyNumber.toString(2); +alert(sBinString); // prints 1011, i.e. 11 +</pre> + +<h3 id="Automatització_de_la_creació_de_màscares">Automatització de la creació de màscares</h3> + +<p>El procés de creació de màscares per a valors <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean" title="/en-US/docs/JavaScript/Reference/Global_Objects/Boolean">Booleans</a></code> pot ser automatitzat:</p> + +<pre class="brush: js">function createMask () { + var nMask = 0, nFlag = 0, nLen = arguments.length > 32 ? 32 : arguments.length; + for (nFlag; nFlag < nLen; nMask |= arguments[nFlag] << nFlag++); + return nMask; +} +var mask1 = createMask(true, true, false, true); // 11, i.e.: 1011 +var mask2 = createMask(false, false, true); // 4, i.e.: 0100 +var mask3 = createMask(true); // 1, i.e.: 0001 +// etc. + +alert(mask1); // prints 11, i.e.: 1011 +</pre> + +<h3 id="Algorisme_invers_un_array_de_booleans_a_partir_d'una_màscara">Algorisme invers: un array de booleans a partir d'una màscara</h3> + +<p>El codi següent crea un <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array" title="/en-US/docs/JavaScript/Reference/Global_Objects/Array">Array</a></code> de <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean" title="/en-US/docs/JavaScript/Reference/Global_Objects/Boolean">Booleans</a></code> a partir d'una màscara:</p> + +<pre class="brush: js">function arrayFromMask (nMask) { + // nMask must be between -2147483648 and 2147483647 + if (nMask > 0x7fffffff || nMask < -0x80000000) { + throw new TypeError("arrayFromMask - out of range"); + } + for (var nShifted = nMask, aFromMask = []; nShifted; + aFromMask.push(Boolean(nShifted & 1)), nShifted >>>= 1); + return aFromMask; +} + +var array1 = arrayFromMask(11); +var array2 = arrayFromMask(4); +var array3 = arrayFromMask(1); + +alert("[" + array1.join(", ") + "]"); +// prints "[true, true, false, true]", i.e.: 11, i.e.: 1011 +</pre> + +<p>Ambdós algorismes poden ser testejats a l'hora...</p> + +<pre class="brush: js">var nTest = 19; // la nostra màscara personal +var nResult = createMask.apply(this, arrayFromMask(nTest)); + +alert(nResult); // 19 +</pre> + +<p>Només amb finalitat didàctica (ja que disposem del mètode<code> <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toString" title="/en-US/docs/JavaScript/Reference/Global_Objects/Number/toString">Number.toString(2)</a></code>), es mostra com és posible modficiar l'algorisme <code>arrayFromMask</code> per a crear un <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/String" title="/en-US/docs/JavaScript/Reference/Global_Objects/String">String</a></code> que contingui la representació d'un <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number" title="/en-US/docs/JavaScript/Reference/Global_Objects/Number">Number</a></code> en comptes d'un <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array" title="/en-US/docs/JavaScript/Reference/Global_Objects/Array">Array</a></code> de <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean" title="/en-US/docs/JavaScript/Reference/Global_Objects/Boolean">Booleans</a></code>:</p> + +<pre class="brush: js">function createBinaryString (nMask) { + // nMask ha d'estar entre -2147483648 i 2147483647 + for (var nFlag = 0, nShifted = nMask, sMask = ""; nFlag < 32; + nFlag++, sMask += String(nShifted >>> 31), nShifted <<= 1); + return sMask; +} + +var string1 = createBinaryString(11); +var string2 = createBinaryString(4); +var string3 = createBinaryString(1); + +alert(string1); +// prints 00000000000000000000000000001011, i.e. 11 +</pre> + +<h2 id="Specifications">Specifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentari</th> + </tr> + <tr> + <td>ECMAScript 1a Edició.</td> + <td>Standard</td> + <td>Definició inicial</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-11.4.8', 'Bitwise NOT operator')}}<br> + {{SpecName('ES5.1', '#sec-11.7', 'Bitwise shift operators')}}<br> + {{SpecName('ES5.1', '#sec-11.10', 'Binary bitwise operators')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-bitwise-not-operator', 'Bitwise NOT operator')}}<br> + {{SpecName('ES6', '#sec-bitwise-shift-operators', 'Bitwise shift operators')}}<br> + {{SpecName('ES6', '#sec-binary-bitwise-operators', 'Binary bitwise operators')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{ CompatibilityTable() }}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característiques</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td><a href="#Bitwise_NOT">Bitwise NOT (<code>~</code>)</a></td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + <tr> + <td><a href="#Bitwise_AND">Bitwise AND (<code>&</code>)</a></td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + <tr> + <td><a href="#Bitwise_OR">Bitwise OR (<code>|</code>)</a></td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + <tr> + <td><a href="#Bitwise_XOR">Bitwise XOR (<code>^</code>)</a></td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + <tr> + <td><a href="#Left_shift">Left shift (<code><<</code>)</a></td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + <tr> + <td><a href="#Right_shift">Right shift (<code>>></code>)</a></td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + <tr> + <td><a href="#Unsigned_right_shift">Unsigned right shift (<code>>>></code>)</a></td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td><a href="#Bitwise_NOT">Bitwise NOT (<code>~</code>)</a></td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + <tr> + <td><a href="#Bitwise_AND">Bitwise AND (<code>&</code>)</a></td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + <tr> + <td><a href="#Bitwise_OR">Bitwise OR (<code>|</code>)</a></td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + <tr> + <td><a href="#Bitwise_XOR">Bitwise XOR (<code>^</code>)</a></td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + <tr> + <td><a href="#Left_shift">Left shift (<code><<</code>)</a></td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + <tr> + <td><a href="#Right_shift">Right shift (<code>>></code>)</a></td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + <tr> + <td><a href="#Unsigned_right_shift">Unsigned right shift (<code>>>></code>)</a></td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Logical_Operators">Operadors lògics</a></li> +</ul> diff --git a/files/ca/web/javascript/referencia/operadors/conditional_operator/index.html b/files/ca/web/javascript/referencia/operadors/conditional_operator/index.html new file mode 100644 index 0000000000..15265c62b3 --- /dev/null +++ b/files/ca/web/javascript/referencia/operadors/conditional_operator/index.html @@ -0,0 +1,170 @@ +--- +title: Operador Condicional (ternari) +slug: Web/JavaScript/Referencia/Operadors/Conditional_Operator +translation_of: Web/JavaScript/Reference/Operators/Conditional_Operator +--- +<div> +<div>{{jsSidebar("Operators")}}</div> +</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>L'operador <strong>condicional (ternari)</strong> és l'únic operador de JavaScript que opera amb tres operands. Aquest operador és freqüentment usat com una simplificació de la sentència <a href="/en-US/docs/Web/JavaScript/Reference/Statements/if...else"><code>if</code></a>.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><em>condition</em> ? <em>expr1</em> : <em>expr2</em> </pre> + +<h2 id="Paràmetres">Paràmetres</h2> + +<dl> + <dt><code>condition</code></dt> + <dd>Una expressió que avalua <code>true</code> o <code>false</code>.</dd> +</dl> + +<dl> + <dt><code>expr1</code>, <code>expr2</code></dt> + <dd>Expressions amb valors de qualsevol tipus.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Si <code>condition</code> és <code>true</code>, l'operador retorna el valor de <code>expr1</code>; de ser el contrari, retorna el valor de <code>expr2</code>. Per exemple, per mostrar diferents missatges basats en el valor de la variable <code>isMember</code>, es podria fer servir aquesta sentència:</p> + +<pre class="brush: js">"The fee is " + (isMember ? "$2.00" : "$10.00") +</pre> + +<p>També es pot assignar variables depenent del resultat ternari:</p> + +<pre class="brush: js">var elvisLives = Math.PI > 4 ? "Yep" : "Nope";</pre> + +<p>És possible realitzar avaluacions ternàries múltiples (nota: L'operador condicional operator s'associa per la dreta):</p> + +<pre class="brush: js">var firstCheck = false, + secondCheck = false, + access = firstCheck ? "Access denied" : secondCheck ? "Access denied" : "Access granted"; + +console.log( access ); // logs "Access granted"</pre> + +<p>També es pot usar avaluacions ternàries en espais lliures per tal de fer diferents operacions:</p> + +<pre class="brush: js">var stop = false, age = 16; + +age > 18 ? location.assign("continue.html") : stop = true; +</pre> + +<p>També es pot fer més d'una sola operació per cas, separant-les amb una coma:</p> + +<pre class="brush: js">var stop = false, age = 23; + +age > 18 ? ( + alert("OK, you can go."), + location.assign("continue.html") +) : ( + stop = true, + alert("Sorry, you are much too young!") +); +</pre> + +<p>I per últim, també es pot fer més d'una operació durant l'assignació d'un valor. En aquest cas, <strong><em>el últim valor del parèntesis serparat per una coma</em> serà el valor assignat</strong>.</p> + +<pre class="brush: js">var age = 16; + +var url = age > 18 ? ( + alert("OK, you can go."), + // alert returns "undefined", but it will be ignored because + // isn't the last comma-separated value of the parenthesis + "continue.html" // the value to be assigned if age > 18 +) : ( + alert("You are much too young!"), + alert("Sorry :-("), + // etc. etc. + "stop.html" // the value to be assigned if !(age > 18) +); + +location.assign(url); // "stop.html"</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>1a edició deECMAScript.</td> + <td>Estàndard</td> + <td>Definició inicial. Implementat en JavaScript 1.0</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-11.12', 'The conditional operator')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-conditional-operator', 'Conditional Operator')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome per Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Statements/if...else">if statement</a></li> +</ul> diff --git a/files/ca/web/javascript/referencia/operadors/function/index.html b/files/ca/web/javascript/referencia/operadors/function/index.html new file mode 100644 index 0000000000..0908f591b6 --- /dev/null +++ b/files/ca/web/javascript/referencia/operadors/function/index.html @@ -0,0 +1,146 @@ +--- +title: function expression +slug: Web/JavaScript/Referencia/Operadors/function +translation_of: Web/JavaScript/Reference/Operators/function +--- +<div>{{jsSidebar("Operators")}}</div> + +<p>La paraula clau <strong><code>function</code></strong> es pot utilitzar per definir una funció dins d'una expressió.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox">function [<em>nom</em>]([<em>paràm1</em>[, <em>paràm2[</em>, ..., <em>paràmN</em>]]]) { + <em>sentències</em> +}</pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<dl> + <dt><code>nom</code></dt> + <dd>El nom de la funció. Es pot ometre, i en aquest cas la funció seria <em>anònima</em>. El nom és només local pel cos de la funció.</dd> + <dt><code>paràmN</code></dt> + <dd>El nom d'un argument que es passa a la funció.</dd> + <dt><code>sentències</code></dt> + <dd>Les sentències que constitueixen el cos de la funció.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Una expressió d'una funció és molt semblant i té gairebé la mateixa sintaxi que una sentència d'una funció (<a href="/en-US/docs/Web/JavaScript/Reference/Statements/function">function sentència d'una funció</a> per més detalls). La principal diferència entre l'expressió d'una funció i una sentèndia d'una expressió és el <em>nom de la functió,</em> el qual es pot ometre en expressions de funcions per tal de crear funcions <em>anònimes</em>. Una expressió d'una funció es pot utilitzar com a un <strong>IIFE </strong>(<em>Immediately Invoked Function Expression</em>) que s'executa un cop s'ha definit. Vegeu també el capítol sobre <a href="/en-US/docs/Web/JavaScript/Reference/Functions">funcions</a> per més informació.</p> + +<h2 id="Exemples">Exemples</h2> + +<p>L'exemple següent defineix una funció sense nom i l'assigna a <code>x</code>. La funció retorna el quadrat del seu argument:</p> + +<pre class="brush: js">var x = function(y) { + return y * y; +}; +</pre> + +<h3 id="Expressió_d'una_funció_amb_nom">Expressió d'una funció amb nom</h3> + +<p>Si vols fer referència a la funció actual dins del cos de la funció, necessitaràs crear una expressió d'una funció amb nom. Aquest nom és llavors només local pel cos de la funció (àmbit). AIxò també evita utilitzar la propietat no estàndard <code><a href="/en-US/docs/Web/JavaScript/Reference/Functions/arguments/callee">arguments.callee.</a></code></p> + +<pre class="brush: js">var math = { + 'factorial': function factorial(n) { + if (n <= 1) + return 1; + return n * factorial(n - 1); + } +}; +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-function-definitions', 'Function definitions')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-function-definitions', 'Function definitions')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-13', 'Function definition')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES3', '#sec-13', 'Function definition')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Definició inicial. Implementat en JavaScript 1.5.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome per Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Functions_and_function_scope", "Functions and function scope")}}</li> + <li>{{jsxref("Function")}}</li> + <li>{{jsxref("Statements/function", "function statement")}}</li> + <li>{{jsxref("Statements/function*", "function* statement")}}</li> + <li>{{jsxref("Operators/function*", "function* expression")}}</li> + <li>{{jsxref("GeneratorFunction")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/operadors/grouping/index.html b/files/ca/web/javascript/referencia/operadors/grouping/index.html new file mode 100644 index 0000000000..45e8566806 --- /dev/null +++ b/files/ca/web/javascript/referencia/operadors/grouping/index.html @@ -0,0 +1,128 @@ +--- +title: Operador d'agrupament +slug: Web/JavaScript/Referencia/Operadors/Grouping +translation_of: Web/JavaScript/Reference/Operators/Grouping +--- +<div> +<div>{{jsSidebar("Operators")}}</div> +</div> + +<h2 id="Resum">Resum</h2> + +<p>L'operador d'agrupament <code>( )</code> controla la precedència de l'avaluació en expresions.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"> ( )</pre> + +<h2 id="Descripció">Descripció</h2> + +<p>L'operador agrupament consisteix en un parell de parèntesis que embolcallen una expressió o una sub-expressió per anular la <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence">precedència d'operadors</a> normal de forma que expressions amb un nivell més baix de precedència poden ser avaluades abans d'una expressió amb més prioritat.</p> + +<h2 id="Exemples">Exemples</h2> + +<p>Primer predomina la multiplicació i la divisió, després la suma i la resta per tal d'avaluar primer la suma.</p> + +<pre class="brush:js">var a = 1; +var b = 2; +var c = 3; + +// default precedence +a + b * c // 7 +// evaluated by default like this +a + (b * c) // 7 + +// now overriding precedence +// addition before multiplication +(a + b) * c // 9 + +// which is equivalent to +a * c + b * c // 9 +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>1a edició de ECMAScript.</td> + <td>Estàndard</td> + <td>Definició inicial. Implementat en JavaScript 1.0</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-11.1.6', 'The Grouping Operator')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-grouping-operator', 'The Grouping Operator')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{ CompatibilityTable() }}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome per Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence">Precedència d'operadors</a></li> + <li>{{jsxref("Operators/delete", "delete")}}</li> + <li>{{jsxref("Operators/typeof", "typeof")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/operadors/index.html b/files/ca/web/javascript/referencia/operadors/index.html new file mode 100644 index 0000000000..4a70edc4fb --- /dev/null +++ b/files/ca/web/javascript/referencia/operadors/index.html @@ -0,0 +1,282 @@ +--- +title: Expressions and operators +slug: Web/JavaScript/Referencia/Operadors +tags: + - JavaScript + - NeedsTranslation + - Operators + - TopicStub +translation_of: Web/JavaScript/Reference/Operators +--- +<div>{{jsSidebar("Operators")}}</div> + +<p>Aquest capítol documenta totls els operadors, expressions i paraules clau del llenguatge JavaScript.</p> + +<h2 id="Expressions_i_operadors_per_categoria">Expressions i operadors per categoria</h2> + +<p>Per a un llistat en order alfabetic vegeu el menú de l'esquerra.</p> + +<h3 id="Expressions_primàries">Expressions primàries</h3> + +<p>Paraules clau bàsiques i expressions generals en JavaScript.</p> + +<dl> + <dt>{{jsxref("Operadors/this", "this")}}</dt> + <dd>La paraula clau <code>this</code> fa referència al contexte d'execució de la funció actual.</dd> + <dt>{{jsxref("Operadors/function", "function")}}</dt> + <dd>La paraula clau <code>function</code> defineix una expressió de funció.</dd> + <dt>{{experimental_inline()}} {{jsxref("Operadors/function*", "function*")}}</dt> + <dd>La paraula clau <code>function*</code> defineix una expressió de funció generadora.</dd> + <dt>{{experimental_inline()}} {{jsxref("Operadors/yield", "yield")}}</dt> + <dd>Pausa i resumeix una funció generadora.</dd> + <dt>{{experimental_inline()}} {{jsxref("Operadors/yield*", "yield*")}}</dt> + <dd>Delega a una altra funció generadora o objecte iterable.</dd> + <dt>{{jsxref("Global_Objects/Array", "[]")}}</dt> + <dd>Sintaxi d'inicialització o literal d'arrays.</dd> + <dt>{{jsxref("Operators/Object_initializer", "{}")}}</dt> + <dd>Sintaxi d'inicialitzador o literal d'objectes.</dd> + <dt>{{jsxref("Global_Objects/RegExp", "/ab+c/i")}}</dt> + <dd>Sintaxi de literals formats per expressions regulars.</dd> + <dt>{{experimental_inline()}} {{jsxref("Operadors/Array_comprehensions", "[for (x of y) x]")}}</dt> + <dd>Comprensió d'arrays.</dd> + <dt>{{experimental_inline()}} {{jsxref("Operadors/Generator_comprehensions", "(for (x of y) y)")}}</dt> + <dd>Comprensió de generators.</dd> + <dt>{{jsxref("Operadors/Grouping", "( )")}}</dt> + <dd>Operador d'agrupament.</dd> +</dl> + +<h3 id="Expressions_de_banda_esquerra">Expressions de banda esquerra</h3> + +<p>Els valors de l'esquerra són la destinació d'una assignació.</p> + +<dl> + <dt>{{jsxref("Operadors/Property_accessors", "Property accessors", "", 1)}}</dt> + <dd>Els operadors membres proporcionen accés a una propietat o mètode d'un objecte<br> + (<code>object.property</code> i <code>object["property"]</code>).</dd> + <dt>{{jsxref("Operadors/new", "new")}}</dt> + <dd>L'operador <code>new</code> crea una instància d'un constructor.</dd> + <dt>{{experimental_inline()}} {{jsxref("Operadors/super", "super")}}</dt> + <dd>La paraula clau <code>super</code> crida el constructor de l'objecte pare.</dd> + <dt>{{experimental_inline()}} {{jsxref("Operadors/Spread_operator", "...obj")}}</dt> + <dd>L'operador d'extensió permet que una expressió s'expandeixi en llocs on s'esperen mútiples argurments (per a crides de funcions) o elements (per a literals d'arrays).</dd> +</dl> + +<h3 id="Increment_i_decrement">Increment i decrement</h3> + +<p>Operadors de increment o decrement en forma de prefix/sufix.</p> + +<dl> + <dt>{{jsxref("Operadors/Arithmetic_Operators", "A++", "#Increment")}}</dt> + <dd>Operador sufix d'increment.</dd> + <dt>{{jsxref("Operadors/Arithmetic_Operators", "A--", "#Decrement")}}</dt> + <dd>Operador sufix de decrement.</dd> + <dt>{{jsxref("Operadors/Arithmetic_Operators", "++A", "#Increment")}}</dt> + <dd>Operador prefix d'increment.</dd> + <dt>{{jsxref("Operadors/Arithmetic_Operators", "--A", "#Decrement")}}</dt> + <dd>Operador prefix de decrement.</dd> +</dl> + +<h3 id="Operadors_unaris">Operadors unaris</h3> + +<p>Un operador unari és un operador que només accepta un operand.</p> + +<dl> + <dt>{{jsxref("Operadors/delete", "delete")}}</dt> + <dd>L'operador <code>delete</code> esborra una propietat d'un objecte.</dd> + <dt>{{jsxref("Operadors/void", "void")}}</dt> + <dd>L'operador <code>void</code> evalua una expressió i descarta el que retorni.</dd> + <dt>{{jsxref("Operadors/typeof", "typeof")}}</dt> + <dd>L'operador <code>typeof</code> determina el tipus d'un objecte donat.</dd> + <dt>{{jsxref("Operadors/Arithmetic_Operators", "+", "#Unary_plus")}}</dt> + <dd>L'operador unari més converteix l'operand donat al tipus Number.</dd> + <dt>{{jsxref("Operadors/Arithmetic_Operators", "-", "#Unary_negation")}}</dt> + <dd>L'operador unari negació converteix l'operand donat al tipus Number i llavors el nega.</dd> + <dt>{{jsxref("Operadors/Bitwise_Operators", "~", "#Bitwise_NOT")}}</dt> + <dd>Operador binari NOT.</dd> + <dt>{{jsxref("Operadors/Logical_Operators", "!", "#Logical_NOT")}}</dt> + <dd>Operador lògic NOT.</dd> +</dl> + +<h3 id="Operadors_aritmètics">Operadors aritmètics</h3> + +<p>Els operadors aritmètics accepten valors numèrics (ja siguin literals o variables) com a operands i retornen un únic valor numèric.</p> + +<dl> + <dt>{{jsxref("Operadors/Arithmetic_Operators", "+", "#Addition")}}</dt> + <dd>Operador de suma.</dd> + <dt>{{jsxref("Operadors/Arithmetic_Operators", "-", "#Subtraction")}}</dt> + <dd>Operador de resta.</dd> + <dt>{{jsxref("Operadors/Arithmetic_Operators", "/", "#Division")}}</dt> + <dd>Operador de divisió.</dd> + <dt>{{jsxref("Operadors/Arithmetic_Operators", "*", "#Multiplication")}}</dt> + <dd>Operador de multiplicació.</dd> + <dt>{{jsxref("Operadors/Arithmetic_Operators", "%", "#Remainder")}}</dt> + <dd>Operador de mòdul.</dd> +</dl> + +<h3 id="Operadors_relacionals">Operadors relacionals</h3> + +<p>Els operadors relacionals compara els operands donats i retorna un valor de tipus <code>Boolean</code> value basat en si la relació és certa o no.</p> + +<dl> + <dt>{{jsxref("Operadors/in", "in")}}</dt> + <dd>L'operador <code>in</code> determina si un objecte té la propietat donada.</dd> + <dt>{{jsxref("Operadors/instanceof", "instanceof")}}</dt> + <dd>L'operador <code>instanceof</code> determina si un objecte és una instància d'un altre objecte.</dd> + <dt>{{jsxref("Operadors/Comparison_Operators", "<", "#Less_than_operator")}}</dt> + <dd>Operador menor que.</dd> + <dt>{{jsxref("Operadors/Comparison_Operators", ">", "#Greater_than_operator")}}</dt> + <dd>Operador major que.</dd> + <dt>{{jsxref("Operadors/Comparison_Operators", "<=", "#Less_than_or_equal_operator")}}</dt> + <dd>Operador menor o igual que.</dd> + <dt>{{jsxref("Operadors/Comparison_Operators", ">=", "#Greater_than_or_equal_operator")}}</dt> + <dd>Operador major o igual que.</dd> +</dl> + +<h3 id="Operadors_d'igualtat">Operadors d'igualtat</h3> + +<p>El resultat d'evaluar un operador d'igualtat és sempre de tipus <code>Boolean</code> i el resultat es basa en si la comparació és certa.</p> + +<dl> + <dt>{{jsxref("Operadors/Comparison_Operators", "==", "#Equality")}}</dt> + <dd>Operador d'igulatat.</dd> + <dt>{{jsxref("Operadors/Comparison_Operators", "!=", "#Inequality")}}</dt> + <dd>Operador de no igualtat.</dd> + <dt>{{jsxref("Operadors/Comparison_Operators", "===", "#Identity")}}</dt> + <dd>Operador identitat.</dd> + <dt>{{jsxref("Operadors/Comparison_Operators", "!==", "#Nonidentity")}}</dt> + <dd>Operador de no identitat.</dd> +</dl> + +<h3 id="Operadors_de_desplaçament_de_bits">Operadors de desplaçament de bits</h3> + +<p>Operacions que desplacen tots els bits d'un operand.</p> + +<dl> + <dt>{{jsxref("Operadors/Bitwise_Operators", "<<", "#Left_shift")}}</dt> + <dd>Operador de desplaçament de bits a l'esquerra.</dd> + <dt>{{jsxref("Operadors/Bitwise_Operators", ">>", "#Right_shift")}}</dt> + <dd>Operador de desplaçament de bits a la dreta.</dd> + <dt>{{jsxref("Operadors/Bitwise_Operators", ">>>", "#Unsigned_right_shift")}}</dt> + <dd>Operador de desplaçament a la dreta sense signe.</dd> +</dl> + +<h3 id="Operadors_binaris">Operadors binaris</h3> + +<p>Els operadors binaris tracten els seus operands com un conjunt de 32 bits (uns i zeros) i retornen valors numèrics standards de JavaScript.</p> + +<dl> + <dt>{{jsxref("Operadors/Bitwise_Operators", "&", "#Bitwise_AND")}}</dt> + <dd>AND binari.</dd> + <dt>{{jsxref("Operadors/Bitwise_Operators", "|", "#Bitwise_OR")}}</dt> + <dd>OR binari.</dd> + <dt>{{jsxref("Operadors/Bitwise_Operators", "^", "#Bitwise_XOR")}}</dt> + <dd>XOR binari.</dd> +</dl> + +<h3 id="Operadors_lògics">Operadors lògics</h3> + +<p>Els operadors lògics típicament s'utilitzen amb valors booleans (és a dir, logics) i retornen un valor booleà.</p> + +<dl> + <dt>{{jsxref("Operadors/Logical_Operators", "&&", "#Logical_AND")}}</dt> + <dd>AND lògic.</dd> + <dt>{{jsxref("Operadors/Logical_Operators", "||", "#Logical_OR")}}</dt> + <dd>OR lògic.</dd> +</dl> + +<h3 id="Operador_condicional_(ternari)">Operador condicional (ternari)</h3> + +<dl> + <dt>{{jsxref("Operadors/Conditional_Operator", "(condition ? ifTrue : ifFalse)")}}</dt> + <dd> + <p>L'operador condicional retorna un dels dos valors basat en l'evaluació lògica de la condició.</p> + </dd> +</dl> + +<h3 id="Operadors_d'assignació">Operadors d'assignació</h3> + +<p>Els operadors d'assignació asignen un valor a l'operand de l'esquerra basant-se en l'evaluació de l'operand de la dreta.</p> + +<dl> + <dt>{{jsxref("Operadors/Assignment_Operators", "=", "#Assignment")}}</dt> + <dd>Operador d'assignació.</dd> + <dt>{{jsxref("Operadors/Assignment_Operators", "*=", "#Multiplication_assignment")}}</dt> + <dd>Assignació de la multiplicació.</dd> + <dt>{{jsxref("Operadors/Assignment_Operators", "/=", "#Division_assignment")}}</dt> + <dd>Assignació de la divisó.</dd> + <dt>{{jsxref("Operadors/Assignment_Operators", "%=", "#Remainder_assignment")}}</dt> + <dd>Assignació del mòdul.</dd> + <dt>{{jsxref("Operadors/Assignment_Operators", "+=", "#Addition_assignment")}}</dt> + <dd>Assignació de la suma.</dd> + <dt>{{jsxref("Operadors/Assignment_Operators", "-=", "#Subtraction_assignment")}}</dt> + <dd>Assignació de la resta.</dd> + <dt>{{jsxref("Operadors/Assignment_Operators", "<<=", "#Left_shift_assignment")}}</dt> + <dd>Assignació del desplaçament a l'esquerra.</dd> + <dt>{{jsxref("Operadors/Assignment_Operators", ">>=", "#Right_shift_assignment")}}</dt> + <dd>Assignació del desplaçament a la dreta.</dd> + <dt>{{jsxref("Operadors/Assignment_Operators", ">>>=", "#Unsigned_right_shift_assignment")}}</dt> + <dd>Assignació del desplaçament a la dreta sense signe.</dd> + <dt>{{jsxref("Operadors/Assignment_Operators", "&=", "#Bitwise_AND_assignment")}}</dt> + <dd>Assignació de l'AND binari.</dd> + <dt>{{jsxref("Operadors/Assignment_Operators", "^=", "#Bitwise_XOR_assignment")}}</dt> + <dd>Assignació del XOR binari.</dd> + <dt>{{jsxref("Operadors/Assignment_Operators", "|=", "#Bitwise_OR_assignment")}}</dt> + <dd>Assignació de l'OR binari.</dd> + <dt>{{experimental_inline()}} {{jsxref("Operadors/Destructuring_assignment", "[a, b] = [1, 2]")}}<br> + {{experimental_inline()}} {{jsxref("Operadors/Destructuring_assignment", "{a, b} = {a:1, b:2}")}}</dt> + <dd> + <p>L'assignació de desestructuració permet assignar les propietats d'un array o objecte a variables utilitzant una sintaxi que recorda la de literals d'arrays o objectes.</p> + </dd> +</dl> + +<h3 id="Operador_coma">Operador coma</h3> + +<dl> + <dt>{{jsxref("Operadors/Comma_Operator", ",")}}</dt> + <dd>L'operador coma permet que múltiples expressions siguin evaluades en una sola sentència i retorna el resultat de l'última expressió.</dd> +</dl> + +<h3 id="Característiques_no_standard">Característiques no standard</h3> + +<dl> + <dt>{{non-standard_inline}} {{jsxref("Operadors/Legacy_generator_function", "Legacy generator function", "", 1)}}</dt> + <dd>La paraula clau <code>function</code> es pot emprar per a definir una funció generadora obsoleta dins una expressió. Per a crear una funció generadora obsoleta el cos de la funció ha de contindre al menys una expressió {{jsxref("Operators/yield", "yield")}}.</dd> + <dt>{{non-standard_inline}} {{jsxref("Operadors/Expression_closures", "Expression closures", "", 1)}}</dt> + <dd>La sintaxi d'expressions closure és una abreviació per a escriure funcions simples.</dd> +</dl> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>ECMAScript 1a Edició.</td> + <td>Standard</td> + <td>Definició inicial.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-11', 'Expressions')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-ecmascript-language-expressions', 'Llenguatge ECMAScript: Expressions')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> + <p>Nou: L'operador d'extensió, l'assignació de desestructuració, la paraula clau <code>super</code>, la comprensió d'arrays i la comprensió de generadors</p> + </td> + </tr> + </tbody> +</table> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence">Precendència d'operadors</a></li> +</ul> diff --git a/files/ca/web/javascript/referencia/operadors/logical_operators/index.html b/files/ca/web/javascript/referencia/operadors/logical_operators/index.html new file mode 100644 index 0000000000..d8ef9e99c1 --- /dev/null +++ b/files/ca/web/javascript/referencia/operadors/logical_operators/index.html @@ -0,0 +1,301 @@ +--- +title: Operadors Lògics +slug: Web/JavaScript/Referencia/Operadors/Logical_Operators +translation_of: Web/JavaScript/Reference/Operators +--- +<div> +<div>{{jsSidebar("Operators")}}</div> +</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>Els operadors lògics s'utilitzen normalment amb valors <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean">Boolean</a></code> (lògics). En cas de serh-hi presents, retornen un valor booleà. Tot i així, els operadors <code>&&</code> i <code>||</code> retornen el valor d'un dels operands especificats, així que si aquests operadors es fan servir amb valors no booleans, poden retornar un valor no booleà.</p> + +<h2 id="Descripció">Descripció</h2> + +<p>Els operadors lògics es descriuren en la taula següent:</p> + +<table class="fullwidth-table"> + <tbody> + <tr> + <th>Operador</th> + <th>Ús</th> + <th>Descripció</th> + </tr> + <tr> + <td>AND lògic (<code>&&</code>)</td> + <td><code><em>expr1</em> && <em>expr2</em></code></td> + <td>Retorna <code>expr1 </code>si es pot convertir en false; sinó, retorna expr2. Així, quan es fa servir amb valors booleans, <code>&&</code> retorna true si ambdós operands són true; de ser el contrari, retorna false.</td> + </tr> + <tr> + <td>OR lògic(<code>||</code>)</td> + <td><code><em>expr1</em> || <em>expr2</em></code></td> + <td>Retorna <code>expr1</code> si es pot converir en true; de ser al contrari, retorna <code>expr2</code>. Així, quan s'usa amb valors Booleans, <code>||</code> retorna true si l'operand és true; si amdós són false, retorna false.</td> + </tr> + <tr> + <td>NOT lògic (<code>!</code>)</td> + <td><code>!<em>expr</em></code></td> + <td>Retorna false si el seu únic operand pot convertir-se a true; sinó, retorna true.</td> + </tr> + </tbody> +</table> + +<p>Exemples d'expressions que es poden converir a false son aquelles que avaluen <code>null</code>, <code>0</code>, la cadena buida (""), o <code>undefined</code>.</p> + +<p>Tot i que els operadors <code>&&</code> i <code>||</code> es poden fer servir amb operands que no siguin valors Booleans, poden ser considerats operadors Booleans ja que els valors que retornen sempre es poden convertir en valors Booleans.</p> + +<h3 id="Short-Circuit_Evaluation" name="Short-Circuit_Evaluation">Avaluació de tipus curtcircuit</h3> + +<p>Com a expressions lògiques que són, s'avaluen d'esquerra a dreta, they are tested for possible "short-circuit" evaluation fent servir les regles següents:</p> + +<ul> + <li><code>false && (<em>quelcom)</em></code> is short-circuit evaluated to false.</li> + <li><code>true || (<em>quelcom)</em></code> is short-circuit evaluated to true.</li> +</ul> + +<p>Les regles de la lògica garanteixen que aquestes avaluacions són sempre correctes. Fixeu-vos que la part <code><em>quelcom</em></code> d'adalt no s'avalua, així que els efectes secundaris d'això no tindràn efecte. Fixeu-vos també que la part de l'expressió de dalt anomenada <code><em>quelcom </em></code>és una expressió lògica simple (com s'indiquen amb els parèntesis).</p> + +<p>Per exemple, les dues funcions següents són equivalents.</p> + +<pre class="brush: js">function shortCircuitEvaluation() { + doSomething() || doSomethingElse() +} + +function equivalentEvaluation() { + var flag = doSomething(); + if (!flag) { + doSomethingElse(); + } +} +</pre> + +<p>Tot i així, les següents expressions no són equivalents degut a la <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence">precendència dels operadors</a>, i remarca la importància de requerir que l'operador de la dreta sigui una sola expressió (agrupada, si s'escau, per parèntesi).</p> + +<pre class="brush: js">false && true || true // returns true +false && (true || true) // returns false</pre> + +<h3 id="Logical_AND_.28&&.29" name="Logical_AND_.28&&.29"><a name="Logical_AND">AND lògic (<code>&&</code>)</a></h3> + +<p>El codi següent mostra exemples de l'operador <code>&&</code> (AND lògic).</p> + +<pre class="brush: js">a1 = true && true // t && t returns true +a2 = true && false // t && f returns false +a3 = false && true // f && t returns false +a4 = false && (3 == 4) // f && f returns false +a5 = "Cat" && "Dog" // t && t returns "Dog" +a6 = false && "Cat" // f && t returns false +a7 = "Cat" && false // t && f returns false +</pre> + +<h3 id="OR_lògic_()"><a name="Logical_OR">OR lògic (<code>||</code>)</a></h3> + +<p>El codi següent mostra exemples de l'operador <code>||</code> (OR lògic).</p> + +<pre class="brush: js">o1 = true || true // t || t returns true +o2 = false || true // f || t returns true +o3 = true || false // t || f returns true +o4 = false || (3 == 4) // f || f returns false +o5 = "Cat" || "Dog" // t || t returns "Cat" +o6 = false || "Cat" // f || t returns "Cat" +o7 = "Cat" || false // t || f returns "Cat" +</pre> + +<h3 id="Logical_NOT_.28.21.29" name="Logical_NOT_.28.21.29"><a name="Logical_NOT">NOT lògic (<code>!</code>)</a></h3> + +<p>El codi següent mostra exemples de l'operador <code>!</code> (NOT lògic).</p> + +<pre class="brush: js">n1 = !true // !t returns false +n2 = !false // !f returns true +n3 = !"Cat" // !t returns false +</pre> + +<h3 id="Regles_de_conversió">Regles de conversió</h3> + +<h4 id="Convertir_AND_a_OR">Convertir AND a OR</h4> + +<p>L'operació següent que inclou Booleans:</p> + +<pre class="brush: js">bCondition1 && bCondition2</pre> + +<p>sempre és igual a:</p> + +<pre class="brush: js">!(!bCondition1 || !bCondition2)</pre> + +<h4 id="Convertir_OR_a_AND">Convertir OR a AND</h4> + +<p>L'operació següent que inclou Booleans:</p> + +<pre class="brush: js">bCondition1 || bCondition2</pre> + +<p>sempre és igual a:</p> + +<pre class="brush: js">!(!bCondition1 && !bCondition2)</pre> + +<h3 id="Desfer-se_de_parèntesis_aniuats">Desfer-se de parèntesis aniuats</h3> + +<p>Com que les expressions lògiques s'avaluen d'esquerra a dreta, sempre és posible esborrar els parèntesi d'expressions complexes mitjançant les regles següents.</p> + +<h4 id="Desfer-se_d'un_AND_aniuat">Desfer-se d'un AND aniuat</h4> + +<p>L'operació següent que inclou Booleans:</p> + +<pre class="brush: js">bCondition1 || (bCondition2 && bCondition3)</pre> + +<p>sempre és igual a:</p> + +<pre class="brush: js">bCondition1 || bCondition2 && bCondition3</pre> + +<h4 id="Desfer-se_d'un_OR_aniuat">Desfer-se d'un OR aniuat</h4> + +<p>L'operació següent que inclou Booleans:</p> + +<pre class="brush: js">bCondition1 && (bCondition2 || bCondition3)</pre> + +<p>sempre és igual a:</p> + +<pre class="brush: js">!(!bCondition1 || !bCondition2 && !bCondition3)</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentari</th> + </tr> + <tr> + <td>1a edició de ECMAScript.</td> + <td>Estàndard</td> + <td>Definició inicial.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-11.4.9', 'Logical NOT Operator')}}<br> + {{SpecName('ES5.1', '#sec-11.11', 'Binary Logical Operators')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-logical-not-operator', 'Logical NOT operator')}}<br> + {{SpecName('ES6', '#sec-binary-logical-operators', 'Binary Logical Operators')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{ CompatibilityTable() }}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td><a href="#Logical_AND">AND lògic (<code>&&</code>)</a></td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + <tr> + <td><a href="#Logical_OR">OR </a><a href="#Logical_AND">lògic </a><a href="#Logical_OR">(<code>||</code>)</a></td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + <tr> + <td><a href="#Logical_NOT">NOT </a><a href="#Logical_AND">lògic</a><a href="#Logical_NOT"> (<code>!</code>)</a></td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome per Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td><a href="#Logical_AND">AND </a><a href="#Logical_AND">lògic</a><a href="#Logical_AND"> (<code>&&</code>)</a></td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + <tr> + <td><a href="#Logical_OR">OR </a><a href="#Logical_AND">lògic </a><a href="#Logical_OR">(<code>||</code>)</a></td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + <tr> + <td><a href="#Logical_NOT">NOT </a><a href="#Logical_AND">lògic</a><a href="#Logical_NOT"> (<code>!</code>)</a></td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + </tbody> +</table> +</div> + +<h3 id="JavaScript_1.0_and_1.1" name="JavaScript_1.0_and_1.1">Compatibilitat amb versions anteriors: Comportament a JavaScript 1.0 i 1.1</h3> + +<p>Els operadors && i <code>||</code> es comporten de la forma següent:</p> + +<table class="fullwidth-table"> + <tbody> + <tr> + <th>Operador</th> + <th>Ús</th> + <th>Comportament</th> + </tr> + <tr> + <td><code>&&</code></td> + <td><code><em>expr1</em> && <em>expr2</em></code></td> + <td>Si el primer operand (<code>expr1</code>) es pot converitr a false, l'operador <code>&&</code> retorna false en comptes del valor de <code>expr1</code>.</td> + </tr> + <tr> + <td><code>||</code></td> + <td><code><em>expr1</em> || <em>expr2</em></code></td> + <td>Si el primer operand (<code>expr1</code>) es pot converitr a true, l'operador <code>||</code> retorna true en comptes del valor de <code>expr1</code>.</td> + </tr> + </tbody> +</table> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators">Bitwise operators</a></li> +</ul> diff --git a/files/ca/web/javascript/referencia/operadors/operador_coma/index.html b/files/ca/web/javascript/referencia/operadors/operador_coma/index.html new file mode 100644 index 0000000000..f6a62d2bc8 --- /dev/null +++ b/files/ca/web/javascript/referencia/operadors/operador_coma/index.html @@ -0,0 +1,129 @@ +--- +title: Operador Coma +slug: Web/JavaScript/Referencia/Operadors/Operador_Coma +translation_of: Web/JavaScript/Reference/Operators/Comma_Operator +--- +<div> +<div>{{jsSidebar("Operators")}}</div> +</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p><span class="seoSummary"><strong>L'operador <em>coma</em></strong> avalua cadascun dels seus operands (d'esquerra a dreta) i retorna el valor de l´últim operand.</span></p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><em>expr1</em>, <em>expr2, expr3...</em></pre> + +<h2 id="Paràmetres">Paràmetres</h2> + +<dl> + <dt><code>expr1</code>, <code>expr2, expr3...</code></dt> + <dd>Qualsevol expressions.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Es pot fer servir l'operador coma quan es vulgui incloure múltiples expressions en una localització que requereix una sola expressió. L'ús més freqüent que es fa d'aquest operador es per subministrar múltiples paràmetres en una <code>for</code> loop.</p> + +<h2 id="Exemple">Exemple</h2> + +<p>Si <code>a</code> és un array de 2 dimesnions amb 10 elements on a side, el codi següent usa l'operador coma per incrementar dos variables al mateix temps. Vegeu que la coma en la sentència <code>var</code> <em><strong>no </strong></em> és l'operador coma, ja que no existeix dins d'una expressió. Més aviat, és un caràcter especial en les sentències <code>var</code> que combina múltiples d'ells en un. Pràcticament, la coma es comporta quasi igual que l'operador coma. El codi imprimeix els valors dels elements de la diagonal de l'array:</p> + +<pre class="brush:js;highlight:[1]">for (var i = 0, j = 9; i <= 9; i++, j--) + document.writeln("a[" + i + "][" + j + "] = " + a[i][j]);</pre> + +<h3 id="Processar_i_després_retornar">Processar i després retornar</h3> + +<p>Un altre exemple sobre l'ús que es pot fer sobre l'operador coma és processar abansd e retornar. Com s'indica, només l'últim element serà retornat, però tots els altres també seràn avaluats. Així doncs, es podria fer:</p> + +<pre>function myFunc () { + var x = 0; + + return (x += 1, x); // the same of return ++x; +}</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentari</th> + </tr> + <tr> + <td>ECMAScript 1st Edition.</td> + <td>Estàndard</td> + <td>Definició inicial.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-11.14', 'Comma operator')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-comma-operator', 'Comma operator')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{ CompatibilityTable() }}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>Sí</td> + <td>Sí</td> + <td>3.0</td> + <td>Sí</td> + <td>Sí</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome per Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>Sí</td> + <td>Sí</td> + <td>Sí</td> + <td>Sí</td> + <td>Sí</td> + <td>Sí</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Statements/for">for loop</a></li> +</ul> diff --git a/files/ca/web/javascript/referencia/operadors/super/index.html b/files/ca/web/javascript/referencia/operadors/super/index.html new file mode 100644 index 0000000000..c19e58cba1 --- /dev/null +++ b/files/ca/web/javascript/referencia/operadors/super/index.html @@ -0,0 +1,119 @@ +--- +title: super +slug: Web/JavaScript/Referencia/Operadors/super +translation_of: Web/JavaScript/Reference/Operators/super +--- +<div>{{jsSidebar("Operators")}}</div> + +<h2 id="Resum">Resum</h2> + +<p>La paraula clau <strong>super</strong> s'utilitza per cridar funcions del pare de l'objecte.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox">super([arguments]); // crida el constructor del pare. +super.functionOnParent([arguments]); +</pre> + +<h2 id="Descripció">Descripció</h2> + +<p>Quan s'utilitza en un constructor, la paraula clau <code>super</code> apareix sola i s'ha d'utilitzar abans de la paraula clau <code>this</code>. Aquesta paraula clau també es pot utilitzar per cridar funcions en un objecte pare.</p> + +<h2 id="Exemple">Exemple</h2> + +<p>Aquest fragment de codi es pren de la mostra de classes <a href="https://github.com/GoogleChrome/samples/blob/gh-pages/classes-es6/index.html">mostra de classes</a> (<a href="https://googlechrome.github.io/samples/classes-es6/index.html">demostració en viu</a>).</p> + +<pre class="brush: js">class Square extends Polygon { + constructor(length) { + // Aquí es crida el constructor del pare de la classe amb les longituds + // proveïdes per l'alçada i l'amplada del polígon + super(length, length); + // Nota: En classes derivades, s'ha de cridar super() abans de poder + // utilitzar 'this'. Obviar això causarà un error de referència. + this.name = 'Square'; + } + + get area() { + return this.height * this.width; + } + + set area(value) { + this.area = value; + } +}</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-super-keyword', 'super')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definició inicial.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatChrome(42.0)}}</td> + <td>{{CompatNo}}<br> + {{bug(1066239)}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile">Safari Mobile +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome per Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatChrome(42.0)}}</td> + <td>{{CompatNo}}<br> + {{bug(1066239)}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Classes">Classes</a></li> +</ul> diff --git a/files/ca/web/javascript/referencia/operadors/typeof/index.html b/files/ca/web/javascript/referencia/operadors/typeof/index.html new file mode 100644 index 0000000000..a7407e79ce --- /dev/null +++ b/files/ca/web/javascript/referencia/operadors/typeof/index.html @@ -0,0 +1,240 @@ +--- +title: typeof +slug: Web/JavaScript/Referencia/Operadors/typeof +translation_of: Web/JavaScript/Reference/Operators/typeof +--- +<div> +<div>{{jsSidebar("Operators")}}</div> +</div> + +<h2 id="Resum">Resum</h2> + +<p>L'operador <code>typeof</code> retorna una cadena de caràcters que representa el tipus de l'operand, que en cap cas és evaluat.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<p>L'operador <code>typeof</code> va seguit del seu operand:</p> + +<pre class="syntaxbox"><code>typeof <code><em>operand</em></code></code></pre> + +<h3 id="Paràmetres">Paràmetres</h3> + +<p><code><em>operand</em></code> és una expressió que representa l'objecte o {{Glossary("Primitive", "primitive")}} del qual es retornarà el tipus.</p> + +<h2 id="Descripció">Descripció</h2> + +<p>La taula següent resumeix els possibles valor de<code> typeof</code>. Per més informació sobre tipus i tipus primitius, vegeu també la pàgina de <a href="/en-US/docs/Web/JavaScript/Data_structures">JavaScript data structure</a>.</p> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Tipus</th> + <th scope="col">Resultat</th> + </tr> + </thead> + <tbody> + <tr> + <td>Undefined</td> + <td><code>"undefined"</code></td> + </tr> + <tr> + <td>Null</td> + <td><code>"object" </code>(vegeu a sota)</td> + </tr> + <tr> + <td>Boolean</td> + <td><code>"boolean"</code></td> + </tr> + <tr> + <td>Number</td> + <td><code>"number"</code></td> + </tr> + <tr> + <td>String</td> + <td><code>"string"</code></td> + </tr> + <tr> + <td>Symbol (nou a l'ECMAScript 6)</td> + <td><code>"symbol"</code></td> + </tr> + <tr> + <td>Host object (proporcionat per l'entorn JS)</td> + <td><em>Depenent de l'implementació</em></td> + </tr> + <tr> + <td>Objecte Funció (implements [[Call]] in ECMA-262 terms)</td> + <td><code>"function"</code></td> + </tr> + <tr> + <td>Qualsevol altre objecte</td> + <td><code>"object"</code></td> + </tr> + </tbody> +</table> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Casos_normals">Casos normals</h3> + +<pre class="brush:js">// Numbers +typeof 37 === 'number'; +typeof 3.14 === 'number'; +typeof Math.LN2 === 'number'; +typeof Infinity === 'number'; +typeof NaN === 'number'; // A pesar de ser un "Not-A-Number" +typeof Number(1) === 'number'; // però no l'utilitzeu mai així! + + +// Strings +typeof "" === 'string'; +typeof "bla" === 'string'; +typeof (typeof 1) === 'string'; // typeof sempre retorna una string +typeof String("abc") === 'string'; // però no l'utilitzeu mai així! + + +// Booleans +typeof true === 'boolean'; +typeof false === 'boolean'; +typeof Boolean(true) === 'boolean'; // però no l'utilitzeu mai així! + + +// Symbols +typeof Symbol() === 'symbol' +typeof Symbol('foo') === 'symbol' +typeof Symbol.iterator === 'symbol' + + +// Undefined +typeof undefined === 'undefined'; +typeof blabla === 'undefined'; // una variable no definida + + +// Objects +typeof {a:1} === 'object'; + +// utilitzeu <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/isArray" title="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/isArray">Array.isArray</a> o bé Object.prototype.toString.call +// per a diferenciar objectes normals d'arrays +typeof [1, 2, 4] === 'object'; + +typeof new Date() === 'object'; + + +// Els següents exemples són confusos, no els utilitzeu! +typeof new Boolean(true) === 'object'; +typeof new Number(1) === 'object'; +typeof new String("abc") === 'object'; + + +// Funcions +typeof function(){} === 'function'; +typeof Math.sin === 'function'; +</pre> + +<h3 id="null"><code>null</code></h3> + +<pre class="brush:js">// Això es manté així des de l'inici de JavaScript +typeof null === 'object'; +</pre> + +<p>A la primera implementació de JavaScript, els valors de JavaScript es representaven com a una etiqueta de tipus i un valor. L'etiqueta de tipus per objectes era 0. <code>null</code> era representat amb el punter NULL (0x00 a la majoria de plataformes). D'aquesta manera null tenia 0 com a etiqueta de tipus, i això és el que determina que <code>typeof</code> retorni 'object' per a <code>null</code>. (<a href="http://www.2ality.com/2013/10/typeof-null.html">referència</a>)</p> + +<p>Es va proposar una esmena per a canviar aquest comportament per l'ECMAScript (via una <em>opt-in</em>), però aquesta <a class="external" href="http://wiki.ecmascript.org/doku.php?id=harmony:typeof_null">va ser rebutjada</a>. El resultat hagués estat <code>typeof null === 'null'</code>.</p> + +<h3 id="Expressions_regulars">Expressions regulars</h3> + +<p>Expressions regulars que poden ser cridades van ser un afegit no standard en alguns navegadors web.</p> + +<pre class="brush:js">typeof /s/ === 'function'; // Chrome 1-12 No cumpleix l'standard ECMAScript 5.1 +typeof /s/ === 'object'; // Firefox 5+ D'acord amb ECMAScript 5.1 +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentari</th> + </tr> + <tr> + <td>1a edició ECMAScript.</td> + <td>Estàndard</td> + <td>Definició inicial. Implementat en JavaScript 1.1</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-11.4.3', 'The typeof Operator')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-typeof-operator', 'The typeof Operator')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{ CompatibilityTable() }}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome per Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + </tbody> +</table> +</div> + +<h3 id="Els_objects_host_a_Internet_Explorer_són_objectes_en_comptes_de_funcions">Els objects host a Internet Explorer són objectes en comptes de funcions</h3> + +<p>A IE 6, 7, i 8 molts dels host objects són objectes i no funcions. Per exemple:</p> + +<pre class="brush: js">typeof alert === 'object'</pre> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li><code><a href="/en-US/docs/Web/JavaScript/Reference/Operators/instanceof" title="/en-US/docs/JavaScript/Reference/Operators/instanceof">instanceof</a></code></li> +</ul> diff --git a/files/ca/web/javascript/referencia/operadors/void/index.html b/files/ca/web/javascript/referencia/operadors/void/index.html new file mode 100644 index 0000000000..ddf98ebfd9 --- /dev/null +++ b/files/ca/web/javascript/referencia/operadors/void/index.html @@ -0,0 +1,138 @@ +--- +title: L'operador void +slug: Web/JavaScript/Referencia/Operadors/void +translation_of: Web/JavaScript/Reference/Operators/void +--- +<div>{{jsSidebar("Operators")}}</div> + +<h2 id="Resum">Resum</h2> + +<p>L'operador <code>void</code> evalua l'<code><em>expressió</em></code> donada i retorna <code>undefined</code>.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox">void <em>expressió</em></pre> + +<h2 id="Descripció">Descripció</h2> + +<p>Aquest operador permet inserir expressions que produeixen efectes secundaris en llocs on es vol una expressió que s'evalui a <code>undefined</code>.</p> + +<p>L'operador <code>void</code> tot sovint s'utilitza simplement per a obtenir el valor primitiu<code> undefined</code>, normalment usant "<code>void(0)</code>" (que és equivalent a "<code>void 0</code>"). En aquests casos es pot utilitzar la variable global <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined" title="/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined"><code>undefined</code></a> en comptes de l'operador <code>void</code> (asumint que no ha sigut assignada a un valor no standard).</p> + +<h2 id="Expressions_de_funció_invocades_de_forma_immediata">Expressions de funció invocades de forma immediata</h2> + +<p>A l'utilitzar una <a href="/en-US/docs/Glossary/IIFE">expressió de funció invocada de forma immediata</a>, es pot usar <code>void</code> per a forçar que la paraula clau <code>function</code> sigui tractada com a una expressió en comptes d'una declaració.</p> + +<pre class="brush: js">void function iife() { + var bar = function () {}; + var baz = function () {}; + var foo = function () { + bar(); + baz(); + }; + var biz = function () {}; + + foo(); + biz(); +}(); +</pre> + +<h2 id="URIs_de_JavaScript">URIs de JavaScript</h2> + +<p>Quan un navegador segueix una URI de l'estil <code>javascript:</code> , aquest evalua el codi que hi ha a la URI i llavors reemplaça el contingut de la pàgina amb el valor retornat, a no ser que el valor retornat sigui <code>undefined</code>. L'operador<code> void</code> pot ser emprat en aquest case per a retornar <code>undefined</code>. Per exemple:</p> + +<pre class="brush: html"><a href="javascript:void(0);"> + Cliqueu aquí per a no fer res +</a> + +<a href="javascript:void(document.body.style.backgroundColor='green');"> + Clique aquí per a un fons de color verd +</a> +</pre> + +<p>Tingueu en compte, però, que el pseudo protocol <code>javascript:</code> no és recomanat ja que existeixen alternatives, com ara manegadors d'events no obtrusius.</p> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>ECMAScript 1a Edició.</td> + <td>Standard</td> + <td>Definició inicial. Implementat al JavaScript 1.1</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-11.4.2', 'The void Operator')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-void-operator', 'The void Operator')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{ CompatibilityTable() }}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li><code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined">undefined</a></code></li> +</ul> diff --git a/files/ca/web/javascript/referencia/operadors/yield/index.html b/files/ca/web/javascript/referencia/operadors/yield/index.html new file mode 100644 index 0000000000..d01f641767 --- /dev/null +++ b/files/ca/web/javascript/referencia/operadors/yield/index.html @@ -0,0 +1,152 @@ +--- +title: yield +slug: Web/JavaScript/Referencia/Operadors/yield +translation_of: Web/JavaScript/Reference/Operators/yield +--- +<div>{{jsSidebar("Operators")}}</div> + +<h2 id="Resum">Resum</h2> + +<p>La paraula clau <code>yield</code> s'utilitza per a pausar i reprendre una funció generadora ({{jsxref("Statements/function*", "function*")}} o bé una <a href="/en-US/docs/Web/JavaScript/Reference/Statements/Legacy_generator_function">funció generadora obsoleta</a>).</p> + +<h2 id="Syntax" name="Syntax">Sintaxi</h2> + +<pre class="syntaxbox language-html"> yield [[expressió]];</pre> + +<dl> + <dt><code>expressió</code></dt> + <dd>La expresssió a retornar. Si s'omet es retorna <code>undefined</code>.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>La paraula clau <code>yield</code> causa que l'execució d'una funció generadora es pausi i retorni el valor de l'expressió que la segueix. La paraula clau <code>yield</code> es pot entendre com una versió de la paraula clau <code>return</code> per a generadors.</p> + +<p>La paraula clau <code>yield</code> retorna en realitat un objecte de tipus <code>IteratorResult</code> amb dues propietats: <code>value</code> i <code>done</code>. La propietat <code>value</code> és el resultat d'evaluar l'expresssió que segueix <code>yield</code> mentre que la propietat <code>done</code> és de tipus booleà i indica si la funció generadora ha completat la seva execució o no.</p> + +<p>Un cop pausada mitjançant una expressió <code>yield</code>, l'execució de codi del generador no es reprendrà a no ser que s'invoqui externament mitjançant la crida a la funció <code>next()</code> del generador. Això permet un control directe de l'execució del generador i valors de retorn incrementals.</p> + +<h2 id="Exemples">Exemples</h2> + +<p>El següent codi és un exemple de la declaració d'una funció generadora al llarg d'una funció d'ajut.</p> + +<pre class="brush: js">function* foo(){ + var index = 0; + while (index <= 2) // quan index arriba a 3, + // la propietat done del yield serà true + // i el seu valor serà undefined; + yield index++; +}</pre> + +<p>Un cop la funció generadora és definida es pot utilitzar tot construïnt un iterador tal i com es mostra a continuació:</p> + +<pre class="brush: js">var iterator = foo(); +console.log(iterator.next()); // { value:0, done:false } +console.log(iterator.next()); // { value:1, done:false } +console.log(iterator.next()); // { value:2, done:false } +console.log(iterator.next()); // { value:undefined, done:true }</pre> + +<h2 id="Specifications" name="Specifications">Especificacions</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ES6', '#', 'Yield')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definició inicial</td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility" name="Browser_compatibility">Compatibilitat amb navegadors</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari (WebKit)</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>39</td> + <td>{{CompatGeckoDesktop("26.0")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + <tr> + <td>Objecte<code> IteratorResult</code> en comptes de <code>throwing</code></td> + <td>{{CompatUnknown}}</td> + <td>{{CompatGeckoDesktop("29.0")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>yes (when?)</td> + <td>{{CompatGeckoMobile("26.0")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{ CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + <tr> + <td>Objecte<code> IteratorResult</code> en comptes de <code>throwing</code></td> + <td>{{CompatUnknown}}</td> + <td>{{CompatGeckoMobile("29.0")}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h3 id="Notes_específiques_per_a_Firefox">Notes específiques per a Firefox</h3> + +<ul> + <li>A partir de Gecko 29 {{geckoRelease(29)}} la funció generadora, un cop completada, no llença un {{jsxref("TypeError")}} "generator has already finished" sino que retorna un objecte de tipus <code>IteratorResult</code> com per exemple<code> { value: undefined, done: true }</code> ({{bug(958951)}}).</li> + <li>A partir de Gecko 33 {{geckoRelease(33)}} l'anàlisi de l'expressió que segueix al yield s'ha actualitzat per a satisfer l'especificació de ES6 ({{bug(981599)}}): + <ul> + <li>L'expressió que segueix la paraula clau yield és opcional i si s'omet ja no es llença SyntaxError: <code>function* foo() { yield; }</code></li> + </ul> + </li> +</ul> + +<h2 id="See_also" name="See_also">Vegeu tambè</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Guide/The_Iterator_protocol">El protocol dels iteradors</a></li> + <li>{{jsxref("Statements/function*", "function*")}}</li> + <li>{{jsxref("Operators/function*", "function* expression")}}</li> + <li>{{jsxref("Operators/yield*", "yield*")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/sentencies/block/index.html b/files/ca/web/javascript/referencia/sentencies/block/index.html new file mode 100644 index 0000000000..cfa5d7fd20 --- /dev/null +++ b/files/ca/web/javascript/referencia/sentencies/block/index.html @@ -0,0 +1,138 @@ +--- +title: block +slug: Web/JavaScript/Referencia/Sentencies/block +translation_of: Web/JavaScript/Reference/Statements/block +--- +<div> +<div>{{jsSidebar("Statements")}}</div> +</div> + +<h2 id="Resum">Resum</h2> + +<p>Una<strong> sentència bloc</strong> (o <strong>sentència composta</strong> en altres llengües) s'usa per agrupar zero o més sentències. El bloc està delimitat per un parell de claus.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox">{ + <var>sentència_1</var>; + <var>sentència_2;</var> + ... + <var>sentència_n;</var> +} +</pre> + +<dl> + <dt><code>statement_1</code>, <code>statement_2</code>, <code>statement_n</code></dt> + <dd>Sentències agrupades dins la sentència block.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Aquesta sentència s'utilitza normalment amb les sentències de control de flux (p.ex. <code>if</code>, <code>for</code>, <code>while</code>). Per exemple:</p> + +<pre class="brush: js">while (x < 10) { + x++; +} +</pre> + +<p>Tingueu en compte que la sentència block no acaba amb un punt i coma.</p> + +<p>La sentència bloc sovint s'anomena <strong>sentència composta</strong> en altres llengües. Aquesta sentència permet usar múltiples sentències allà on JavaScript espera només una única sentència. Combinar sentències en blocs és una pràctica comuna en JavaScript. El comportament oposat és possible fent servir una <a href="/en-US/docs/Web/JavaScript/Reference/Statements/Empty">sentència buida</a>, on no es proporciona cap declaració, encara que es requereixi una.</p> + +<h3 id="Fora_de_l'àmbit_del_bloc">Fora de l'àmbit del bloc</h3> + +<p><strong>Important</strong>: Les variables declarades amb <code>var</code> no tenen àmbit de bloc. Les variables introduïdes amb un bloc estàn en l'àmbit de la funció o l'script que els conté, i els efectes d'establir-los persisteixen més enllà del mateix bloc. En altres paraules, les sentències de bloc no introdueixen un àmbit. Encara que els blocs "independents" són sintàcticament vàlids, no és desitjable usar-los en JavaScript, ja que no fan el que pensem que fan, en el cas que penseu que fan alguna cosa semblant als blocs en C o Java. Per exemple:</p> + +<pre class="brush: js">var x = 1; +{ + var x = 2; +} +console.log(x); // logs 2 +</pre> + +<p>Això registra 2 ja que la sentència <code>var x</code> dins el bloc es troba en el mateix àmbit que la sentència <code>var x</code> anterior al bloc. En C o Java, el codi equivalent hauria emès 1.</p> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificacions</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>1a edició d'ECMAScript.</td> + <td>Estàndard</td> + <td>Definició inicial. Implementat en JavaScript 1.0</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-12.1', 'Block statement')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-block', 'Block statement')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{ CompatibilityTable() }}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome per Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li>{{jsxref("Statements/while", "while")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/sentencies/break/index.html b/files/ca/web/javascript/referencia/sentencies/break/index.html new file mode 100644 index 0000000000..d71eff620d --- /dev/null +++ b/files/ca/web/javascript/referencia/sentencies/break/index.html @@ -0,0 +1,154 @@ +--- +title: break +slug: Web/JavaScript/Referencia/Sentencies/break +translation_of: Web/JavaScript/Reference/Statements/break +--- +<div>{{jsSidebar("Statements")}}</div> + +<p>La <strong> sentència</strong> <strong>break</strong> acaba el bucle actual, {{jsxref("Statements/switch", "switch")}}, o una sentència {{jsxref("Statements/label", "label")}} i transfereix el control de programa a la sentència següent de la sentència acabada.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code>break [<em>etiqueta</em>];</code></pre> + +<dl> + <dt><code>Etiqueta</code></dt> + <dd>Opcional. És l'identificador associat amb l'etiqueta de la sentència. Si la sentència no és un bucle o un {{jsxref("Statements/switch", "switch")}}, això és necessari.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>La sentència <code>break</code> inclou una etiqueta opcional que permet al programa sortir de la sentència etiquetada. La sentència <code>break</code> necessita ser imbricada dins l'etiqueta de referència. La sentència etiquetada pot ser qualsevol sentència {{jsxref("Statements/block", "block")}}, no ha de ser precedida per una sentència de bucle.</p> + +<h2 id="Exemples">Exemples</h2> + +<p>La funció següent té una sentència <code>break</code> que acaba amb el bucle{{jsxref("Statements/while", "while")}} quan <code>i</code> és 3, per després retornar el valor 3 * <code>x</code>.</p> + +<pre class="brush:js;highlight:[6];">function testBreak(x) { + var i = 0; + + while (i < 6) { + if (i == 3) { + break; + } + i += 1; + } + + return i * x; +}</pre> + +<p>El codi següent utilitza sentències<code> break</code> amb blocs etiquetats. Una sentència <code>break</code> ha de ser imbricada dins de qualsevol etiqueta que fa referència. Vegeu que <code>inner_block</code> és troba imbricada dins <code>outer_block</code>.</p> + +<pre class="brush:js;highlight:[1,2,4];">outer_block: { + inner_block: { + console.log('1'); + break outer_block; // surt tan de inner_block com de outer_block + console.log(':-('); // es salta + } + console.log('2'); // es salta +} +</pre> + +<p>El codi següent també utilitza sentències <code>break</code> amb blocs etiquetats però cenera un Syntax Error perquè la sentència <code>break</code> es troba dins de <code>block_1</code> però fa referència a <code>block_2</code>. Una sentència <code>break</code> ha d'estar sempre imbricada dins de l'eitqueta a la que fa referència.</p> + +<pre class="brush:js;highlight:[1,3,6];">block_1: { + console.log('1'); + break block_2; // SyntaxError: etiqueta no trobada +} + +block_2: { + console.log('2'); +} +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definició inicial. Versió no etiquetada.</td> + </tr> + <tr> + <td>{{SpecName('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>versió etiquetada afegida.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-12.8', 'Break statement')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-break-statement', 'Break statement')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome per Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Statements/continue", "continue")}}</li> + <li>{{jsxref("Statements/label", "label")}}</li> + <li>{{jsxref("Statements/switch", "switch")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/sentencies/buida/index.html b/files/ca/web/javascript/referencia/sentencies/buida/index.html new file mode 100644 index 0000000000..6800d476f8 --- /dev/null +++ b/files/ca/web/javascript/referencia/sentencies/buida/index.html @@ -0,0 +1,138 @@ +--- +title: Buida +slug: Web/JavaScript/Referencia/Sentencies/Buida +translation_of: Web/JavaScript/Reference/Statements/Empty +--- +<div> +<div>{{jsSidebar("Statements")}}</div> +</div> + +<h2 id="Resum">Resum</h2> + +<p>Una sentència <strong>buida</strong> es fa servir per no proveïr cap sentència, encara que la sintaxi de JavaScript n'esperaria una.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox">; +</pre> + +<h2 id="Descripció">Descripció</h2> + +<p>La sentència buida és un punt i coma (;) que indica que cap sentència s'executarà, encara que la sintaxi de JavaScript en requereixi una. Pel contrari, quan es vol realitzar múltiples sentències, però JavaScript només en permet un, és possible realitzar-ho mitjançant l'ús d'una <a href="/en-US/docs/Web/JavaScript/Reference/Statements/block">sentència de block</a>; que combina diverses sentències en una única sentència.</p> + +<h2 id="Exemples">Exemples</h2> + +<p>La sentència buida sovint s'utilitza amb sentències de bucles. Vegeu l'exemple segúent amb el cos del bucle buit:</p> + +<pre class="brush: js">var arr = [1, 2, 3]; + +// Assign all array values to 0 +for (i = 0; i < arr.length; arr[i++] = 0) /* empty statement */ ; + +console.log(arr) +// [0, 0, 0] +</pre> + +<p><strong>Nota:</strong> És una bona idea comentar l'ús intencional de la sentència buida, ja que no és fa molt obvi diferenciar-lo d'un punt i coma normal. En el següent exemple l'ús probablement no és intencional:</p> + +<pre class="brush: js">if (condition); // Caution, this "if" does nothing! + killTheUniverse() // So this gets always executed!!! +</pre> + +<p>Un altre exemple: Una sentència <a href="/en-US/docs/Web/JavaScript/Reference/Statements/if...else"><code>if...else</code></a> sense claus (<code>{}</code>). Si <code>tres</code> és cert, no passarà res, <u><code>four</code> does not matter, </u>ni tampoc s'executarà la funció <code>launchRocket()</code> en el cas <code>else</code>.</p> + +<pre class="brush: js">if (one) + doOne(); +else if (two) + doTwo(); +else if (three) + ; // nothing here +else if (four) + doFour(); +else + launchRocket();</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>1a edició de ECMAScript.</td> + <td>Estàndard</td> + <td>Definició inicial.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-12.3', 'Empty statement')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-empty-statement', 'Empty statement')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{ CompatibilityTable() }}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li>{{jsxref("Statements/block", "Block statement")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/sentencies/continue/index.html b/files/ca/web/javascript/referencia/sentencies/continue/index.html new file mode 100644 index 0000000000..a6928d15b7 --- /dev/null +++ b/files/ca/web/javascript/referencia/sentencies/continue/index.html @@ -0,0 +1,199 @@ +--- +title: continue +slug: Web/JavaScript/Referencia/Sentencies/continue +translation_of: Web/JavaScript/Reference/Statements/continue +--- +<div>{{jsSidebar("Statements")}}</div> + +<p>La <strong> sentència continue</strong> acaba l'execució de les sentències en la iteració actual del bucle actual o etiquetat, i continua l'execució del bucle amb la següent iteració.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox">continue [<em>etiqueta</em>];</pre> + +<dl> + <dt><code>Etiqueta</code></dt> + <dd>Identificador associat amb l'etiqueta de la sentència.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>En contrast amb la sentència {{jsxref("Statements/break", "break")}} , <code>continue</code> no acaba l'execució del bucle: En comptes d'això,</p> + +<ul> + <li>En un bucle {{jsxref("Statements/while", "while")}}, salta un altre cop a la condició.</li> +</ul> + +<ul> + <li>En un bucle {{jsxref("Statements/for", "for")}}, Salta a l'actualització de l'expressió.</li> +</ul> + +<p>La sentència <code>continue</code> pot incloure una etiqueta opcional que permet al programa saltar a la següent iteració d'una sentència d'un bucle etiquetat en comptes del bucle actual. En aquest cas, la sentència <code>continue</code> necessita trobar-se imbricada dins de la sentència etiquetada.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_continue_amb_while">Utilitzar <code>continue</code> amb <code>while</code></h3> + +<p>L'exemple següent mostra un bucle{{jsxref("Statements/while", "while")}} que contè una sentència <code>continue</code> que s'executa quan el valor de <code>i</code> és 3. Així doncs, <code>n</code> pren els valors 1, 3, 7, i 12.</p> + +<pre class="brush: js">var i = 0; +var n = 0; + +while (i < 5) { + i++; + + if (i === 3) { + continue; + } + + n += i; +} +</pre> + +<h3 id="Utilitzar_continue_amb_una_etiqueta">Utilitzar <code>continue</code> amb una etiqueta</h3> + +<p>En l'exemple següent, una sentència etiquetada <code>checkiandj</code> contè una sentència etiquetada <code>checkj</code>. si es troba un <code>continue</code>, el programa continua al començament de la sentència <code>checkj</code>. Cada cop que es troba <code>continue</code>, <code>checkj</code> reitera fins que la condició retorna falç. Quan es retorna falç, es completa la resta de la sentència <code>checkiandj</code>.</p> + +<p>Si <code>continue</code> té una etiqueta de <code>checkiandj</code>, el programa continuarà al començament de la sentència <code>checkiandj</code>.</p> + +<p>Vegeu també {{jsxref("Statements/label", "label")}}.</p> + +<pre class="brush: js">var i = 0; +var j = 8; + +checkiandj: while (i < 4) { + console.log("i: " + i); + i += 1; + + checkj: while (j > 4) { + console.log("j: "+ j); + j -= 1; + + if ((j % 2) == 0) + continue checkj; + console.log(j + " is odd."); + } + console.log("i = " + i); + console.log("j = " + j); +} +</pre> + +<p>Resultat:</p> + +<pre class="brush: js">"i: 0" + +// start checkj +"j: 8" +"7 is odd." +"j: 7" +"j: 6" +"5 is odd." +"j: 5" +// end checkj + +"i = 1" +"j = 4" + +"i: 1" +"i = 2" +"j = 4" + +"i: 2" +"i = 3" +"j = 4" + +"i: 3" +"i = 4" +"j = 4" +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Definició inicial. Versió sense etiqueta.</td> + </tr> + <tr> + <td>{{SpecName('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Versió amb etiqueta afegida.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-12.7', 'Continue statement')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-continue-statement', 'Continue statement')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome per Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Statements/break", "break")}}</li> + <li>{{jsxref("Statements/label", "label")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/sentencies/debugger/index.html b/files/ca/web/javascript/referencia/sentencies/debugger/index.html new file mode 100644 index 0000000000..54d8d02e3d --- /dev/null +++ b/files/ca/web/javascript/referencia/sentencies/debugger/index.html @@ -0,0 +1,116 @@ +--- +title: debugger +slug: Web/JavaScript/Referencia/Sentencies/debugger +translation_of: Web/JavaScript/Reference/Statements/debugger +--- +<div>{{jsSidebar("Statements")}}</div> + +<p>La <strong>sentència</strong> <strong>debugger </strong>invoca qualsevol funcionalitat de depuració disponible, com l'establiment d'un breakpoint (punt de ruptura). Si no hi ha cap funcionalitat de depuració disponible, aquesta sentència queda sense efecte.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox"><code>debugger;</code></pre> + +<h2 id="Exemples">Exemples</h2> + +<p>L'exemple següent mostra un codi on s'ha insertat una sentència de depuració, de forma que es crida un debugger (si existeix) quan es crida la funció.</p> + +<pre class="brush:js">function potentiallyBuggyCode() { + debugger; + // codi potencialment erroni a examinar, executar pas a pas, etc. +}</pre> + +<p>Quan es crida el debugger, s'atura l'execució a la sentència del debugger. Es com un breakpoint en la font de l'script.</p> + +<p><a href="https://mdn.mozillademos.org/files/6963/Screen Shot 2014-02-07 at 9.14.35 AM.png"><img alt="Paused at a debugger statement." src="https://mdn.mozillademos.org/files/6963/Screen%20Shot%202014-02-07%20at%209.14.35%20AM.png" style="height: 371px; width: 700px;"></a></p> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-debugger-statement', 'Debugger statement')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-12.15', 'Debugger statement')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td>Definició inicial</td> + </tr> + <tr> + <td>{{SpecName('ES3', '#sec-7.5.3', 'Debugger statement')}}</td> + <td>{{Spec2('ES3')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES1', '#sec-7.4.3', 'Debugger statement')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Només mencionat com a paraula reservada.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome per Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li><a href="/en-US/docs/Debugging_JavaScript">Debugging JavaScript</a></li> + <li><a href="/en-US/docs/Tools/Debugger">El depurador en eines de desenvoupador de Firefox</a></li> +</ul> diff --git a/files/ca/web/javascript/referencia/sentencies/do...while/index.html b/files/ca/web/javascript/referencia/sentencies/do...while/index.html new file mode 100644 index 0000000000..88f221f83d --- /dev/null +++ b/files/ca/web/javascript/referencia/sentencies/do...while/index.html @@ -0,0 +1,124 @@ +--- +title: do...while +slug: Web/JavaScript/Referencia/Sentencies/do...while +translation_of: Web/JavaScript/Reference/Statements/do...while +--- +<div>{{jsSidebar("Statements")}}</div> + +<p>La <strong>sentència</strong> <strong><code>do...while</code> </strong> crea un bucle que executa una sentència especificada fins que la condició avalui a fals. La condició s'avalua després de la sentència, donant lloc a l'execució de la sentència especificada almenys un cop.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox">do + <em>sentència</em> +while (<em>condició</em>); +</pre> + +<dl> + <dt><code>sentència</code></dt> + <dd>Una sentència que s'executa almenys un cop i que es torna a executar cada cop que la condició avalui a certa. Per executar múltiples sentències dins d'un bucle, utilitzeu una sentència {{jsxref("Statements/block", "block")}} (<code>{ ... }</code>) per agrupar aquestes sentències.</dd> +</dl> + +<dl> + <dt><code>condició</code></dt> + <dd>Una expressió que s'avalua després de cada volta del bucle. si <code>condició</code> avalua a certa, la <code>sentència</code> es torna a executar. Quan la <code>condició</code> avalua a falç, control passa a la següent sentència que segueix el <code>do...while</code>.</dd> +</dl> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utilitzar_el_do...while">Utilitzar el <code>do...while</code></h3> + +<p>En l'exemple següent, el bucle <code>do...while</code> itera almenys un cop i torna a iterar fins que <code>i</code> deixa de ser més petit que 5.</p> + +<pre class="brush: js">var i = 0; +do { + i += 1; + console.log(i); +} while (i < 5); +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>{{SpecName('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Definició inicial. Implementat en JavaScript 1.2</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-12.6.1', 'do-while statement')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-do-while-statement', 'do-while statement')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Trailing ; ara és opcional.</td> + </tr> + </tbody> +</table> + +<h2 id="Browser_compatibility">Browser compatibility</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>6</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome per Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Statements/while", "while")}}</li> + <li>{{jsxref("Statements/for", "for")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/sentencies/export/index.html b/files/ca/web/javascript/referencia/sentencies/export/index.html new file mode 100644 index 0000000000..c1d92ab504 --- /dev/null +++ b/files/ca/web/javascript/referencia/sentencies/export/index.html @@ -0,0 +1,158 @@ +--- +title: export +slug: Web/JavaScript/Referencia/Sentencies/export +translation_of: Web/JavaScript/Reference/Statements/export +--- +<div>{{jsSidebar("Statements")}}</div> + +<p>La<strong> </strong>sentència <strong>export</strong> s'utilitza per exportar funcions, objectes o valors primitius d'un fitxer donat (o <em>mòdul</em>) per a que els puguin fer servir altres programes amb la sentència {{jsxref("Statements/import", "import")}}.</p> + +<p>Els mòduls exportats estan sempre {{jsxref("Strict_mode","strict mode", "", 1)}} tan si es declaren així com si no. La sentència export no es pot fer servir en mòduls incrustats (embedded).</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox notranslate">export <em>nom1</em>, <em>nom2</em>, ..., <em>nomN</em>; +export default <em>nom1</em> </pre> + +<dl> + <dt><code>nomN</code></dt> + <dd>Propietat, funció, o objecte que s'ha d'exportar (de manera que es pot importar a través de <code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/import">import</a></code> en un altre script).</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Hi ha dos tipus diferents d'export:</p> + +<ul> + <li>Exportacions nominals (una o més per mòdul): + <pre class="brush: js notranslate">export myFunction; // exporta una funció declarada anteriorment +export const foo = Math.sqrt(2); // exporta una constant +export let <var>name1</var>, <var>name2</var>, …, <var>nameN</var>; +export let <var>name1</var> = …, <var>name2</var> = …, …, <var>nameN</var>; +export function functionName(){...} +export class ClassName {...}</pre> + </li> + <li>Exportacions per defecte (una per mòdul): + <pre class="notranslate">export default <em>expression</em>; +export default function (…) { … } // també class, function* +export default function name1(…) { … } // també class, function* +export { <var>name1</var> as default, … };</pre> + </li> +</ul> + +<p>Les exportacions amb nom són útils per exportar diversos valors. Durant la importació, un serà capaç d'utilitzar el mateix nom per referir-se al valor corresponent.</p> + +<p>Sobre la exportació per defecte, només pot haver-n'hi una per mòdul. Una exportació per defecte pot ser una funció, una classe un objecte o qualsevol altra cosa. Aquest valor es considerarà el principal valor exportat, ja que serà el més fàcil d'importar.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Usant_les_exportacions_nominals">Usant les exportacions nominals</h3> + +<p>En el mòdul podem fer servir el codi següent:</p> + +<pre class="brush: js notranslate">// "modul.js" +export function cub(x) { + return x * x * x; +} +const foo = Math.PI + Math.SQRT2; +export foo; +</pre> + +<p>Així, en un altre mòdul podem tenir:</p> + +<pre class="brush: js notranslate">import { cub, foo } from 'modul.js'; +console.log(cub(3)); // 9 +console.log(foo); // 4.555806215962888</pre> + +<h3 id="Usant_lexportació_per_defecte">Usant l'exportació per defecte</h3> + +<p>Si volem exportar un únic valor o tenir un valor per defecte per al nostre mòdul podem fer::</p> + +<pre class="brush: js notranslate">// "modul.js" +var function cub(x) { + return x * x * x; +} +export default cub;</pre> + +<p>Així, en un altre mòdul podem importar directament:</p> + +<pre class="brush: js notranslate">import laFuncio from 'modul'; +console.log(laFuncio(3)); // 9 +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-imports', 'Imports')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definició inicial</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome per Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + <td>{{CompatNo}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li>{{jsxref("Statements/import", "import")}}</li> + <li><a href="https://hacks.mozilla.org/2015/08/es6-in-depth-modules/">ES6 in Depth: Modules</a>, Hacks blog post per Jason Orendorff</li> + <li><a href="http://exploringjs.com/es6/ch_modules.html">Axel Rauschmayer's book: "Exploring JS: Modules"</a></li> +</ul> diff --git a/files/ca/web/javascript/referencia/sentencies/for...of/index.html b/files/ca/web/javascript/referencia/sentencies/for...of/index.html new file mode 100644 index 0000000000..5cc16f52f8 --- /dev/null +++ b/files/ca/web/javascript/referencia/sentencies/for...of/index.html @@ -0,0 +1,181 @@ +--- +title: for...of +slug: Web/JavaScript/Referencia/Sentencies/for...of +translation_of: Web/JavaScript/Reference/Statements/for...of +--- +<div> +<div>{{jsSidebar("Statements")}}</div> +</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>La instrucció <code>for...of</code> crea un bucle que itera sobre <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/iterable">objectes iterables</a> (incloent {{jsxref("Array")}}, {{jsxref("Map")}}, {{jsxref("Set")}}, l'objecte <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions_and_function_scope/arguments">arguments</a>, etcètera), tot invocant un bloc de codi amb les instruccions a executar per a cada valor de la propietat.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox">for (<em>variable</em> of <em>objecte</em>) + codi +</pre> + +<dl> + <dt><code>variable</code></dt> + <dd>A cada iteració el valor d'una propietat diferent és asignat a <em>variable</em>.</dd> + <dt><code>object</code>e</dt> + <dd>L'objecte del qual s'iteren les propietats, que són iterables.</dd> +</dl> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Diferència_entre_for...of_i_for...in">Diferència entre <code>for...of</code> i <code>for...in</code></h3> + +<p>El següent exemple mostra la diferència entre el bucle <code>for...of</code> i el bucle <code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...in" title="en-US/docs/JavaScript/Reference/Statements/for...in">for...in</a></code>. Mentre <code>for...in</code> itera sobre noms de propietats, <code>for...of</code> itera sobre els valors de les propietats:</p> + +<pre class="brush:js">let arr = [3, 5, 7]; +arr.foo = "hola"; + +for (let i in arr) { + console.log(i); // mostra "0", "1", "2", "foo" +} + +for (let i of arr) { + console.log(i); // mostra "3", "5", "7" +} +</pre> + +<h3 id="Ús_de_Array.prototype.forEach()">Ús de <code>Array.prototype.forEach()</code></h3> + +<p>Per a aconseguir els mateixos valors que s'obtenen amb <code>for...of</code> també es pot utilitzar el mètode {{jsxref("Array.prototype.forEach()")}}:</p> + +<pre class="brush: js">let arr = [3, 5, 7]; +arr.foo = "hola"; + +arr.forEach(function (element, index) { + console.log(element); // mostra "3", "5", "7" + console.log(index); // mostra "0", "1", "2" +}); + +// or with Object.keys() + +Object.keys(arr).forEach(function (element, index) { + console.log(arr[element]); // mostra "3", "5", "7", "hello" + console.log(arr[index]); // mostra "3", "5", "7" +});</pre> + +<h3 id="Iteració_de_coleccions_del_DOM">Iteració de coleccions del DOM</h3> + +<p>Iterant sobre coleccions del DOM com {{domxref("NodeList")}}: el següent exemple afegeix la classe <code>read</code> als paràgrafs que són descendens directes d'un article:</p> + +<pre class="brush:js">// Nota: Això només funcionarà en plataformes que +// implementen NodeList.prototype[Symbol.iterator] +let articleParagraphs = document.querySelectorAll("article > p"); + +for (let paragraph of articleParagraphs) { + paragraph.classList.add("read"); +} +</pre> + +<h3 id="Iteració_de_generadors">Iteració de generadors:</h3> + +<p>Els <a href="/en-US/docs/Web/JavaScript/Reference/Statements/function*">generadors</a> també són iterables:</p> + +<pre class="brush:js">function* fibonacci() { // una funció generadora + let [prev, curr] = [0, 1]; + for (;;) { + [prev, curr] = [curr, prev + curr]; + yield curr; + } +} + +for (let n of fibonacci()) { + // trunca la seqüència als 1000 + if (n > 1000) + break; + print(n); +} +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentari</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-for-in-and-for-of-statements', 'for...of statement')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Definició inicial.</td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{CompatibilityTable()}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatChrome(29)}}<a href="#chrome-note-1">[1]</a><br> + {{CompatChrome(38)}}</td> + <td>{{CompatGeckoDesktop("13")}}<br> + {{CompatGeckoDesktop("17")}} (.iterator)<br> + {{CompatGeckoDesktop("27")}} ("@@iterator")<br> + {{CompatGeckoDesktop("36")}} (Symbol.iterator)</td> + <td>{{CompatNo}}</td> + <td>25</td> + <td>7.1</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatChrome(29)}}<a href="#chrome-note-1">[1]</a><br> + {{CompatChrome(38)}}</td> + <td>{{CompatGeckoMobile("13")}}<br> + {{CompatGeckoMobile("17")}} (.iterator)<br> + {{CompatGeckoMobile("27")}} ("@@iterator")<br> + {{CompatGeckoMobile("36")}} (Symbol.iterator)</td> + <td>{{CompatUnknown}}</td> + <td>{{CompatUnknown}}</td> + <td>iOS 8</td> + </tr> + </tbody> +</table> +</div> + +<p><a name="chrome-note-1"></a>[1] La característica està disponible sota una preferència. A chrome://flags/#enable-javascript-harmony, activar la entrada “Enable Experimental JavaScript”.</p> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for_each...in">for each...in</a> - una instrucció similar, però itera els valors de les propietats d'un objecte en comptes de les propietats mateixes de l'objecte (en desús).</li> + <li>{{jsxref("Array.prototype.forEach()")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/sentencies/for/index.html b/files/ca/web/javascript/referencia/sentencies/for/index.html new file mode 100644 index 0000000000..00a16b62df --- /dev/null +++ b/files/ca/web/javascript/referencia/sentencies/for/index.html @@ -0,0 +1,190 @@ +--- +title: for +slug: Web/JavaScript/Referencia/Sentencies/for +translation_of: Web/JavaScript/Reference/Statements/for +--- +<div> +<div>{{jsSidebar("Statements")}}</div> +</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>La<strong> sentència</strong> <strong>for</strong> crea un bucle que consta de tres expressions opcionals, embolcallades entre paràntesis i separades per punts i comes, seguits d'una sentència o un grup de sentències executades en el bucle.</p> + +<h2 id="Syntax" name="Syntax">Sintaxi</h2> + +<pre class="syntaxbox">for ([<em>inicialització</em>]; [<em>condició</em>]; [<em>expressió final</em>]) + <em>sentència</em> +</pre> + +<dl> + <dt><code>inicialització</code></dt> + <dd>Una expressió (incloent expressions d'assignació) o declaració de variables. Normalment s'usa per inicialitzar una variable al contador. Opcionalment aquesta expressió pot declarar noves variables amb la paraula clau <code>var</code>. Aquestes variables no sóc locals pel bucle, és a dir, es troben en el mateix àmbit en que es troba el bucle <code>for</code>. El resultat d'aquesta expressió es descarta.</dd> + <dt><code>condició</code></dt> + <dd>Una expressió que s'avalua abans de cada iteració del bucle. Si aquesta expressió s'avalua<strong> true,</strong> s'executa la <code>sentència</code>. Aquesta prova condicional és opcional. Si s'omet, la condició sempre avalua<strong> true.</strong> Si l'expressió avalua a false, l'execució salta a la primera expressió que es trobi després del constructe <code>for</code>.</dd> + <dt><code>Expressió final</code></dt> + <dd>Una expressió per ser avaluada al final de cada iteració del bucle. Això passa abans de la següent avaluació de <code>condició</code>. Generalment s'usa per actualitzar o incrementar la variable contador.</dd> + <dt><code>sentència</code></dt> + <dd>Una sentència que s'executa mentre la condició avalui a true. Per executar múltiples sentències dins el bucle, utilitzeu una sentència <a href="/en-US/docs/JavaScript/Reference/Statements/block" title="JavaScript/Reference/Statements/block">block</a> (<code>{ ... }</code>) per agrupar aquestes sentències. Per no executar cap sentència dins el bucle, utilitzeu una sentència <a href="/en-US/docs/Web/JavaScript/Reference/Statements/Empty">buida</a> (<code>;</code>).</dd> +</dl> + +<h2 id="Examples" name="Examples">Exemples</h2> + +<h3 id="Example.3A_Using_for" name="Example.3A_Using_for">Exemple: Fer servir <code>for</code></h3> + +<p>La següent sentència <code>for</code> comença declarant la variable <code>i</code> i l'inicialitza a <code>0</code>. Comprova que <code>i</code> és menor que nou, realitza les dues sentències següents<u>, i incrementa <code>i</code> per 1 després de cada pas pel bucle.</u></p> + +<pre class="brush: js">for (var i = 0; i < 9; i++) { + console.log(i); + // more statements +} +</pre> + +<h3 id="Exemple_Expressions_for_opcionals"><u>Exemple: Expressions <code>for</code> opcionals</u></h3> + +<p>Les tres expressions en la capçalera del bucle <code>for</code> són opcionals.</p> + +<p>Per exemple, enel bloc d'<em>inicialització</em> no es requereix inicialitzar les variablesblock it is not required to initialize variables:</p> + +<pre class="brush: js">var i = 0; +for (; i < 9; i++) { + console.log(i); + // more statements +} +</pre> + +<p><u>Com el bloc d'<em>inicialització</em>, el bloc de <em>condició</em> també és opcional. Si s'omet aquesta expressió, s'ha de d'assegurar de trencar el bucle en el cos per evitar crear un bucle infinit.</u></p> + +<pre class="brush: js">for (var i = 0;; i++) { + console.log(i); + if (i > 3) break; + // more statements +}</pre> + +<p>També es pot ometre els tres blocs. Un alre cop, assegureu-vos de fer servir la sentència <code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/break">break</a></code> per finalitzar el bucle i també modificar (incrementar) una variable, de forma que la condició per la sentència break esdevé certa en algun moment determinat.</p> + +<pre class="brush: js">var i = 0; + +for (;;) { + if (i > 3) break; + console.log(i); + i++; +} +</pre> + +<h3 id="Example.3A_Using_for_without_the_statement_section" name="Example.3A_Using_for_without_the_statement_section"><u>Exemple: Fer servir <code>for</code> amb una sentència buida</u></h3> + +<p><u>El cicle <code>for</code> següent callcula la possició de desplaçament d'un node en la secció <em>[expressió final]</em>, i per tant no requereix l'ús d'una <code>sentència</code> o secció de sentències <code><a href="/en-US/docs/JavaScript/Reference/Statements/block" title="JavaScript/Reference/Statements/block">block</a></code>, es fa servir una sentència <a href="/en-US/docs/Web/JavaScript/Reference/Statements/Empty">buida</a> en el seu lloc</u>.</p> + +<pre class="brush: js">function showOffsetPos (sId) { + var nLeft = 0, nTop = 0; + + for (var oItNode = document.getElementById(sId); // initialization + oItNode; // condition + nLeft += oItNode.offsetLeft, nTop += oItNode.offsetTop, oItNode = oItNode.offsetParent) // final-expression + /* empty statement */ ; + + console.log("Offset position of \"" + sId + "\" element:\n left: " + nLeft + "px;\n top: " + nTop + "px;"); +} + +// Example call: + +showOffsetPos("content"); + +// Output: +// "Offset position of "content" element: +// left: 0px; +// top: 153px;"</pre> + +<div class="note"><strong>Nota:</strong> En aquest cas, quan no es fa servir la secció <code>sentència</code>, <strong>es fica un punt i coma immediatament despres de la declaració del cicle</strong>.</div> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>1a edició de ECMAScript.</td> + <td>Estàndard</td> + <td>Definició inicial.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-12.6.3', 'for statement')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-for-statement', 'for statement')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{ CompatibilityTable() }}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li>{{jsxref("Statements/break", "break")}}</li> + <li>{{jsxref("Statements/continue", "continue")}}</li> + <li>{{jsxref("Statements/empty", "empty")}}</li> + <li>{{jsxref("Statements/while", "while")}}</li> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Statements/do...while"><code>do...while</code></a></li> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...in"><code>for...in</code></a></li> + <li><code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...of"><code>for...of</code></a></code></li> +</ul> diff --git a/files/ca/web/javascript/referencia/sentencies/function/index.html b/files/ca/web/javascript/referencia/sentencies/function/index.html new file mode 100644 index 0000000000..37deff748f --- /dev/null +++ b/files/ca/web/javascript/referencia/sentencies/function/index.html @@ -0,0 +1,171 @@ +--- +title: function +slug: Web/JavaScript/Referencia/Sentencies/function +translation_of: Web/JavaScript/Reference/Statements/function +--- +<div> +<div>{{jsSidebar("Statements")}}</div> +</div> + +<h2 id="Resum">Resum</h2> + +<p>La <strong>declaració d'una funció</strong> defineix una funció amb uns paràmetres especificats.</p> + +<div class="noinclude"> +<p>També podeu definir funcions fent servir el constructor {{jsxref("Function")}} i un {{jsxref("Operators/function", "function expression")}}.</p> +</div> + +<h2 id="Syntax" name="Syntax">Sintaxi</h2> + +<pre class="syntaxbox">function <em>nom</em>([<em>paràm</em>,[, <em>paràm</em>,[..., <em>paràm</em>]]]) { + [<em>sentències</em>] +} +</pre> + +<dl> + <dt><code>nom</code></dt> + <dd>El nom de la funció.</dd> +</dl> + +<dl> + <dt><code>paràm</code></dt> + <dd>El nom d'un argument que se li passarà a la funció. Una funció pot arribar a tenir fins a 255 arguments.</dd> +</dl> + +<dl> + <dt><code>sentències</code></dt> + <dd>Les sentències que comprenen el cos de la funció.</dd> +</dl> + +<h2 id="Description" name="Description">Descripció</h2> + +<p>Una funció creada amb una declaració d'una funció és un objecte <code>Function</code> i té totes les propietats, mètodes i comportament dels objectes <code>Function</code>. Vegeu {{jsxref("Function")}} per informació detallada sobre funcions.</p> + +<p>Una funció també es pot crear fent servir una expressió (vegeu {{jsxref("Operators/function", "function expression")}}).</p> + +<p>Per defecte, les funcions retornen <code>undefined</code>. Per tal de retornar qualsevol altre valor, la funció ha de tenir una sentència {{jsxref("Statements/return", "return")}} que especifiqui el valor que retorna.</p> + +<h3 id="Funcions_creades_de_forma_condicional">Funcions creades de forma condicional</h3> + +<p>Les funcions poden ser declarades de forma condicional, és a dir, una sentència d'una funció pot estar aniuada dins d'una sentència <code>if</code>. La majoria de navegadors que no siguin Mozilla tractaran aquestes declaracions condicionals com a declaracions incondicionals i crearàn la funció tant si la condició és vertadera o falsa, vegeu <a href="http://kangax.github.io/nfe/#function-statements">aquest article</a> per una visió general. Per tant, no s'haurien de fer servir, per creacions condicionals feu servir expressions de funcions.</p> + +<h3 id="Declarar_les_funcions_abans_de_definir-les_(hosting)">Declarar les funcions abans de definir-les <em>(hosting)</em></h3> + +<p><u>Function declarations in JavaScript are hoisting the function definition</u>. En Javascript es pot ser cridar una funció abans de declarar-la. En anglès existeix un ver:</p> + +<pre class="brush: js">hoisted(); // logs "foo" + +function hoisted() { + console.log("foo"); +} +</pre> + +<p>Vegeu que {{jsxref("Operators/function", "function expressions")}} no estan hoisted:</p> + +<pre class="brush: js">notHoisted(); // TypeError: notHoisted is not a function + +var notHoisted = function() { + console.log("bar"); +}; +</pre> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Exemple_Fer_servir_function">Exemple: Fer servir <code>function</code></h3> + +<p>El codi següent declara una funció que retorna la quantitat total de vendes, quan se li dóna el nombre d'unitat venudes d' <code>a</code>, <code>b</code>, i <code>c</code>.</p> + +<pre class="brush: js">function calc_sales(units_a, units_b, units_c) { + return units_a*79 + units_b * 129 + units_c * 699; +} +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>1a edició de ECMAScript.</td> + <td>Estàndard</td> + <td>Definició iniciañ. Implementat en JavaScript 1.0</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-13', 'Function definition')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-function-definitions', 'Function definitions')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{ CompatibilityTable() }}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome per Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li>{{jsxref("Functions_and_function_scope", "Functions and function scope")}}</li> + <li>{{jsxref("Function")}}</li> + <li>{{jsxref("Operators/function", "function expression")}}</li> + <li>{{jsxref("Statements/function*", "function* statement")}}</li> + <li>{{jsxref("Operators/function*", "function* expression")}}</li> + <li>{{jsxref("GeneratorFunction")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/sentencies/if...else/index.html b/files/ca/web/javascript/referencia/sentencies/if...else/index.html new file mode 100644 index 0000000000..b45e9bea3c --- /dev/null +++ b/files/ca/web/javascript/referencia/sentencies/if...else/index.html @@ -0,0 +1,203 @@ +--- +title: if...else +slug: Web/JavaScript/Referencia/Sentencies/if...else +translation_of: Web/JavaScript/Reference/Statements/if...else +--- +<div> +<div>{{jsSidebar("Statements")}}</div> +</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>La <strong><a href="/en-US/docs/Web/JavaScript/Guide/Statements">sentència </a>if </strong>executa una sentència si una condició especificada és certa. Si la condició és falsa, opcionalment s'executa una declaració diferent.</p> + +<h2 id="Syntax" name="Syntax">Sintaxi</h2> + +<pre class="syntaxbox">if (<em>condició</em>) + <em>sentència1</em> +[else + <em>sentència2</em>] +</pre> + +<dl> + <dt><code>condició</code></dt> + <dd><u>Una <a href="/en-US/docs/Web/JavaScript/Guide/Expressions_and_Operators#Expressions">expressió</a> que esdevé o certa o falsa.</u></dd> +</dl> + +<dl> + <dt><code>sentència1</code></dt> + <dd><u>És la sentència que s'executa si la <code>condició</code> esdevé certa. Pot ser qualsevol declaració, incloent més sentències <code>if</code> aniuades.</u> Per executar múltimples sentències, es fa servir una sentència <a href="/en-US/docs/Web/JavaScript/Reference/Statements/block" title="en/JavaScript/Reference/Statements/block">block</a> ({ ... }) per agrupar aquestes sentències, si no es vol executar cap sentència, es fa servir una sentència <a href="/en-US/docs/Web/JavaScript/Reference/Statements/Empty">buida</a>.</dd> +</dl> + +<dl> + <dt><code>sentència2</code></dt> + <dd>La sentència que s'executa si la <code>condition</code> esdevé falsa i hi ha la clàusula <code>else</code>. Pot ser qualsevol sentència, incloent sentències en<u> block </u>i més sentències <code>if</code> aniuades.</dd> +</dl> + +<h2 id="Description" name="Description">Descripció</h2> + +<p>Múltiples sentències <code>if...else</code> poden aniuar-se per crear una clàusula <code>else if</code>. Fixeu-vos que no hi ha la paraula clau <code>elseif</code> (en una paraula) en JavaScript.</p> + +<pre class="eval">if (<em>condició1</em>) + <em>sentència1</em> +else if (<em>condició2</em>) + <em>sentència2</em> +else if (<em>condició3</em>) + <em>sentència3</em> +... +else + <em>sentènciaN</em> +</pre> + +<p>Per veure com funciona, així es com es veuria amb l'aniuament degudament indentat.</p> + +<pre class="eval">if (<em>condició1</em>) + <em>sentència1</em> +else + if (<em>condició2</em>) + <em>sentència2</em> + else + if (<em>condició3</em>) +... +</pre> + +<p>Per executar múltiples sentències dins una clàusula, utilitzeu una sentència block (<code>{ ... }</code>) per agrupar aquestes sentències. En general, és una bona pràctica utilitzar sempre sentències de <u>block</u>, especialment en codi que inclogui sentències <code>if</code> aniuades:</p> + +<pre class="eval">if (<em>condició</em>) { + <em>sentència1</em> +} else { + <em>sentència2</em> +} +</pre> + +<p>No confongueu els valors booleans primitius <code>true</code> i <code>false</code> amb els valors cert i fals de l'objecte <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean" title="en/JavaScript/Reference/Global_Objects/Boolean">Boolean</a>. Qualsevol valor que no sigui <code>undefined</code>, <code>null</code>, <code>0</code>, <code>NaN</code>, o una cadena buida (<code>""</code>), i qualsevol objecte, incloent un objecte Boolean que tingui el valor fals, esdevé cert quan es passa a una sentència condicional. Per exemple:</p> + +<pre class="brush: js">var b = new Boolean(false); +if (b) // this condition evaluates to true +</pre> + +<h2 id="Examples" name="Examples">Exemples</h2> + +<h3 id="Example:_Using_if...else" name="Example:_Using_if...else">Exemple: Fer servir <code>if...else</code></h3> + +<pre class="brush: js">if (cipher_char === from_char) { + result = result + to_char; + x++; +} else { + result = result + clear_char; +} +</pre> + +<h3 id="Exemple_Fer_servir_else_if">Exemple: Fer servir <code>else if</code></h3> + +<p>Vegeu que no hi ha cap sintaxi <code>elseif</code> en JavaScript. Tanmateix, es pot escriure amb un espai entre <code>else</code> i <code>if</code>:</p> + +<pre class="brush: js">if (x > 5) { + +} else if (x > 50) { + +} else { + +}</pre> + +<h3 id="Example:_Assignment_within_the_conditional_expression" name="Example:_Assignment_within_the_conditional_expression">Exemple: Assignació dins l'expressió condicional</h3> + +<p>És recomanable no utilitzar assignacions simples en una expressió condicional, atès que l'assignació es pot confondre amb l'igualtat quan es mira per sobre el codi. Per exemple, no utilitzeu el codi següent:</p> + +<pre class="brush: js">if (x = y) { + /* do the right thing */ +} +</pre> + +<p>Si necessiteu usar una assignació dins d'una expressió condicional, una pràctica comuna és ficar parèntesis addicionals embolcallant l'assignació. Per exemple:</p> + +<pre class="brush: js">if ((x = y)) { + /* do the right thing */ +} +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificacó</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>1a edició de ECMAScript.</td> + <td>Estàndard</td> + <td>Definció inicial.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-12.5', 'if statement')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-if-statement', 'if statement')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{ CompatibilityTable() }}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome for Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li>{{jsxref("Statements/block", "block")}}</li> + <li>{{jsxref("Statements/switch", "switch")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/sentencies/index.html b/files/ca/web/javascript/referencia/sentencies/index.html new file mode 100644 index 0000000000..e91e446cbf --- /dev/null +++ b/files/ca/web/javascript/referencia/sentencies/index.html @@ -0,0 +1,129 @@ +--- +title: Statements and declarations +slug: Web/JavaScript/Referencia/Sentencies +tags: + - JavaScript + - NeedsTranslation + - Reference + - TopicStub + - statements +translation_of: Web/JavaScript/Reference/Statements +--- +<div>{{jsSidebar("Statements")}}</div> + +<p>Les aplicacions de JavaScript consisteixen en sentències amb una sintaxi adequada. Una sola sentència pot ocupar múltiples línies. Múltiples sentències poden donar-se en una sola línia si cada sentència és separada per un punt i coma. Això no és una paraula clau sino un grup de paraules claus.</p> + +<h2 id="Sentències_i_declaracions_per_categoria">Sentències i declaracions per categoria</h2> + +<p>Per a un llistat alfabetic vegeu el menú de l'esquerra.</p> + +<h3 id="Control_de_fluxe">Control de fluxe</h3> + +<dl> + <dt>{{jsxref("Sentencies/block", "Block")}}</dt> + <dd>Una sentència bloc s'utilitza per a agrupar zero o més sentències. El bloc és delimitat per un parell de claus {}.</dd> + <dt>{{jsxref("Sentencies/break", "break")}}</dt> + <dd>Acaba la sentència bucle, switch o label actual i transfereix el control del programa a la sentència que segueix la sentència que tot just s'ha acabat.</dd> + <dt>{{jsxref("Sentencies/continue", "continue")}}</dt> + <dd>Acaba l'execució de les sentències de la iteració del bucle actual o bé del bucle especificat, i continua l'execució del bucle amb la següent iteració.</dd> + <dt>{{jsxref("Sentencies/Empty", "Empty")}}</dt> + <dd>Una sentència buida s'utilitza per a proporcionar una sentència que no fa res quan JavaScript espera una sentència però no se'n necesita executar cap.</dd> + <dt>{{jsxref("Sentencies/if...else", "if...else")}}</dt> + <dd>Executa una sentència si la condició especificada és certa. Si la condició és falsa una altra sentència pot ser executada.</dd> + <dt>{{jsxref("Sentencies/switch", "switch")}}</dt> + <dd>Evalua una expressió, compara el resultat de l'evaluació amb una clàusula de tipus <em>case </em>i executa la sentència pertanyent a la clàusula case que és igual a l'evaluació de l'expressió.</dd> + <dt>{{jsxref("Sentencies/throw", "throw")}}</dt> + <dd>Llença una excepció definida per l'usuari.</dd> + <dt>{{jsxref("Sentencies/try...catch", "try...catch")}}</dt> + <dd>Executa un bloc de sentències i, en cas que alguna sentència del bloc llenci una excepció, executa una sentència alternativa.</dd> +</dl> + +<h3 id="Declaracions">Declaracions</h3> + +<dl> + <dt>{{jsxref("Sentencies/var", "var")}}</dt> + <dd>Declara una variable, opcionalment li assigna un valor.</dd> + <dt>{{experimental_inline()}} {{jsxref("Sentencies/let", "let")}}</dt> + <dd>Declara un bloc de variables d'àmbit local, opcionalment li assigna un valor.</dd> + <dt>{{experimental_inline()}} {{jsxref("Sentencies/const", "const")}}</dt> + <dd>Declara una constant de només lectura.</dd> +</dl> + +<h3 id="Funcions">Funcions</h3> + +<dl> + <dt>{{jsxref("Sentencies/function", "function")}}</dt> + <dd>Declara una funció amb els paràmetres especificats.</dd> + <dt>{{experimental_inline()}} {{jsxref("Sentencies/function*", "function*")}}</dt> + <dd>Funcions generadores que permeten escriure <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/The_Iterator_protocol">iteradors</a> de forma més senzilla.</dd> + <dt>{{jsxref("Sentencies/return", "return")}}</dt> + <dd>Especifica el valor que retornarà una funció.</dd> +</dl> + +<h3 id="Iteracions">Iteracions</h3> + +<dl> + <dt>{{jsxref("Sentencies/do...while", "do...while")}}</dt> + <dd>Crea un bucle que executa una sentència especificada fins que la condició de test s'evalua a fals. La condició s'evalua després d'executar la sentència, resultant en que la sentència especificada s'executa al menys un cop.</dd> + <dt>{{jsxref("Sentencies/for", "for")}}</dt> + <dd>Crea un bucle que sonsisteix en tres expressions opcionals embolcallades per parèntesi i separades per punts i coma, seguides d'una sentència que s'executarà en el bucle.</dd> + <dt>{{deprecated_inline()}} {{non-standard_inline()}} {{jsxref("Sentencies/for_each...in", "for each...in")}}</dt> + <dd>Itera sobre tots els valors de les propietats d'un objecte, assignant a una variable determinada el seu valor. Per a cada propietat distinta s'executa una sentència.</dd> + <dt>{{jsxref("Sentencies/for...in", "for...in")}}</dt> + <dd>Itera sobre les propietats enumerables d'un objecte en un ordre arbitrari. Per a cada propietat distinta s'executa una sentència.</dd> + <dt>{{experimental_inline()}} {{jsxref("Sentencies/for...of", "for...of")}}</dt> + <dd>Itera sobre objectes iterables (incloent <a href="https://developer.mozilla.org/en-US/docs/Core_JavaScript_1.5_Reference/Global_Objects/Array" title="Array">arrays</a>, objectes similar a arrays, <a href="https://developer.mozilla.org/en-US/docs/JavaScript/Guide/Iterators_and_Generators" title="Iterators and generators">iteradors i generadors</a>), executant una sentència per al valor de cada propietat distinta.</dd> + <dt>{{jsxref("Sentencies/while", "while")}}</dt> + <dd>Crea un bucle que executa la sentència donada mentre una condició sigui certa. La condició s'evalua abans d'executar la sentència.</dd> +</dl> + +<h3 id="Altres">Altres</h3> + +<dl> + <dt>{{jsxref("Sentencies/debugger", "debugger")}}</dt> + <dd>Invoca qualsevol funcionalitat de depuració que estigui disponible. Si no hi ha cap funcionalitat de depuració disponible aquesta sentència no te cap efecte.</dd> + <dt>{{experimental_inline()}} {{jsxref("Sentencies/export", "export")}}</dt> + <dd>Utilitzada per a exportar funcions per a que aquestes estiguin disponibles per a imports a mòduls externs, en altres scripts.</dd> + <dt>{{experimental_inline()}} {{jsxref("Sentencies/import", "import")}}</dt> + <dd>Utilitzada per a importar funcions exportades d'un mòdul extern, un altre script.</dd> + <dt>{{jsxref("Sentencies/label", "label")}}</dt> + <dd>Asigna un identificador a una sentència. Aquest identificador pot ser emprat en sentències <code>break</code> o <code>continue</code>.</dd> +</dl> + +<dl> + <dt>{{deprecated_inline()}} {{jsxref("Sentencies/with", "with")}}</dt> + <dd>Extèn la cadena d'àmbit per a una sentència.</dd> +</dl> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentari</th> + </tr> + <tr> + <td>ECMAScript 1a Edició</td> + <td>Standard</td> + <td>Definició inicial.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-12', 'Statements')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-ecmascript-language-statements-and-declarations', 'Llenguatge ECMAScript: Sentències i declaracions')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Nou: function*, let, for...of, yield</td> + </tr> + </tbody> +</table> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators">Operadors</a></li> +</ul> diff --git a/files/ca/web/javascript/referencia/sentencies/return/index.html b/files/ca/web/javascript/referencia/sentencies/return/index.html new file mode 100644 index 0000000000..5b3c3e902a --- /dev/null +++ b/files/ca/web/javascript/referencia/sentencies/return/index.html @@ -0,0 +1,183 @@ +--- +title: return +slug: Web/JavaScript/Referencia/Sentencies/return +translation_of: Web/JavaScript/Reference/Statements/return +--- +<div> +<div>{{jsSidebar("Statements")}}</div> +</div> + +<h2 id="Resum">Resum</h2> + +<p><u>La <strong>sentència</strong> <strong><code>return</code> </strong>finalitza l'execució de la funció i especifica un valor que retornarà a la funció que l'ha cridat.</u></p> + +<h2 id="Syntax" name="Syntax">Sintaxi</h2> + +<pre class="syntaxbox">return [[expressió]]; </pre> + +<dl> + <dt><code>expressió</code></dt> + <dd>L'expressió que retorna. En cas d'ometre-s, es retorna <code>undefined</code>.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Quan una sentència <code>return</code> és cridada dins una funció, l'execució d'aquesta funció s'atura. En cas d'especificar-se, un valor donat és retornat a la funció que l'ha cridat. Si s'omet l'expressió, es retornarà <code>undefined</code>. En les següents sentències return totes aturen l'execució de la funció:</p> + +<pre class="brush: js">return; +return true; +return false; +return x; +return x + y / 3; +</pre> + +<h3 id="Insersió_automàtica_de_punt_i_coma">Insersió automàtica de punt i coma</h3> + +<p><u>La sentència <code>return</code> es veu afectada per la <a href="/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#Automatic_semicolon_insertion">insersió automàtica de punt i coma ()</a>. No hi ha cap final de línia entre la paraula clau <code>return</code> i l'expressió permesa.</u></p> + +<pre class="brush: js">return +a + b; + +// is transformed by ASI into + +return; +a + b; +</pre> + +<h2 id="Examples" name="Examples">Exemples</h2> + +<h3 id="Example:_Using_return" name="Example:_Using_return">Exemple: Fer servir <code>return</code></h3> + +<p>La següent funció retorna el quadrat del seu argument, <code>x</code>, on <code>x</code> és un nombre.</p> + +<pre class="brush: js">function square(x) { + return x * x; +} +</pre> + +<h3 id="Example:_Interrupt_a_function" name="Example:_Interrupt_a_function">Exemple: Interrompre una funció</h3> + +<p>Una funció s'atura immediatament en el moment en que es crida <code>return</code>.</p> + +<pre class="brush: js">function counter() { + for (var count = 1; ; count++) { // infinite loop + console.log(count + "A"); // until 5 + if (count === 5) { + return; + } + console.log(count + "B"); // until 4 + } + console.log(count + "C"); // never appears +} + +counter(); + +// Output: +// 1A +// 1B +// 2A +// 2B +// 3A +// 3B +// 4A +// 4B +// 5A +</pre> + +<h3 id="Exemple_Returning_a_function">Exemple: Returning a function</h3> + +<p>Per més informació sobre closures, llegiu la <a href="/en-US/docs/Web/JavaScript/Guide/Closures">Guia de JavaScript</a>.</p> + +<pre class="brush: js">function magic(x) { + return function calc(x) { return x * 42}; +} + +var answer = magic(); +answer(1337); // 56154 +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>1a edició de ECMAScript</td> + <td>Estàndard</td> + <td>Definició inicial.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-12.9', 'Return statement')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-return-statement', 'Return statement')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{ CompatibilityTable() }}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome per Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Functions_and_function_scope" title="En/Core_JavaScript_1.5_Reference/Functions">Funcions</a></li> + <li><a href="/en-US/docs/Web/JavaScript/Guide/Closures">Closures</a></li> +</ul> diff --git a/files/ca/web/javascript/referencia/sentencies/throw/index.html b/files/ca/web/javascript/referencia/sentencies/throw/index.html new file mode 100644 index 0000000000..37d13b964b --- /dev/null +++ b/files/ca/web/javascript/referencia/sentencies/throw/index.html @@ -0,0 +1,228 @@ +--- +title: throw +slug: Web/JavaScript/Referencia/Sentencies/throw +translation_of: Web/JavaScript/Reference/Statements/throw +--- +<div>{{jsSidebar("Statements")}}</div> + +<p>La <strong>sentència <code>throw</code> </strong>llença una excepció definida per l'usuari. L'execució de la funció actual s'aturarà (les sentències de després de <code>throw</code> no s'executaran) i es passarà el control al primer bloc <a href="/en-US/docs/Web/JavaScript/Reference/Statements/try...catch"><code>catch</code></a> en la pila de crides. Si no existeix cap bloc <code>catch</code> en les funcions de crides, el programa s'acabarà.</p> + +<h2 id="Sintaxi">Sintaxi</h2> + +<pre class="syntaxbox">throw <em>expressió</em>; </pre> + +<dl> + <dt><code>expressió</code></dt> + <dd>L'expressió que es llença.</dd> +</dl> + +<h2 id="Descripció">Descripció</h2> + +<p>Utilitzeu una sentència <code>throw</code> per llençar una excepció. Quan es llença l'excepció, <code>expression</code> especifica el valor de l'excepció. Cadascun dels exemples següents llença una excepció:</p> + +<pre class="brush: js">throw "Error2"; // genera una excepció amb un valor tipus cadena +throw 42; // genera una excepció amb el valor 42 +throw true; // genera una excepció amb el valor true</pre> + +<p>Tingueu en compte que la sentència <code>throw</code> queda afectada per <a href="/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#Automatic_semicolon_insertion">insersió automàtica de punts i comes (ASI)</a> ja que no es permet cap final de línia<u> </u>entre la paraula clau <code>throw</code> i l'expressió.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Llença_un_objecte">Llença un objecte</h3> + +<p>Es pot especificar un objecte quan es llença una excepció. Es pot fer referència a les propietats de l'objecte en el bloc <code>catch</code>. L'exemple següent crea un objecte <code>myUserException</code> de tipus <code>UserException</code> i l'utilitza en una sentència <code>throw</code>.</p> + +<pre class="brush: js">function UserException(message) { + this.message = message; + this.name = "UserException"; +} +function getMonthName(mo) { + mo = mo-1; // Adjustar el número de mes per un índex d'array (1=Jan, 12=Dec) + var months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", + "Aug", "Sep", "Oct", "Nov", "Dec"]; + if (months[mo] !== undefined) { + return months[mo]; + } else { + throw new UserException("InvalidMonthNo"); + } +} + +try { + // sentències que s'intentarà exxecutar + var myMonth = 15; // 15 està fora del rang i llençarà l'excepció + monthName = getMonthName(myMonth); +} catch (e) { + monthName = "unknown"; + logMyErrors(e.message, e.name); // es pasa l'objecte excepció al manegador d'errors +} +</pre> + +<h3 id="Un_altre_exemple_de_llençar_un_objecte">Un altre exemple de llençar un objecte</h3> + +<p>L'exemple següent comprova si una cadena donada és un codi postal per EE.UT. SI el codi postal utilitza un format invàlid, la sentència throw llença una excepció creant un objecte de tipus <code>ZipCodeFormatException</code>.</p> + +<pre class="brush: js">/* + * Crea un objecte ZipCode. + * + * Els formats acceptats per a un codi postal són: + * 12345 + * 12345-6789 + * 123456789 + * 12345 6789 + * + * Si l'argument passat al constructor ZipCode no s'adjusta a + * un d'aquests patrons, es llença una excepció. + */ + +function ZipCode(zip) { + zip = new String(zip); + pattern = /[0-9]{5}([- ]?[0-9]{4})?/; + if (pattern.test(zip)) { + // el valor del codi postal serà el primer trobat dins la cadena + this.value = zip.match(pattern)[0]; + this.valueOf = function() { + return this.value + }; + this.toString = function() { + return String(this.value) + }; + } else { + throw new ZipCodeFormatException(zip); + } +} + +function ZipCodeFormatException(value) { + this.value = value; + this.message = "no s'adjusta al format esperat per a un codi postal"; + this.toString = function() { + return this.value + this.message; + }; +} + +/* + * Això podria trobar-se en un script que valida adresses d'EE.UU. + */ + +const ZIPCODE_INVALID = -1; +const ZIPCODE_UNKNOWN_ERROR = -2; + +function verifyZipCode(z) { + try { + z = new ZipCode(z); + } catch (e) { + if (e instanceof ZipCodeFormatException) { + return ZIPCODE_INVALID; + } else { + return ZIPCODE_UNKNOWN_ERROR; + } + } + return z; +} + +a = verifyZipCode(95060); // retorna 95060 +b = verifyZipCode(9560); // retorna -1 +c = verifyZipCode("a"); // retorna -1 +d = verifyZipCode("95060"); // retorna 95060 +e = verifyZipCode("95060 1234"); // retorna 95060 1234 +</pre> + +<h3 id="Rellençar_una_excepció">Rellençar una excepció</h3> + +<p>Es pot utilitzar <code>throw</code> per rellençar una excepció després de caputrar-la. L'exemple següent captura una excepció amb un valor numèric i el rellença si el valor és major de 50. L'excepció rellençada es propaga fins a la funció que l'envolcalla o al nivell superior de forma que l'usuari ho vegi.</p> + +<pre class="brush: js">try { + throw n; // llença una excepció amb un valor numèric +} catch (e) { + if (e <= 50) { + // sentències per manejar excepcions 1-50 + } else { + // no es pot manejar aquesta excepció, per tant es rellença + throw e; + } +} +</pre> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>{{SpecName('ES3')}}</td> + <td>{{Spec2('ES3')}}</td> + <td>Definició inicial. Implementat en JavaScript 1.4</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-12.13', 'throw statement')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-throw-statement', 'throw statement')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{CompatibilityTable}}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome per Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + <td>{{CompatVersionUnknown}}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="Vegeu_també">Vegeu també</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Statements/try...catch"><code>try...catch</code></a></li> +</ul> diff --git a/files/ca/web/javascript/referencia/sentencies/while/index.html b/files/ca/web/javascript/referencia/sentencies/while/index.html new file mode 100644 index 0000000000..d3997dbefd --- /dev/null +++ b/files/ca/web/javascript/referencia/sentencies/while/index.html @@ -0,0 +1,131 @@ +--- +title: while +slug: Web/JavaScript/Referencia/Sentencies/while +translation_of: Web/JavaScript/Reference/Statements/while +--- +<div>{{jsSidebar("Statements")}}</div> + +<h2 id="Summary" name="Summary">Resum</h2> + +<p>la <strong>sentència while</strong> crea un bucle que executa una sentència especificada sempre que la condició s'avalui certa. La condició s'avalua abans d'executar la sentència..</p> + +<h2 id="Syntax" name="Syntax">Sintaxi</h2> + +<pre class="syntaxbox">while (<em>condició</em>) { + <em>sentència</em> +}</pre> + +<dl> + <dt><code>condició</code></dt> + <dd>Una expressió que s'avalua abans de cada passada del bucle. Si aquesta condició esdevé certa, s'executa la <code>sentència</code>. Quan la condició esdevé falsa, l'execució continua amb la sentència posterior al bucle <code>while</code>.</dd> + <dt><code>sentència</code></dt> + <dd>Una sentència que s'executa sempre que la condició esdevingui certa. Per executar múltiples sentències dins un bucle, podeu fer ús de la sentència <a href="/en-US/docs/JavaScript/Reference/Statements/block" title="JavaScript/Reference/Statements/block">block</a> (<code>{ ... }</code>) per agrupar aquestes sentències.</dd> +</dl> + +<h2 id="Examples" name="Examples">Exemples</h2> + +<p>El següent bucle <code>while</code> itera sempre que <code>n</code> sigui menor que tres.</p> + +<pre class="brush:js">var n = 0; +var x = 0; + +while (n < 3) { + n++; + x += n; +}</pre> + +<p>En cada iteració, el bucle incrementa <code>n</code> i ho suma a <code>x</code>. Per tant, <code>x</code> i <code>n</code> prenen els següents valors:</p> + +<ul> + <li>Després de la primera volta: <code>n</code> = 1 i <code>x</code> = 1</li> + <li>Després de la segona volta: <code>n</code> = 2 i <code>x</code> = 3</li> + <li>Després de la tercera volta: <code>n</code> = 3 i <code>x</code> = 6</li> +</ul> + +<p>Després de completar la tercera volta, la condició <code>n</code> < 3 ja no esdevé més certa, i per tant finalitza el bucle.</p> + +<h2 id="Especificacions">Especificacions</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Especificació</th> + <th scope="col">Estat</th> + <th scope="col">Comentaris</th> + </tr> + <tr> + <td>1a edició de ECMAScript.</td> + <td>Estàndard</td> + <td>Definició inicial.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-12.6.2', 'while statement')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-while-statement', 'while statement')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilitat_amb_navegadors">Compatibilitat amb navegadors</h2> + +<p>{{ CompatibilityTable() }}</p> + +<div id="compat-desktop"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Chrome</th> + <th>Firefox (Gecko)</th> + <th>Internet Explorer</th> + <th>Opera</th> + <th>Safari</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + </tbody> +</table> +</div> + +<div id="compat-mobile"> +<table class="compat-table"> + <tbody> + <tr> + <th>Característica</th> + <th>Android</th> + <th>Chrome per Android</th> + <th>Firefox Mobile (Gecko)</th> + <th>IE Mobile</th> + <th>Opera Mobile</th> + <th>Safari Mobile</th> + </tr> + <tr> + <td>Suport bàsic</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + <td>{{ CompatVersionUnknown() }}</td> + </tr> + </tbody> +</table> +</div> + +<h2 id="See_also" name="See_also">Vegeu també</h2> + +<ul> + <li><a href="/en-US/docs/Web/JavaScript/Reference/Statements/do...while"><code>do...while</code></a></li> + <li>{{jsxref("Statements/for", "for")}}</li> +</ul> diff --git a/files/ca/web/javascript/referencia/sobre/index.html b/files/ca/web/javascript/referencia/sobre/index.html new file mode 100644 index 0000000000..b1fa0734b3 --- /dev/null +++ b/files/ca/web/javascript/referencia/sobre/index.html @@ -0,0 +1,44 @@ +--- +title: Sobre aquesta referència +slug: Web/JavaScript/Referencia/Sobre +translation_of: Web/JavaScript/Reference/About +--- +<p>{{JsSidebar}}</p> + +<p>La referència de JavaScript serveix com a repositori de coneixement del llenguatge. Hom trobarà aquí el llenguatge descrit en detall. Durant el transcurs d'escriure codi en JavaScript, aquestes pàgines seran de gran ajut com a referència (d'aquí el títol). Si el que es pretén és aprendre JavaScript, o el que es necessita ajuda a l'hora d'entendre algunes de les seves capacitats o característiques, trobarà la informació que buaca a la <a href="/ca/docs/Web/JavaScript/Guide">guia de JavaScript</a>.</p> + +<p>El llenguatge de programació JavaScript està pensat per a ser utilitzat sota un entorn més gran, ja sigui un navegador web, scripts de servidor o quelcom similar. Aquesta referència intenta majoriariament ser agnòstica quant a l'entorn i no per tant no està adreçada únicament a un entorn donat pel navegador web.</p> + +<h2 id="On_trobar_informació_sobre_JavaScript">On trobar informació sobre JavaScript</h2> + +<p>La documentació de les característiques bàsiques de Javascript (<a href="/ca/docs/Web/JavaScript/Language_Resources">ECMAScript</a> pur, majoritàriament) inclou el següent:</p> + +<ul> + <li>La <a href="/ca/docs/Web/JavaScript/Guide">guia de JavaScript</a></li> + <li>La <a href="/ca/docs/Web/JavaScript/Reference">referència de JavaScript</a></li> +</ul> + +<p>Si s'és nou quant a JavaScript, es recomana començar per la <a href="/ca/docs/Web/JavaScript/Guide">guia</a>. Un cop assolits els fonaments, la <a href="/ca/docs/Web/JavaScript/Reference">referència</a> esdevindrà útil per obtindre més detalls sobre objectes individuals i construccions del llenguatge.</p> + +<h2 id="Estructura_de_la_referència">Estructura de la referència</h2> + +<p>La referència de JavaScript es composa dels següents capítols:</p> + +<dl> + <dt><a href="/ca/docs/Web/JavaScript/Reference/Global_Objects">Objectes bàsics estandard</a></dt> + <dd>Aquest capítol documenta tots els objectes standard proporcionats per JavaScript, així com els seus mètodes i propietats.</dd> + <dt><a href="/ca/docs/Web/JavaScript/Reference/Statements">Sentències i declaracions</a></dt> + <dd>Una aplicació en JavaScript consisteix en un conjunt de sentències amb una sintaxi adequada. Una sola sentència pot ocupar més d'una línia. Tanmateix múltimples sentències poden aparèixer en una única línia si estan separades per un punt i coma (;).</dd> + <dt><a href="/ca/docs/Web/JavaScript/Reference/Functions">Funcions</a></dt> + <dd>Capítol dedicat a les funcions en JavaScript.</dd> + <dt><a href="/ca/docs/Web/JavaScript/New_in_JavaScript">Històric de versions</a></dt> + <dd>Aquest capítol mostra les diferències entre les diferents versions de JavaScript.</dd> +</dl> + +<h2 id="Més_pàgines_de_referència">Més pàgines de referència</h2> + +<ul> + <li><a href="/ca/docs/Web/JavaScript/Reference/Deprecated_and_obsolete_features">Característiques obsoletes i en desús</a></li> + <li><a href="/ca/docs/Web/JavaScript/Reference/Lexical_grammar">Gramàtica lèxica</a></li> + <li><a href="/ca/docs/Web/JavaScript/Data_structures">Tipus de dades i estructures de dades</a></li> +</ul> |