Seleccionar página

Referencia de ECMAScript 5.1 – Operadores

Índice

Aritméticos | Asignación | Binarios | Comparación | Lógicos | Condicional | Cadenas | Coma | delete | function | in | instanceof | new | typeof | void


Aritméticos

Operadores aritméticos.

Operador Nombre Ejemplo
+ suma
var num = 1 + 2; // num = 3
- resta
var num = 4 - 2; // num = 2
/ división

var num = 6 / 2; // num = 3
* multiplicación
var num = 7 * 2; // num = 14
% módulo
var num = 8 % 2 // num = 0
++ incremento
var num = 1;
num++;         // num = 2
++num;         // num = 3
-- decremento
var num = 3;
num--;         // num = 2
--num;         // num = 1
- negativo

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.

Operador Nombre Significado
x += y Suma y asignación x = x + y
x -= y Resta y asignación x = x - y
x *= y Multiplicación y asignación x = x * y
x /= y División y asignación x = x / y
x %= y Módulo y asignación x = % y
x <<= y Desplazamiento de bits a la izquierda y asignación x = x << y
x >>= y Desplazamiento de bits a la derecha con signo y asignación x = x >> y
x >>>= y Desplazamiento de bits a la derecha sin signo y asignación x = x >>> y
x &= y AND binario y asingación x = x & y
x ^= y OR binario y asignación x = x ^ y
x |= y XOR binario y asignación x = x | y

Binarios

Operadores trabajan a nivel de bit:

Operador Nombre Ejemplo
& AND binario
var a = 9;     // a =     (9) 1001
var b = 15;    // b =    (15) 1111
var c = b & a; // b & a = (9) 1001
& AND binario
var a = 9;     // a =     (9) 1001
var b = 15;    // b =    (15) 1111
var c = b & a; // b & a = (9) 1001
| OR binario
var a = 9;     // a =      (9) 1001
var b = 15;    // b =     (15) 1111
var c = b | a; // b | a = (15) 1111
| XOR binario
var a = 9;     // a =     (9) 1001
var b = 15;    // b =    (15) 1111
var c = b ^ a; // b ^ a = (6) 0110
~ NOT binario
var a = 10; // a =   (10)  1010
var c = ~a; // ~a = (-11) -1011
<< Desplazamiento binario a la izquierda
var a = 1;      // a =       (1)     1
var c = a << 4; // a << 4 = (16) 10000
>> Desplazamiento binario a la derecha con signo
var a = -256;   // a = (-256) -100000000
var c = a >> 4; // a >> 4 = (-16) -10000
>>> Desplazamiento binario a la derecha sin signo
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):

Operador Nombre Descripción Ejemplos
== Igual Devuelve true si los operandos son iguales
5 == 5;
5 == '5';
!= Distinto Devuelve true si los operandos no son iguales
5 != 3;
5 != '3';
=== Estrictamente igual Devuelve true si los operandos son iguales y del mismo tipo
5 === 5;
'5' === '5';
!== Estrictamente distinto Devuelve true si los operandos son diferentes iguales y del diferente tipo
5 !== 3;
5 !== '5';
> Mayor que Devuelve true si el operando izquierdo es mayor que el derecho
5 > 3;
'b' > 'a';
>= Mayor o igual que Devuelve true si el operando izquierdo es mayor o igual que el derecho
5 >= 5;
'b' >= 'a';
< Menor que Devuelve true si el operando izquierdo es menor que el derecho
3 < 5;
'a' < 'b';
<= Menor o igual que Devuelve true si el operando izquierdo es menor o igual que el derecho
5 <= 5;
'a' <= 'b';

Lógicos

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

Operador Nombre Descripción Ejemplos
&& AND lógico Evalúa la expresión de la izquierda y si es verdadera evalúa la expresión de la derecha.
Si ambas son verdaderas devuelve verdadero

|| OR lógico Evalúa la expresión de la izquierda y si es falsa evalúa la expresión de la derecha.
Si alguna de las dos son verdaderas devuelve verdadero

! NOT lógico Devuelve true si la expresión es verdadera y false cuando la expresión es verdadera
!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';
ECMA-262

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"
ECMA-262

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]);
}
ECMA-262

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.

ECMA-262

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.

ECMA-262

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.

ECMA-262

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.

ECMA-262

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));
ECMA-262

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

Tipo Resultado Ejemplo
sin definir (undefined) "undefined"
typeof variable_sin_definir;    // "undefined"
nulo (null) "object"
var x = null;
typeof x;    // "object"
lógico (true o false) "boolean"
var x = true;
typeof x;    // "boolean"
número (number) o NaN "number"
var x = 10;
typeof x;    // "number"
cadena (string) "string"
var x = "hola";
typeof x;    // "string"
función (function) "function"
function x() {
    // sentencias
}
typeof x;    // "function"
objeto (object) "object"
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') {
    // ...
}
ECMA-262

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.

ECMA-262