Saltar al contenido principal

Operadores

JavaScript es un lenguaje de programación versátil que ofrece una amplia gama de operadores para realizar diversas operaciones sobre variables y valores. Estos operadores son fundamentales para cualquier desarrollo en este lenguaje, permitiendo manipular datos, realizar cálculos y controlar el flujo de ejecución. En este artículo, exploraremos los operadores más comunes en JavaScript, desde los básicos hasta los más modernos e innovadores, como el spread operator y el optional chaining.

Operadores aritméticos​

Los operadores aritméticos permiten realizar operaciones matemáticas básicas. Los más utilizados son:

  • + Suma
  • - Resta
  • * Multiplicación
  • / División
  • % Módulo (residuo de una división)
  • ** Exponenciación
let a = 10;
let b = 3;
console.log(a + b); // 13
console.log(a % b); // 1 (residuo de la división de 10 entre 3)
console.log(a ** b); // 1000 (10 elevado a la 3)

Operadores de asignación​

Los operadores de asignación permiten asignar valores a variables. El más simple es =, pero existen otros más complejos que combinan operaciones con la asignación:

  • = Asignación simple
  • += Suma y asignación
  • -= Resta y asignación
  • *= Multiplicación y asignación
  • /= División y asignación
  • %= Módulo y asignación
let x = 5;
x += 3; // x ahora es 8 (equivale a x = x + 3)

Operadores de comparación​

Los operadores de comparación se utilizan para comparar valores y devuelven un valor booleano (true o false):

  • == Igualdad laxa (realiza conversiones de tipo automáticas, compara solo el valor)
  • === Igualdad estricta (compara el valor y el tipo)
  • != Desigualdad
  • !== Desigualdad estricta
  • > Mayor que
  • < Menor que
  • >= Mayor o igual que
  • <= Menor o igual que
console.log(5 == '5'); // true (compara solo el valor)
console.log(5 === '5'); // false (compara valor y tipo)

Operadores lógicos​

Los operadores lógicos permiten combinar expresiones booleanas:

  • && Y lógico (devuelve true si ambas expresiones son verdaderas)
  • || O lógico (devuelve true si alguna de las expresiones es verdadera)
  • ! Negación lógica (invierte el valor de una expresión booleana)
let a = true;
let b = false;
console.log(a && b); // false
console.log(a || b); // true
console.log(!a); // false

Operadores bit a bit​

JavaScript también soporta operadores a nivel de bits, útiles en ciertos contextos avanzados como el manejo de máscaras de bits:

  • & Y a nivel de bits
  • | O a nivel de bits
  • ^ XOR a nivel de bits
  • ~ Negación a nivel de bits
  • << Desplazamiento de bits a la izquierda
  • >> Desplazamiento de bits a la derecha

Operador ternario​

El operador ternario (?:) es una forma compacta de escribir una expresión if-else. Su sintaxis es:

condición ? valor_si_verdadero : valor_si_falso;
let edad = 18;
let mensaje = (edad >= 18) ? 'Es adulto' : 'Es menor de edad';
console.log(mensaje); // Es adulto

Operador de propagación (spread operator)​

Uno de los operadores más modernos y poderosos es el spread operator, representado por .... Este operador permite expandir elementos de un iterable (como un array) o las propiedades de un objeto. Es muy útil para combinar o clonar arrays y objetos.

// En arrays
let arr1 = [1, 2, 3];
let arr2 = [4, 5];
let combinado = [...arr1, ...arr2];
console.log(combinado); // [1, 2, 3, 4, 5]
// En objetos
let obj1 = { a: 1, b: 2 };
let obj2 = { c: 3, d: 4 };
let objCombinado = { ...obj1, ...obj2 };
console.log(objCombinado); // { a: 1, b: 2, c: 3, d: 4 }

Encadenamiento opcional (optional chaining)​

El optional chaining (?.) es una característica introducida en las versiones más recientes de JavaScript, que permite acceder a propiedades anidadas de objetos sin necesidad de verificar explícitamente si cada nivel existe. Si alguna propiedad no existe, devuelve undefined en lugar de lanzar un error.

Ejemplo:

let persona = {
  nombre: 'Juan',
  direccion: {
    ciudad: 'Madrid'
  }
};

console.log(persona.direccion?.ciudad); // Madrid
console.log(persona.direccion?.pais); // undefined (sin error)

Este operador es especialmente útil para evitar errores cuando se trabaja con datos inciertos o estructuras anidadas complejas, como las que se obtienen de APIs.

Operador de nulish (nullish coalescing)​

El nullish coalescing (??) es otro operador moderno que devuelve el operando de la derecha cuando el de la izquierda es null o undefined, pero no si es false o 0.

Ejemplo:

let nombre = null;
let saludo = nombre ?? 'Desconocido';
console.log(saludo); // Desconocido

Este operador es especialmente útil cuando quieres proporcionar valores por defecto solo cuando la variable es null o undefined.