Expressions i operadors

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.

Expressions

Una expressió és qualsevol unitat de codi vàlida que esdevé un valor.

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

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

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.

JavaScript té les següents categories d'expressions:

• Aritmètiques: s'avaluen a un nombre, per exemple 3.14159. (Generalment utilitzen operadors aritmètics.)
• String: s'avaluen a una cadena de caràcters, per exemple, "Pau" o "234". (Generalment utilitzen operadors d'strings.)
• Lògiques: s'avaluen a cert o fals. (sovint inclouen operadors lògics.)
• Objecte: s'avaluen a un objecte. (Vegeu els operadors especials més informació.)

Operadors

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

• Operadors d'assignació
• Operadors de comparació
• Operadors aritmètics
• Operadors de bits
• Operadors lògics
• Operadors de strings
• Operadors especials

JavaScript té operadors binaris i unaris, 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:

operand1 operador operand2

Per exemple, 3+4 o x*y.

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

operador operand

o be

operand operador

Per exemple, x++ o ++x.

Operadors d'assignació

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 (=), que assigna el valor de l'operand de la dreta a l'operand de l'esquerra. És a dir, x = y assigna el valor de y a x.

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

Operadors de comparació

This seems to me kind of poorly explained, mostly the difference betwen "==" and "==="...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ó.
 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 === i !==, 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:

var var1 = 3, var2 = 4;

Operadors aritmètics

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 Infinity). Per exemple:

console.log(1 / 2); /* imprimeix 0.5 */
console.log(1 / 2 == 1.0 / 2.0); /* això també és cert */

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

Operadors de bits

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.

La taula següent resumeix els operadors de bits disponibles a JavaScript.

Operadors lògics de bits

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

• Es converteixen els operands a nombres sencers de 32 bits expressats per una sèrie de bits (zeros i uns).
• 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.
• S'aplica l'operador per a cada parella de bits, i el resultat es construeix de forma binària.

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:

Fixeu-vos que a l'utilitzar l'operador de bits NOT 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).

Operadors de desplaçament de bits

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.

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.

Operadors lògics

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.

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

El codi següent mostra exemples de l'operador && (AND lògic).

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

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

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

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

var n1 = !true;  // !t retorna false
var n2 = !false; // !f retorna true
var n3 = !"Cat"; // !t retorna false

Avaluació en curtcircuit

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:

• false && quelcom es curtcircuita avaluant-se a false.
• true || quelcom es curtcircuita avaluant-se a true.

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

Operadors de Strings

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, "la meva " + "string" retorna la string "la meva string".

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

Operadors especial

JavaScript ofereix els següents operadors especials:

• Operador condicional
• Operador coma
• delete
• in
• instanceof
• new
• this
• typeof
• void

Operador condicional

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:

condició ? val1 : val2

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

Per exemple,

var estat = (edat >= 18) ? "adult" : "menor";

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

Operador coma

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

Per exemple, si a é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:

for (var i = 0, j = 9; i <= j; i++, j--)
  document.writeln("a[" + i + "][" + j + "]= " + a[i][j]);

delete

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

delete nomObjecte;
delete nomObjecte.property;
delete nomObjecte[index];
delete propietat; // Només és legal dins una sentència with

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

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

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

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

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)

Esborrar elements d'un array

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

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

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

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 delete. Al següent exemple, trees[3] rep el valor undefined, però l'elelement de l'array encara existeix:

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

in

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

nomPropOnombre in nomObjecte

on nomPropOnombre é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 nomObjecte és el nom d'un objecte.

Els següents exemples mostren alguns usos de l'operador in.

// 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

instanceof

L'operador instanceof retorna cert si l'objecte especificat és del tipus especificat. La sintaxi és:

nomObjecte instanceof tipusObjecte

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

Utilitzeu instanceof 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.

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

var dia = new Date(1995, 12, 17);
if (dia instanceof Date) {
  // bloc de codi que s'executarà
}

new

L'operador new 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 Array, Boolean, Date, Function, Image, Number, Object, Option, RegExp, o String. Al servidor també es pot emprar amb DbPool, Lock, File, i SendMail. La sintaxi de new és la següent:

var nomObjecte = new tipusObjecte([param1, param2, ..., paramN]);

També és posible crear objectes mitjançant inicialitzadors d'objectes, tal i com s'explica a utilitzar inicialitzadors d'objectes.

Vegeu la pàgina de l'operador new a la Referència del nucli de JavaScript per a més informació.

this

La paraula clau this 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 this és la següent:

this["nomPropietat"]

this.nomPropietat

Exemple 1.
Suposem que una funció anomenada validate valida la propietat value d'un objecte, donat l'objecte i el rang de valors:

function validate(obj, lowval, hival){
  if ((obj.value < lowval) || (obj.value > hival))
    alert("Valor no vàlid!");
}

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

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

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

<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>

typeof

L'operador typeof es pot utilitzar de qualsevol de les formes següents:

1. typeof operand
   

2. typeof (operand)
   

L'operador typeof 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.

Suposem que es defineixen les següents variables:

var myFun = new Function("5 + 2");
var forma = "rodona";
var tamany = 1;
var avui = new Date();

L'operador typeof retornarà els següents resultats per a aquestes variables:

typeof myFun;      // retorna "function"
typeof forma;      // retorna "string"
typeof tamany;     // retorna "number"
typeof avui;       // retorna "object"
typeof noExisteix; // retorna "undefined"

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

typeof true; // retorna "boolean"
typeof null; // retorna "object"

Per a un nombre o string, l'operador typeof retorna els següents resultats:

typeof 62;            // retorna "number"
typeof 'Hola món';    // retorna "string"

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

typeof document.lastModified; // retorna "string"
typeof window.length;         // retorna "number"
typeof Math.LN2;              // retorna "number"

Per a mètodes i funcions, l'operador typeof retorna els següents resultats:

typeof blur;        // retorna "function"
typeof eval;        // retorna "function"
typeof parseInt;    // retorna "function"
typeof shape.split; // retorna "function"

Per a objectes predefinits, l'operador typeof retorna els resultats següents:

typeof Date;     // retorna "function"
typeof Function; // retorna "function"
typeof Math;     // retorna "object"
typeof Option;   // retorna "function"
typeof String;   // retorna "function"

void

L'operador void es pot emprar de qualsevol de les maneres següents:

1. void (expression)
   

2. void expression
   

L'operador void avalua una expressió però no retorna cap valor. expression é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.

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

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, void(0) serà avaluada com a undefined, la qual cosa no té cap efecte en JavaScript.

<A HREF="javascript:void(0)">Cliqueu aquí per a no fer res</A>

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

<A HREF="javascript:void(document.form.submit())">
Feu clic aquí per a enviar el formulari</A>

Precedència d'operadors

La precedència 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.

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

Trobareu una versió més detallada d'aqueta taula, completa amb enllaços a a detalls adicionals per a cada operador a la Referència de JavaScript.