Números y Operaciones Matemáticas en JavaScript

Clase 7 de 55 • Curso de Fundamentos de JavaScript

Resumen

¿Cuál es el tipo de dato `number` en JavaScript?

En JavaScript, el tipo de dato primitivo number es esencial para el manejo de operaciones numéricas. Aunque existen diversas formas de escribir números, como enteros y decimales, todos se reconocen bajo el mismo tipo de dato: number. Esta unificación facilita la manipulación y el cálculo numérico. Veamos cómo se representan en este lenguaje:

Enteros y decimales: Se escriben de forma diferente, pero en su naturaleza subyacente ambos son números.

let entero = 42;
let decimal = 3.14;
console.log(typeof entero); // "number"
console.log(typeof decimal); // "number"

Notación científica: En JavaScript, también podemos utilizar la notación científica para representar números. Se usa la letra e para indicar una potencia de 10.
```
let cientifico = 5e3; // equivale a 5000
```
Infinity y NaN: La representación de números infinitos usa Infinity, mientras que un cálculo o valor indefinido se representa como NaN (Not a Number).
```
let infinito = Infinity;
let noNumero = NaN;
```

¿Cómo realizar operaciones aritméticas?

JavaScript proporciona operadores aritméticos para realizar cálculos básicos y avanzados. Entre ellos destacan:

Operaciones básicas

Suma (+): Adición de dos números.
Resta (-): Diferencia entre dos números.
Multiplicación (*): Producto de dos números.
División (/): Cociente de dos números.

let suma = 5 + 3;
let resta = 10 - 6;
let multiplicacion = 2 * 3;
let division = 9 / 3;

Operaciones avanzadas

Módulo (%): Retorna el residuo de una división entre dos números. Útil para saber si un número es múltiplo de otro.
```
let modulo = 10 % 3; // resultado es 1
```
Exponenciación ()**: Eleva un número a una potencia específica.
```
let potencia = 2 ** 3; // equivale a 8
```

Dilemas con la precisión

JavaScript a veces enfrenta problemas de precisión en operaciones decimales.

Ejemplo: Al sumar 0.1 y 0.2, podríamos esperar 0.3, pero el resultado podría ser un número decimal largo y preciso.
```
let resultado = 0.1 + 0.2;
console.log(resultado); // Imprime algo como 0.30000000000000004
```

Para redondear resultados a un número fijo de decimales, podemos utilizar .toFixed().

console.log(resultado.toFixed(2)); // "0.30"

¿Qué operaciones avanzadas podemos hacer con `Math`?

JavaScript brinda el objeto Math para operaciones matemáticas avanzadas:

Raíz cuadrada (Math.sqrt): Calcula la raíz cuadrada de un número.
```
let raizCuadrada = Math.sqrt(16); // 4
```
Valor absoluto (Math.abs): Devuelve el valor absoluto de un número.
```
let valorAbsoluto = Math.abs(-7); // 7
```
Número aleatorio (Math.random): Genera un número aleatorio entre 0 y 1.
```
let aleatorio = Math.random();
```

El tipo de dato number en JavaScript es fundamental en el desarrollo de aplicaciones donde se requiere manejo de números y cálculos matemáticos, asegurando versatilidad y facilidad en su implementación.

Arnol Daniel Degollado Garrocho

student•

Jhony Daniel Ramirez Bonilla

student•

muchas gracias por tu aporte

Aitor Garcia Ramos

student•

¡Excelente aporte! Me gustaría resaltar una cosilla:

Aarón González

student•

Considerar que toFixed() les vuelve el resultado como string. Ya no seria un integer.

Matias Ezequiel Rivero

student•

Gracias, completo con ejemplos:

Bryan Ramírez

student•

Con parseFloat() podemos convertir ese string a numero.

let numero = 3.14159;

let resultado = parseFloat(numero.toFixed(2));

Andrés Soret Chacin

student•

Tipos de datos en JavaScript: Números

En esta clase vamos a hablar sobre el tipo number en JavaScript.
Es importante conocer los tres tipos de números que podemos escribir: enteros, decimales y notación científica.

Enteros y decimales

Tanto los enteros como los decimales son del tipo number.

let entero = 42;
let decimal = 3.14;
console.log(typeof entero);  // 'number'
console.log(typeof decimal); // 'number'

En JavaScript, no hay distinción entre enteros y decimales a nivel de tipo de dato.

Notación científica

