JavaScript – Operadores y expresiones

Los operadores permiten manipular el valor de las variables, realizar operaciones matemáticas con sus valores y comparar diferentes variables. De esta forma, los operadores permiten a los programas realizar cálculos complejos y tomar decisiones lógicas en función de comparaciones y otros tipos de condiciones.

uniwebsidad

let x = 0;
x = "1";

console.log(x) // 1;

Existen además los operadores de asignación compuestos, siendo estos una forma de abreviar operaciones simples como:

NOMBRE                                             OPERADOR     SIGNIFICADO
Asignación	                                   x = y	x = y
Asignación de adición	                           x += y	x = x + y
Asignación de resta	                           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 residuo	                           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
A. de desplazamiento a la derecha sin signo	   x >>>= y	x = x >>> y
Asignación AND bit a bit	                   x &= y	x = x & y
Asignación XOR bit a bit	                   x ^= y	x = x ^ y
Asignación OR bit a bit	                           x |= y	x = x | y
Asignación AND lógico	                           x &&= y	x && (x = y)
Asignación OR lógico	                           x ||= y	x || (x = y)
Asignación de anulación lógica	                   x ??= y	x ?? (x = y)

OPERADOR	             DESCRIPCION	
Igual (==)	             Devuelve true si los operandos son iguales.

No es igual (!=)             Devuelve true si los operandos no son iguales.

Estrictamente igual (===)    Devuelve true si los operandos son iguales y del mismo tipo y consulta también Object.is y similitud en JS.

Desigualdad estricta (!==)   Devuelve true si los operandos son del mismo tipo pero no iguales, o son de diferente tipo.

Mayor que (>)	             Devuelve true si el operando izquierdo es mayor que el operando derecho.

Mayor o igual que (>=)	     Devuelve true si el operando izquierdo es mayor o igual que el operando derecho.

Menor que (<)	             Devuelve true si el operando izquierdo es menor que el operando derecho.

Menor o igual (<=)	     Devuelve true si el operando izquierdo es menor o igual que el operando derecho.

OPERADOR	                DESCRIPCION
	
Residuo (%)	                Devuelve el resto entero de dividir los dos operandos.	

Incremento (++)	                Agrega uno a su operando. 
                                Si se usa como operador prefijo (++x), devuelve el valor de su operando después de agregar uno.
                                Si se usa como operador sufijo (x++), devuelve el valor de su operando antes de agregar uno.

Decremento (--)	                Resta uno de su operando.

Negación unaria (-)	        Devuelve la negación de su operando.

Positivo unario (+)	        Intenta convertir el operando en un número

Operador de exponenciación (**)	Calcula la base a la potencia de exponente.

• AND Logico &&
• OR Logico ||
• NOT Logico !

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

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

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

Mas información aquí!

console.log('mi ' + 'cadena'); // "mi cadena".

var mystring = 'alpha';
mystring += 'bet'; // "alphabet"

let age = 19;
var status = (age >= 18) ? 'adult' : 'minor';
//            pregunta      true      false

console.log(status) // adult

var a = [x, x, x, x, x];

for (var i = 0, j = 9; i <= j; i++, j--)
//                                ^ operador coma
  console.log('a[' + i + '][' + j + ']= ' + a[i][j]);

delete object.property;
delete object[propertyKey];
delete objectName[index];
delete property; // legal solo dentro de una declaración with

x = 42; // implícitamente crea window.x
var y = 43;
var myobj = {h: 4}; // crea un objeto con la propiedad h

delete x;       // devuelve true (se puede eliminar si se crea implícitamente)
delete y;       // devuelve false (no se puede borrar si se declara con var)
delete Math.PI; // devuelve false (no se pueden eliminar propiedades no configurables)
delete myobj.h; // devuelve true (puede eliminar propiedades definidas por el usuario)

Dado que los arreglos solo son objetos, técnicamente es posible delete elementos de ellos. Sin embargo, esto se considera una mala práctica, trata de evitarlo.

Typeof

El operador typeof devuelve una cadena que indica el tipo de un string, palabra clave o objeto para que que se devolvera el tipo.

