Cursos Empresas Blog Live Conf Eventos Precios

0:0018:40

Recursos

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.

Operadores aritméticos y especiales en JavaScript

Curso de Fundamentos de JavaScript

Clase 6 / 39

Ver clases

Operadores aritméticos y especiales en JavaScript

Curso de Fundamentos de JavaScript

Clase 6 de 39

Clase 6 / 39

Operadores aritméticos y especiales en JavaScript

Curso de Fundamentos de JavaScript

Clase 6 / 39

Ver clases

Cynthia Rodriguez#5698171

// --- 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í

  const suma = a + b;

  return{
    suma: suma
  }
}
console.log(calcularSuma(4,5));
// --- 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í
  const resta = a - b;

  return{
    resta: resta
  }
}
console.log(calcularResta(8,9));

// --- 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í

  const multiplica = a * b;

  return{
    multiplica: multiplica
  }
}
console.log(calcularMultiplicacion(2,5));

// --- 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í
  const division = a / b;

  return{
    division: division
  }
}
console.log(calcularDivision(10,5));

// --- 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í
  const residuo = a % b;

  return{
    residuo: residuo
  }
}
console.log(calcularModulo(5,8));
// --- 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í
  const potencia = base ** exponente;

  return{
    potencia: potencia
  }
}
console.log(calcularPotencia(48,16));
// --- 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 aplica = valor+=incremento

  return{
    aplica: valor+=incremento
  }

}
console.log(aplicarAsignacionSuma(100,50));

// --- 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 resultado = valor;
  resultado -= decremento;
  return{
      aplica : resultado
  }
}
console.log(aplicarAsignacionResta(100,50));
// --- 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 aplica = valor;
  aplica *= factor

  return{
    aplica: aplica
  }
}
console.log(aplicarAsignacionMultiplicacion(52,52));

// --- 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 aplica = valor 
  aplica /= divisor

  return{
    aplicas:aplica
  }
}
console.log(aplicarAsignacionDivision(45,85));
// --- 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í

  contador++

  return{
    contador:contador
  }
}
console.log(incrementarEnUno(1));
// --- 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í

  contador--

  return{
    contador:contador
  }
}
console.log(decrementarEnUno(5));
// --- 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 == true){
    positivo = 1/0;
  }else{
    positivo = -1/0
  }

  return{
    positivo:positivo
  }
}
console.log(resultadoDivisionPorCero(false));
// --- 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í
  let resultado = 'Hola'
  let numero = 9;

  let operacion = resultado * numero;

  return{
    operacion: operacion 
  }

}
console.log(obtenerNaN());
// --- 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í

   return Number.isNaN(valor);
}
console.log(esValorNaN(0/0));
module.exports = {
  calcularSuma,
  calcularResta,
  calcularMultiplicacion,
  calcularDivision,
  calcularModulo,
  calcularPotencia,
  aplicarAsignacionSuma,
  aplicarAsignacionResta,
  aplicarAsignacionMultiplicacion,
  aplicarAsignacionDivision,
  incrementarEnUno,
  decrementarEnUno,
  resultadoDivisionPorCero,
  obtenerNaN,
  esValorNaN,
};

Comentarios (21)21 comentarios

Cristian Alejandro Pereira Rodriguez

Hace 9 meses•editado

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

Hace 8 meses•editado

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

Lidia Andrade Martínez

Hace 8 meses

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

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;
  }
}

Ana Karen Rivas Roman

estaba buscando el video, pero no encontré el link

Eugenia Maldonado

Hace 6 meses

Me pasa lo mismo

Ciro Alejandro Rivera Solorzano

Hace 3 meses

Este es el enlace del video: Wat

Miguel Angel Hurtado Perdomo

Hace 6 días

// ============================================
// 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;
}

// --- 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;
}

// --- 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;
}

// --- 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;
}

// --- 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;
}

