MDN’s new design is in Beta! A sneak peek: https://blog.mozilla.org/opendesign/mdns-new-design-beta/

Esta traducción está incompleta. Por favor, ayuda a traducir este artículo del inglés.

Este capítulo describe expresiones y operadores de JavaScript, incluyendo los de asignación, comparación, aritméticos, bit a bit, lógicos, strings, ternarios y otros.

También tienes disponible una lista completa y detallada de las expresiones y los operadores en la referencia.

Operadores

JavaScript tiene los siguientes tipos de operadores. Esta sección describe dichos operadores y contiene información sobre el orden de los mismos:

JavaScript tiene operadores binarios y unarios, y un operador ternario especial, el operador condicional. Un operador binario necesita dos operandos, uno antes del operador y otro después de este.

operando1 operador operando2

Por ejemplo, 3+4 o x*y.

Un operador unario requiere solamente un operando antes o después del operador:

operando operador

o

operador operando

Por ejemplo, x++ o ++x

Operadores de asignación

Un operador de asignación asigna un valor al operando de la izquierda en función del valor del operando de la derecha. El operador básico de asignación es el de igual (=), que asigna el valor del operando de la derecha al operando de la izquierda. Por ejemplo, x = y, está asignando el valor de y a x.

También existen operadores compuestos de asignación que son la forma abreviada de las operaciones de la siguiente tabla:

Tabla 3.1 Operadores de asignación
Nombre  Operador abreviado Significado
Operadores de asignación x = y x = y
Asignación de adición x += y x = x + y
Asignación de sustracción x -= y x = x - y
Asignación de multiplicación x *= y x = x * y
Asignación de división x /= y x = x / y
Asignación de resto x %= y x = x % y
Asignación de exponenciación x **= y x = x ** y
Asignación de desplazamiento a la izquierda x <<= y x = x << y
Asignación de desplazamiento a la derecha x >>= y x = x >> y
Asignación de desplazamiento a la derecha sin signo x >>>= y x = x >>> y
Asignación AND binaria x &= y x = x & y
Asignación XOR binaria x ^= y x = x ^ y
Asignación OR binaria x |= y x = x | y

Operadores de comparación

This seems to me kind of poorly explained, mostly the difference betwen "==" and "==="... Un operador de comparación compara sus operandos y devuelve un valor lógico en función de si la comparación es verdadera (true) o falsa (false). Los operadores pueden ser númericos, de cadena de caracteres (Strings), lógicos o de objetos. Las cadenas de caracteres son comparadas basándose en un orden lexicográfico estándar, usando valores Unicode. En la mayoría de los casos, si los dos operandos no son del mismo tipo, JavaScript intenta convertirlos en el tipo apropiado para permitir la comparación, generalmente esta conversión se realiza de manera numérica. Las únicas excepciones que tiene esta conversión son los operadores === y !== que ejecutan comparaciones de igualdad o desigualdad de manera estricta (chequeando si ambos operandos son del mismo tipo). Estos operadores no intentan convertir los operandos a un tipo compatible antes de comprobar su igualdad. La siguiente tabla describe los operadores de comparación en base al siguiente código de ejemplo:

var var1 = 3;
var var2 = 4;
Tabla 3.2 Operadores de comparación
Operador Descripción Ejemplos devolviendo true
Igualdad (==) Devuelve true si ambos operandos son iguales. 3 == var1

"3" == var1
3 == "3"

Desigualdad (!=) Devuelve true si ambos operandos no son iguales. var1 != 4
var2 != "3"
Estrictamente iguales (===)

Devuelve true si los operandos son igual y tienen el mismo tipo. Mira también Object.is y sameness in JS.

3 === var1
Estrictamente desiguales (!==)

Devuelve true si los operandos no son iguales y/o no son del mismo tipo.

var1 !== "3"
3 !== "3"
Mayor que (>)

Devuelve true si el operando de la izquierda es mayor que el operando de la derecha.

var2 > var1
"12" > 2
Mayor o igual que (>=) Devuelve true si el operando de la izquierda es mayor o igual que el operando de la derecha. var2 >= var1
var1 >= 3
Menor que (<) Devuelve true si el operando de la izquierda es menor que el operando de la derecha. var1 < var2
"2" < 12
Menor o igual que (<=) Devuelve true si el operando de la izquierda es menor o igual que el operando de la derecha. var1 <= var2
var2 <= 5

