Operadores aritméticos y especiales en JavaScript

Cursos Empresas Blog Live Conf Precios

Contenido del curso

No sé dónde empezar

Fundamentos Javascript

Funciones, Scope y Estructuras de Datos

DOM y Experiencia en el Navegador

Modulos y Asincronía

Tomar examen

Operadores aritméticos y especiales en JavaScript

Resumen

Los operadores aritméticos en JavaScript son la base para trabajar con valores numéricos y construir cálculos dentro de tus programas. Aquí aprenderás cómo usar suma, resta, multiplicación, división, módulo y exponenciación, además de operadores de asignación, incremento, decremento y los valores especiales que devuelve el lenguaje.

¿Cuáles son los operadores aritméticos en JavaScript?

JavaScript ofrece seis operadores aritméticos básicos que puedes combinar con variables declaradas con const cuando el resultado no va a cambiar.

Suma (+): const suma = 5 + 3; devuelve 8.
Resta (-): const resta = 5 - 3; devuelve 2.
Multiplicación (*): const multiplicacion = 5 * 3; devuelve 15.
División (/): const division = 6 / 3; devuelve 2.
Módulo (%): const modulo = 5 % 2; devuelve 1, que es el residuo de la división.
Exponenciación (**): const potencia = 2 ** 3; devuelve 8.

Un detalle clave que se menciona alrededor del [2:30] es evitar nombres de variables con acentos o que empiecen con mayúscula. JavaScript distingue entre mayúsculas y minúsculas, así que Multiplicación y multiplicacion se interpretan como variables distintas, lo que puede provocar errores difíciles de rastrear.

¿Qué hace el operador módulo en JavaScript? Devuelve el residuo de una división entera. Por ejemplo, 5 % 2 da 1 porque al dividir 5 entre 2 sobra 1.

¿Cómo funcionan los operadores de asignación?

Los operadores de asignación combinan una operación aritmética con la reasignación del valor a la misma variable. Por eso necesitas declararlas con let, ya que su valor va a cambiar.

En el [6:00] se muestran cuatro casos prácticos:

+= asignación con suma: si let a = 5; y luego a += 3;, el resultado es 8. Equivale a a = a + 3.
-= asignación con resta: con let b = 10; y b -= 4;, obtienes 6.
*= asignación con multiplicación: con let c = 6; y c *= 2;, el valor pasa a 12.
/= asignación con división: con let d = 15; y d /= 3;, queda en 5.

Una advertencia importante del instructor: usar nombres como a, b, c o d sirve para ejemplos matemáticos, pero no es una buena práctica en código real. Cuando alguien lea tu programa va a preguntarse qué representa esa letra. Mejor usa nombres descriptivos.

¿Cómo usar incremento y decremento en JavaScript?

Los operadores ++ y -- aumentan o disminuyen en uno el valor de una variable. Son ideales para contadores.

El ejemplo del [9:30] parte de let contador = 0;. Al ejecutar contador++, el valor sube a 1. Después, con contador--, regresa a 0. Si cambias el valor inicial a 10, el incremento lo lleva a 11 y el decremento lo devuelve a 10.

Esto solo funciona con let porque const no permite reasignar valores.

¿Cuándo uso let en lugar de const? Usa let cuando el valor de la variable vaya a cambiar, como en contadores o asignaciones compuestas. Usa const cuando el valor sea fijo.

¿Qué son Infinity, -Infinity y NaN en JavaScript?

JavaScript sigue un estándar internacional para representar números en memoria, y ese estándar define tres valores especiales que aparecen en operaciones límite. La explicación llega alrededor del [11:30].

Infinity: aparece al ejecutar console.log(1 / 0);. En lugar de lanzar un error, JavaScript devuelve un número extremadamente grande representado como Infinity.
-Infinity: se obtiene con console.log(-1 / 0); y representa el extremo negativo.
NaN (Not a Number): aparece cuando intentas una operación que no produce un número válido. Por ejemplo, console.log(0 / 0); o console.log("hola" * 2); devuelven NaN.

