Tipos básicos de TypeScript
Los tipos básicos permiten a los desarrolladores describir con mayor precisión la estructura y la intención de los datos.
TypeScript incluye los siguientes tipos de datos:
| Tipo | Descripción | Ejemplo |
|---|---|---|
string | Representa datos de texto. | let name: string = "Alice"; |
number | Representa números, incluidos enteros y decimales (punto flotante). | let age: number = 30; |
boolean | Representa valores booleanos.trueofalse | let isDone: boolean = true; |
array | Representa un arreglo de elementos del mismo tipo. | let list: number[] = [1, 2, 3]; |
tuple | Representa un arreglo con tipos y longitud conocidos. | let person: [string, number] = ["Alice", 30]; |
enum | Define un conjunto de constantes con nombre. | enum Color { Red, Green, Blue }; |
any | Cualquier tipo; no se realiza comprobación de tipos. | let value: any = 42; |
void | Sin valor de retorno (común en funciones). | function log(): void {} |
null | Representa un valor nulo. | let empty: null = null; |
undefined | Representa un valor indefinido. | let undef: undefined = undefined; |
never | Representa que nunca se devuelve un valor. | function error(): never { throw new Error("error"); } |
object | Representa tipos no primitivos. | let obj: object = { name: "Alice" }; |
union | Tipo unión: representa que puede ser uno de varios tipos. | `let id: string |
unknown | Tipo incierto; debe verificarse su tipo antes de usarse. | let value: unknown = "Hello"; |
Nota:TypeScript y JavaScript no tienen tipo entero.
1. string (cadena)
Representa datos de texto; solo puede almacenar cadenas y se usa normalmente para describir información textual.
let message: string = "Hello, TypeScript!";
Plantillas de cadena:TypeScript admiteplantillas de cadena,que se definen con comillas invertidas`(recuerda que no son comillas simples '). Permiten insertar variables o expresiones en la cadena; son ideales para texto multilínea y concatenación de variables.
let name: string = "Alice";
let greeting: string = `Hello, ${name}! Welcome to TypeScript.`;
console.log(greeting); // 输出:Hello, Alice! Welcome to TypeScript.
2. number (número)
TypeScript usa 'number' para representar todos los números, incluidos enteros y decimales (punto flotante).
let age: number = 25; let temperature: number = 36.5;
3. boolean (booleano)
Representa los valores lógicos 'true' o 'false', usados en las comprobaciones condicionales.
let isCompleted: boolean = false;
4. array (arreglo)
Puede representar un conjunto de elementos del mismo tipo. Se puede expresar de dos maneras: 'type[]' o 'Array<type>'.
let numbers: number[] = [1, 2, 3]; let names: Array<string> = ["Alice", "Bob"];
5. tuple (tupla)
Representa un arreglo con una cantidad y tipos conocidos. Cada elemento puede ser de un tipo diferente; es adecuado para representar datos con una estructura fija.
let person: [string, number] = ["Alice", 25];
6. enum (enumeración)
Se usa para definir un conjunto de constantes con nombre. Por defecto, los valores del enumerado comienzan en 0 y se incrementan.
enum Color {
Red,
Green,
Blue,
}
let favoriteColor: Color = Color.Green;
7. any (cualquier tipo)
Puede representar cualquier tipo. Es adecuado cuando el tipo de dato no es seguro, pero debe usarse con cuidado porque 'any' evita la comprobación de tipos.
let randomValue: any = 42; randomValue = "hello";
El tipo 'any' es un tipo de datos que TypeScript usa para variables cuyo tipo no está claro durante la programación. Se utiliza comúnmente en los siguientes tres casos:
1. Cuando el valor de la variable cambia dinámicamente, como la entrada del usuario, el tipo 'any' permite que estas variables omitan la comprobación de tipos en la fase de compilación. El código de ejemplo es el siguiente:
let x: any = 1; // 数字类型 x = 'I am who I am'; // 字符串类型 x = false; // 布尔类型
2. Al reescribir código existente, 'any' permite incluir o eliminar selectivamente la comprobación de tipos durante la compilación. El código de ejemplo es el siguiente:
let x: any = 4; x.ifItExists(); // 正确,ifItExists方法在运行时可能存在,但这里并不会检查 x.toFixed(); // 正确
3. Al definir un arreglo que almacena datos de varios tipos. El código de ejemplo es el siguiente:
let arrayList: any[] = [1, false, 'fine']; arrayList[1] = 100;
8. void (vacío)
Se usa en funciones sin valor de retorno. Al declarar una variable, el tipo 'void' significa que solo se le puede asignar 'null' o 'undefined'.
function logMessage(message: string): void {
console.log(message);
}
9. null y undefined
'null' y 'undefined' representan respectivamente 'valor nulo' e 'indefinido'. De forma predeterminada, son subtipos de todos los tipos, pero se puede activar la comprobación estricta mediante 'strictNullChecks'.
let empty: null = null; let notAssigned: undefined = undefined;
null
En JavaScript, 'null' significa 'no hay nada'.
'null' es un tipo especial que tiene un único valor. Representa una referencia a un objeto vacío.
Usar 'typeof' sobre 'null' devuelve 'object'.
undefined
En JavaScript, 'undefined' significa que una variable no tiene un valor asignado.
'typeof' sobre una variable sin valor devuelve 'undefined'.
'null' y 'undefined' son subtipos de cualquier otro tipo (incluido 'void'), por lo que pueden asignarse a otros tipos, como el tipo numérico; en ese caso, el tipo después de la asignación se convierte en 'null' o 'undefined'. Sin embargo, al activar la verificación estricta de nulos (--strictNullChecks), 'null' y 'undefined' solo pueden asignarse a 'void' o a sus propios tipos correspondientes. El código de ejemplo es el siguiente:
// 启用 --strictNullChecks let x: number; x = 1; // 编译正确 x = undefined; // 编译错误 x = null; // 编译错误
En el ejemplo anterior, la variable 'x' solo puede ser de tipo numérico. Si un tipo puede contener 'null' o 'undefined', se puede usar '|' para admitir varios tipos. El código de ejemplo es el siguiente:
// 启用 --strictNullChecks let x: number | null | undefined; x = 1; // 编译正确 x = undefined; // 编译正确 x = null; // 编译正确
Puedes consultar más contenido en:JavaScript typeof, null y undefined
10. never (nunca)
Representa que nunca se devolverá un valor; se usa normalmente en funciones que lanzan errores o entran en bucles infinitos, lo que indica que la función nunca termina de forma normal.
function throwError(message: string): never {
throw new Error(message);
}
'never' es un subtipo de los demás tipos (incluidos 'null' y 'undefined') y representa valores que nunca aparecen. Esto significa que una variable declarada como 'never' solo puede recibir un valor de tipo 'never'. En funciones, suele manifestarse como el lanzamiento de una excepción o la imposibilidad de alcanzar el punto de terminación (por ejemplo, un bucle infinito). El código de ejemplo es el siguiente:
let x: never;
let y: number;
// 编译错误,数字类型不能转为 never 类型
x = 123;
// 运行正确,never 类型可以赋值给 never类型
x = (()=>{ throw new Error('exception')})();
// 运行正确,never 类型可以赋值给 数字类型
y = (()=>{ throw new Error('exception')})();
// 返回值为 never 的函数可以是抛出异常的情况
function error(message: string): never {
throw new Error(message);
}
// 返回值为 never 的函数可以是无法被执行到的终止点的情况
function loop(): never {
while (true) {}
}
11. object (objeto)
Representa valores no primitivos; es adecuado para estructuras de objetos complejas.
let person: object = { name: "Alice", age: 30 };
12. unión de tipos (Union)
Representa que una variable puede ser uno de varios tipos. Se implementa mediante el símbolo '|'.
let id: string | number; id = "123"; id = 456;
13. unknown (desconocido)
Es similar a 'any', pero más estricto. Solo se puede asignar a otras variables de tipo después de pasar la comprobación de tipos.
let value: unknown = "Hello";
if (typeof value === "string") {
let message: string = value;
}14. aserciones de tipo (Type Assertions)
Las aserciones de tipo permiten al desarrollador indicar explícitamente al compilador el tipo de una variable, y se usan a menudo cuando no se puede inferir. Se pueden usar con la sintaxis 'as' o con corchetes angulares.
let someValue: any = "this is a string"; let strLength: number = (someValue as string).length;
15. tipos literales
Los tipos literales permiten que una variable solo pueda tener valores específicos. Se utilizan junto con los tipos unión para definir estados concretos de una variable.
let direction: "up" | "down" | "left" | "right"; direction = "up";
Con estos tipos, TypeScript ofrece mayor seguridad de tipos y capacidades de comprobación de código, lo que permite a los desarrolladores expresar datos e intenciones de forma más clara y precisa, y reducir los errores en tiempo de ejecución.
Ejemplo
El siguiente ejemplo muestra la definición y el uso de los principales tipos básicos de TypeScript, simulando un objeto de usuario y las funciones relacionadas:
Ejemplo
enum Role {
Admin,
User,
Guest,
}
// Usa 'interface' para definir la estructura del usuario
interface User {
id: number; // Tipo 'number', para identificar de forma única al usuario
username: string; // Tipo 'string', representa el nombre de usuario
isActive: boolean; // Tipo 'boolean', indica si el usuario está activo
role: Role; // Tipo 'enum', para representar el rol del usuario
hobbies: string[]; // Tipo 'array', almacena los intereses del usuario
contactInfo: [string, number]; // Tipo 'tuple', una tupla que contiene el número de teléfono, con el formato: [código de área, número de teléfono]
}
// Crea el objeto de usuario que cumple con la estructura de la interfaz 'User'
const user: User = {
id: 1,
username: "Alice",
isActive: true,
role: Role.User,
hobbies: ["Reading", "Gaming"],
contactInfo: ["+1", 123456789],
};
// Define una función que devuelve una cadena para obtener la información del usuario
function getUserInfo(user: User): string {
return `User ${user.username} is ${user.isActive ? "active" : "inactive"} with role ${Role[user.role]}`;
}
// Usa el tipo 'void' para definir una función que imprime la información del usuario
function printUserInfo(user: User): void {
console.log(getUserInfo(user));
}
// Define un parámetro de función de tipo unión que acepta el ID del usuario (number) o el nombre de usuario (string)
function findUser(query: number | string): User | undefined {
// Usa 'typeof' para determinar el tipo de 'query'
if (typeof query === "number") {
// Si es un número, busca al usuario por ID
return query === user.id ? user : undefined;
} else if (typeof query === "string") {
// Si es una cadena, busca al usuario por nombre de usuario
return query === user.username ? user : undefined;
}
return undefined;
}
// Define una función de tipo 'never' para manejar situaciones excepcionales del programa
function throwError(message: string): never {
throw new Error(message);
}
// Usa el tipo 'any' para manejar datos de tipo desconocido
let unknownData: any = "This is a string";
unknownData = 42; // Se reasigna a un número; el tipo es 'any'
// Usa el tipo 'unknown' para manejar datos inciertos; es más seguro
let someData: unknown = "Possible data";
if (typeof someData === "string") {
console.log(`Length of data: ${(someData as string).length}`);
}
// Llama a cada función y realiza pruebas
printUserInfo(user); // Imprime la información del usuario
console.log(findUser(1)); // Buscar usuario por ID
console.log(findUser("Alice")); // Buscar usuario por nombre de usuario
// Variables que usan tipos null y undefined
let emptyValue: null = null;
let uninitializedValue: undefined = undefined;
Descripción:
- Tipo de enumeración (
Role): utilizado para definir constantes con nombre para roles de usuarioAdmin、UseryGuest。 - Interfaz (
User): define laUserestructura del objeto, incluyendoid、username、isActivepropiedades como ..., mostrandostring、number、boolean、arrayytupleel uso del tipo. - Función
getUserInfo: devuelve la información descriptiva del usuario, utiliza interpolación de cadenas y combinaenum。 - la función
printUserInfo: el tipo esvoid, porque solo genera información y no devuelve ningún valor. - Tipo unión (
number | string): se utiliza para elfindUserparámetro de la función, puede aceptar números o cadenas. neverTipo:throwErrorLa función lanza un error y no retorna normalmente, por lo tanto se usanevertipo.anyTipo: muestra cómo declarar una variable que puede recibir cualquier tipo.unknownTipo: similar aany, pero más seguro; en el ejemplo se realiza una verificación de tipo antes de la aserción de tipo.nullyundefined: demuestra el uso de valores nulos.