// --- 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) {
  let aplica = valor += incremento;
  return aplica;
}

// --- 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) {
  let aplica = valor -= decremento;
  return aplica;
}

// --- 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) {
  let aplica = valor *= factor;
  return aplica;
}

// --- 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) {
  let aplica = valor /= divisor;
  return aplica;
}

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

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

// --- 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){
    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() {
  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) {
  if(Number.isNaN(valor)){
    return true;
  } else {
    return false;
  }
}

export {
  calcularSuma,
  calcularResta,
  calcularMultiplicacion,
  calcularDivision,
  calcularModulo,
  calcularPotencia,
  aplicarAsignacionSuma,
  aplicarAsignacionResta,
  aplicarAsignacionMultiplicacion,
  aplicarAsignacionDivision,
  incrementarEnUno,
  decrementarEnUno,
  resultadoDivisionPorCero,
  obtenerNaN,
  esValorNaN,
};

Julian Mateo Olivares Padilla

Hace un mes

Resultado del reto:

// ============================================
// 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;
}

// --- 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;
}

// --- 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;
}

// --- 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;
}

// --- 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;
}

// --- 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) {
  let resultado = valor;
  resultado += incremento;
  return resultado;
}

// --- 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) {
  let resultado = valor;
  resultado -= decremento;
  return resultado;
}

// --- 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) {
  let resultado = valor;
  resultado *= factor;
  return resultado;
}

// --- 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) {
  let resultado = valor;
  resultado /= divisor;
  return resultado;
}

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

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

// --- 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) {
    return 1 / 0; // Infinity
  } else {
    return -1 / 0; // -Infinity
  }
}

// --- 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 0 / 0; // Esto producirá NaN
}

// --- 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) {
  if (Number.isNaN(valor)) {
    return true;
  } else {
    return false;
  }
}

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

Maria Paulina Aristizabal Pelaez

Hace 2 meses

les comparto mi codigo:

function calcularSuma(a, b) {
  return a + b;
}

console.log(calcularSuma(5, 3));

// --- 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;
}

// --- 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;
}

// --- 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;
}

// --- 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;
}

// --- 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;
}

// --- 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;
}

// --- 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;
}

// --- 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;
}

// --- 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;
}

// --- 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;
}

// --- 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;
}

// --- 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 if (positivo === false) {
    return -1 / 0;
  } else {
    return "Type true or false";
  }
}

// --- 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 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) {
  if (Number.isNaN(valor) === true) {
    return true;
  } else {
    return false;
  }
}

Cynthia Rodriguez

Por cierto no encontré el link con el video divertido, me gustaría verlo.

Angela Buitrago

Hace 7 meses

No encontre el video

Hernán García Urrutia

Comparto mi solución

// ============================================
// 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;
}

// --- 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;
}

// --- 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;
}

// --- 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;
}

// --- 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;
}

// --- 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) {
  let resultado = (valor += incremento);
  return resultado;
}

// --- 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) {
  let resultado = (valor -= decremento);
  return resultado;
}

// --- 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) {
  let resultado = (valor *= factor);
  return resultado;
}

// --- 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) {
  let resultado = (valor /= divisor);
  return resultado;
}

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

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

// --- 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) {
  const infinity = 1 / 0;
  if (positivo) {
    return infinity;
  } else {
    return -infinity;
  }
}

// --- 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 0 * "Hola mundo`";
}

// --- 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) {
  if (Number.isNaN(valor)) {
    return true;
  } else {
    return false;
  }
}

export {
  calcularSuma,
  calcularResta,
  calcularMultiplicacion,
  calcularDivision,
  calcularModulo,
  calcularPotencia,
  aplicarAsignacionSuma,
  aplicarAsignacionResta,
  aplicarAsignacionMultiplicacion,
  aplicarAsignacionDivision,
  incrementarEnUno,
  decrementarEnUno,
  resultadoDivisionPorCero,
  obtenerNaN,
  esValorNaN,
};

