Operadores

Los operadores son símbolos especiales que le indican al compilador que debe realizar una operación matemática, relacional o lógica y debe producir un resultado.

Operadores de asignación

Un operador de asignación asigna un valor a su operando izquierdo basándose en el valor de su operando derecho.

El operador de asignación simple es representado por el símbolo "igual" (=), que asigna el valor de su operando derecho a su operando izquierdo. Es decir, x = y asigna el valor de y a x.

También hay operadores de asignación compuestos que son una abreviatura de las operaciones enumeradas en la siguiente tabla:

Nombre	Operador abreviado	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
Asignación 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)

Operadores de comparación

Un operador de comparación compara sus operandos y devuelve un valor lógico en función de si la comparación es verdadera (verdadero) o falsa (falso).

Los operandos pueden ser valores numéricos, de cadena, lógicos u objetos. Las cadenas se comparan según el orden lexicográfico estándar, utilizando valores Unicode. En la mayoría de los casos, si los dos operandos no son del mismo tipo, EsJS intenta convertirlos a un tipo apropiado para la comparación. Este comportamiento generalmente resulta en comparar los operandos numéricamente. Las únicas excepciones a la conversión de tipos dentro de las comparaciones involucran a los operadores === y !==, que realizan comparaciones estrictas de igualdad y desigualdad. Estos operadores no intentan convertir los operandos a tipos compatibles antes de verificar la igualdad.

La siguiente tabla describe los operadores de comparación en términos de este código de ejemplo:

mut var1 = 3;
mut var2 = 4;

Operador	Descripción	Ejemplos que devuelven verdadero
Igual (==)	Devuelve verdadero si los operandos son iguales.	3 == var1 "3" == var1 3 == '3'
No es igual (!=)	Devuelve verdadero si los operandos no son iguales.	var1 != 4 var2 != "3"
Estrictamente igual (===)	Devuelve verdadero si los operandos son iguales y del mismo tipo. Consulta también Object.is y similitud en JS.	3 === var1
Desigualdad estricta (!==)	Devuelve verdadero si los operandos son del mismo tipo pero no iguales, o son de diferente tipo.	var1 !== "3 3 !== '3
Mayor que (>)	Devuelve verdadero si el operando izquierdo es mayor que el operando derecho.	var2 > var1 "12" > 2
Mayor o igual que (>=)	Devuelve verdadero si el operando izquierdo es mayor o igual que el operando derecho.	var2 >= var1 var1 >= 3
Menor que (<)	Devuelve verdadero si el operando izquierdo es menor que el operando derecho.	var1 < var2 "2" < 12
Menor o igual (<=)	Devuelve verdadero si el operando izquierdo es menor o igual que el operando derecho.	var1 <= var2 var2 <= 5

Nota: => no es un operador, sino la notación para Funciones Flecha.

Operadores lógicos

Los operadores lógicos se utilizan normalmente con valores booleanos (lógicos); cuando lo son, devuelven un valor booleano.

Sin embargo, los operadores && y || en realidad devuelven el valor de uno de los operandos especificados, por lo que si estos operadores se utilizan con valores no booleanos, pueden devolver un valor no booleano. Los operadores lógicos se describen en la siguiente tabla.

Operador	Uso	Descripción
AND Lógico (&&)	expr1 && expr2	Devuelve expr1 si se puede convertir a falso; de lo contrario, devuelve expr2. Por lo tanto, cuando se usa con valores booleanos, && devuelve verdadero si ambos operandos son verdadero; de lo contrario, devuelve falso.
OR lógico (||)	expr1 || expr2	Devuelve expr1 si se puede convertir a verdadero; de lo contrario, devuelve expr2. Por lo tanto, cuando se usa con valores booleanos, `
NOT lógico (!)	!expr	Devuelve falso si su único operando se puede convertir a true; de lo contrario, devuelve true.

Ejemplos de expresiones que se pueden convertir a falso son aquellos que se evalúan como null, 0, NaN, la cadena vacía ("") o undefined.

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

mut a1 =  true && true;     // t && t devuelve true
mut a2 =  true && falso;    // t && f devuelve falso
mut a3 = falso && true;     // f && t devuelve falso
mut a4 = falso && (3 == 4); // f && f devuelve falso
mut a5 = 'Cat' && 'Dog';    // t && t devuelve Dog
mut a6 = falso && 'Cat';    // f && t devuelve falso
mut a7 = 'Cat' && falso;    // t && f devuelve falso

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

mut o1 =  true || true;     // t || t devuelve true
mut o2 = falso || true;     // f || t devuelve true
mut o3 =  true || falso;    // t || f devuelve true
mut o4 = falso || (3 == 4); // f || f devuelve falso
mut o5 = 'Cat' || 'Dog';    // t || t devuelve Cat
mut o6 = falso || 'Cat';    // f || t devuelve Cat
mut o7 = 'Cat' || falso;    // t || f devuelve Cat

El siguiente código muestra ejemplos de el operador ! (NOT lógico).

mut n1 = !true;  // !t devuelve falso
mut n2 = !falso; // !f devuelve true
mut n3 = !'Cat'; // !t devuelve falso

Operadores de cadena

Además de los operadores de comparación, que se pueden usar en valores de cadena, el operador de concatenación (+) concatena dos valores de cadena, devolviendo otra cadena que es la unión de los dos operandos de cadena.

Por ejemplo,

consola.escribir('mi ' + 'cadena'); // Muestra "mi cadena"

El operador de asignación abreviada += también se puede utilizar para concatenar cadenas.

Por ejemplo,

mut miCadena = 'alfa';
miCadena += 'beto'; // se evalúa como "alfabeto" y asigna este valor a miCadena.

consola.escribir(miCadena); // Muestra "alfabeto"