Operadores aritméticos

Los operadores aritméticos toman los valores númericos (tanto literales como variables) de sus operandos y devuelven un único resultado numérico. Los operadores aritméticos estandar son la suma (+), la resta (-), la multiplicación (*) y la división (/). Estos operadores funcionan como en la mayoría de los lenguajes de programación cuando son usados con números de coma flotante (en particular, tenga en cuenta que la división por cero produce Infinity). Por ejemplo:

1 / 2; // 0.5
1 / 2 == 1.0 / 2.0; // es true

Además de las operaciones de aritmética estándar (+, -, * y /), JavaScript brinda los siguientes operadores aritméticos descritos en la tabla:

Tabla 3.3 Operadores aritméticos
Operador Descripción Ejemplo
Resto (%)

Operador binario correspondiente al módulo de una operación. Devuelve el resto de la división de dos operandos.

12 % 5 devuelve 2.
Incremento (++)

Operador unario. Incrementa en una unidad al operando. Si es usado antes del operando (++x) devuelve el valor del operando después de añadirle 1 y si se usa después del operando (x++) devuelve el valor de este antes de añadirle 1.

Si x es 3, entonces ++x establece x a 4 y devuelve 4, mientras que x++ devuelve 3 y, solo después de devolver el valor, establece x a 4.
Decremento (--)
 

Operador unario. Resta una unidad al operando. Dependiendo de la posición con respecto al operando tiene el mismo comportamiento que el operador de incremento.

Si x es 3, entonces --x establece x a 2 y devuelve 2, mientras que x-- devuelve 3 y, solo después de devolver el valor, establece x a 2.
Negación Unaria (-)

Operación unaria. Intenta convertir a número al operando y devuelve su forma negativa.

-"3" devuelve -3.
-true devuelve -1.

Unario positivo (+) Operación unaria. Intenta convertir a número al operando. +"3" devuelve 3.
+true devuelve 1.
Exponenciación (**)  Calcula la potencia de la base al valor del exponente. Es equivalente a baseexponente 2 ** 3 devuelve 8.
10 ** -1 devuelve 0.1.

Operadores Bit a bit

Los operadores bit a bit tratan a sus operandos como un conjunto de 32 bits (ceros y unos), en vez de como números decimales, hexadecimales u octales. Por ejemplo, el número decimal 9 se representa en binario como 1001. Los operadores bit a bit realizan sus operaciones en dicha representación binaria, pero devuelven un valor númerico estándar.

La siguiente tabla muestra los operadores bit a bit con los que cuenta JavaScript

Tabla 3.4 Operadores bit a bit
Operador Uso Descripción
AND bit a bit a & b

Devuelve uno por cada posición de bit en la cuales los bits correspondientes de ambos operandos tienen valor uno.

OR bit a bit a | b

Devuelve uno por cada posición de bit en la cual al menos uno de los bits correspondientes de ambos operandos tiene valor uno.

XOR bit a bit a ^ b

Por cada posición de bit en la cual los bits correspondientes de ambos operandos son iguales devuelve cero y si son diferentes devuelve uno.

NOT bit a bit ~ a Invierte los bits del operando.
Desplazamiento a la izquierda a << b

Desplaza b posiciones a la izquierda la representación binaria de a, el exceso de bits desplazados a la izquierda se descarta, dejando ceros a la derecha de los bits desplazados.

Desplazamiento a la derecha con propagación de signo

a >> b

Desplaza b posiciones a la derecha la representación binaria de a, el exceso de bits desplazados a la derecha se descarta.

Desplazamiento a la derecha con relleno de ceros a >>> b

Desplaza b posiciones a la derecha la representación binaria de a, el exceso de bits desplazados a la derecha se descarta, dejando ceros a la izquierda de los bits desplazados.

Operadores lógicos bit a bit

