Programación con JavaScript: Operadores

Los operadores son elementos fundamentales en cualquier lenguaje de programación, y JavaScript no es una excepción. Los operadores en JavaScript nos permiten realizar diferentes tipos de operaciones con valores, como aritmética, asignación, comparación y lógica, entre otros. A continuación explicaremos los distintos tipos de operadores disponibles en JavaScript, junto con muchos ejemplos para cada uno.

Operadores aritméticos

Los operadores aritméticos se utilizan para realizar operaciones matemáticas con números.

  • Suma (+): Se utiliza para sumar dos valores numéricos.
  • Resta (-): Se utiliza para restar un valor numérico de otro.
  • Multiplicación (*): Se utiliza para multiplicar dos valores numéricos.
  • División (/): Se utiliza para dividir un valor numérico entre otro.
let a = 5 + 3; // 8
let b = a + 10; // 18

let c = 10 - 4; // 6
let d = 8 - 3; // 5

let e = 3 * 4; // 12
let f = 5 * 2; // 10

let g = 15 / 5; // 3
let h = 20 / 4; // 5
  • Módulo (%): Se utiliza para obtener el resto de la división de dos números.
let i = 17 % 5; // 2 (17 dividido por 5 es 3 con un resto de 2)
let j = 8 % 3; // 2 (8 dividido por 3 es 2 con un resto de 2)
  • Incremento (++): Se utiliza para aumentar el valor de una variable en 1.
  • Decremento (--): Se utiliza para disminuir el valor de una variable en 1.
let k = 10;
k++; // k se convierte en 11
let l = 3;
l++; // l se convierte en 4

let m = 7;
m--; // m se convierte en 6
let n = 9;
n--; // n se convierte en 8

Operadores de asignación

Los operadores de asignación se utilizan para asignar valores a variables.

  • Asignación básica (=): Se utiliza para asignar un valor a una variable.
let x = 10;
let y = "Hola";
  • Operadores de asignación combinados (+=, -=, *=, /=): Estos operadores combinan una operación aritmética con una asignación.
let a = 5;
a += 2; // a se convierte en 7 (a = a + 2)

let b = 8;
b -= 3; // b se convierte en 5 (b = b - 3)

let c = 3;
c *= 4; // c se convierte en 12 (c = c * 4)

let d = 20;
d /= 5; // d se convierte en 4 (d = d / 5)

let y = 5;
y += 2; // 'y' se convierte en 7 (y = y + 2)
y -= 3; // 'y' se convierte en 4 (y = y - 3)
y *= 2; // 'y' se convierte en 8 (y = y * 2)
y /= 4; // 'y' se convierte en 2 (y = y / 4)

Operadores de comparación

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

  • Igualdad (==): Compara si dos valores son iguales, sin considerar el tipo de datos.
let a = 5;
let b = "5";
console.log(a == b); // true (compara solo los valores)

let c = true;
let d = 1;
console.log(c == d); // true (true es igual a 1)
  • Desigualdad (!=): Compara si dos valores no son iguales, sin considerar el tipo de datos.
let e = 10;
let f = "5";
console.log(e != f); // true (los valores son diferentes)

let g = false;
let h = 0;
console.log(g != h); // false (false es igual a 0)
  • Igualdad estricta (===): Compara si dos valores son iguales, considerando también el tipo de datos.
let i = 5;
let j = "5";
console.log(i === j); // false (compara valores y tipos de datos)

let k = true;
let l = 1;
console.log(k === l); // false (true y 1 son diferentes tipos de datos)
  • Desigualdad estricta (!==): Compara si dos valores no son iguales, considerando también el tipo de datos.
let m = 10;
let n = "10";
console.log(m !== n); // true (los valores son iguales, pero los tipos de datos son diferentes)

let o = true;
let p = 1;
console.log(o !== p); // true (true y 1 son diferentes tipos de datos)
  • Mayor que (>): Compara si el valor del operando izquierdo es mayor que el valor del operando derecho.
let a = 5;
let b = 3;
console.log(a > b); // true (5 es mayor que 3)

let c = 10;
let d = 20;
console.log(c > d); // false (10 no es mayor que 20)