Estos valores existen para que tu programa no se rompa cuando ocurre una operación inválida. Puedes detectarlos con lógica adicional y mostrar mensajes o lanzar excepciones según el caso.

¿Qué significa NaN en JavaScript? Significa Not a Number. Aparece cuando una operación no puede producir un número válido, como multiplicar un texto por un número.

Mucha gente cree que "hola" * 2 daría "holahola", pero la multiplicación no concatena strings. Para eso existen otros operadores que vas a conocer más adelante.

Ahora te toca a ti: prueba estos operadores en tu propio archivo operators.js y deja en los comentarios qué resultados curiosos encontraste al combinar tipos de datos distintos.

Comentarios

Cristian Alejandro Pereira Rodriguez

Estudiante

•

Se le llama módulo (%) al residuo de una división.

Ejemplo: si dividimos 5 entre 2, el resultado es 2 con un residuo de 1, por lo tanto el módulo es 1

Yeison Stiven Cuenca Cedeño

Estudiante

•

Un pequeño aporte

let contador = 0;

console.log(contador++); //Imprime 0 y luego suma 1

console.log(++contador); //Suma 1 y luego imprime 2

Ana Karen Rivas Roman

Estudiante

estaba buscando el video, pero no encontré el link

Eugenia Maldonado

Estudiante

Me pasa lo mismo

Lidia Andrade Martínez

Estudiante

En el reto #15 el string debía ser true porque no es un número, pero en los tests me marcaba que debía ser false, no lo sé, o hay algo que no tome en cuenta.

// ============================================
// Reto: Operadores aritméticos en JavaScript
// ============================================
// Completa cada función según las instrucciones.
// Ejecuta los tests con: npx vitest src/03-operadores-aritmeticos
// ============================================

// --- Reto 1: Suma ---
// Recibe dos números "a" y "b".
// Retorna el resultado de sumarlos con el operador +.
function calcularSuma(a, b) {
  // Tu código aquí
  return (a + b);
}

// --- Reto 2: Resta ---
// Recibe dos números "a" y "b".
// Retorna el resultado de restar b a a con el operador -.
function calcularResta(a, b) {
  // Tu código aquí
  return (a - b);
}

// --- Reto 3: Multiplicación ---
// Recibe dos números "a" y "b".
// Retorna el resultado de multiplicarlos con el operador *.
function calcularMultiplicacion(a, b) {
  // Tu código aquí
  return (a * b);
}

// --- Reto 4: División ---
// Recibe dos números "a" y "b".
// Retorna el resultado de dividir a entre b con el operador /.
function calcularDivision(a, b) {
  // Tu código aquí
  return (a / b);
}

// --- Reto 5: Módulo ---
// Recibe dos números "a" y "b".
// Retorna el residuo de la división de a entre b con el operador %.
function calcularModulo(a, b) {
  // Tu código aquí
  return (a % b);
}

// --- Reto 6: Exponenciación ---
// Recibe "base" y "exponente" (números).
// Retorna base elevado a exponente con el operador **.
function calcularPotencia(base, exponente) {
  // Tu código aquí
  return (base ** exponente);
}

// --- Reto 7: Operador de asignación += ---
// Recibe "valor" e "incremento" (números).
// Usa una variable con let, aplica += (valor += incremento) y retorna el valor resultante.
function aplicarAsignacionSuma(valor, incremento) {
  // Tu código aquí
  let asignacionSuma = valor;
  asignacionSuma += incremento;
  return asignacionSuma;
}

// --- Reto 8: Operador de asignación -= ---
// Recibe "valor" y "decremento" (números).
// Usa una variable con let, aplica -= y retorna el valor resultante.
function aplicarAsignacionResta(valor, decremento) {
  // Tu código aquí
  let asignacionResta = valor;
  asignacionResta -= decremento;
  return asignacionResta;
}

// --- Reto 9: Operador de asignación *= ---
// Recibe "valor" y "factor" (números).
// Usa una variable con let, aplica *= y retorna el valor resultante.
function aplicarAsignacionMultiplicacion(valor, factor) {
  // Tu código aquí
  let asignacionMultiplicacion = valor;
  asignacionMultiplicacion *= factor;
  return asignacionMultiplicacion;
}

