introducción

TypeScript es un lenguaje fuertemente tipado, y sus características de tipo avanzadas permiten a los desarrolladores definir tipos de manera más flexible y operar con ellos, para escribir mejor código mantenible y extensible.
En este artículo, me centraré en tres tipos avanzados: tipos de unión, tipos de intersección y alias de tipo. Describiremos estos tipos en detalle y también proporcionaremos algunos ejemplos de código útiles.

tipo de union

联合类型是最常见的高级类型之一，是指一个变量可以有不同的数据类型，通过 | 符号来表示, está destinado a ser 将多个类型组合成一个类型. Estos tipos pueden ser 基本类型, o pueden ser 自定义类型.
```
// 联合类型的基本用法
let myVar: string | number;
myVar = 'hello';
myVar = 123;
```
Aquí, definimos una variable myVar que puede ser de tipo cadena o número. Podemos asignar cualquier cadena o número a la variable myVar.

联合类型用于在编写代码时可以接受多种类型的情况. Por ejemplo, si deseamos aceptar un parámetro, que puede ser una cadena o un número, podemos usar un tipo de unión. Los ejemplos son los siguientes:

// 在函数的形参中使用联合类型
function printId(id: number | string) {
      
      
    console.log(`id is ${
        
        id}`);
}
printId(101); // 输出：id is 101 printId("abc"); // 输出：id is abc

En el código anterior, hemos definido una función llamada printId que toma una identificación de parámetro que puede ser un número o una cadena.

// 自定义类型
interface Cat {
      
      
    name: string;
    purr: () => void;
}
interface Dog {
      
      
    name: string;
    bark: () => void;
}
function feedPet(pet: Cat | Dog) {
      
      
    console.log("Feeding " + pet.name);
    if ("purr" in pet) {
      
      
        pet.purr();
    } else if ("bark" in pet) {
      
      
        pet.bark();
    }
}

En este ejemplo, definimos una función feedPet que acepta un parámetro pet, que es de tipo Gato o Perro. Cuando llamamos a esta función, podemos pasar un objeto gato o perro. En el cuerpo de la función, verificamos si el objeto mascota tiene un atributo de "ronroneo" o "ladrido" y luego
llamamos al método de la mascota en consecuencia.

La ventaja del tipo de unión es que puede simplificar el código en algunos casos, pero la desventaja es que reducirá la legibilidad y el mantenimiento del código. Cuando hay demasiados tipos de unión, la complejidad del código aumentará significativamente.

tipo de cruz

交叉类型是将多个类型组合成一个类型，通过 & 符号来表示. Estos tipos pueden tener propiedades y métodos de todos los tipos al mismo tiempo. Podemos pensar en los tipos de intersección como tipos de "unión". Los ejemplos son los siguientes:

interface Person {
      
      
    name: string;
    age: number;
}
interface Employee {
      
      
    company: string;
}
type EmployeePerson = Employee & Person;
const employeePerson: EmployeePerson = {
      
      
    name: "John",
    age: 30,
    company: "ABC Inc",
};
console.log(employeePerson); // 输出：{ name: 'John', age: 30, company: 'ABC Inc' }

En el código anterior, hemos definido dos interfaces Persona y Empleado. La interfaz de Persona define los atributos de una persona (nombre y edad), mientras que la interfaz de Empleado define los atributos de un empleado (empresa). Usamos &la notación para definir el tipo EmployeePerson, que combina los tipos Person y Employee en un solo tipo. Finalmente, creamos un objeto de tipo EmployeePerson y mostramos sus propiedades.

Veamos otro ejemplo:

interface Student {
      
      
    name: string;
    age: number;
}
interface Teacher {
      
      
    name: string;
    teachingSubject: string;
}
type StudentTeacher = Student & Teacher;
let jenny: StudentTeacher = {
      
      
    name: 'Jenny',
    age: 25,
    teachingSubject: 'Math'
}

Aquí, definimos dos interfaces: Estudiante y Profesor. También definimos un alias de tipo StudentTeacher que es la intersección de Student y Teacher. Luego creamos una variable jenny de tipo StudentTeacher que contiene las propiedades nombre, edad y asignatura de enseñanza.

La ventaja de los tipos de intersección es que nos permite definir rápidamente tipos de objetos con múltiples propiedades y métodos, pero la desventaja es que cuando hay demasiados tipos de intersección, la complejidad del código también aumentará significativamente.

tipo de alias

类型别名是一种命名类型的方式，是指为一种类型定义一个新名字. Los alias de tipo pueden reemplazar definiciones de tipo largas o repetitivas. En TypeScript, podemos usar type 关键字para crear alias de tipo. Por ejemplo:

type UserId = number | string;
function printUserId(id: UserId) {
      
      
    console.log(`id is ${
        
        id}`);
}
printUserId(101); // 输出：id is 101
printUserId("abc"); // 输出：id is abc

En el código anterior, hemos definido un alias de tipo UserId utilizando la palabra clave type, que puede ser un número o una cadena. Definimos una función llamada printUserId para aceptar un parámetro de tipo UserId. Finalmente, llamamos a esta función dos veces, pasando argumentos numéricos y de cadena respectivamente.

Veamos otro ejemplo

type User = {
      
      
    name: string;
    age: number;
    email: string;
}
type UserID = string | number;
type UserCollection = Record<UserID, User>;
let users: UserCollection = {
      
      
    one: {
      
      
        name: 'Tom',
        age: 20,
        email: '[email protected]'
    },
    two: {
      
      
        name: 'Jerry',
        age: 22,
        email: '[email protected]'
    }
}

Aquí, definimos un tipo de alias Usuario, que representa un objeto de usuario, que contiene propiedades de nombre, edad y correo electrónico. También definimos un tipo de ID de usuario de alias que es de tipo cadena o número. Finalmente, definimos un alias de tipo UserCollection, que es un objeto Record con UserID como clave y User como valor, que representa una colección de usuarios. En el ejemplo, creamos un objeto UserCollection usuarios, que contiene dos objetos de usuario cuyas ID son uno y dos.

La ventaja de los alias de tipo es que nos permiten definir fácilmente tipos complejos y, al mismo tiempo, hacer que el código sea más legible y comprensible. Pero la desventaja es que el uso excesivo de alias de tipo puede hacer que el código sea detallado y difícil de mantener.

Aviso

El tipo de unión, el tipo de intersección y el alias de tipo de los tipos avanzados de TypeScript tienen sus propias ventajas y podemos usarlos razonablemente en diferentes escenarios. Cabe señalar que el uso excesivo de tipos avanzados aumentará la complejidad del código y afectará la legibilidad y la capacidad de mantenimiento del código. Por lo tanto, 在使用高级类型时需要慎重考虑.

en conclusión

En este artículo, presentamos tres tipos de alto nivel: 联合类型, 交叉类型y 类型别名. Estos tipos nos ayudan a escribir mejor código mantenible y extensible. Le recomendamos que utilice estos tipos al escribir código para mejorar la legibilidad y la capacidad de mantenimiento de su código.

Tipos avanzados de TypeScript: tipos de unión, tipos de intersección y alias de tipo

Tabla de contenido