Referencia de ECMAScript 5.1 – Operadores

Aritméticos

Operadores aritméticos.

var num = 1 + 2; // num = 3

var num = 4 - 2; // num = 2

var num = 6 / 2; // num = 3

var num = 7 * 2; // num = 14

var num = 8 % 2 // num = 0

var num = 1;
num++;         // num = 2
++num;         // num = 3

var num = 3;
num--;         // num = 2
--num;         // num = 1

var a = 5;
var b = -a;    // b = -5 y a = 5

Asignación

Operador básico de asignación = y sus combinaciones con otros operadores.

Ejemplo

var a = 10;
var c = "cadena";
a = 20;
c = "otra cadena";

El resto de operadores de asignación compuesta realizan modificaciones previas a la asignación por medio de otros operadores.

Binarios

Operadores trabajan a nivel de bit:

var a = 9;     // a =     (9) 1001
var b = 15;    // b =    (15) 1111
var c = b & a; // b & a = (9) 1001

var a = 9;     // a =     (9) 1001
var b = 15;    // b =    (15) 1111
var c = b & a; // b & a = (9) 1001

var a = 9;     // a =      (9) 1001
var b = 15;    // b =     (15) 1111
var c = b | a; // b | a = (15) 1111

var a = 9;     // a =     (9) 1001
var b = 15;    // b =    (15) 1111
var c = b ^ a; // b ^ a = (6) 0110

var a = 10; // a =   (10)  1010
var c = ~a; // ~a = (-11) -1011

var a = 1;      // a =       (1)     1
var c = a << 4; // a << 4 = (16) 10000

var a = -256;   // a = (-256) -100000000
var c = a >> 4; // a >> 4 = (-16) -10000

var a = -262144; 
var c = a >>> 4; 
// a =         (-262144)         -1000000000000000000
// a >>> 4 = (268419072) 1111111111111100000000000000

Comparación

Comparan dos valores y devuelven siempre un valor verdadero (true) o falso (false):

5 == 5;
5 == '5';

5 != 3;
5 != '3';

5 === 5;
'5' === '5';

5 !== 3;
5 !== '5';

5 > 3;
'b' > 'a';

5 >= 5;
'b' >= 'a';

3 < 5;
'a' < 'b';

5 <= 5;
'a' <= 'b';

Lógicos

Operadores lógicos y que devuelven siempre un valor verdadero (true) o falso (false)

!false;

Condicional

El operador condicional permite seleccionar entre dos valores dependiendo de una condición.

Sintaxis

condicion ? exp_si_verdadero : exp_si_falso;

condicion

Expresión que se evalúa para llevar la ejecución a la primera expresión o a la segunda.

exp_si_verdadero

Expresión que se evalúa si la condición es verdadera (true).

exp_si_falso

Expresión que se evalúa si la condición es falsa (false).

Ejemplo

var tratamiento = (numero > 1) ? 'plural' : 'singular';

Cadenas

Además de los operadores de comparación, es posible utilizar con cadenas el operador + para concatenar las mismas.

Sintaxis

cadena1 + candena2;

Este operador devuelve una nueva cadena de caracteres que une las dos cadenas indicadas.

Ejemplo

var c1 = "Javascript";
var c2 = " es el mejor";

console.log(c1 + c2); // "Javascript es el mejor"

Coma

El operador coma permite evaluar dos expresiones.

Tiene la característica de que devolverá siempre el valor retornado por la segunda expresion.

Sintaxis

exp1, exp2

Es utilizando habitualmente junto a la instrucción var para encadenar varias definiciones o en bucles for cuando se quieren definir varias variables iniciales.

Ejemplo

var a = 1, b = 2;

var matriz = ['uno','dos','tres'];
for (x = 0, max = matriz.length; x < max; x++) {
    console.log(matriz[x]);
}

delete

Borra la propiedad de un objeto o un elemento de una matriz.

Sintaxis

delete objeto.propiedad;
delete matriz[elemento];

Si delete puede borrar el elemento que se le indica devuelve verdadero (true). Si no puede borrar el elemento y se está siendo usado en modo "use strict" se producirá un error, si no devolverá falso (false).

Si se ejecuta delete sin "use strict" se pueden borrar variables definidas de forma explícita, es decir, que no han sido declaradas con var.

Ejemplos

var obj = { nombre: 'Quijote', apellido: 'de La Mancha' };
console.log(obj.nombre);    // Quijote

delete miObjeto.nombre;     // true
console.log(obj.nombre);    // undefined

Tras el borrado de la propiedad está siempre es undefined.

var matriz = ['naranjas','peras','albaricoques'];
console.log(matriz[1]);     // peras

