Operadores Aritméticos en JavaScript
Los operadores en JavaScript son símbolos o palabras clave que se utilizan para realizar operaciones sobre valores o variables. Estos operadores permiten manipular datos y realizar cálculos, comparaciones, asignaciones, y mucho más. Los operadores son fundamentales para escribir lógica en JavaScript.
A continuación se presenta una clasificación de los principales tipos de operadores en JavaScript:
script.js
// Declaramos las variables iniciales
let a = 10;
let b = 3;
// Suma
let suma = a + b; // 10 + 3 = 13
console.log("Suma:", suma);
// Resta
let resta = a - b; // 10 - 3 = 7
console.log("Resta:", resta);
// Multiplicación
let multiplicacion = a * b; // 10 * 3 = 30
console.log("Multiplicación:", multiplicacion);
// División
let division = a / b; // 10 / 3 = 3.3333...
console.log("División:", division);
// Módulo (resto de la división)
let modulo = a % b; // 10 % 3 = 1
console.log("Módulo:", modulo);
// Exponenciación
let exponenciacion = a ** b; // 10 ** 3 = 1000
console.log("Exponenciación:", exponenciacion);
// Operadores combinados con asignación
let c = 5;
// Suma y asignación
c += 2; // c = c + 2 → c = 5 + 2 = 7
console.log("Suma y asignación:", c);
// Resta y asignación
c -= 3; // c = c - 3 → c = 7 - 3 = 4
console.log("Resta y asignación:", c);
// Multiplicación y asignación
c *= 2; // c = c * 2 → c = 4 * 2 = 8
console.log("Multiplicación y asignación:", c);
// División y asignación
c /= 4; // c = c / 4 → c = 8 / 4 = 2
console.log("División y asignación:", c);
// Módulo y asignación
c %= 2; // c = c % 2 → c = 2 % 2 = 0
console.log("Módulo y asignación:", c);
// Precedencia de operadores
let resultado = (a + b) * (a - b) / b; // (10 + 3) * (10 - 3) / 3 = 13 * 7 / 3 = 30.3333...
console.log("Resultado con precedencia:", resultado);
OutPut
Suma: 13
Resta: 7
Multiplicación: 30
División: 3.3333333333333335
Módulo: 1
Exponenciación: 1000
Suma y asignación: 7
Resta y asignación: 4
Multiplicación y asignación: 8
División y asignación: 2
Módulo y asignación: 0
Resultado con precedencia: 30.333333333333332
Operadores aritméticos en JavaScript
Los operadores aritméticos en JavaScript se utilizan para realizar cálculos matemáticos como suma, resta, multiplicación, división, etc. Son una parte fundamental del lenguaje, ya que permiten trabajar con números de manera sencilla.
Principales operadores aritméticos
| Operador | Nombre | Ejemplo | Resultado |
|---|---|---|---|
+ | Suma | 5 + 3 | 8 |
- | Resta | 10 - 4 | 6 |
* | Multiplicación | 6 * 7 | 42 |
/ | División | 20 / 5 | 4 |
% | Módulo (resto) | 10 % 3 | 1 |
** | Exponenciación | 2 ** 3 | 8 |
1. Suma (+)
Se utiliza para sumar dos o más valores.
let a = 5;
let b = 3;
let suma = a + b;
console.log(suma); // Muestra: 8
2. Resta (-)
Se utiliza para restar un valor de otro.
let a = 10;
let b = 4;
let resta = a - b;
console.log(resta); // Muestra: 6
3. Multiplicación (*)
Se utiliza para multiplicar dos valores.
let a = 6;
let b = 7;
let producto = a * b;
console.log(producto); // Muestra: 42
4. División (/)
Se utiliza para dividir un valor entre otro. Si divides entre 0, el resultado es Infinity.
let a = 20;
let b = 5;
let division = a / b;
console.log(division); // Muestra: 4
let divisionPorCero = a / 0;
console.log(divisionPorCero); // Muestra: Infinity
5. Módulo (%)
El operador de módulo devuelve el resto de una división.
let a = 10;
let b = 3;
let resto = a % b;
console.log(resto); // Muestra: 1
Number (Números)
Se utilizan para representar números, tanto enteros como decimales.
let edad = 25; // Número entero
let precio = 19.99; // Número decimal
let resultado = edad * precio; // Operaciones matemáticas
6. Exponenciación (**)
Este operador eleva un número a la potencia de otro.
let base = 2;
let exponente = 3;
let potencia = base ** exponente;
console.log(potencia); // Muestra: 8
Operadores aritméticos con asignación
Puedes combinar operadores aritméticos con el operador de asignación ( = ) para actualizar el valor de una variable de manera más concisa.
| Operador | Ejemplo | Equivalente a |
|---|---|---|
+= | a += b | a = a + b |
-= | a -= b | a = a - b |
*= | a *= b | a = a * b |
/= | a /= b | a = a / b |
%= | a %= b | a = a % b |
**= | a **= b | a = a ** b |
De esta forma al realizarse cualquier operación, el resultado se vuelve a guardar en la misma variable «repetida».
Ejemplo:
let numero = 10;
numero += 5; // Equivale a numero = numero + 5
console.log(numero); // Muestra: 15
numero *= 2; // Equivale a numero = numero * 2
console.log(numero); // Muestra: 30
Como vemos en el ejemplo, primero la variable «numero» almacena el valor 10. Luego se declara otra variable:
» numero += 5; «
que es lo mismo que:
» numero = numero + 5; «
Al realizarse la operación (numero = 10 + 5), la variable «numero» recibe un nuevo valor igual a la operación realizada, en este caso 15.
Luego se realiza la misma operación pero multiplicando la variable «numero» por dos (numero = 15 * 2), quedándose al final del código la variable con un valor de 30.
Precedencia de operadores
Cuando usas varios operadores en una misma expresión, la precedencia (orden de operaciones) define cuál se evalúa primero. El orden es:
- Paréntesis:
() - Exponenciación:
** - Multiplicación, División y Módulo:
*,/,% - Suma y Resta:
+,-
let resultado = 5 + 3 * 2; // Multiplicación se evalúa primero
console.log(resultado); // Muestra: 11
let resultadoConParentesis = (5 + 3) * 2; // Paréntesis primero
console.log(resultadoConParentesis); // Muestra: 16
Ejercicio Práctico
Declara dos variables a y b con los valores 12 y 5. Realiza las siguientes operaciones: suma, resta, multiplicación, división y módulo. Muestra los resultados en la consola.
Calcula el cuadrado de un número usando el operador de exponenciación ( ** ).
Escribe una expresión que combine al menos tres operadores aritméticos y muestra el resultado en la consola.
Usa un operador con asignación ( += , *= ) para actualizar una variable en dos pasos.