Tipos de Datos en TypeScript

Este artículo explica los tipos de datos en TypeScript.

YouTube Video

Tipos de Datos en TypeScript

TypeScript ofrece una variedad de tipos de datos. Esto le permite definir tipos estrictos para variables, argumentos de funciones y valores de retorno. A continuación, se presentan los principales tipos de datos y su uso.

Tipos Primitivos

Tipo number

1let age: number = 25;
2console.log(age);          // Outputs: 25
3console.log(typeof age);    // Outputs: number

• number es un tipo utilizado para manejar valores numéricos, incluyendo enteros y números de punto flotante (decimales). El manejo de valores que exceden ciertos límites da como resultado Infinity o NaN (No-es-un-número).

1// Decimal calculations
2console.log(0.1 + 0.2 === 0.3); // false
3console.log(0.1 + 0.2); // 0.30000000000000004
4
5// Calculations with large numbers
6console.log(9007199254740991 + 1); // correct value
7console.log(9007199254740991 + 2); // incorrect value

• En TypeScript, los números se representan como números de punto flotante. Esto puede ocasionar leves imprecisiones en los resultados de los cálculos.

• Cuando se requieren cálculos precisos, como en montos financieros, es necesario evitar errores de redondeo como estos. Por ejemplo, puedes usar BigInt o toFixed(), o ajustar los decimales utilizando bibliotecas como decimal.js.

Tipo string

El tipo string maneja datos textuales.

1let greeting: string = "Hello, TypeScript!";
2console.log(greeting);     // Outputs: Hello, TypeScript!
3console.log(typeof greeting);  // Outputs: string

boolean (Tipo lógico)

El tipo boolean tiene dos valores: true o false.

1let isOpen: boolean = true;
2console.log(isOpen);       // Outputs: true
3console.log(typeof isOpen);    // Outputs: boolean

nulo y indefinido

null representa un 'valor inexistente', y undefined representa un 'valor no definido'.

1let emptyValue: null = null;
2let notDefined: undefined = undefined;
3
4console.log(emptyValue);       // Outputs: null
5console.log(typeof emptyValue);    // Outputs: object (JavaScript specification)
6
7console.log(notDefined);       // Outputs: undefined
8console.log(typeof notDefined);    // Outputs: undefined

Array

En TypeScript, puedes especificar el tipo de elementos de un array. number[] es un array de números, y string[] es un array de cadenas.

1let numbers: number[] = [1, 2, 3, 4];
2console.log(numbers);        // Outputs: [1, 2, 3, 4]
3console.log(typeof numbers); // Outputs: object
4
5let words: string[] = ["TypeScript", "JavaScript"];
6console.log(words);          // Outputs: ["TypeScript", "JavaScript"]
7console.log(typeof words);   // Outputs: object

Tupla

Una tupla es un arreglo con elementos de diferentes tipos.

1let person: [string, number] = ["Alice", 30];
2console.log(person);         // Outputs: ["Alice", 30]
3console.log(typeof person);  // Outputs: object

Enum

enum define un conjunto de constantes con nombre.

1enum Color {
2    Red,
3    Green,
4    Blue
5}
6
7let favoriteColor: Color = Color.Green;
8console.log(favoriteColor);  // Outputs: 1 (Defaults start from 0)
9console.log(typeof favoriteColor); // Outputs: number

any

El tipo any puede contener cualquier tipo de valor y se utiliza cuando desea desactivar la verificación de tipos.

1let anything: any = "Hello";
2console.log(anything);       // Outputs: Hello
3console.log(typeof anything);    // Outputs: string
4
5anything = 42;
6console.log(anything);       // Outputs: 42
7console.log(typeof anything);    // Outputs: number

Tipo Unión

Usando tipos de Unión, puede definir variables que puedan contener uno de varios tipos.

1let identifier: number | string = "ID_12345";
2console.log(identifier);     // Outputs: ID_12345
3console.log(typeof identifier);  // Outputs: string
4
5identifier = 12345;
6console.log(identifier);     // Outputs: 12345
7console.log(typeof identifier);  // Outputs: number

Resumen

• number, string, boolean: Tipos primitivos.
• null, undefined: Valores especiales.
• Array: Un arreglo con anotaciones de tipo.
• Tuple: Un array con elementos de diferentes tipos.
• enum: Un tipo enumerado.
• any: Cualquier tipo de dato.
• Union: Una variable que puede tomar uno de múltiples tipos.

Al usar estos tipos de datos, TypeScript mejora la seguridad de los tipos, facilitando la prevención de errores durante el desarrollo.

Objetos Envoltorios

Objetos Wrapper en TypeScript son objetos creados automáticamente para tratar los tipos de datos primitivos como objetos. Los tipos primitivos permiten operaciones ligeras y rápidas, mientras que los tipos de objetos tienen métodos y propiedades, permitiendo operaciones más completas.

En JavaScript (y TypeScript), existen objetos wrapper correspondientes a los tipos primitivos como string, number y boolean. Estos se crean utilizando funciones constructoras llamadas String, Number y Boolean, respectivamente.

