Operadores de JavaScript

Introducción

Un operador toma uno o más valores (sus operandos) y produce un nuevo valor. En JavaScript, los operadores se usan para realizar operaciones aritméticas, comparar valores, asignar valores a variables y construir condiciones lógicas. Este capítulo cubre los operadores de uso diario — asignación, aritméticos, de comparación y concatenación de string — explica la coerción de tipos que hace que algunos resultados sean sorprendentes, y finaliza con una referencia de precedencia de operadores para que sepas qué se evalúa primero.

Algunos términos usados a lo largo del capítulo:

• Operando — el valor sobre el que actúa un operador. En 5 + 3, 5 y 3 son operandos.
• Operador unario — toma un operando (p. ej. -x).
• Operador binario — toma dos operandos (p. ej. x + y).
• Operador ternario — toma tres operandos; JavaScript tiene exactamente uno (?:).

Operadores de Asignación

El operador de asignación básico = almacena un valor en una variable. Los operadores de asignación compuestos combinan una operación aritmética con la asignación, por lo que x += 5 es una forma abreviada de x = x + 5.

Ten en cuenta que = es una asignación, no una comparación. Para comparar valores, usa === o == (ver más abajo).

Operadores Aritméticos en JavaScript

Operadores Básicos: Suma (+), Resta (-), Multiplicación (*) y División (/)

Estos operadores realizan las cuatro operaciones aritméticas básicas.

Módulo (%) y Exponenciación (**)

El módulo (%) devuelve el resto de una división — útil para pruebas como "¿es este número par?" (n % 2 === 0). La exponenciación (**) eleva un número a una potencia.

Más y Menos Unarios

- niega un valor, y el + unario convierte su operando en un número — una forma rápida de convertir un string numérico en un número.

Incremento (++) y Decremento (--)

++ suma 1 a una variable y -- resta 1. Su posición importa: la forma prefija (++x) cambia el valor y devuelve el nuevo, mientras que la forma posfija (x++) devuelve primero el valor antiguo y luego lo cambia.

Operadores de Comparación en JavaScript

Los operadores de comparación siempre devuelven un valor boolean (true o false). Consulta el capítulo dedicado a Operadores de Comparación para más detalles.

Igualdad Estricta (===) y Flexible (==)

La igualdad estricta (===) devuelve true solo cuando ambos operandos tienen el mismo tipo y el mismo valor — nunca convierte tipos. La igualdad flexible (==) primero coerciona los operandos a un tipo común y luego los compara, lo que puede dar resultados sorprendentes.

Sus formas negadas son !== (desigualdad estricta) y != (desigualdad flexible).

Mayor Que (>), Menor Que (<) y Sus Formas "o Igual"

Estos operadores comparan el orden. También tienen variantes >= (mayor o igual que) y <= (menor o igual que).

Comparación de Valores No Numéricos

Con los operadores relacionales (<, >, <=, >=), JavaScript realiza coerción de tipos. La regla: si ambos operandos son string, se comparan carácter a carácter (alfabéticamente); de lo contrario, ambos operandos se convierten a números antes de comparar.

Esto explica un resultado que al principio parece incorrecto:

Comparaciones con NaN

NaN (Not-A-Number) es el único valor que no es igual a nada, ni siquiera a sí mismo. Por eso === NaN nunca se puede usar para detectarlo. Usa Number.isNaN() en su lugar.

Concatenación de Strings y el Operador + Binario

Concatenar Strings

En JavaScript, el operador + se usa tanto para la suma numérica como para la concatenación de strings.

+ Binario y Coerción de Tipos

Cuando uno de los operandos es un string, JavaScript convierte el otro a string también.

Buenas Prácticas para la Concatenación

Operadores Lógicos, Condicionales y de Tipo

JavaScript tiene varias familias de operadores más, cada una con su propio capítulo. A continuación, un mapa rápido para saber qué hacen y dónde leer más.

Operadores Lógicos (&&, ||, !)

&& (AND), || (OR) y ! (NOT) combinan condiciones boolean. && y || también son de cortocircuito y devuelven uno de sus operandos (no siempre un boolean), lo que los hace muy útiles para valores por defecto y guardas. Consulta Operadores Lógicos.

Operador Condicional (Ternario) (?:)

El operador ternario es un if/else compacto que devuelve un valor: condición ? valorSiVerdadero : valorSiFalso. Consulta Operadores Condicionales.

typeof e instanceof

typeof devuelve un string que indica el tipo de un valor. instanceof comprueba si un object fue creado por un constructor determinado — se trata en Comprobación de Clases: instanceof.

Precedencia de Operadores

Cuando una expresión mezcla operadores, la precedencia determina cuál se ejecuta primero, y la asociatividad decide el orden entre operadores de igual precedencia. Por ejemplo, * tiene mayor precedencia que +, por lo que 2 + 3 * 4 es 14, no 20.

Aquí están los operadores comunes de mayor a menor precedencia:

Resumen y Errores Comunes

• Usa === / !==, no == / != a menos que necesites específicamente coerción de tipos.
• '2' < true es false porque los operadores relacionales convierten los operandos que no son string a números (2 < 1).
• Comparar strings es alfabético, por lo que '10' < '9' es true aunque 10 < 9 sea false.
• Detecta NaN con Number.isNaN(x) — x === NaN es siempre false.
• + es sobrecargado: con un operando string concatena ('3' + 2 da '32'); prefiere los literales de plantilla para mayor claridad.
• x++ devuelve el valor antiguo, ++x el nuevo.
• ** y = son de asociatividad derecha; la mayoría de los demás operadores binarios son de asociatividad izquierda.
• Usa paréntesis en lugar de memorizar la tabla de precedencia completa.

Práctica