// --- Reto 10: Operador de asignación /= ---
// Recibe "valor" y "divisor" (números).
// Usa una variable con let, aplica /= y retorna el valor resultante.
function aplicarAsignacionDivision(valor, divisor) {
  // Tu código aquí
  let asignacionDivision = valor;
  asignacionDivision /= divisor;
  return asignacionDivision;
}

// --- Reto 11: Incrementar en uno ---
// Recibe un número "contador".
// Retorna el valor de contador incrementado en 1 (equivalente a usar ++).
function incrementarEnUno(contador) {
  // Tu código aquí
  let incrementoContador = contador;
  incrementoContador++;
  return incrementoContador;
}

// --- Reto 12: Decrementar en uno ---
// Recibe un número "contador".
// Retorna el valor de contador decrementado en 1 (equivalente a usar --).
function decrementarEnUno(contador) {
  // Tu código aquí
  let decrementoContador = contador;
  decrementoContador--;
  return decrementoContador;
}

// --- Reto 13: División por cero (Infinity / -Infinity) ---
// Recibe un booleano "positivo".
// Si positivo es true, retorna el resultado de dividir 1 entre 0 (Infinity).
// Si positivo es false, retorna el resultado de dividir -1 entre 0 (-Infinity).
function resultadoDivisionPorCero(positivo) {
  // Tu código aquí
  if(positivo) {
    return (1 / 0);
  } else {
    return (-1 / 0);
  }
}

// --- Reto 14: Obtener NaN ---
// Retorna el resultado de una operación que produzca NaN en JavaScript.
// Por ejemplo: 0/0 o multiplicar un string por un número.
function obtenerNaN() {
  // Tu código aquí
  return (0 /0 );
}

// --- Reto 15: Detectar NaN ---
// Recibe un valor cualquiera.
// Retorna true si el valor es NaN, false en caso contrario.
// Pista: usa Number.isNaN(valor).
function esValorNaN(valor) {
  // Tu código aquí
  if(isNaN(valor)) {
    return true;
  } else {
    return false;
  }
}

module.exports = {
  calcularSuma,
  calcularResta,
  calcularMultiplicacion,
  calcularDivision,
  calcularModulo,
  calcularPotencia,
  aplicarAsignacionSuma,
  aplicarAsignacionResta,
  aplicarAsignacionMultiplicacion,
  aplicarAsignacionDivision,
  incrementarEnUno,
  decrementarEnUno,
  resultadoDivisionPorCero,
  obtenerNaN,
  esValorNaN,
};

Marco Antonio Evangelista Armenta

Estudiante

Tu función funciona en algunos casos, pero isNaN() no es recomendable porque convierte el valor a número antes de validar. Es mejor usar Number.isNaN() porque es más estricto y solo devuelve true si el valor realmente es NaN.

function esValorNaN(valor) {
  if(Number.isNaN(valor)) {
    return true;
  } else {
    return false;
  }
}

Steven Andres Moreno Melendez

Estudiante

// ============================================
// Reto: Operadores aritméticos en JavaScript
// ============================================
// Completa cada función según las instrucciones.
// Ejecuta los tests con: npx vitest src/03-operadores-aritmeticos
// ============================================

// --- Reto 1: Suma ---
// Recibe dos números "a" y "b".
// Retorna el resultado de sumarlos con el operador +.
function calcularSuma(a, b) {
    return a + b;
}

// --- Reto 2: Resta ---
// Recibe dos números "a" y "b".
// Retorna el resultado de restar b a a con el operador -.
function calcularResta(a, b) {
    return a - b; // Tu código aquí
}

// --- Reto 3: Multiplicación ---
// Recibe dos números "a" y "b".
// Retorna el resultado de multiplicarlos con el operador *.
function calcularMultiplicacion(a, b) {
    return a * b;// Tu código aquí
}

