Introducción a JavaScript
¿Por qué aprender JavaScript?
¡Hola Mundo! en Mac
¡Hola Mundo! en Windows
Anatomía de una variable
Tipos de datos en JavaScript
Creación de strings
Operadores aritméticos
Conversión de tipos: Type Casting y Coerción
Conversión de tipos explícita e implícita
Estructuras de Control y Lógica
Operadores de comparación
Operadores lógicos
Ejecución condicional: if
Ejercicio: Adivina el número
Ejecución condicional: switch
Loop: for
Loop: for of
Loop: for in
Loop: while
Loop: do while
Funciones y This
Anatomía de una función
Funciones vs Métodos
Funciones puras e impuras
Arrow function y enlace léxico
Contextos de ejecución y scope chain
¿Qué es Closure?
Preguntas a Desarrolladores Senior: ¿Por qué aprender Desarrollo Web?
Manipulación de Arrays
Introducción a Arrays
Mutabilidad e inmutabilidad de Arrays
Modificación básica del final con push( ), pop( )
Iteración con map( ) y forEach( )
Filtrado y reducción con filter( ) y reduce( )
Búsqueda de elementos con find( ) y findIndex( )
Crear copias con slice( )
Spread operator: casos de uso
Programación Orientada a Objetos
Anatomía de un Objeto
Trabajando con objetos en JavaScript
Función constructora
¿Qué es una clase?
Prototipos y herencias
Herencia en la práctica
Prototipos en la práctica
this en JavaScript
Proyecto: Crea una red social
Proyecto: Crea una red social parte 2
Asincronía en JavaScript
¿Cómo funciona el JavaScript Engine?
Promesas en JavaScript
Usando Async y await en JavaScript
For await of
¿Cómo funciona la web?
¿Cómo funciona HTTP?
Método GET en JavaScript
Método POST en JavaScript
Método DELETE en JavaScript
Importancia del id en el método DELETE
ECMAScript 6 y tus siguientes pasos
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
Si ya tienes una cuenta,
Operadores aritméticos
7/55Recursos
Aportes 20
Preguntas 3
Ordenar por:
**MI RESUMEN:**
![]()
Tipos de datos en JavaScript: Números
- En esta clase vamos a hablar sobre el tipo
numberen 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) yNaN(Not a Number) son valores especiales del tiponumber.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);
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
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>
![]()
Genial, ya estoy comprendiendo al máximo todo lo que indican.
La propiedad toPrecision() cumple la misma función que la propiedad toFixed()
no se si sirva de algo pero me genero curiosidad.
```js
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:
1. **Divide 15 entre 8**: Esto te dará un cociente de 1.875.
2. **Multiplica el cociente entero (1) por el divisor (8)**: (1 \times 8 = 8).
3. **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
Considerar que toFixed() les vuelve el resultado como string. Ya no seria un integer.
**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:
```js
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.
**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:
```js
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.
```js
console.log(resultado.toFixed(1)) // ayuda para establcer el rango de numeros despues del cero
console.log(resultado=== 0.3)
// Operaciones Avanzadas
const raizCuadrada = Math.sqrt(4) // raiz cuadrada
const ValorAbsoluto = Math.abs(-7)
const aleatorio = Math.random() // aletario entre 0 y 1
const aletaorioEntero = Math.floor(Math.random() * 10) + 1 // numeros de 0 a 10 enteros
console.log(raizCuadrada)
console.log(ValorAbsoluto)
console.log(aleatorio.toFixed(2))
console.log(aletaorioEntero)
```console.log(resultado.toFixed(1)) // ayuda para establcer el rango de numeros despues del ceroconsole.log(resultado=== 0.3)
// Operaciones Avanzadas *const* raizCuadrada = Math.sqrt(4) // raiz cuadrada *const* ValorAbsoluto = Math.abs(-7)*const* aleatorio = Math.random() // aletario entre 0 y 1*const* aletaorioEntero = Math.floor(Math.random() \* 10) + 1 // numeros de 0 a 10 enteros
console.log(raizCuadrada)console.log(ValorAbsoluto)console.log(aleatorio.toFixed(2))console.log(aletaorioEntero)
Les dejo mis apuntes de la clase! :D
Es interesante ver cómo puede JavaScritp procesar las operaciones, estaba fuera de mi conocimiento. Les comparto mi ejercicio practico, al final lo procesé todo con Node y los resultados fueron perfectos
¿Cómo puedo hacer para que el número random me lo proporcione en número entero y cómo puedo agregarle un parámetro?
ejemplo:
parámetro 1-10
resultado: 5
**Método toFixed( )**
**Recuerda que en la igualdad estricta, nos da FALSO porque el resultado de utilizar el método toFixed( ) es un STRING)**
```js
// tipos de datos los decimales y enteros
const entero = 5;
const decimales = 5.5;
console.log(typeof entero , typeof decimales);
//Notación Científica
const notacionCientifica = 999e9;
console.log(notacionCientifica, typeof notacionCientifica);
//Operaciones Aritmeticas Básicas
const suma = 55 + 55;
const resta = 100 - 5;
const multiplicacion = 25 *5;
const division = 100 / 5;
const modulo = 100 % 5; //otorga el resto de una division, en el presente caso, al ser exacta, el resutlado es 0
const exponenciacion = 5 ** 2 ; //otorgará 25, porque es 5 elevado a la 2
console.log("suma " + suma,"resta " + resta ,"multiplicacion " + multiplicacion,"division "+ division, "modulo " + modulo, "exponencianción " + exponenciacion );
//infinity, NaN, Max y Min value.
/*
INFINITY
Es el valor usado por javascript cuando se realizan operaciones que exceden los
valores numericos a los cuales esta configuarado
*/
const infinito = Infinity;
//Especificación del signo del infinito
const infinitoNegativo = Number.NEGATIVE_INFINITY;
const infinitoPositivo = Number.POSITIVE_INFINITY;
//Ciertos casos de uso
const casoA1 = 100 / 0; // otorgará infinity positivo
const casoA2 = -100 / 0; //otorgará infinity negativo
const casoA3 = 100 / -0; //otorgará infinity negativo
const casoA4 = 25 / null;//otorgará infinity positivo
const casoA5 = Infinity / null ; //otorgará infinity positivo
const casoA6 = 25 ** 5 ** 5;
const casoA7 = 999e999; //Número exageradamente grandes, daran infinity ya sean negativos o positivos
//funciones
const funcionA1 = isFinite(casoA1);// Será false, si la variable otorgada es infinita
/*
NaN NOT A NUMBER
Es un tipo de dato primitvo, el cual se encuentra en la funcion Number entre los recursos de javascript, y es considerado un tipo de dato especial
*/
const noEsUnNumero = NaN; //primera forma de ser declarado
const noEsUnNumero2 = Number.NaN; //segunda forma de ser declarado
//casos de uso
const casoB1 = 0 / 0;
const casoB2 = 6 + undefined;
const casoB3 = null / null;
const casoB4 = 25 * undefined;
const casoB5 = 25 + NaN;
const casoB6 = Infinity / Infinity;
const casoB7 = NaN + NaN;
//funciones
const funcionB1 = isNaN(casoB1);//otorgara true si la variable otorgada es NaN
const funcionB2 = NaN === NaN; //false porque NaN no es igual a nigún valor incluyendose así mismo
const funcionB3 = NaN == NaN;//false porque NaN no es igual a nigún valor incluyendose así mismo
const funcionB4 = NaN == Number.NaN; //false porque NaN no es igual a nigún valor incluyendose así mismo
const funcionB5 = NaN === Number.NaN; //false porque NaN no es igual a nigún valor incluyendose así mismo
/*
Max y Min Value
son los Maximos y Minimos valores que javascript puede soportar
*/
const max = Number.MAX_VALUE;
const min = Number.MIN_VALUE;
const excediendoLimites = max * 0.00000000000000005551 + max;
/*
Console.log
infinity
*/
console.log(infinito, infinitoNegativo, infinitoPositivo);
console.log(casoA1, casoA2, casoA3, casoA4,casoA5, casoA6, casoA7);
console.log(funcionA1);
// NaN
console.log(noEsUnNumero,noEsUnNumero2);
console.log( casoB1, casoB2, casoB3, casoB4, casoB5, casoB6, casoB7);
console.log(funcionB1, funcionB2, funcionB3, funcionB4, funcionB5);
//Max y Min Value
console.log(max, " " + min);
console.log("limite " + excediendoLimites);
//impresición de javascript con los decimales
const resultado = 0.1 + 0.2;
console.log(resultado);
console.log(resultado.toFixed(1));
console.log(resultado.toFixed(1) == 0.3); // Se compara el valor y no el tipo de variable, da true, al ser el mismo valor
console.log(resultado.toFixed(1) === 0.3);// Se compara el valor y el tipo de variable, sa false, a pesar de tener el mismo valor, pero distinto tipo de variable
console.log( "Tipos de Variables " + typeof resultado.toFixed(1), typeof 0.3, typeof resultado);
//Operaciones Avanzadas
const raizCuadrada = Math.sqrt(10000);
const valorAbsoluto = Math.abs(-25);
const aleatorio = Math.random();
console.log(raizCuadrada); // La Raiz Cuadrada de 10000 que es 100
console.log(valorAbsoluto); // valor absoluto del valor otorgado, en este caso -25
console.log(aleatorio);//Un número aleatorio mayor o igual a 0 pero menor a 1
console.log(Number.EPSILON); // la constante de Epsilon
```*// tipos de datos los decimales y enteros* const entero = 5; const decimales = 5.5;
console.log(typeof entero , typeof decimales);
*//Notación Científica* const notacionCientifica = 999e9;
console.log(notacionCientifica, typeof notacionCientifica);
*//Operaciones Aritmeticas Básicas*
const suma = 55 + 55; const resta = 100 - 5; const multiplicacion = 25 \*5; const division = 100 / 5; const modulo = 100 % 5; *//otorga el resto de una division, en el presente caso, al ser exacta, el resutlado es 0* const exponenciacion = 5 \*\* 2 ; *//otorgará 25, porque es 5 elevado a la 2*
console.log("suma " + suma,"resta " + resta ,"multiplicacion " + multiplicacion,"division "+ division, "modulo " + modulo, "exponencianción " + exponenciacion );
*//infinity, NaN, Max y Min value.*
*/\* INFINITY Es el valor usado por javascript cuando se realizan operaciones que exceden los valores numericos a los cuales esta configuarado \*/*
const infinito = Infinity;
*//Especificación del signo del infinito* const infinitoNegativo = Number.NEGATIVE\_INFINITY; const infinitoPositivo = Number.POSITIVE\_INFINITY;
*//Ciertos casos de uso* const casoA1 = 100 / 0; *// otorgará infinity positivo* const casoA2 = -100 / 0; *//otorgará infinity negativo* const casoA3 = 100 / -0; *//otorgará infinity negativo* const casoA4 = 25 / null;*//otorgará infinity positivo* const casoA5 = Infinity / null ; *//otorgará infinity positivo* const casoA6 = 25 \*\* 5 \*\* 5; const casoA7 = 999e999; *//Número exageradamente grandes, daran infinity ya sean negativos o positivos*
*//funciones* const funcionA1 = isFinite(casoA1);*// Será false, si la variable otorgada es infinita*
*/\* NaN NOT A NUMBER Es un tipo de dato primitvo, el cual se encuentra en la funcion Number entre los recursos de javascript, y es considerado un tipo de dato especial\*/*
const noEsUnNumero = NaN; *//primera forma de ser declarado* const noEsUnNumero2 = Number.NaN; *//segunda forma de ser declarado*
*//casos de uso* const casoB1 = 0 / 0; const casoB2 = 6 + undefined; const casoB3 = null / null; const casoB4 = 25 \* undefined; const casoB5 = 25 + NaN; const casoB6 = Infinity / Infinity; const casoB7 = NaN + NaN;
*//funciones* const funcionB1 = isNaN(casoB1);*//otorgara true si la variable otorgada es NaN* const funcionB2 = NaN === NaN; *//false porque NaN no es igual a nigún valor incluyendose así mismo* const funcionB3 = NaN == NaN;*//false porque NaN no es igual a nigún valor incluyendose así mismo* const funcionB4 = NaN == Number.NaN; *//false porque NaN no es igual a nigún valor incluyendose así mismo* const funcionB5 = NaN === Number.NaN; *//false porque NaN no es igual a nigún valor incluyendose así mismo*
*/\* Max y Min Value son los Maximos y Minimos valores que javascript puede soportar\*/* const max = Number.MAX\_VALUE; const min = Number.MIN\_VALUE;
const excediendoLimites = max \* 0.00000000000000005551 + max; */\* Console.log infinity \*/* console.log(infinito, infinitoNegativo, infinitoPositivo); console.log(casoA1, casoA2, casoA3, casoA4,casoA5, casoA6, casoA7); console.log(funcionA1);
*// NaN* console.log(noEsUnNumero,noEsUnNumero2); console.log( casoB1, casoB2, casoB3, casoB4, casoB5, casoB6, casoB7); console.log(funcionB1, funcionB2, funcionB3, funcionB4, funcionB5);
*//Max y Min Value* console.log(max, " " + min); console.log("limite " + excediendoLimites);*//impresición de javascript con los decimales*const resultado = 0.1 + 0.2;
console.log(resultado);console.log(resultado.toFixed(1));console.log(resultado.toFixed(1) == 0.3); *// Se compara el valor y no el tipo de variable, da true, al ser el mismo valor*console.log(resultado.toFixed(1) === 0.3);*// Se compara el valor y el tipo de variable, sa false, a pesar de tener el mismo valor, pero distinto tipo de variable*console.log( "Tipos de Variables " + typeof resultado.toFixed(1), typeof 0.3, typeof resultado);
*//Operaciones Avanzadas*
const raizCuadrada = Math.sqrt(10000);const valorAbsoluto = Math.abs(-25);const aleatorio = Math.random();
console.log(raizCuadrada); *// La Raiz Cuadrada de 10000 que es 100*console.log(valorAbsoluto); *// valor absoluto del valor otorgado, en este caso -25*console.log(aleatorio);*//Un número aleatorio mayor o igual a 0 pero menor a 1*console.log(Number.EPSILON); *// la constante de Epsilon*
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?