let e = "25";
let f = 15;
console.log(e > f); // true (la comparación se realiza mediante la conversión a números, "25" es mayor que 15)

En este ejemplo, la comparación e > f evalúa si "25" es mayor que 15, pero como uno de los operandos es una cadena de texto, JavaScript intentará convertirlo a número y luego realizar la comparación. En este caso, "25" se convierte a 25, y la comparación resulta en verdadero (true).

  • Menor que (<): Compara si el valor del operando izquierdo es menor que el valor del operando derecho.
let a = 5;
let b = 10;
console.log(a < b); // true (5 es menor que 10)

let c = 15;
let d = 5;
console.log(c < d); // false (15 no es menor que 5)

let e = "10";
let f = 15;
console.log(e < f); // true (la comparación se realiza mediante la conversión a números, "10" es menor que 15)

En este ejemplo, la comparación e < f evalúa si "10" es menor que 15, pero como uno de los operandos es una cadena de texto, JavaScript intentará convertirlo a número y luego realizar la comparación. En este caso, "10" se convierte a 10, y la comparación resulta en verdadero (true).

  • Mayor o igual que (>=): Compara si el valor del operando izquierdo es mayor o igual que el valor del operando derecho.
let a = 5;
let b = 3;
console.log(a >= b); // true (5 es mayor o igual que 3)

let c = 10;
let d = 10;
console.log(c >= d); // true (10 es igual a 10)

let e = "25";
let f = 20;
console.log(e >= f); // true (la comparación se realiza mediante la conversión a números, "25" es mayor o igual que 20)

En este ejemplo, la comparación e >= f evalúa si "25" es mayor o igual que 20, pero como uno de los operandos es una cadena de texto, JavaScript intentará convertirlo a número y luego realizar la comparación. En este caso, "25" se convierte a 25, y la comparación resulta en verdadero (true).

  • Menor o igual que (<=): Compara si el valor del operando izquierdo es menor o igual que el valor del operando derecho.
let a = 5;
let b = 10;
console.log(a <= b); // true (5 es menor o igual que 10)

let c = 15;
let d = 15;
console.log(c <= d); // true (15 es igual a 15)

let e = "10";
let f = 20;
console.log(e <= f); // true (la comparación se realiza mediante la conversión a números, "10" es menor o igual que 20)

En este ejemplo, la comparación e <= f evalúa si "10" es menor o igual que 20, pero como uno de los operandos es una cadena de texto, JavaScript intentará convertirlo a número y luego realizar la comparación. En este caso, "10" se convierte a 10, y la comparación resulta en verdadero (true).

Operadores lógicos

Los operadores lógicos se utilizan para combinar o negar valores booleanos (true o false).

  • AND lógico (&&): Devuelve true si ambos operandos son true.
let a = true;
let b = false;
console.log(a && b); // false

let c = true;
let d = true;
console.log(c && d); // true
  • OR lógico (||): Devuelve true si al menos uno de los operandos es true.
let e = true;
let f = false;
console.log(e || f); // true

let g = false;
let h = false;
console.log(g || h); // false
  • Negación lógica (!): Devuelve el valor contrario del operando.
let i = true;
console.log(!i); // false

let j = false;
console.log(!j); // true

Otros operadores

Operador ternario

El operador ternario es una forma abreviada de escribir una declaración if...else en una sola línea.

let age = 25;
let result = (age >= 18) ? "Adulto" : "Menor de edad";
console.log(result); // "Adulto"

Operador de concatenación

Los operadores de concatenación se utilizan para unir cadenas de texto.

  • Concatenación básica (+): Une dos cadenas de texto.
let firstName = "John";
let lastName = "Doe";

let fullName = firstName + " " + lastName;
console.log(fullName); // "John Doe"

Operador de tipo

  • Operador typeof: Se utiliza para obtener el tipo de dato de una variable.
let x = 5;
let y = "Hola";
let z = true;

console.log(typeof x); // "number"
console.log(typeof y); // "string"
console.log(typeof z); // "boolean"

Test

Comprueba tus conocimientos con este test sobre operadores y otros conceptos relacionados con esta unidad.