Tipos Básicos de Datos en TypeScript

Tipos Básicos de Datos en TypeScript

por

Necesitamos poder trabajar con tipos simples de datos para que nuestros programas sean útiles, como números, cadenas, estructuras, valores booleanos y otros tipos de datos. TypeScript admite casi los mismos tipos que JavaScript, además de un nuevo tipo de enumeración para ayudar a crear mejores aplicaciones.

Tabla de contenidos

Valores booleanos

Los valores true y false dos de los tipos de datos más simples, en JavaScript y TypeScript se denominan booleanos o boolean.

let isDone: boolean = false;

Números

Al igual que con JavaScript, todos los números en TypeScript son valores de coma flotante. Estos decimales de coma flotante están asociados con el tipo number. TypeScript también admite datos binarios y octales introducidos por ECMAScript 2015, así como literales hexadecimales y decimales.

let decimal: number = 6;
let hex: number = 0xf00d;
let binary: number = 0b1010;
let octal: number = 0o744;

Datos de textos (String)

Trabajar con datos de texto también es una parte esencial de los programas de JavaScript. Como en otros lenguajes, TypeScript se basa en el tipo string para indicar este tipo de datos de texto. Similar a JavaScript, TypeScript también se basa en comillas dobles ( " ) o simples ( ‘ ) para encerrar datos de cadena.

let color: string = "blue";
color = 'red';

También puede usar cadenas de plantilla, que pueden almacenar varias líneas y contener expresiones en línea. Estas cadenas están encerradas en un carácter ( `) y las expresiones se pueden incrustar en ellas como ‎${expr}‎.

let fullName: string = `Jon Doe`;
let age: number = 37;
let sentence: string = `Hola, mi nombre es ${ fullName }.
          Tengo ${ age + 1 } años el mes que viene.`;

Esto es equivalente a declarar la variable sentence de la siguiente manera:

let sentence: string = "Hola, mi nombre es " + fullName + ".\n\n" +
    "Tengo " + (age + 1) + " años el mes que viene.";

Arreglos

TypeScript le permite trabajar con matrices de valores como en JavaScript. Los tipos de matriz se pueden escribir de dos maneras. Ya sea usando el tipo de elemento de matriz seguido de paréntesis [] para definir una matriz con el tipo de elemento dado, en el siguiente ejemplo definimos una matriz de números usando el tipo number:

let list: number[] = [1, 2, 3];

La otra forma es mediante el uso de un tipo de matriz genérica del formulario ‎Array‎<elemType>‎con un reemplazo con el elemType‎tipo deseado:

let list: Array<number> = [1, 2, 3];

Tuple

Las clases permiten la expresión de un arreglo en el que se conoce el número de tipos de elementos, sin que sean del mismo tipo. Por ejemplo, es posible que desee representar un valor como una cadena string y un par de números number:

// define el tipo de matriz
let x: [string, number];
// almacenar datos en la fila 
x = ["hello", 10];  // declaración verdadera 
// almacenando incorrectamente datos en la fila
x = [10, "hello"];  // Lanzará Error

Al acceder a un elemento cuyo índice (índice) se conoce, obtendrá el tipo apropiado:

console.log(x[0].substr(1)); // OK 
console.log(x[1].substr(1)); // Falso porque el número no tiene esta función / 'number' does not have 'substr'

Al acceder a un elemento fuera del conocido conjunto de índices, se usa el tipo de unión en su lugar:

// La cadena se puede establecer porque es un elemento del conjunto (cadena o número) 
x[3] = "world"; // OK, 'string' can be assigned to 'string | number'

// La función está presente en ambos tipos de 
console.log(x[5].toString()); // OK, 'string' and 'number' both have 'toString'

// (cadena o número) Falso, el valor booleano no es del conjunto 
x[6] = true; // Error, 'boolean' isn't 'string | number'

Los tipos de unión son temas avanzados que discutiremos en otro capítulo.

Múltiples constantes (enum)

El tipo enum es un tipo de datos útil sobre los tipos estándar que se encuentran en JavaScript. Este tipo representa el tipo de constantes múltiples que funciona de manera similar a lo que ocurre en otros lenguajes como C#, y es un tipo que permite nombrar conjuntos de valores numéricos con etiquetas explícitas.

enum Color {Red, Green, Blue}
let c: Color = Color.Green;

De manera predeterminada, el conteo de elementos de múltiples constantes comienza desde 0. Puede cambiar esto configurando el valor de un elemento. Por ejemplo, podemos comenzar el ejemplo anterior con un número 1 en lugar de 0:

enum Color {Red = 1, Green, Blue}
let c: Color = Color.Green;

O todos los valores de múltiples constantes se pueden configurar manualmente:

enum Color {Red = 1, Green = 2, Blue = 4}
let c: Color = Color.Green;

Varias constantes proporcionan una función que le permite acceder al nombre de un valor a partir de su valor escalar. Por ejemplo, si tenemos el valor 2 y no sabemos con qué está relacionado en la constante múltiple Color anterior, podemos buscar el nombre del valor de la siguiente manera:

enum Color {Red = 1, Green, Blue}
let colorName: string = Color[2];

alert(colorName); // 'Green'

Tenga en cuenta que el nombre que se muestra es Green porque su valor 2 está en la constante múltiple Color anterior.

Cualquier tipo (Any)

Es posible que necesitemos describir el tipo de variables que no conocemos al escribir la aplicación. Estos valores pueden provenir de contenido dinámico, como un usuario o una biblioteca de terceros. En estos casos, queremos desmarcar los tipos y permitir que los valores pasen por verificaciones en tiempo de compilación. Para hacer esto, usamos el tipo any para describir estas variables:

let notSure: any = 4;
notSure =  "El valor puede ser una cadena, no un número" ; 
notSure = false;  // es un valor booleano

El tipo any es una forma de trabajar con JavaScript preexistente, lo que le permite usar gradualmente la verificación de tipos al compilar. Puede esperar que el tipo funcione Object de manera similar a otros lenguajes de programación. Pero las variables de tipo Object solo permiten que se les asigne cualquier tipo de valor, y no puede llamar a métodos arbitrarios en ellas, incluso si ya existen:

let notSure: any = 4;
// el método ifItExists 
//puede existir en tiempo de ejecución (runtime)
notSure.ifItExists();
notSure.toFixed(); // La función existe, pero el compilador no la verifica 

let prettySure: Object = 4;
// error de función no encontrado 
prettySure.toFixed(); // Error: Property 'toFixed' doesn't exist on type 'Object'.

El tipo también es any útil cuando conoce parte del tipo de una variable, pero no todo. Por ejemplo, una matriz puede tener diferentes tipos de elementos, de la siguiente manera:

let list: any[] = [1, true, "free"];

list[1] = 100;

Tipo vacío (void)

Tipo void es contrario de tipo any en especie, e indica la ausencia de tipo. Por lo general, lo verá como un tipo de devolución para funciones que no devuelven ningún valor:

function warnUser(): void {
    alert("This is my warning message");
}

Declarar una variable de tipo void no sirve porque la variable solo aceptará asignarle el valor undefined o valor null.

// Esta variable no tiene valor
let unusable: void = undefined;

Tipos nulo (null) e indefinido (undefined)

En TypeScript tipos undefined, null que se nombran con el mismo nombre undefined y null. Al igual que con type void, no son muy útiles cuando están solos:

// No podemos asignar ningún otro valor a las siguientes dos variables
let u: undefined = undefined;
let n: null = null;

De forma predeterminada, tanto los tipos undefined cómo los subtipos se consideran null subtipos de todos los demás. Lo que significa que puede asignar undefined y  null, al tipo  number por ejemplo.

Pero cuando usa la bandera ‎‎--‎strictNullChecks‎ con el compilador, solo podrá asignar el undefined y null al tipo void más sus respectivos tipos. Esto ayuda a evitar muchos errores comunes. Y si desea pasar un valor de type string, type undefined o type null, puede usar union type string | null | undefined. Para obtener más información sobre los tipos de unión, consulte la página Tipos avanzados.

Nota: Se recomienda que use la opción ‎‎--‎strictNullChecks‎‎ siempre posible, pero esta autenticación considera que la opción está deshabilitada para usted.

Tipo never

El tipo never representa el tipo de valores que nunca aparecen. Por ejemplo, una expresión de función devuelve un valor del tipo never, una expresión de función de flecha que siempre arroja una excepción o una función que nunca devuelve nada. Las variables pueden contener un tipo never cuando están definidas por cualquier tipo de protección que nunca puede tener un valor booleano válido.

El tipo never es un subtipo de todos los tipos y también se puede asignar a todos los tipos. Pero no tiene subtipo, y no se puede asignar ningún tipo al tipo never(excepto él mismo). Incluso el tipo any no es asignable al tipo never. Algunos ejemplos de funciones que devuelven type never:

// El tipo de devolución de función no tiene un punto final accesible 
// Function returning never must have unreachable end point
function error(message: string): never {
    throw new Error(message);
}
// Debido a que la función llama a una función que lanza una excepción, el tipo se infiere 
// Inferred return type is never
function fail() {
    return error("Something failed");
}
// una función que se ejecuta infinitamente y nunca devuelve nada 
function infiniteLoop(): never {
    while (true) {
    }
}

Tipo de objeto

El tipo representa tipos object. Es decir, cada tipo es diferente de uno de los siguientes tipos: number, string, boolean, symbol, null y undefined

El tipo proporciona object una buena forma de representar API como Object.create. por ejemplo:

declare function create(o: object | null): void;

create({ prop: 0 }); // OK
create(null); // OK

create(42); // Error
create("string"); // Error
create(false); // Error
create(undefined); // Error

Tipos de aserciones (Type assertions)

A veces puede caer en una situación en la que sabe más sobre un valor que TypeScript. Esto suele suceder cuando sabe que el tipo de un objeto puede ser más específico que su tipo actual. Las pruebas de tipo son una forma de decirle al compilador que sabe lo que está haciendo y qué tipo de objeto es. La conversión de tipos es similar a la conversión de tipos en otros lenguajes de programación, pero no realiza ninguna validación especial ni refactorización de datos. 

No tiene impacto en el tiempo de ejecución y solo lo usa el compilador. TypeScript considera que usted, como programador, ha validado los datos correctamente. Las pruebas de tipos tienen dos formas. La primera figura está usando paréntesis angulares:

let someValue: any = "this is a string";
let strLength: number = (<string>someValue).length;

La otra forma es usando la palabra clave as:

let someValue: any = "this is a string";
let strLength: number = (someValue as string).length;

Los dos ejemplos anteriores son equivalentes. El uso de una forma sin otra es simplemente una elección del programador. Pero cuando se usa JSX con TypeScript, solo se permite el método de palabra clave .

Nota sobre la palabra clave let

Puede notar que usamos la palabra clave let en lugar de la var palabra clave común en JavaScript. La palabra clave let es una característica del nuevo lenguaje JavaScript, que proporciona TypeScript. Muchos problemas de JavaScript se pueden resolver usando la palabra clave let, por lo que es una buena idea usarla en su lugar var cuando sea posible.

Recursos