Juliana Marcela Muñoz Gaviria

Aquí mi solución al reto:

// ============================================
// 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;
}

console.log(calcularSuma(20,30));

// --- 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;
}

console.log(calcularResta(30,20));

// --- 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;
}

console.log(calcularMultiplicacion(5,3));

// --- 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;
}

console.log(calcularDivision(50,10));

// --- 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;
}

console.log(calcularModulo(7,2));

// --- 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;
}

console.log(calcularPotencia(2,3));

// --- 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 a = valor;
  a += incremento;
  return a;
}

console.log(aplicarAsignacionSuma(20,366));

// --- 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 a = valor;
  a -= decremento;
  return a;
}

console.log(aplicarAsignacionResta(50,6));

// --- 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 a = valor;
  a *= factor;
  return a;
}

console.log(aplicarAsignacionMultiplicacion(6,10));

// --- 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 a = valor;
  a /= divisor;
  return a;
}

console.log(aplicarAsignacionDivision(20,5));

// --- 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 a = contador;
  a ++; 
  return a;
}

console.log(incrementarEnUno(20));

// --- 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 a = contador;
  a --;
  return a;
}

console.log(decrementarEnUno(12));

// --- 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í
  let a = positivo;
  if (a == true) {
    return 1/0
  }
  else {
    return -1/0;
    }
}

console.log(resultadoDivisionPorCero(false));

// --- 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í
  let a = "Hola";
  return a*3;
}

console.log(obtenerNaN());

// --- 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í
  return Number.isNaN(valor);
}

console.log(esValorNaN("Chao"));

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

Miguel Lozano

Mi solución:

// ============================================
// 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 resultado = valor;
    resultado += incremento;
    return resultado;
}

// --- 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 resultado = valor;
    resultado -= decremento;
    return resultado;
}

// --- 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 resultado = valor;
    resultado *= factor;
    return resultado;
}

// --- 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 resultado = valor;
    resultado /= divisor;
    return resultado;
}

// --- 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í
    return ++contador;

}

// --- 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í
    return --contador;
}

// --- 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 === true) {
        return 1/0; //infinity
    } else if (positivo === false){
        return -1/0; //-infinity
    }
}

// --- 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 "hola" * 2;
}

// --- 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í
    return Number.isNaN(valor);
}

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

Todos los tests en verde 💚

Jeremy Roberts Manayay Lucana

Hace 4 meses

//operadores aritmeticos
//Suma

const suma = 5 + 3 // 8
console.log(suma);

//resta

const resta = 5 - 3 // 2
console.log(resta)

//Multiplicación *

const multiplicación = 5 * 3 // 15
console.log(multiplicación);


//división 
const division = 6 / 3 // Como resultado debería ser 2
console.log(division);

//Modulo (%)

const modulo = 5 % 2 // 1
console.log(modulo);

//Exponeciación (**)

const exponeciacion = 2 ** 3 // 8
console.log(exponeciacion);




//Operadores de Asignación 


//Asignación con suma
let a = 5;

a += 3;

console.log(a);


//Asignación con resta 

let b = 5;
b -= 2;
console.log(b);


//Asignación con multiplicación *

let c = 6
c *= 3
console.log(c);  // El resultado se le vuelve a  asignar a C


//Asignación con división /

let d = 9
d /= 3

console.log(d);


//Aporedares de incremento y descremento 

let contador = 10;

contador++

console.log(contador);  // Lo agregamos un numero

contador--; 
console.log(contador) // Lo restamos una unidad

//infinity / -infinitive


console.log(1 / 0); //JavaScript devuelve un valor "infinity" el cual es un numero "Muy grande"

console.log(-1 / 0) //JavaScript devuelve un valor "-infinity" el cual es un numero negativo "Muy pequeño"

//Vamos a reconocer "NaN" "not a number"