var myFun = new Function('5 + 2');
var shape = 'round';
var size = 1;
var foo = ['Apple', 'Mango', 'Orange'];
var today = new Date();

typeof myFun;       // devuelve "function"
typeof shape;       // devuelve "string"
typeof size;        // devuelve "number"
typeof foo;         // devuelve "object"
typeof today;       // devuelve "object"
typeof doesntExist; // devuelve "undefined"

//Para las palabras clave true y null, el operador typeof devuelve los siguientes resultados:
typeof true; // devuelve "boolean"
typeof null; // devuelve "object"


//Para métodos y funciones, el operador typeof devuelve los siguientes resultados:
typeof blur;        // devuelve "function"
typeof eval;        // devuelve "function"
typeof parseInt;    // devuelve "function"
typeof shape.split; // devuelve "function"

//Para objetos predefinidos, el operador typeof devuelve los siguientes resultados:
typeof Date;     // devuelve "function"
typeof Function; // devuelve "function"
typeof Math;     // devuelve "object"
typeof Option;   // devuelve "function"
typeof String;   // devuelve "function"

Void

El operador void especifica una expresión que se evaluará sin devolver un valor.

const output = void 1;
console.log(output);
// expected output: undefined

void console.log('expression evaluated');
// expected output: "expression evaluated"

void function iife() {
  console.log('iife is executed');
}();
// expected output: iife is executed

void function test() {
  console.log('test function executed');
};
try {
  test();
} catch (e) {
  console.log('test function is not defined');
  // expected output: "test function is not defined"
}

In

El operador in devuelve true si la propiedad especificada está en el objeto especificado.

// Arreglos
var trees = ['redwood', 'bay', 'cedar', 'oak', 'maple'];
0 in trees;        // devuelve true
3 in trees;        // devuelve true
6 in trees;        // devuelve false
'bay' in trees;    // devuelve false (debes especificar el número del índice,
                   // no el valor en ese índice)
'length' en trees; // devuelve true (es una propiedad de Array)

// objetos integrados
'PI' in Math;          // devuelve true
var myString = new String('coral');
'length' in myString;  // devuelve true

// Objetos personalizados
var mycar = { make: 'Honda', model: 'Accord', year: 1998 };
'make' in mycar;  // devuelve true
'model' in mycar; // devuelve true

Instanceof

El operador instanceof devuelve true si el objeto especificado es del tipo de objeto especificado.

Confirma el tipo de un objeto en tiempo de ejecución. Por ejemplo, al detectar excepciones, puedes ramificar a diferentes controladores según el tipo de excepción lanzada.

/*  El siguiente código usa instanceof para determinar si theDay es un objeto Date. 
//  Debido a que theDay es un objeto Date, las instrucciones de la expresión if se 
*/  ejecutan.


var theDay = new Date(1995, 12, 17);
if (theDay instanceof Date) {
  console.log("hola mundo");
}

// Esta expresión usa el operador = para asignar el valor siete a la variable x. 
// La expresión en sí se evalúa como siete.

X = 7

// Esta expresión usa el operador + para sumar tres y cuatro sin asignar el
// resultado, siete, a una variable.

3 + 4

this['propertyName']
this.propertyName

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

// precedencia predeterminada
a + b * c  ===  a + (b * c)   // 7

// ahora prevalece sobre la precedencia
// suma antes de multiplicar
(a + b) * c   // 9

// que es equivalente a
a * c + b * c // 9

var objectName = new objectType([param1, param2, ..., paramN]);

Super

La palabra clave super se utiliza para llamar a funciones en el padre de un objeto. Es útil con clases llamar al constructor padre.

super([arguments]); // llama al constructor padre.
super.functionOnParent([arguments]);

---

Puede interesarte:

JavaScript
JavaScript es el lenguaje de programación que debes usar para añadir características interactivas a tu sitio web.

HTML
HTML (Lenguaje de Marcas de Hipertexto, del inglés HyperText Markup Language) es el componente más básico de la Web. Define el significado y la estructura del contenido web.

CSS
CSS es el lenguaje de estilos utilizado para describir la presentación de documentos HTML.

JavaScript – números y fechas

JavaScript – Variables y tipos de datos

JavaScript – strings y sus métodos

---