Conceptualmente, los operadores lógicos bit a bit funcionan de la siguiente manera:

  • Los operandos son convertidos a enteros de 32 bits y expresados como series de bits (ceros y unos). Se descartarán los bits más relevantes de los números con más de 32 bits. Por ejemplo el siguiente entero con más de 32 bits será convertido a un entero de 32 bits:
     
    Antes:   11100110111110100000000000000110000000000001
    Después:             10100000000000000110000000000001
  • Cada bit en el primer operando es emparejado con el correspondiente bit en el segundo operando: el primer bit del primer operando con el primer bit del segundo operando, el segundo bit del primer operando con el segundo bit del segundo operando y así consecutivamente.
  • La operación se aplica a cada par de bits y el resultado es construido bit a bit.

Por ejemplo, la representación binaria de 9 es 1001, y la representación binaria de 15 es 1111. Cuando se le aplican a estos valores las operaciones bit a bit, los resultados son los siguientes:

Tabla 3.5 Ejemplo de operadores bit a bit
Expresión Resultado Descripción binaria
15 & 9 9 1111 & 1001 = 1001
15 | 9 15 1111 | 1001 = 1111
15 ^ 9 6 1111 ^ 1001 = 0110
~15 -16 ~00000000...00001111 = 11111111...11110000
~9 -10 ~00000000...00001001 = 11111111...11110110

Observa que los 32 bits son invertidos cuando se usa el operador NOT bit a bit (~), y que los valores con los bits más relevantes (extremo izquierdo) con valor 1 representan números negativos (representación en complemento a dos).

Los operadores de desplazamiento binario

Los operadores de desplazamiento binario utilizan dos operandos: el primero es el número que será desplazado, y el segundo es el número de posiciones binarias que el primer operando será desplazado. La dirección del desplazamiento es controlada por el operador utilizado.

Los operadores de desplazamiento binario convierten los operandos en enteros de 32 bits y retornarán un resultado que será del mismo tipo que el operando de la izquierda

La siguiente tabla recoge los operadores de desplazamiento binario:

Tabla 3.6 Operadores de desplazamiento binario
Operador Descripción Ejemplo
Desplazamiento a la izquierda (<<)

Este operador desplaza hacia la izquierda la representación binaria del primer operando. La cantidad de posiciones de bits desplazadas es marcada por el segundo operando. El exceso de bits desplazado a la izquierda se descarta, dejando ceros a la derecha de los bits desplazados.

9<<2 retorna 36, puesto que la representación binaria de 9 es 1001 y al ser desplazado 2 posiciones de bits hacia la izquierda, da como resultado 100100, cuya representación decimal es 36.

Desplazamiento a la derecha con propagación de signo (>>)

Este operador desplaza hacia la derecha la representación binaria del primer operando. La cantidad de posiciones de bits desplazadas es marcada por el segundo operando. El exceso de bits desplazado a la derecha se descarta.

9>>2 retorna 2, puesto que la representación binaria de 9 es 1001 y al ser desplazada 2 posiciones de bits hacia la derecha, da como resultado 10, cuya representación decimal es 2. Del mismo modo, -9>>2 retorna -3, puesto que al mantener los bits relevantes a la izquierda, el signo se mantiene.
Desplazamiento a la derecha con relleno de ceros (>>>)

Este operador desplaza hacia la derecha la representación binaria del primer operando. La cantidad de posiciones de bits desplazadas es marcada por el segundo operando. El exceso de bits desplazado a la derecha se descarta, dejando ceros a la izquierda de los bits desplazados.

19>>>2 retorna 4, puesto que la representación binaria de 19 es 10011 y al ser desplazada 2 posiciones de bits hacia la derecha da como resultado 100, cuya representación decimal es 4. Para números no negativos este operador generará el mismo resultado que el de desplazamiento a la derecha con propagación de signo (>>).

Operadores lógicos

Los operadores lógicos son comúnmente utilizados con valores booleanos; estos operadores devuelven un valor booleano. Sin embargo, los operadores && y || realmente devuelven el valor de uno de los operandos, asi que si estos operadores son usados con valores no booleanos, podrían devolveran un valor no booleano. En la siguiente tabla se describen los operadores lógicos:

Tabla 3.6 Operadores lógicos
Operador Uso Descripción
AND Lógico (&&) expr1 && expr2