console.log(0 / 0); //JavaScript devuelve el resultado NaN debido a que devidir estos numeros practicamente es imposible 
console.log("String" * 2); //El resultado es imposible que sea un numero debido a que esta multplicando un "string" por un valor numerico

VICTOR GONZÁLEZ PEREIRA

todos los tests listo, vamoooos !

Andres Lopez

Hace 5 meses

no creo.que asignar a, al nombre de la variable sea un error.

Porque? creo que la asignación de variables tiene que ir definida por contexto, que sea autodocumental.

'a', contextualmente tiene mucho sentido, ya que es el primer término de una operación.

Steven Andres Moreno Melendez

// ============================================
// 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 ---

// 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 ---

// 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 ---

// Retorna el resultado de multiplicarlos con el operador *.

function calcularMultiplicacion(a, b) {

return a * b;// Tu código aquí

// --- Reto 4: División ---

// 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 ---

// 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;

// --- 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;

// --- 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;

// --- 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 ---

// Retorna el valor de contador decrementado en 1 (equivalente a usar --).

function decrementarEnUno(contador) {

contador--;

// --- 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,

};

Lizeth Montserrat Ramos Reyes

Gran clase!

Comparto el código que hice para los ejercicios

// ============================================
// 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í
  suma=a+b;
  return suma;
}
console.log(calcularSuma(2,5));
// --- 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í
  let resta= a-b;
  return resta;
}
console.log(calcularResta(10,3));

// --- 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í
  let multiplicacion= a*b;
  return multiplicacion;
}
console.log(calcularMultiplicacion(10,3));

// --- 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í
  let division=a/b;
  return division;
}
console.log(calcularDivision(10,2));

// --- 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í
   let modulo=a%b;
  return modulo;
}
console.log(calcularModulo(5,3));

// --- 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í
  let exp=base**exponente;
  return exp;
}
console.log(calcularPotencia(2,4));
// --- 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 asignarSuma=valor+=incremento;
  return asignarSuma;
}
console.log(aplicarAsignacionSuma(1,3));

// --- 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 asignarResta=valor-=decremento;
  return asignarResta;
}
console.log(aplicarAsignacionResta(10,1));

// --- 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*=factor;
  return asignacionMultiplicacion;
}
console.log(aplicarAsignacionMultiplicacion(5,5));

// --- 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/=divisor;
  return asignacionDivision;
}
console.log(aplicarAsignacionDivision(10,2));

// --- 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í
  contador++;
  return contador;
}
console.log(incrementarEnUno(1));

// --- 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í
  contador--;
  return contador;
}
console.log(decrementarEnUno(2));

// --- 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;
  }
}
console.log(resultadoDivisionPorCero(true));
console.log(resultadoDivisionPorCero(false));

// --- 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 "hola"/2;
}
console.log(obtenerNaN());

// --- 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í
  return Number.isNaN(valor);
}
console.log(esValorNaN(NaN));

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

Cualquier comentario es bienvenido.

Erica Avendaño

En estas operaciones también podemos utilizar la.palabra let

Juan Riaño

Hace 9 meses

La potenciación es básicamente un "atajo" matemático. En lugar de escribir una multiplicación larga del mismo número varias veces, usamos la potencia para resumirlo.

Recursos

Resumen

Operadores aritméticos y especiales en JavaScript

Operadores aritméticos y especiales en JavaScript

Operadores aritméticos y especiales en JavaScript

Progreso del curso

Fundamentos Javascript

Funciones, Scope y Estructuras de Datos

DOM y Experiencia en el Navegador

Modulos y Asincronía

Operadores aritméticos y especiales en JavaScript

Operadores aritméticos y especiales en JavaScript

Recursos

Resumen

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

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

¿Cómo usar incremento y decremento en JavaScript?

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

Comentarios

Recursos

Resumen

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

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

¿Cómo usar incremento y decremento en JavaScript?

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

Comentarios