Operadores JavaScript

01 — Aritméticos

Los operadores aritméticos en JavaScript son aquellos que permiten realizar operaciones matemáticas básicas como suma, resta, multiplicación y división. Estos operadores toman valores numéricos (ya sean literales o variables) como operandos y devuelven un solo valor numérico. Algunos de los operadores aritméticos más comunes son:

let a = 5;
let b = 7;

console.log(a + b); // suma
console.log(a - b); // resta
console.log(a * b); // multiplicacion
console.log(a / b); // division
console.log(a % b); // resto
console.log(a ** b); // potencia

// incrementar
console.log(++a);
console.log(a++);
console.log(a);

// decrementar
console.log(--a);
console.log(a--);
console.log(a);

02 — Asignación

Los operadores de asignación en JavaScript son utilizados para asignar un valor a una variable o constante. El operador de asignación básico es el signo igual (=), que asigna el valor del operando derecho al operando izquierdo, es decir, x = y asigna el valor de y a x.

Además de este operador básico, existen operadores de asignación compuestos que son una abreviatura de las operaciones enumeradas en la siguiente tabla:

Adición: x += y es equivalente a x = x + y, pero la expresión x se evalúa solo una vez.

Resta: x -= y es equivalente a x = x – y.

Multiplicación: x *= y es equivalente a x = x * y.

División: x /= y es equivalente a x = x / y.

Residuo: x %= y es equivalente a x = x % y.

Exponenciación: x **= y es equivalente a x = x ** y.

Desplazamiento a la izquierda: x <<= y es equivalente a x=x << y. Desplazamiento a la derecha: x>>= y es equivalente a x
= x >> y.

Desplazamiento a la derecha sin signo: x >>>= y es equivalente a x = x >>> y.

AND bit a bit: x &= y es equivalente a x = x & y.

XOR bit a bit: x ^= y es equivalente a x = x ^ y.

OR bit a bit: x |= y es equivalente a x = x | y.

AND lógico: x &&= y es equivalente a x && (x = y).

OR lógico: x ||= y es equivalente a x || (x = y).

Anulación lógica: x ??= y es equivalente a x ?? (x = y).

let a = 5; // valdría 5
a = a + 5; // valdría 10

a += 5; //es equivalente a "a = a + 5", pero la expresión a se evalúa solo una vez.

console.log(a);

03 — Comparación

Los operadores de comparación en JavaScript son utilizados para comparar dos valores y devolver un valor booleano (true o false). Estos operadores se utilizan comúnmente en declaraciones condicionales para determinar el flujo del programa.

let a = 10;
console.log(a > 5);
console.log(a >= 5);
console.log(a < 5);
console.log(a <= 5);

console.log(a == 5);
console.log(a != 5); // comprueba si son diferentes
console.log(a == '10');
console.log(a === '10'); //comprueba no solo el valor sino también el tipo de dato

04 — Lógicos

Los operadores lógicos en JavaScript son utilizados para comparar valores booleanos y devolver respuestas booleanas. Existen dos tipos principales de operadores lógicos: AND (&&) y OR (||).

El operador AND (&&) devuelve el valor de la primera expresión si esta se puede convertir a false; de lo contrario, devuelve el valor de la segunda expresión. Cuando se usan con valores booleanos, el operador AND devuelve true si ambos operandos son true; de lo contrario, devuelve false.

El operador OR (||) devuelve el valor de la primera expresión si esta se puede convertir a true; de lo contrario, devuelve el valor de la segunda expresión. Cuando se usan con valores booleanos, el operador OR devuelve true si alguno de los operandos es true; si ambos son falsos, devuelve false.

Además, el operador NOT (!) invierte el valor booleano de su único operando. Si el operando se puede convertir a true, el operador NOT devuelve false; de lo contrario, devuelve true.

Estos operadores funcionan con la evaluación de corto circuito, lo que significa que si el resultado de la operación puede determinarse con la evaluación de la primera expresión, no se evalúa la segunda.

// AND, OR, NOT

// AND &&
let mayor = true;
let suscrito = true;
console.log('operador AND', mayor && suscrito);

// OR ||
console.log('operador OR', mayor || suscrito);

//NOT
console.log('operador not', !mayor);

05 — Falsy

En JavaScript, los valores falsy son aquellos que se interpretan como false en un contexto booleano. Estos valores son esenciales para manejar casos específicos donde queremos identificar si una expresión es falsa.

Algunos ejemplos de valores falsy son: cadenas de texto vacías, como », el número 0, valores especiales null y undefined, y la palabra clave false.

Cuando se utilizan valores no booleanos con el operador lógico AND (&&), este no convierte automáticamente los valores a true o false. En lugar de eso, simplemente retorna el primer valor que se evalúa como falso o, si no encuentra ningún valor falso, retorna el último valor.

Es importante tener en cuenta que, aunque algunos valores, como el cero o null, parezcan seguir una regla sólida al ser evaluados como falsy, no siempre es tan simple. Por ejemplo, un valor numérico que es 0 equivale a false mientras que cualquier otro número equivale a true.

// Falsys:
// Falso
// 0
// ''
// null
// undefined
// Nan
let nombre = 'Pedro';
let username = nombre || 'anonimo';

console.log(username);

function fn1() {
    console.log('Soy funcion 1');
    return false;
}

function fn2() {
    console.log('Soy funcion 2');
    return true;
}

let x = fn1() && fn2();

06 — Bitwise

Los operadores bitwise en JavaScript son operadores que realizan operaciones en los bits individuales de los operandos. Estos operadores trabajan con valores binarios de 32 bits y realizan operaciones booleanas en cada bit de los operandos.

// bit:digito en binario, 0 o 1
// byte: 8 bits
// byte: 00000000 -> 0
// byte: 00000001 -> 1
// byte: 00000010 -> 2
// el operador | hace el OR binario, con que haya un 1 es 1
// el operador & hace el AND binario, si los dos no son 1 es 0

console.log(1 | 3);
console.log(1 | 4);
console.log(3 | 5);

console.log(1 & 3);
console.log(1 & 4);
console.log(3 & 5);

07 — Orden

Los operadores en JavaScript tienen una precedencia específica que determina el orden en que se aplican al evaluar una expresión. La precedencia de los operadores va de mayor a menor, y puedes redefinir la precedencia mediante el uso de paréntesis.

let resultado = 8/2*(2+2);
console.log(resultado);

let resultado2 = 8/(2*(2+2));
console.log(resultado2);

08 — Ternario

El operador ternario en JavaScript es un operador condicional que evalúa una expresión condicional y devuelve un valor verdadero o falso. Su sintaxis es la siguiente:

// expresion ? 'si es true' : 'si es false'
let edad = 20;
let acceso = edad > 17 ? 'Permitir ingreso' : 'No puede ingresar';

console.log(acceso);