El tipo de dato number se usa para variables que contendrán números positivos, negativos o decimales.
Operaciones
En JavaScript, una variable de tipo number puede fácilmente ser concatenado con otra de tipo string:
//JavaScript let myNumber = 30; myNumber = myNumber + "5"; //El resultado sería '305'
Sin embargo, esto podría llevar confusiones y errores durante la ejecución del programa, además de estar cambiando el tipo de dato de la variable. Por ello, en TypeScript solo se pueden hacer operaciones numéricas entre números valga la redundancia:
//TypeScript let myNumber: number = 30; myNumber = myNumber + 10; //CORRECTO myNumber = myNumber + "10"; //INCORRECTO
Uso de variables sin inicializar
//TypeScript let productInStock: number; console.log("Product in stock: " + productInStock);
Señalar que si no se va a inicializar aún la variable, definir explícitamente el tipo de dato, pues TypeScript no puede inferirlo si no tiene un valor inicial.
Conversión de números de tipo string a tipo number
Para esto usaremos el método parseInt:
let discount: number = parseInt("123"); let numeroString: string = "100"; let nuevoNumero: number; nuevoNumero = parseInt(numeroString);
Esto funciona si el string tiene solo y exclusivamente números que no empiecen con 0. De lo contrario, el resultado será de tipo NaN (Not a Number):
//TypeScript let numeroPrueba: number = parseInt("palabra"); console.log(numeroPrueba); //NaN
Binarios y Hexadecimales
TypeScript nos puede indicar error si intentamos definir números binarios que tengan números que no sean 0 o 1 y si declaramos hexadecimales usando valores fuera del rango:
//**********TypeScript********** //Binarios: se definen colocando "0b" al inicio del valor let primerBinario = 0b1010; //CORRECTO let segundobinario = 0b1210; //INCORRECTO. El 2 es inválido //Hexadecimales: se definen colocando "0x" al inicio del valor let primerHexa = 0xfff; //CORRECTO let segundoHexa = 0xffz; //INCORRECTO. El "z" es inválido
En consola, si están correctamente asignados, se hará una conversión a decimal de dichos números:
let primerHexa = 0xfff; console.log(primerHexa); // 4095 let primerBinario = 0b1010; console.log(primerBinario); // 10
Consejo
Cuando definas una variable de tipo de dato number, es preferible que el nombre de tipo sea en minúscula. Esto como buena práctica, pues se hará referencia al tipo de dato number y no al objeto Number propio del lenguaje:
let myNumber: number = 20; // Buena practica. let otherNumber: Number = 20; // Mala practica.
Contribución creada por: Martín Álvarez.
Pepe Sosa
Tip: Si no quieres ir ejecutando todos los archivos, existe una extensión que te da los valores en tiempo real, se llama Quokka y es extremadamente útil para este tipo de cosas.
Solo la instalas y en el archivo que quieres que funcione presionas "F1" y eliges "Quokka: start on current file" es todo.
Pepe Sosa
No cabe duda, Quokka entre mi top 5 de extensiones para desarrollar.
Jordy Mairena Montoya
Gracias, crack
Baltazar Andersson
Tipazo: Existe una extensión que se llama Error Lens, que te muestra los errores(en general) directamente en el código, esto incluye los de TS.
Marcelo Arias
Profesor¡Esa extensión es genial! 😊
Jhon Eduard Bocanegra Ortiz
Muy buena extensión, la descubri hace poco y me esta gustanto mucho.
mmorenov6489
Axel Enrique Galeed Gutierrez
Les comparto mis apuntes. :D
Declaración de variables
En caso de simplemente declarar una variable y no asignarle un valor, estamos obligados a agregar el tipo de dato que es esa variable.
let productInStock: number;
NaN
Not A Number, entra dentro de la categoría de tipos de datos number.
Hexadecimal
Para usarlos, antes de asignar un número tenemos que colocar 0x y luego colocar valores entre el 0 y la f.
let hex: number = 0x0f124;
Binarios
Para usarlos, antes de asignar un número tenemos que colocar 0b y luego colocar 0 o 1.
let binariy: number = 0b00110101;
Octales
Para usarlos, antes de asignar un número tenemos que colocar 0o y luego colocar valores entre el 0 y el 7.
let octal: number = 0o0771234;
Al momento de compilar, en todos los casos, sea cual sea el valor que hayamos puesto va a ser convertido al valor decimal que corresponda.
Andrés Felipe Eslava Zuluaga
Recordar pues ome!
number !== Number
Santiago Molano
Juan Carlos Pinzón
Para números grandes podemos hacer uso de una sintaxis más legible, por ejemplo:
const price = 10_000_000
Que sería el equivalente a 10000000, su valor real es ese. Solo que visualmente para el humano es más fácil de leer.
Juan David Reyes
number
let productPrice = 100;
let productPrice:number = 100;
Casos
let productPrice:number;
El análisis de código estático de TS nos marcara un error si trabajamos con una variable que no tiene un cierto valor.
Tipos de números
let hex = 0xfff;
let bin = 0b10101;
Para poder manejarlos tenemos que utilizar los primeros 2 espacios ya sea 0b para binario o 0x para hexadecimal.
number y Number
Number es un tipado pero no tiene que ver con el conjunto de números que nosotros necesitamos usar basándose en el objeto number, como conclusión no debemos trabajar con “Number” si no con “number”.
Santiago de la Cruz López Vecino
Cuando pongo el comando node .\dist\number.js no pasa nada, ayuda jajaja
Henry Alexander Velásquez Rosas
Hey! ¿Lograste solucionarlo?
Julio Manuel Nieto
Para que funcione, la IIFE tiene que terminar en () osea:
(()=>{ })();
Sin el ultimo () no se va a ejecutar la funcion al hacer node dist/number.js en la terminal
Ayriel Noriega
Formas de inicializar variables en TypeScript
Existen varias maneras de inicializar variables en TypeScript, dependiendo de si usas tipos explícitos, inferencia de tipos o características avanzadas como valores predeterminados o null.
1. Inicialización con tipo explícito
Cuando declaras una variable en TypeScript, puedes especificar explícitamente el tipo de dato. Esto asegura que la variable solo pueda almacenar valores de ese tipo.
Ejemplo de tipo explícito:
let nombre: string = "Juan"; // Inicialización explícita de una variable tipo string
let edad: number = 30; // Inicialización explícita de una variable tipo number
let esActivo: boolean = true; // Inicialización explícita de una variable tipo boolean
En este caso, la variable nombre solo puede almacenar valores de tipo string, edad solo puede ser number y esActivo solo puede ser boolean.
2. Inicialización con inferencia de tipos
Cuando no defines explícitamente un tipo, TypeScript puede inferir el tipo basado en el valor que le asignas a la variable. Este es un enfoque más flexible que reduce la necesidad de escribir el tipo manualmente.
Ejemplo de inferencia de tipos:
let nombre = "Juan"; // Inferido como string
let edad = 30; // Inferido como number
let esActivo = true; // Inferido como boolean
Aquí, TypeScript infiere automáticamente el tipo de la variable basándose en el valor que se le asigna. En este caso, nombre será de tipo string, edad será de tipo number y esActivo será de tipo boolean.
3. Inicialización de variables con const, let y var
En TypeScript, puedes declarar variables con los siguientes modificadores de alcance:
const: Usado para declarar variables cuyo valor no cambiará después de la inicialización. El valor es constante, pero su tipo puede ser inferido. const pi = 3.14; // Inferido como number, no puede cambiar su valor
let: Usado para declarar variables cuyo valor puede cambiar. El tipo puede ser inferido o explícito.typescriptCopiar códigolet contador = 0; // Inferido como number, puede cambiar su valor
var: Aunque es menos común en TypeScript, se usa para declarar variables con un alcance de función. Tiene un comportamiento diferente en cuanto a hoisting y puede ser reemplazado por let o const en la mayoría de los casos. var mensaje = "Hola"; // Inferido como string, puede cambiar
4. Inicialización con valores predeterminados
Puedes asignar un valor predeterminado a las variables al momento de declararlas, lo cual es útil cuando quieres asegurar que la variable tenga un valor inicial adecuado.
Ejemplo con valores predeterminados:
let nombre: string = "Juan"; // Valor predeterminado "Juan"
let edad: number = 30; // Valor predeterminado 30
Si más adelante deseas cambiar el valor de la variable, puedes hacerlo sin restricciones:
nombre = "Maria"; // El tipo sigue siendo string
edad = 25; // El tipo sigue siendo number
5. Inicialización con null o undefined
En TypeScript, puedes inicializar una variable con null o undefined, pero debes tener en cuenta que esto puede hacer que el tipo sea más flexible.
Ejemplo con null o undefined:
let persona: { nombre: string, edad: number } | null = null;
En este ejemplo, persona puede ser un objeto con una propiedad nombre de tipo string y una propiedad edad de tipo number, o puede ser null. Esto es útil cuando necesitas representar un valor ausente o vacío.
Si no deseas permitir que una variable tenga valores null o undefined, puedes usar el operador strictNullChecks en el tsconfig.json para forzar una mayor seguridad de tipos.
Cristian Javier Lizardìa
Algo interesante que vi, es que en el parseInt si le cargamos por ejempo '12d3', en lugar de no aceptarlo como numero real, toma los primeros numeros hasta que encuentre algo que no lo es, en este caso devolveria un number 12. Solo da NaN si el value comienza con una letra.
Jean Rodriguez
Aprendi demasiado en esta clase.
JERSSON ARLEY OSMA CIFUENTES
cuando inicializas una variable con let sin ningun valor esta por defecto es undefined
asi que si esta tipado con number saltará error porque undefined no es un numero
la solucion va que si declaro una variable sin valor y sin tipado por defecto le asigna tipado any
la otra solución es tiparla directamente con any
//primera solucion let onlyNumber; console.log('onlyNumber', onlyNumber); //segunda solucion let onlyNumber: any; console.log('onlyNumber', onlyNumber);
Sergio Estrella
ProfesorEn qué casos convendría tipar Number (con la clase) en lugar de number (El tipo)?
Bárbara Monzú
hola, no me esta mostrando la terminal del code ningún console.log, y he comprado que esta guardado y que la ruta esta bien puesta y el watch activado desde el git bash. pero no lo muestra.!
Jose Mauricio Hualpa lopez
reisaste la segunda parte de la funcion anonima autoejecutada quisa sea eso es (() => {codigo..}) ();
Aaron Contreras Garibay
se puede excluir algunos numeros del conjunto? como el NaN
Nicolas Molina
ProfesorHola, por ahora no se puede, es decir NaN hace parte del conjunto de los números, si quieres evitar errores de tipo NaN te tocaría hacer una validación; sin embargo, si se está trabajando en una opción para que de forma opcional le digas al compilar no aceptar NaN como un número.
marcelo veron
hexadecimales => 0xfff binario => 0b121212
Marvin Javier Santos Fernández
// Vamos a crear un scopes es decir
/* Si tenemos mismas variables en otros
archivos no darán errores ni van a interferir
en el código.
*/
(() =>{
// Como tenemos tipo let podemos cambiar su tipo
// siempre cuando sea igual.
let producuPrecio = 300;
producuPrecio = 16;
console.log('Precio del producto: ', producuPrecio);
// Nuevamente una variable con la identificación del tipo
// de dato.
let modificarEdad: number = 20;
// modificarEdad = + modificarEdad + '1'; aquí es una concatenación no una suma.
modificarEdad = modificarEdad + 1; // Aqui será un incremento de + 1.
console.log('Edad modificada: ', modificarEdad);
// Declaramos la variable con el tip de valor
// pero sin asignarlo.
let productStock: number;
console.log('Stock: ', productStock); // Error sin asignación.
// Convertimos un string a entero, con parseInt.
let conver_int = parseInt('345');
console.log('Ver número: ', conver_int);
if (conver_int <= 400) {
console.log('Aplica');
}else{
console.log('No aplica');
}
let hexa = 0xfff;
console.log('Hexadecimal', hexa);
let binar = 0b1010;
console.log('Binario: ', binar);
})();
Gildder Guerrero Ramirez
¿Puedo usar esto para decimales y hexadecimales?
Absolutamente. El tipo number en TypeScript es extremadamente versátil y soporta múltiples bases numéricas directamente sin necesidad de configuraciones extra. Puedes asignar valores decimales tradicionales como let pi: number = 3.1416;, pero también puedes trabajar con sistemas numéricos más complejos usando prefijos específicos. Por ejemplo, puedes definir valores hexadecimales usando el prefijo 0x (let colorHex: number = 0xffffff;), valores binarios con el prefijo 0b (let binario: number = 0b1010;) y valores octales con 0o (let permisos: number = 0o744;). Todos estos formatos son reconocidos, procesados y validados bajo el mismo paraguas del tipo number. Esto resulta especialmente útil cuando estás desarrollando aplicaciones que interactúan con colores en CSS, operaciones a nivel de bits, criptografía o configuraciones de permisos en sistemas operativos.
(() => { //forma inferida let productPrice = 100; productPrice = 12; console.log('productPrice', productPrice); //forma explicita let customerAge: number = 28; // forma erronea //customerAge = customerAge + '1'; //281 //forma adecuada customerAge = customerAge + 1; //29 console.log('customerAge', customerAge); //no quiero inicializar la variable, entonces por obligación la dejo de manera explicita let productInStock: number; console.log('productInStock', productInStock); if(productInStock > 10){ console.log('es mayor') } //lo convierten en INT si no lo lee dice NaN let discount = parseInt('100'); console.log('discount', discount); if(discount <= 200){ console.log('aplica') } else{ console.log('No aplica') } //exadecimal y binarios let hex = 0xFFF; console.log('hex', hex); let bin = 0b10100000000000000000000001111110000000; console.log('bin', bin); //simepre en minuscula //X const myNumber: Number = 10; const myNumber: Number = 10; })();