// --- Reto 4: División ---
// Recibe dos números "a" y "b".
// Retorna el resultado de dividir a entre b con el operador /.
function calcularDivision(a, b) {
    return a / b;// Tu código aquí
}

// --- Reto 5: Módulo ---
// Recibe dos números "a" y "b".
// Retorna el residuo de la división de a entre b con el operador %.
function calcularModulo(a, b) {
    return a % b// Tu código aquí
}

// --- Reto 6: Exponenciación ---
// Recibe "base" y "exponente" (números).
// Retorna base elevado a exponente con el operador **.
function calcularPotencia(base, exponente) {
    return base ** exponente;// Tu código aquí
}

// --- Reto 7: Operador de asignación += ---
// Recibe "valor" e "incremento" (números).
// Usa una variable con let, aplica += (valor += incremento) y retorna el valor resultante.
function aplicarAsignacionSuma(valor, incremento) {
    valor += incremento;
    return valor;// Tu código aquí
}

// --- Reto 8: Operador de asignación -= ---
// Recibe "valor" y "decremento" (números).
// Usa una variable con let, aplica -= y retorna el valor resultante.
function aplicarAsignacionResta(valor, decremento) {
    valor -= decremento;
    return valor;// Tu código aquí
}

// --- Reto 9: Operador de asignación *= ---
// Recibe "valor" y "factor" (números).
// Usa una variable con let, aplica *= y retorna el valor resultante.
function aplicarAsignacionMultiplicacion(valor, factor) {
    valor *= factor;
    return valor; // Tu código aquí
}

// --- Reto 10: Operador de asignación /= ---
// Recibe "valor" y "divisor" (números).
// Usa una variable con let, aplica /= y retorna el valor resultante.
function aplicarAsignacionDivision(valor, divisor) {
    valor /= divisor;
    return valor; // Tu código aquí
}

// --- Reto 11: Incrementar en uno ---
// Recibe un número "contador".
// Retorna el valor de contador incrementado en 1 (equivalente a usar ++).
function incrementarEnUno(contador) {
    contador++;
    return contador; // Tu código aquí
}

// --- Reto 12: Decrementar en uno ---
// Recibe un número "contador".
// Retorna el valor de contador decrementado en 1 (equivalente a usar --).
function decrementarEnUno(contador) {
    contador--;
    return contador; // Tu código aquí
}

// --- Reto 13: División por cero (Infinity / -Infinity) ---
// Recibe un booleano "positivo".
// Si positivo es true, retorna el resultado de dividir 1 entre 0 (Infinity).
// Si positivo es false, retorna el resultado de dividir -1 entre 0 (-Infinity).
function resultadoDivisionPorCero(positivo) {
    if (positivo === true) {
        return 1 / 0;
    }
    else {
        return -1 / 0;
    }     // Tu código aquí
}

// --- Reto 14: Obtener NaN ---
// Retorna el resultado de una operación que produzca NaN en JavaScript.
// Por ejemplo: 0/0 o multiplicar un string por un número.
function obtenerNaN() {
   return 5 * "s"; // Tu código aquí
}

// --- Reto 15: Detectar NaN ---
// Recibe un valor cualquiera.
// Retorna true si el valor es NaN, false en caso contrario.
// Pista: usa Number.isNaN(valor).
function esValorNaN(valor) {
return Number.isNaN(valor);
}

module.exports = {
    calcularSuma,
    calcularResta,
    calcularMultiplicacion,
    calcularDivision,
    calcularModulo,
    calcularPotencia,
    aplicarAsignacionSuma,
    aplicarAsignacionResta,
    aplicarAsignacionMultiplicacion,
    aplicarAsignacionDivision,
    incrementarEnUno,
    decrementarEnUno,
    resultadoDivisionPorCero,
    obtenerNaN,
    esValorNaN,
};

// ============================================

// Reto: Operadores aritméticos en JavaScript

// ============================================

// Completa cada función según las instrucciones.

// Ejecuta los tests con: npx vitest src/03-operadores-aritmeticos

// ============================================

// --- Reto 1: Suma ---