Devuelve expr1 si puede ser convertido a false de lo contrario devuelve expr2. Por lo tanto, cuando se usa con valores booleanos, && devuelve true si ambos operandos son true, en caso contrario devuelve false.

OR Lógico (||) expr1 || expr2

Devuelve expr1 si puede ser convertido a true de lo contrario devuelve expr2. Por lo tanto, cuando se usa con valores booleanos, || devuelve true si alguno de los operandos es true, o false si ambos son false.

NOT Lógico (!) !expr

Devuelve false si su operando puede ser convertido a true, en caso contrario, devuelve true.

Ejemplos de expresiones que pueden ser convertidas a false son aquellas que pueden ser evaluadas como null, 0, NaN, undefined o una cadena vacía.

El siguiente código muestra ejemplos del operador && (AND Lógico).

var a1 = true  && true;     // t && t devuelve true
var a2 = true  && false;    // t && f devuelve false
var a3 = false && true;     // f && t devuelve false
var a4 = false && (3 == 4); // f && f devuelve false
var a5 = "Cat" && "Dog";    // t && t devuelve "Dog"
var a6 = false && "Cat";    // f && t devuelve false
var a7 = "Cat" && false;    // t && f devuelve false

El siguiente código muestra ejemplos del operador || (OR Lógico).

var o1 = true  || true;     // t || t devuelve true
var o2 = false || true;     // f || t devuelve true
var o3 = true  || false;    // t || f devuelve true
var o4 = false || (3 == 4); // f || f devuelve false
var o5 = "Cat" || "Dog";    // t || t devuelve "Cat"
var o6 = false || "Cat";    // f || t devuelve "Cat"
var o7 = "Cat" || false;    // t || f devuelve "Cat"

El siguiente código muestra ejemplos del operador ! (NOT Lógico).

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

Evaluación mínima o evaluación de circuito corto

Como las expresiones lógicas son evaluadas de izquierda a derecha, estas son evaluadas de manera mínima (también llamada de circuito corto) usando las siguientes reglas:

  • false && algo  es mínimamente evaluada a false.
  • true || algo  es mínimamente evaluada a true.

Las reglas de la lógica garantizan que lan anteriores evaluaciones son siempre correctas. Nota que el operando algo no es evaluado, por lo que situarlo no surte ningún efecto.

Operadores de cadenas de caracteres

Además de los operadores de comparación, que pueden ser usados en cadenas de caracteres, el operador de concatenación (+) une dos valores de tipo String, devolviendo otro String correspondiente a la unión de los dos operandos.

Por ejemplo,

console.log("mi " + "string"); // lanza el String "mi string" en la consola.

La versión acortada de este operador de asignación (+=) puede ser usada también para concatenar cadenas de caracteres.

Por ejemplo,

var mistring = "alfa";
mistring += "beto"; // devuelve "alfabeto" y asigna este valor a "mistring".

Operador condicional (ternario)

El operador condicional es el único operador de JavaScript que necesita tres operandos. El operador asigna uno de dos valores basado en una condición. La sintaxis de este operador es:

condición ? valor1 : valor2

Si la condición es true, el operador tomará el valor1, de lo contrario tomará el valor2. Puedes usar el operador condicional en cualquier lugar que use un operador estándar.

Por ejemplo,

var estado = (edad >= 18) ? "adulto" : "menor";

Esta sentencia asigna el valor adulto a la variable estado si edad es mayor o igual a 18, de lo contrario le asigna el valor menor.

Operador coma

El operador coma (,) simplemente evalúa ambos operandos y retorna el valor del último. Este operador es ante todo utilizado dentro de un ciclo for, permitiendo que diferentes variables sean actualizadas en cada iteración del ciclo.

Por ejemplo, si a es un Array bi-dimensional con 10 elementos en cada lado, el siguiente código usa el operador coma para actualizar dos variables al mismo tiempo. El código imprime en la consola los valores correspondientes a la diagonal del Array:

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

Operadores unarios

Una operación unaria es una operación que sólo necesita un operando.

delete

La función del operador delete es eliminar un objeto, una propiedad de un objeto, o un elemento en el indice específico de un Array. La sintaxis es la siguiente:

delete nombreObjeto;
delete nombreObjeto.propiedad;
delete nombreObjeto[indice];
delete propiedad; // solo admitido con una declaración "with"

Donde nombreObjeto es el nombre de un objeto, propiedad el nombre de la propiedad de un objeto, e indice un entero que representa la localización de un elemento en un Array.

La cuarta forma es admitida solo dentro de una sentencia with, para eliminar una propiedad de un objeto.

Puedes usar el operador delete para eliminar aquellas variables que han sido declaradas implícitamente, pero no aquellas que han sido declaradas con var.

Si la operación delete finaliza con éxito, establece la propiedad o el elemento a undefined. El operador delete devuelve true si la operación ha sido posible y false en caso contrario.

x = 42;
var y = 43;
miObj = new Number();
miObj.h = 4;    // crea la propiedad "h"
delete x;       // devuelve true (se puede eliminar si se declaró implícitamente)
delete y;       // devuelve false (no se puede eliminar si se declaró con var)
delete Math.PI; // devuelve false (no se pueden eliminar propiedades predefinidas)
delete miObj.h; // devuelve true (se pueden eliminar propiedades definidas por el usuario)
delete miObj;   // devuelve true (se puede eliminar si se ha declarado implícitamente)
Eliminando elementos de un Array

Cuando se elimina un elemento de un Array, su tamaño no se verá afectado. Por ejemplo, si elimina a[3], a[4] seguirá existiendo pero el valor de a[3] será undefined ya que dejará de existir en el Array.

En el siguiente ejemplo, arboles[3] es eliminado con delete y como se puede constatar el mismo dejará de existir en el Array.

var arboles = new Array("secoya", "laurel", "cedro", "roble", "arce");
delete arboles[3];
if (3 in arboles) {
  // Esto no se ejecutará
}

Si desea que un elemento de un Array exista pero su valor sea undefined, debe asignarle el valor undefined en vez de usar el operador delete. En el siguiente ejemplo a arboles[3] se le asigna el valor undefined, pero el elemento seguirá existiendo

var arboles = new Array("secoya", "laurel", "cedro", "roble", "arce");
arboles[3] = undefined;
if (3 in arboles) {
  // Este trozo si se ejecutará
}

typeof

El operador typeof es usado de las siguientes maneras:

  1. typeof operando
    
  2. typeof (operando)
    

El operador typeof devuelve una cadena de caracteres indicando el tipo del operando evaluado. En los ejemplos anteriores operando hace referencia a la cadena de caracteres, variable, palabra clave u objeto del que se intenta obtener su tipo. Los paréntesis son opcionales.

Supón que defines las siguientes variables:

var miFuncion = new Function("5 + 2");
var forma = "redonda";
var largo = 1;
var hoy = new Date();

El operador typeof devoverá los siguientes resultados en estas variables:

typeof miFuncion; // devuelve "function"
typeof forma;     // devuelve "string"
typeof largo;     // devuelve "number"
typeof hoy;       // devuelve "object"
typeof noExiste;  // devuelve "undefined"

Con las palabras clave true y null, el operador typeof devuelve los siguientes resultados:

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

Con los números o las cadenas de caracteres, el operador typeof devuelve los siguientes resultados:

typeof 62;            // devuelve "number"
typeof 'Hello world'; // devuelve "string"

En el caso de que se utilice como operando una propiedad, el operador typeof devolverá el tipo de dicha propiedad:

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

Con métodos y funciones, el operador typeof devolverá los siguientes resultados:

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

Para objetos predefinidos, el objeto typeof devuelve los siguientes valores:

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

void

El operador void puede usarse en cualquiera de las siguientes maneras:

  1. void (expresion)
    
  2. void expresion
    

El operador void especifica una expresión que será evaluada y no retornará ningún resultado. En los ejemplos anteriores, expresion hace referencia a la expresión que será evaluada. Si bien los paréntesis que envuelven a la expresión son opcionales, en cuanto a estilo del código, es una buena práctica usarlos.

El operador void puede ser usado para especificar una expresión como un link de hipertexto. La expresión será evaluada pero no cargará una página en el documento actual.

El siguiente código crea un link de hipertexto que no hace nada cuando el usuario hace click en él. Cuando el usuario hace click sobre el link, void(0) será evaluada como undefined, lo cual no tiene efecto en JavaScript.