La notación científica también es reconocida como number.

let cientifico = 5e3; // 5 * 10^3
console.log(cientifico); // 5000

Infinito y NaN

Infinito (Infinity) y NaN (Not a Number) son valores especiales del tipo number.

let infinito = Infinity;
let noEsUnNumero = NaN;
console.log(infinito);      // Infinity
console.log(noEsUnNumero);  // NaN

Operaciones aritméticas

Las operaciones básicas incluyen suma, resta, multiplicación y división.

let suma = 5 + 3;           // 8
let resta = 5 - 3;          // 2
let multiplicacion = 5 * 3; // 15
let division = 5 / 3;       // 1.666...
console.log(suma, resta, multiplicacion, division);

Además, se pueden realizar operaciones de módulo y exponenciación.

let modulo = 5 % 3;         // 2
let exponenciacion = 5 ** 3; // 125
console.log(modulo, exponenciacion);

Problemas de precisión

JavaScript puede tener problemas de precisión con números decimales.

let resultado = 0.1 + 0.2;
console.log(resultado); // 0.30000000000000004

Para solucionar problemas de precisión, podemos usar .toFixed().
```
console.log(resultado.toFixed(1)); // 0.3
```

Comparación de números

Comparar números con precisión puede ser problemático.
```
console.log(resultado === 0.3); // false
```

Operaciones avanzadas con Math

JavaScript proporciona operaciones avanzadas mediante el objeto Math.

let raizCuadrada = Math.sqrt(16);       // 4
let valorAbsoluto = Math.abs(-7);       // 7
let aleatorio = Math.random();          // Número aleatorio entre 0 y 1
console.log(raizCuadrada, valorAbsoluto, aleatorio);

Ejemplo completo en código

let entero = 42;
let decimal = 3.14;
let cientifico = 5e3;
let infinito = Infinity;
let noEsUnNumero = NaN;

console.log(typeof entero);        // 'number'
console.log(typeof decimal);       // 'number'
console.log(cientifico);           // 5000
console.log(infinito);             // Infinity
console.log(noEsUnNumero);         // NaN

let suma = 5 + 3;                  // 8
let resta = 5 - 3;                 // 2
let multiplicacion = 5 * 3;        // 15
let division = 5 / 3;              // 1.666...
let modulo = 5 % 3;                // 2
let exponenciacion = 5 ** 3;       // 125

console.log(suma, resta, multiplicacion, division);
console.log(modulo, exponenciacion);

let resultado = 0.1 + 0.2;
console.log(resultado);            // 0.30000000000000004
console.log(resultado.toFixed(1)); // 0.3
console.log(resultado === 0.3);    // false

let raizCuadrada = Math.sqrt(16);       // 4
let valorAbsoluto = Math.abs(-7);       // 7
let aleatorio = Math.random();          // Número aleatorio entre 0 y 1
console.log(raizCuadrada, valorAbsoluto, aleatorio);

Calvin Rafael Bobadilla Fernandez

student•

MI RESUMEN:

Nicolás Duque

student•

¿Entonces cómo podría comparar 0.1+0.2 y 0.3 y obtener como resultado 'true'?

Lilian de la Puente Toll

student•

Rafful Chang

student•

// Precision Problems
const resultado = 0.1 + 0.2 // 0.30000000000000004
console.log(resultado)
console.log(resultado.toFixed(1))

const resultadoFixed = resultado.toFixed(1)

// Comparación Estricta
resultado === resultadoFixed // false, porque son de distinto tipo
console.log(resultado === resultadoFixed) // uno es string y el otro es number
console.log(typeof(resultado), typeof(resultadoFixed)) //number, string

// Comparación no estricta
console.log(resultadoFixed == 0.3) // true porque el valor es el mismo
console.log(typeof(resultado), typeof(resultadoFixed)) //number, string

Carlos G

student•

Documentación para profundizar el tema de la clase:

Matemáticas básicas en JavaScript — números y operadores https://developer.mozilla.org/es/docs/Learn/JavaScript/First_steps/Math

Math https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Global_Objects/Math

Alejandro Rafael Soto Medina

student•

no se si sirva de algo pero me genero curiosidad.

const modulo = 15 % 8

La expresión const modulo = 15 % 8 se utiliza para calcular el resto de la división de 15 entre 8. En este caso, el operador % es el operador de módulo en JavaScript (y en muchos otros lenguajes de programación).

Aquí está el desglose:

15 es el dividendo.
8 es el divisor.
El resultado de 15 % 8 es 7, porque 15 dividido por 8 es 1 con un resto de 7.

Entonces, const modulo = 15 % 8 asigna el valor 7 a la constante modulo.

Para comprobar esto en una calculadora:

Divide 15 entre 8: Esto te dará un cociente de 1.875.
Multiplica el cociente entero (1) por el divisor (8): (1 \times 8 = 8).
Resta este resultado del dividendo (15): (15 - 8 = 7).

Por lo tanto, el residuo es 7, y 15 % 8 es igual a 7.

ese es el proceso interno que crea las operaciones aritméticas de tipo modulo

Damian Castellini

student•

Exacto, para mí es incorrecto como lo explicaron... El modulo de un número es el valor absoluto del mismo, la distancia que hay desde el cero hasta el.

El modulo de 5 es 5 El modulo de -5 es 5

Andres Alvarez

student•

La propiedad toPrecision() cumple la misma función que la propiedad toFixed()

Matias Ezequiel Rivero

student•

Hola, para los interesados en profundizar más, tiene un pequeña diferencia:

Ejemplos:

¿Cuándo usar cada uno?

toFixed(): Cuando necesitas un número fijo de decimales, como al mostrar precios o porcentajes.
toPrecision(): Cuando necesitas controlar el número total de dígitos significativos, especialmente para números muy grandes o muy pequeños.

*Los dígitos significativos son aquellos que aportan información real y precisa sobre una medición. En otras palabras, son los números que nos indican con qué exactitud conocemos un valor.

Espero que sirva. Gracias.

Jonathan Emmanuel Pumares Chab

student•

En JavaScript podemos escribir 3 tipos de números:

Enteros y decimales
Notación científica
Infinitos y NaN

Los operadores aritméticos

El primer grupo se compone de:

Suma

const suma = 3 + 4;

Resta

const resta = 4 - 4;

Multiplicación

const multiplicacion = 4 * 7;

División

const division = 16 / 2;

En otro grupo tenemos:

Módulo

const modulo = 15 % 8;

Exponenciación

const exponenciacion = 2 ** 3;

Operaciones Avanzadas

Raíz cuadrada

const raizCuadrada = Math.sqrt(16);

Valor absoluto

const valorAbsoluto = Math.abs(-7);

Aleatorio

const aleatorio = Math.random();

Valor absoluto

Jeronimo Murillo Narvaez

student•

Diferencia entre === y ==

El primero se hace llamar: operador de igualdad estricta (===). Cómo dijo la profesora Estefa, compara el tipo de dato y el contenido de los valores

El segundo es el operador de igualdad (==), el cual solo compara el contenido.

Les dejo estos dos recursos, son muy buenos ;)

https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Operators/Equality

https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Operators/Strict_equality

https://developer.mozilla.org/es/docs/Web/JavaScript/Equality_comparisons_and_sameness

Oscar Omar Ruiz Rodriguez

student•

¿Por que en esta clase declaro las variables con const y en las anteriores con let?

Alejandro Rafael Soto Medina

student•

supongo que es para variar...

aparte recuerda que se utilizan para declarar variables, pero tienen diferencias clave en cuanto a su uso y comportamiento:

let

Mutabilidad: Las variables declaradas con let pueden ser reasignadas. Esto significa que puedes cambiar su valor después de haber sido inicializadas.
Ámbito: let tiene un ámbito de bloque, lo que significa que solo está disponible dentro del bloque donde se declara (por ejemplo, dentro de {} en un if, for, etc.).
Hoisting: Las variables declaradas con let se elevan (hoisting) al inicio del bloque, pero no se inicializan. Esto significa que no puedes usarlas antes de su declaración en el código.

const

Inmutabilidad: Las variables declaradas con const no pueden ser reasignadas. Una vez que se les asigna un valor, no puede cambiarse.
Ámbito: Al igual que let, const tiene un ámbito de bloque.
Hoisting: Similar a let, las variables const también se elevan al inicio del bloque pero no se inicializan, por lo que no pueden ser usadas antes de su declaración.

en Resumen:

let: úsalo cuando necesites una variable cuyo valor pueda cambiar a lo largo del tiempo.
const: úsalo cuando tengas una variable que no van a cambiar, como constantes matematicas, url's, o configuraciones fijas

David Castañeda Robles

student•

