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 d'assignació compostos | Significat |
---|---|
x += y |
x = x + y |
x -= y |
x = x - y |
x *= y |
x = x * y |
x /= y |
x = x / y |
x %= y |
x = x % y |
x <<= y |
x = x << y |
x >>= y |
x = x >> y |
x >>>= y |
x = x >>> y |
x &= y |
x = x & y |
x ^= y |
x = x ^ y |
x |= y |
x = x | y |
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;
Operador | Descripció | Exemples que s'avaluen a cert |
---|---|---|
Igualtat (== ) |
Retorna true si els operands són iguals. | 3 == var1
3 == '3' |
No-igualtat (!= ) |
Retorna true si els operands són diferents. | var1 != 4 |
Igualtat estricta (=== ) |
Retorna true si els operands són iguals i del mateix tipus. Vegeu també Object.is i igualtat a JS. |
3 === var1 |
No-igualtat estricta (!== ) |
Retorna true si els operands no són iguals i/o del mateix tipus. | var1 !== "3" |
Major que (> ) |
Retorna true si l'operand de l'esquerra és més gran que l'operand e la dreta. | var2 > var1 |
Major o igual que (>= ) |
Retorna true si l'operand de l'esquera és major o igual que l'operand de la dreta. | var2 >= var1 |
Menor que (< ) |
Retorna true si l'operand de l'esquerra és més petit que l'operand de la dreta. | var1 < var2 |
Menor o igual que (<= ) |
Retorna true si l'operand de l'esquerra és menor o igual que l'operand de la dreta. | var1 <= var2 |
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:
Operador | Descripció | Exemple |
---|---|---|
% (Mòdul) |
Operador binari. Retorna el residu de dividir els dos operands. | 12 % 5 retorna 2. |
++ (Increment) |
Operador unari. Afegeix un al seu operand. Si s'utilitza com a prefix ( |
Si x és 3, llavors ++x assigna 4 a x i retorna 4, mentre que x++ retorna 3 i, només llavors, assigna 4 a x . |
-- (Decrement) |
Operador uniari. Resta un al seu operand. Retorna el valor anàleg a l'operador increment. | Si x és 3, llavors --x assigna 2 a x i retorna 2, mentre que x-- retorna 3 i, només llavors, assigna 2 a x . |
- (Negació unària) |
Operador unari. Retorna el resultat de negar el seu operand. | Si x val 3, llavors -x retorna -3. |
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.
Operador | Ús | Descripció |
---|---|---|
AND binari | a & b |
Retorna 1 a cada posició de bit on la posició corresponent a ambdós operadors conten uns. |
OR binari | a | b |
Retorna 1 a cada posició de bit on al menys un dels operands té un 1 a la posició corresponent. |
XOR binari | a ^ b |
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. |
NOT binari | ~ a |
Inverteix els bits del seu operand. |
Desplaçament a l'esquerra | a << b |
Desplaça la representació binària de a b bits a l'esquerra, afegint zeros a la dreta. |
Desplaçament a la dreta amb propagació de signe | a >> b |
Desplaça la representació binària de a b bits a la dreta, descartant els bits que no hi caben. |
Desplaçament a la dreta amb inserció de zeros | a >>> b |
Desplaça la representació binària de a b bits a la dreta, descartant els bits que no hi caben i inserint zeros a l'esquerra. |
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:
Expressió | Resultat | Descripció binària |
---|---|---|
15 & 9 |
9 |
1111 & 1001 = 1001 |
15 | 9 |
15 |
1111 | 1001 = 1111 |
15 ^ 9 |
6 |
1111 ^ 1001 = 0110 |
~15 |
-16 |
~ 00000000... 00001111 = 1111 1111 ... 11110000 |
~9 |
-10 |
~ 00000000 ... 0000 1001 = 1111 1111 ... 1111 0110 |
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.
Operador | Descripció | Exemple |
---|---|---|
<< (Desplaçament a l'esquerra) |
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. |
9<<2 retorna 36, perquè 1001 desplaçat 2 bits a l'esquerra esdevé 100100, que és la representació binaria de 36. |
>> (Desplaçament a la dreta amb propagació de signe) |
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. |
9>>2 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, -9>>2 retorna -3, perquè el signe l'operand preseva el signe. |
>>> (Desplaçament a la dreta omplint amb zeros) |
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. |
19>>>2 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. |
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.
Operador | Ús | Descripció |
---|---|---|
&& |
expr1 && expr2 |
(AND lògic) Retorna expr1 si pot ser convertida a fals; en qualsevol altre cas retorna expr2 . Així, quan es proporcionen operands booleans, && retorna true si ambdós operands són true: en qualsevol altre cas retorna fals. |
|| |
expr1 || expr2 |
(OR lògic) Retorna expr1 si pot ser convertida a true; en qualsevol altre cas retorna expr2 . És a dir, quan s'utilitza amb operands booleans, || retorna true si qualsevol dels dos operands és true; si ambdós operands són false, retorna false. |
! |
!expr |
(NOT lògic) Retorna false si el seu únic operand es pot convertir a true; en qualsevol altre cas retorna true. |
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
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:
-
typeof operand
-
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:
-
void (expression)
-
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.
Tipus d'operador | Operadors individuals |
---|---|
membre | . [] |
crida / creació d'una instància | () new |
negació/increment | ! ~ - + ++ -- typeof void delete |
multiplicació/divisió | * / % |
suma/resta | + - |
desplaçament de bits | << >> >>> |
relacionals | < <= > >= in instanceof |
igualtat | == != === !== |
AND binari | & |
XOR binari | ^ |
OR binari | | |
AND lògic | && |
OR lògic | || |
condicional | ?: |
assignació | = += -= *= /= %= <<= >>= >>>= &= ^= |= |
coma | , |
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.