Operadores Aritméticos

Los operadores aritméticos se utilizan para realizar operaciones matemáticas comunes sobre tipos numéricos. Estas operaciones incluyen suma, resta, multiplicación, división, módulo, incremento, decremento y exponenciación.

Suma (+)

const primerValor: number = 15;
const segundoValor: number = 25;
const resultadoSuma: number = primerValor + segundoValor;
console.log(resultadoSuma); // Imprime 40

Resta (-)

const minuendo: number = 50;
const sustraendo: number = 18;
const resultadoResta: number = minuendo - sustraendo;
console.log(resultadoResta); // Imprime 32

Multiplicación (*)

const factorA: number = 7;
const factorB: number = 6;
const producto: number = factorA * factorB;
console.log(producto); // Imprime 42

División (/)

const dividendo: number = 100;
const divisor: number = 4;
const cociente: number = dividendo / divisor;
console.log(cociente); // Imprime 25

Módulo o Residuo (%)

const numeroBase: number = 27;
const numeroDivisor: number = 5;
const residuo: number = numeroBase % numeroDivisor;
console.log(residuo); // Imprime 2

Incremento (++)

let contador: number = 10;
console.log(contador++); // Imprime 10 (evalúa y luego incrementa)
console.log(++contador); // Imprime 12 (incrementa y luego evalúa)

Decremento (--)

let cuentaRegresiva: number = 5;
console.log(cuentaRegresiva--); // Imprime 5 (evalúa y luego decrementa)
console.log(--cuentaRegresiva); // Imprime 3 (decrementa y luego evalúa)

Exponenciación (**)

const base: number = 3;
const exponente: number = 4;
const potencia: number = base ** exponente;
console.log(potencia); // Imprime 81

Operadores de Asignación

Estos operadores permiten asignar valores a las variables. Además de la asignación básica, existen operadores compuestos que realizan una operación matemática y asignan el resultado simultáneamente.

Asignación básica (=)

let edadUsuario: number = 28;
let edadCopia: number = edadUsuario;
console.log(edadCopia); // Imprime 28

Asignación de adición (+=)

let puntuacion: number = 100;
const puntosExtra: number = 25;
puntuacion += puntosExtra; // Equivalente a: puntuacion = puntuacion + puntosExtra
console.log(puntuacion); // Imprime 125

Asignación de multiplicación (*=)

let inversion: number = 1000;
const tasaInteres: number = 1.05;
inversion *= tasaInteres; // Equivalente a: inversion = inversion * tasaInteres
console.log(inversion); // Imprime 1050

Asignación de división (/=)

let presupuestoTotal: number = 500;
const cantidadProyectos: number = 4;
presupuestoTotal /= cantidadProyectos; // Equivalente a: presupuestoTotal = presupuestoTotal / cantidadProyectos
console.log(presupuestoTotal); // Imprime 125

Asignación de módulo (%=)

let minutosTotales: number = 130;
const minutosPorHora: number = 60;
minutosTotales %= minutosPorHora; // Equivalente a: minutosTotales = minutosTotales % minutosPorHora
console.log(minutosTotales); // Imprime 10

Asignación de exponenciación (**=)

let capacidadAlmacenamiento: number = 2;
const nivelExpansion: number = 8;
capacidadAlmacenamiento **= nivelExpansion; // Equivalente a: capacidadAlmacenamiento = capacidadAlmacenamiento ** nivelExpansion
console.log(capacidadAlmacenamiento); // Imprime 256

Operadores de Cadena

Cuando se aplican a tipos de datos string, ciertos operadores actúan para concatenar texto en lugar de realizar matemáticas.

Concatenación (+)

const nombre: string = "Ada";
const apellido: string = "Lovelace";
const nombreCompleto: string = nombre + " " + apellido;
console.log(nombreCompleto); // Imprime "Ada Lovelace"

Concatenación y asignación (+=)

let mensaje: string = "Hola";
const saludoAdicional: string = " mundo";
mensaje += saludoAdicional; // Equivalente a: mensaje = mensaje + saludoAdicional
console.log(mensaje); // Imprime "Hola mundo"

Operadores de Comparación

Los operadores de comparación evalúan dos valores y devuelven un resultado booleano (true o false) dependiendo de si se cumple la condición especificada.

Igualdad débil (==)

Compara los valores realizando conversión de tipos si es necesario.

const valorNumerico: number = 42;
const valorCadena: string = "42";
console.log(valorNumerico == valorCadena); // Imprime true (ignora el tipo)

Igualdad estricta (===)

Compara tanto el valor como el tipo de dato sin realizar conversiones.

const edadNumero: number = 30;
const edadTexto: string = "30";
console.log(edadNumero === edadTexto); // Imprime false (los tipos son distintos)

Desigualdad débil (!=)

Verifica si los valores son diferentes, permitiendo conversión de tipos.

const codigoA: number = 101;
const codigoB: string = "101";
console.log(codigoA != codigoB); // Imprime false (son considerados iguales tras conversión)

Desigualdad estricta (!==)

Verifica si los valores o sus tipos son diferentes.

const estadoA: boolean = true;
const estadoB: string = "true";
console.log(estadoA !== estadoB); // Imprime true (distintos tipos)

Mayor que (>)

const temperaturaActual: number = 35;
const temperaturaLimite: number = 30;
console.log(temperaturaActual > temperaturaLimite); // Imprime true

Mayor o igual que (>=)

const edadMinima: number = 18;
const edadUsuario: number = 18;
console.log(edadUsuario >= edadMinima); // Imprime true

Menor que (<)

const stockDisponible: number = 5;
const stockRequerido: number = 10;
console.log(stockDisponible < stockRequerido); // Imprime true

Menor o igual que (<=)

const pesoMaximo: number = 20.5;
const pesoPaquete: number = 19.8;
console.log(pesoPaquete <= pesoMaximo); // Imprime true