Incluso puedes usar la palabra reservada "var", para tomar las variables de forma global, algo similar a let, pero se diferencia por que con let puedes reusar el nombre de variables.

Un ejemplo clásico es cuando quieres recorrer varios set de datos en un solo programa.

OMANI JAEL AMBROCIO GODINEZ

student•

Espero sea de utilidad El resultado de 0.1 + 0.2 = 0.30000000000000004 en JavaScript (y en otros lenguajes como Python, Java, C++) se debe a cómo se representan los números en computación En computación, los números decimales (como 0.1 o 0.2) se convierten a su equivalente en binario usando el estándar IEEE 754 para números de punto flotante. Algunos números decimales no tienen una representación exacta en binario. Por ejemplo:* 0.1 en binario es un número periódico: 0.000110011001100... (se repite indefinidamente).

Lo mismo ocurre con 0.2: 0.001100110011....

Fuente: chatGPT

Luis Eduardo Payano Villar

student•

Genial, ya estoy comprendiendo al máximo todo lo que indican.

Diego Andrés Lopez Rodriguez

student•

Jorge López

student•

Math.sqrt es un método en JavaScript que se utiliza para calcular la raíz cuadrada de un número. Por ejemplo, Math.sqrt(16) devolverá 4, ya que 4 es la raíz cuadrada de 16. Este método es parte del objeto Math, que incluye diversas funciones matemáticas útiles. Utilizar Math.sqrt es una forma sencilla y eficiente de realizar cálculos matemáticos en tus programas de JavaScript.

Miguel Jonathan Madrigal González

student•

Sobre los signos de igualdad == y == ...

Como sabemos existen diversos tipos de datos, cuando comparamos dos variables usando dos signos de igualdad ==, aquí únicamente buscaremos que sean identicos los valores, pero no el tipo de dato. Por ejemplo, tenemos las siguientes variables:

let numero = 2;
let texto = '2';
console.log(numero == texto);
//output: true
```.

Como se muestra en el ejemplo anterior, se compararon dos variables con el valor de 2, pero ambas variables son de diferente tipo de dato, uno siendo numérico y el otro string-texto.

.

**¿Cuál es la diferencia con doble signo de igualdad?**

Bueno, pongamos el mismo ejemplo, pero ahora usemos doble signo de igualdad en la comparación en el console.log...





```js
let numero = 2;
let texto = '2';
console.log(numero === texto);
//output: false
```.

La diferencia radica en que busca que ambas variables sean del mismo tipo de dato, bien ambos siendo numericos o ambos siendo strings o texto.\\

.

**Extra:** `=`

Un único signo de igualdad solamente se usa para asignar valor, no se usa como comparación. Ya sea asignando valores a nuevas variables declaradas.

Miguel Jonathan Madrigal González

student•

Te mostraré como crear una función que utilice Math.random para generar un numero aleatorio de entre un rango de números que tu decidas...

El código es el siguiente:

function numeroAleatorio (max, min) {
  return Math.floor(Math.random() * (max - min + 1) + min);
};

console.log(numeroAleatorio(1, 10));

Solo es necesario que cambies el valor de los parámetros max y min en la función numeroAleatorio dentro del console.log para definir el rango de números. Ejecuta el script con node o otras variantes para ver la generación de tu número random.

Kevin Camacho

student•

Para obtener un número aleatorio entre 1 y 10, usa la siguiente expresión

Math.round((10 - 1) * Math.random()) + 1

modifica los valores mínimo y máximo. El método .round redondea un número decimal al entero más cercano.

Jonathan Garcia

student•

Karla Verónica Álvarez Vázquez

student•

Los operadores aritméticos en JavaScript incluyen:

Suma (+): Suma dos números.
Resta (-): Resta un número de otro.
Multiplicación (*): Multiplica dos números.
División (/): Divide un número entre otro.
Módulo (%): Devuelve el residuo de una división.
Exponenciación (**): Eleva un número a la potencia de otro.

Recuerda que en JavaScript, tanto los enteros como los decimales se representan como el tipo number.

Números y Operaciones Matemáticas en JavaScript

¿Cuál es el tipo de dato number en JavaScript?

¿Cómo realizar operaciones aritméticas?

Operaciones básicas

Operaciones avanzadas

Dilemas con la precisión

¿Qué operaciones avanzadas podemos hacer con Math?

¿Cuál es el tipo de dato `number` en JavaScript?

¿Qué operaciones avanzadas podemos hacer con `Math`?