<a href="javascript:void(0)">Haz click aquí para no hacer nada</a>

El siguiente código crea un link de hipertexto que envía un formulario cuando el usuario hace click en él.

<a href="javascript:void(document.form.submit())">
Haz click para enviar</a>

Operadores relacionales

Un operador relacional compara sus operandos y retorna un valor booleano basado en si la comparación es verdadera.

in

El operador in devuelve true si la propiedad especificada como primer operando se encuentra en el objeto especificado como segundo operando. La sintaxis es:

nombrePropiedadoNumero in nombreObjeto

Donde nombrePropiedadoNumero es una cadena o expresión numérica que representa un nombre de propiedad o índice de matriz y nombreObjeto es el nombre de un objeto.

Los siguientes ejemplos muestran algunos usos del operador in.

// Arrays
var arboles = new Array("secoya", "laurel", "cedro", "roble", "arce");
0 in arboles;        // devuelve true
3 in arboles;        // devuelve true
6 in arboles;        // devuelve false
"laurel" in arboles; // devuelve false (Se debe especificar el número de índice,
                     // no el valor contenido en ese índice)
"length" in arboles; // devuelve true (length es una propiedad del Array)

// Objetos predefinidos
"PI" in Math;          // devuelve true
var miCadena = new String("coral");
"length" in miCadena;  // devuelve true

// Objetos creados
var miCoche = {marca: "Honda", modelo: "Accord", fecha: 1998};
"marca" in miCoche;  // devuelve true
"modelo" in miCoche; // devuelve true

instanceof

El operador instanceof devuelve true si el objeto especificado como primer operando es del tipo de objeto especificado como segundo parámetro. La sintaxis es:

nombreObjeto instanceof tipoObjeto

Donde nombreObjeto es el nombre del objeto que se desea comparar y tipoObjeto es un tipo de objeto, como Date o Array.

Utilice instanceof cuando necesite confirmar el tipo de un objeto en tiempo de ejecución. Por ejemplo, al captar excepciones, puede derivarse a un código de manejo de excepciones diferente dependiendo del tipo de excepción lanzada.

Por ejemplo, el código siguiente utiliza instanceof para determinar si elDia es un objeto de tipo Date. Y debido a que elDia es un objeto Date, las sentencias en la sentencia if se ejecutarán.

var elDia = new Date(1995, 12, 17);
if (elDia instanceof Date) {
  // código a ejecutar
}

Precedencia de operadores

La precedencia de operadores determina el orden en que estos son aplicados cuando se evalúa una expresión. Esta precedencia puede ser alterada usando paréntesis.

La siguiente tabla describe la precedencia de operadores, de mayor a menor importancia.

Tabla 3.7 Precedencia de operadores
Tipo de operador operadores individuales
miembro . []
llamar / crear instancia () new
negación / incremento ! ~ - + ++ -- typeof void delete
multiplicación / división * / %
adición / sustracción + -
desplazamiento binario << >> >>>
relación < <= > >= in instanceof
igualdad == != === !==
AND binario &
XOR binario ^
OR binario |
AND binario &&
OR lógico ||
condicional ?:
asignación = += -= *= /= %= <<= >>= >>>= &= ^= |=
coma ,

Una versión más detallada de esta lista, completa y con links a detalles adicionales acerca de cada operador, puede encontrarse en Referencia de JavaScript.

Expresiones

Una expresión es cualquier unidad válida de código que resuelve un valor.

Cada expresión sintáctica válida resuelve a algún valor, pero conceptualmente, hay dos tipos de expresiones: las que tienen efectos secundarios (por ejemplo: aquellas que asignan un valor a una variable) y las que de alguna manera son evaluadas y resuelven un valor.

La expresión x = 7 es un ejemplo del primer tipo. Esta expresión usa el operador = para asignar el valor siete a la variable x. La expresión en sí misma evalúa a siete.

El código 3 + 4 es un ejemplo del segundo tipo de expresiones. Esta expresión usa el operador + para sumar tres y cuatro sin asignar el valor (siete) a ninguna variable.