A continuación, se presentan ejemplos de objetos wrapper.

Objeto String

El objeto String proporciona propiedades y métodos para cadenas de texto.

1let strPrimitive: string = "Hello, World!";
2let strObject: String = new String("Hello, World!");
3
4console.log(strPrimitive);         // Outputs: Hello, World!
5console.log(typeof strPrimitive);  // Outputs: string
6
7console.log(strObject);            // Outputs: [String: 'Hello, World!']
8console.log(typeof strObject);     // Outputs: object

Características:

• A diferencia del string primitivo, un objeto String es tratado como object por typeof.
• Los objetos envolventes son útiles al manipular cadenas o al llamar métodos sobre ellas.

Objeto Number

El objeto Number proporciona propiedades y métodos para números.

1let numPrimitive: number = 42;
2let numObject: Number = new Number(42);
3
4console.log(numPrimitive);         // Outputs: 42
5console.log(typeof numPrimitive);  // Outputs: number
6
7console.log(numObject);            // Outputs: [Number: 42]
8console.log(typeof numObject);     // Outputs: object

Características:

• El objeto Number, como un envoltorio para números, incluye métodos para operaciones numéricas (por ejemplo, toFixed).

Objeto Boolean

El objeto Boolean proporciona propiedades y métodos para valores booleanos.

1let boolPrimitive: boolean = true;
2let boolObject: Boolean = new Boolean(true);
3
4console.log(boolPrimitive);        // Outputs: true
5console.log(typeof boolPrimitive); // Outputs: boolean
6
7console.log(boolObject);           // Outputs: [Boolean: true]
8console.log(typeof boolObject);    // Outputs: object

Características:

• El objeto Boolean es un envoltorio para el tipo primitivo boolean y se trata como un object.

Diferencias entre Objetos Envolventes y Tipos Primitivos

Dado que los objetos envolventes se tratan como objetos, hay una ligera disminución en el rendimiento, pero son posibles más operaciones funcionales gracias a las propiedades y métodos añadidos. Además, hay diferencias al comparar usando == y ===.

1let numPrimitive: number = 123;
2let numObject: Number = new Number(123);
3
4console.log('==  : ', numPrimitive == numObject);  // Outputs: true (Value comparison)
5console.log('=== : ', numPrimitive === numObject); // Outputs: false (Due to differing types)

Características:

• == compara valores, mientras que === compara estrictamente incluyendo los tipos. === devuelve false al comparar objetos envolventes con tipos primitivos.

Conversión de Tipos

En TypeScript, es importante gestionar adecuadamente las conversiones implícitas y explícitas de tipos.

Conversión Implícita de Tipos

• En TypeScript, las conversiones implícitas de tipos deben evitarse tanto como sea posible para garantizar la seguridad de tipos.

1const result: string = 5 + "5"; // "55" (the number is converted to a string)
2
3console.log(result);

• En este ejemplo, el número 5 se convierte implícitamente en una cadena, dando como resultado la cadena "55".

Conversión Explícita de Tipos

• En TypeScript, utiliza anotaciones de tipos o funciones de conversión de tipos para realizar las conversiones de manera segura.

1const num: string = "123";
2const convertedNum: number = Number(num); // Converts "123" to the number 123
3
4console.log(typeof num);
5console.log(typeof convertedNum);

• En este ejemplo, se utiliza la función Number() para convertir explícitamente la cadena "123" en el número 123.

Comprobación de Tipos

En TypeScript, puedes usar el operador typeof para comprobar el tipo de datos de una variable.

 1// Output: The type of 42 is: number
 2console.log('The type of 42             is:', typeof 42);
 3
 4// Output: The type of 42 is: bigint
 5console.log('The type of 42n            is:', typeof 42n);
 6
 7// Output: The type of "hello" is: string
 8console.log('The type of "hello"        is:', typeof "hello");
 9
10// Output: The type of true is: boolean
11console.log('The type of true           is:', typeof true);
12
13// Output: The type of undefined is: undefined
14console.log('The type of undefined      is:', typeof undefined);
15
16// Output: The type of null is: object
17console.log('The type of null           is:', typeof null);
18
19// Output: The type of Symbol() is: symbol
20console.log('The type of Symbol()       is:', typeof Symbol());
21
22// Output: The type of {} is: object
23console.log('The type of {}             is:', typeof {});
24
25// Output: The type of function () {} is: function
26console.log('The type of function () {} is:', typeof function () {});

• En TypeScript, puedes usar typeof para comprobar tipos, pero para una comprobación más precisa, también es recomendable usar los operadores instanceof o is.

Resumen

• Los Objetos Envolventes se tratan como objetos porque proporcionan métodos y propiedades adicionales para tipos primitivos.
• String, Number y Boolean son ejemplos representativos de objetos envolventes.
• A diferencia de los tipos primitivos, los objetos envolventes se identifican como object mediante typeof.

Puedes seguir el artículo anterior utilizando Visual Studio Code en nuestro canal de YouTube. Por favor, también revisa nuestro canal de YouTube.

YouTube Video