delete matriz[1];           // true
console.log(matriz[1]);     // undefined
console.log(matriz.length); // 3

Si se elimina un elemento de una matriz el tamaño de la matriz no se ve afectado, por lo que los resultados al recorrer los valores de la matriz de 0 a length pueden llegar a ser inesperados.

function

Tiene prácticamente la misma sintaxis que la instrucción function, con la diferencia que el operador function devuelve una función anónima que podemos asignar a una variable, pasar como parámetro a otra función, etc.

Sintaxis

[[var] variable =] function ([parametro1] [, parametro2], [..., parametroN]) {
    // sentencias
}

[[var] variable]

Opcionalmente se puede asignar la función devuelta por este operador a una variable.

parametro

Parámetro o argumento que recibe la función. Pueden definirse hasta 255 parámetros.

Ejemplo

var mas_impuestos = function (importe) {
    return importe * 1.21;
}

var x = [function (y) { return y; }, function (y) { return y * y ; }, function (y) { return y * y * y; }];

var result = x[2](4); // 64

Las funciones pueden crearse también por medio de la instrucción function con prácticamente la misma sintaxis y por medio del objeto Function.

in

Comprueba que una determinada propiedad está presente en un objeto.

Sintaxis

'propiedad' in objeto

propiedad

Nombre de la propiedad que queremos comprobar si existe en el objeto.

objeto

Objeto del que queremos comprobar si tiene la propiedad.

Ejemplos

var obj = { nombre: 'Quijote', apellido: 'de La Mancha' };
'nombre' in obj;    // true
'edad' in obj;      // false

Se comprueba el nombre de la propiedad y si esta no existe, se de devuelve false.

var matriz = ['naranjas','peras','albaricoques'];
0 in matriz;        // true
4 in matriz;        // false

En el caso de las matrices se comprueba que el índice que se sitúa a la izquierda del operador está dentro de la matriz que se indica a la derecha del operador.

instanceof

Comprueba si un determinado objeto es una instancia de otro objeto.

Sintaxis

objeto1 instanceof objeto2

objeto1

Objeto del que queremos comprobar de que es instancia del objeto situado a la derecha del operador.

objeto2

Objeto del que queremos comprobar si el objeto a la izquierda del operador es instancia suya.

Ejemplos

function MiClase() {
}
MiClase instanceof Function; // true
MiClase instanceof Object;   // true

var obj = new MiClase;
obj instanceof Function;     // false
obj instanceof MiClase;      // true
obj instanceof Object;       // true

Las funciones son instancias del objeto Function y este a su vez de Object. Si creamos un objecto con new y la función, esta será una instancia de la función y de Object.

var matriz = [1,2,3];
matriz instanceof Array;     // true
matriz instanceof Object;    // true
matriz instanceof Number;    // false

Las matrices son instancias del objecto Array y este a su vez de Object.

var hoy = new Date();
hoy instanceof Date;         // true
hoy instanceof Object;       // true
hoy instanceof Number;       // false

Las instancia de los objectos predefinidos son instancias de ese objeto y de Object.

new

Crea una instancia de un objeto predefinido o definido por medio de una función.

Sintaxis

[var obj] = new Objeto

[var obj]

Variable que almacenará la nueva instancia del objeto.

Objeto

Objeto del que queremos una nueva instancia

new se puede utilizar para crear objetos predefinidos en Javascript como Date o para crear objetos desde funciones que hayamos definido nosotros con function.

Ejemplos

var hoy = new Date();
console.log(hoy.toISOString())

function MiClase() {
    this.sum = function (x, y) { return x + y; };
}
var obj = new MiClase();
console.log(obj.sum(10, 20));

typeof

Devuelve una cadena con el tipo de una variable o expresión evaluada.

Sintaxis

typeof expresion

expresion

Expresión de la que se quiere obtener su tipo

typeof variable_sin_definir;    // "undefined"

var x = null;
typeof x;    // "object"

var x = true;
typeof x;    // "boolean"

var x = 10;
typeof x;    // "number"

var x = "hola";
typeof x;    // "string"

function x() {
    // sentencias
}
typeof x;    // "function"

function x() {
    // sentencias
}
typeof x;    // "function"

Normalmente typeof se utiliza como parte de una condición donde comparamos el valor que devuelve con la cadena del tipo que esperamos obtener.

var n = 1;
if (typeof n === 'number') {
    // ...
}

void

Evalúa una expresión y retorna siempre `undefined` evitando que devuelva ningún otro valor.

Sintaxis

void (expresion)

Aunque los paréntesis no son estrictamente necesarios, se considera una buena práctica utilizarlos.