You don't have access to this class

Keep learning! Join and start boosting your career

Aprovecha el precio especial y haz tu profesión a prueba de IA

Antes: $249

Currency
$209
Suscríbete

Termina en:

0 Días
14 Hrs
52 Min
29 Seg
Curso de TypeScript

Curso de TypeScript

Nicolas Molina

Nicolas Molina

Numbers

9/24
Resources

The number data type is used for variables that will contain positive, negative or decimal numbers.

Operations

In JavaScript, a variable of type number can easily be concatenated with another variable of type string:

//JavaScriptlet myNumber = 30; myNumber = myNumber + "5"; //The result would be '305'.

However, this could lead to confusion and errors during program execution, in addition to changing the data type of the variable. Therefore, in TypeScript only numeric operations can be performed between numbers, for the sake of redundancy:

//TypeScriptlet myNumber: number = 30; myNumber = myNumber + 10; //CORRECTmyNumber = myNumber + "10"; //INCORRECT.

Use of uninitialized variables

  • Those variables that we want to use without having given them an initial value will be marked as errors:
//TypeScriptlet productInStock: number;console.log("Product in stock: " + productInStock);

Note that if you are not going to initialize the variable yet, explicitly define the data type, because TypeScript cannot infer it if it does not have an initial value.

Conversion of numbers from string to number type

For this we will use the parseInt method:

let discount: number = parseInt("123");let numberString: string = "100";let newNumber: number; newNumber = parseInt(numberString);

This works if the string has only and exclusively numbers that do not start with 0. Otherwise, the result will be of type NaN (Not a Number):

//TypeScriptlet numeroTest: number = parseInt("word");console.log(numeroTest); //NaN.

Binary and Hexadecimal

TypeScript may give us errors if we try to define binary numbers that have numbers other than 0 or 1 and if we declare hexadecimals using out-of-range values:

//**********TypeScript**********//Binary: are defined by placing "0b" at the beginning of the valuelet firstBinary = 0b1010; //CORRECTlet secondbinary = 0b1210; //INCORRECT.  The 2 is invalid//Hexadecimals: they are defined by placing "0x" at the beginning of the valuelet firstHexa = 0xfff; //CORRECTlet secondHexa = 0xffz; //INCORRECT.  The "z" is invalid

In console, if they are correctly assigned, a decimal conversion of those numbers will be done:

let firstHexa = 0xfff;console.log(firstHexa); // 4095let firstBinary = 0b1010;console.log(firstBinary); // 10.

Tip

When defining a variable of data type number, it is preferable that the type name be lowercase. This is a good practice, because you will be referring to the data type number and not to the language's own Number object:

let myNumber: number = 20; // Good practice.let otherNumber: Number = 20; // Bad practice.

Contribution created by: Martín Álvarez.

Contributions 24

Questions 5

Sort by:

Want to see more contributions, questions and answers from the community?

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.

Resumen de la clase:

  • NaN tambien aplica como tipo de dato “number”
  • Datos hexadecimales y binarios tambien son “number” y al mostrarlos en la consola son traducidos a su valor en decimal
  • : number no es lo mismo que : Number. Creo que cuando usamos la mayuscula se refiere al super prototipo Number

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.

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

Les comparto mis apuntes. 😄

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.

Recordar pues ome!

number !== Number
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.

number

  • Forma inferida
let productPrice = 100;
  • Forma explicita
let productPrice:number = 100;

Casos

  • Cuando queremos inicializar una variable pero todavía no tenemos un valor que asignarle siempre debemos declarar el tipo de valor que va a contener esa variable.
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

  • Numero hexadecimal
let hex = 0xfff;
  • Numero binario
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”.

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.

Aprendi demasiado en esta clase.

no me parece lógico que “NaN” sea tratado como number, si “NaN es -not a number-”, re-loco.

Cuando pongo el comando node .\dist\number.js no pasa nada, ayuda jajaja
### **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.
![](https://static.platzi.com/media/user_upload/image-d3c9f85d-186e-40e4-b123-b822e97bc4ab.jpg)

hexadecimales => 0xfff
binario => 0b121212

Muestra de errores

Si coloco el código del profe y ejecuto el comando node dist/04-numbers.ts me da una serie de errores, por lo que decidí quitarle el :number a las dos variables declaradas en el ejemplo. Con este cambio todo funciona bien.

  let customer_age: number = 28; 👈👀
  customer_age = customer_age + 1; // 29
	console.log('Customer age: ', customer_age);
	
	let product_stock: number; 👈👀
	console.log(product_stock);
╰─ node dist/04-numbers.ts
Price:  12
Customer age:  29
undefined
Discount:  123
Tengo este problema: ![](https://static.platzi.com/media/user_upload/image-8cf295ce-a953-4382-8733-f3a1e8f7259a.jpg)

✨ Estructura y orden 😊

Me encanta que todas las clases estén ordenadas/numeradas, esto debería ser un estándar, ya que hay profes que no le dan importancia a ser ordenados y escriben todo en un solo archivo, lo cual solo de ver eso desmotiva un poco.

Me estás diciendo que NaN (NOT A NUMBER) es un number
A veces programar es comedia

  // Do's and Don'ts de TS
  // Nunca usar String, Boolean, Number, Object, Symbol (se usan en JS), usar los tipos que recomienda TS, en este caso string, boolean, number, object, symbol

  // Si una variable no se va a asignar, se debe tipar siempre
  let customerAge: number;

  // Números: [int, float, octal: "0o0771234", hex: "0xfff", binary: "ob1010", NaN, Infinity]
  let productPrice: number = 100;

Profe, muchas gracias por enseñarme la manera de organizar mis clases. Lo de enumerar los archivos me parece genial.

No es necesario usar el comando npx:

npx tsc --watch

Para recortar el comando y tener su mismo resultado, es mas facil:

tsc --watch