JavaScript cuenta con las siguientes categorías de expresiones:

  • Aritméticas: evalúan a un número, por ejemplo 3.14159. (Usos generales Operadores aritméticos.)
  • Cadenas de caracteres: evalúan a una cadena de caracteres, por ejemplo, "Juan" o "234". (Usos generales Operadores de cadenas de caracteres.)
  • Lógicas: evalúan a true o false. (A menudo involucran a los Operadores lógicos.)
  • Expresiones primarias: Palabras clave básicas y expresiones generales en JavaScript.
  • Expresiones al lado izquierdo: Los valores izquierdos son el destino de una asignación.

Expresiones primarias

Son palabras claves básicas y expresiones generales en JavaScript.

this

Use esta palabra reservada this para referirse al objeto actual. En general, this hace referencia al objeto llamador en un método. Se usa de la siguiente manera:

this["nombreDePropiedad"]

o

this.nombreDePropiedad

Ejemplo 1:
Supongamos una función llamada validate que valida la propiedad value de un objeto, dado un objeto y dos valores, lowval y hival, como extremos de un rango.

function validate(obj, lowval, hival){
  if ((obj.value < lowval) || (obj.value > hival))
    alert("¡Valor inválido!");
}

Puedes invocar a esta función validate para cada evento onChange de los elementos de un formulario, utilizando this para pasar el campo del formulario como elemento a validar. Por ejemplo:

<b>Ingrese un número entre 18 y 99:</b>
<input type="text" name="age" size=3 onChange="validate(this, 18, 99);">

Ejemplo 2:
Cuando es combinada con la propiedad form, this puede hacer referencia al formulario padre del elemento actual. En el siguiente ejemplo, el formulario miFormulario contiene un elemento input de tipo text y un elemento input de tipo button. Cuando el usuario hace clic en el botón, se le asigna el nombre del formulario al input de tipo text. El evento onClick del botón usa this.form para hacer referencia al formulario padre, miFormulario.

<form name="miFormulario">
    Nombre del formulario:
    <input type"text" name="text1" value="Beluga"/>
    <input type="button" name="button1" value="Mostrar nombre del formulario"
        onClick="this.form.text1.value = this.form.name;"/>
</form>

Operador de agrupación

El operador de agrupación ( ) controla la precedencia de la evaluación en las expresiones. Por ejemplo, puedes cambiar el orden de la multiplicación y la división antes de la suma y la resta para que se evalúe la suma primero:

var a = 1;
var b = 2;
var c = 3;

// precedencia por defecto
a + b * c     // 7
// se evalúa por defecto como
a + (b * c)   // 7

// ahora cambiamos la precedencia por defecto
// sumaremos primero antes de multiplicar   
(a + b) * c   // 9

// lo cual es equivalente a
a * c + b * c // 9

Expresiones al lado izquierdo

Los valores izquierdos son el destino de una asignación

new

Utilice el operador new para crear una instancia de un tipo propio o de uno de los tipos de objetos predefinidos: Array, Boolean, Date, Function, Image, Number, Object, Option, RegExp o String. La semántica es la siguiente:

var nombreDeObjeto = new tipoDeObjeto([param1, param2, ..., paramN]);

super

La palabra clave super es usada para llamar funciones en el objeto padre. Es útil con clases para llamar al constructor padre, por ejemplo.

super([argumentos]); // llama al constructor padre.
super.funcionEnPadre([argumentos]);

Operador de propagación

El operador de propagación permite que una expresión sea expandida en situaciones donde se esperan múltiples argumentos (para llamadas a funciones) o múltiples elementos (para Arrays literales).

Ejemplo:
Hoy, si tienes un Array y deseas crear un nuevo Array que contenga también los elementos del primero, la sintaxis de un Array literal no es suficiente y debes recurrir a piezas de código que hagan uso de métodos como push, splice, concat, etc. Con la sintaxis de propagación esto se convierte en algo mucho más simple:

var partes = ["hombros", "rodillas"];
var letra = ["cabeza", ...partes, "y", "dedos"];

De manera similar el operador de propagación funciona también con llamadas a funciones:

function f(x, y, z) { }
var args = [0, 1, 2];
f(...args);

Etiquetas y colaboradores del documento

 Última actualización por: ElChiniNet,