Inventario de tipos integrados de TypeScript

Inventario de tipos integrados de TypeScript

Conocer y comprender los tipos integrados es un paso importante cuando los desarrolladores comienzan a aprender TypeScript. TypeScript proporciona una serie de tipos integrados que nos ayudan a definir y utilizar mejor variables, funciones y objetos.

Primero, TypeScript proporciona tipos primitivos básicos, incluidos number, string, y . Estos tipos se pueden utilizar para declarar los tipos de datos básicos de variables.booleannullundefined

Además, TypeScript también proporciona algunos tipos integrados más avanzados, como Array, Tupley . Los tipos se utilizan para definir matrices, los tipos se utilizan para definir matrices con una longitud fija y un tipo específico. Los tipos se utilizan para definir tipos de enumeración, lo que nos permite dar un nombre más descriptivo a un grupo de constantes relacionadas. Los tipos son tipos de nivel superior en TypeScript, que nos permiten compilar sin verificación de tipos.EnumAnyArrayTupleEnumAny

TypeScript también presenta algunos tipos integrados más complejos, como Object, Functiony Promise. ObjectLos tipos se utilizan para describir variables de tipos no primitivos, Functionlos tipos se utilizan para describir funciones y Promiselos tipos se utilizan para manejar los resultados de operaciones asincrónicas.

Además, TypeScript proporciona algunos tipos integrados útiles como Date, RegExpy Error. DateLos tipos se usan para manejar fechas y horas, RegExplos tipos se usan para manejar expresiones regulares y Errorlos tipos se usan para manejar errores.

Finalmente, TypeScript también admite algunos operadores de tipos avanzados e inferencia de tipos, como union, y . Estas características hacen que la definición y el uso de tipos complejos en TypeScript sean más flexibles y potentes.intersectiontype assertiontype inference

Comprender y familiarizarse con estos tipos integrados es fundamental para escribir código TypeScript sólido, mantenible y con seguridad de tipos. Al utilizar estos tipos de forma inteligente, podemos detectar mejor los errores durante el desarrollo, mejorar la calidad del código y reducir el tiempo de depuración.

Este artículo lo guiará a través del uso de algunos tipos avanzados de TypeScript y su implementación.

Parcial

PartialSe utiliza para hacer que todas las propiedades de un tipo determinado sean opcionales. En otras palabras, Partialpuede crear un nuevo tipo que tenga las mismas propiedades que el tipo original, pero estas propiedades son opcionales.

El uso Partialpuede definir fácilmente un objeto a cuyas propiedades se les pueden asignar valores opcionalmente. Esto es útil para situaciones en las que necesita establecer dinámicamente propiedades de objetos según el contexto o cuando desea actualizar solo una parte de las propiedades de un objeto.

A continuación se muestra un ejemplo que demuestra cómo utilizar Partialla herramienta de texto:

interface User {
    
    
  name: string;
  age: number;
  email: string;
}

function updateUser(user: Partial<User>): void {
    
    
  // 更新用户信息
  // ...
}

const user: User = {
    
    
  name: "John",
  age: 30,
  email: "[email protected]"
};

updateUser({
    
     name: "John Doe" }); // 仅更新名称
updateUser({
    
     age: 31, email: "[email protected]" }); // 仅更新年龄和邮箱

En el ejemplo anterior, definimos una Userinterfaz que tiene namepropiedades agey email. Luego definimos una updateUserfunción que acepta un Partial<User>parámetro de tipo, que es un Userobjeto parcialmente completado.

Al usarlo Partial<User>, podemos updateUserpasar solo las propiedades que deben actualizarse al llamar a la función sin proporcionar el Userobjeto completo. Esto nos facilita actualizar solo ciertas propiedades del usuario sin tener que modificar otras propiedades.

En resumen, Partialla herramienta de texto es una herramienta útil en TypeScript, que puede ayudarnos a definir tipos de objetos con propiedades opcionales y actualizar fácilmente algunas propiedades del objeto cuando sea necesario.

Echemos un vistazo a su implementación:

/**
 * Make all properties in T optional
 */
type Partial<T> = {
    
    
    [P in keyof T]?: T[P];
};

• type Partial<T>: typeUn tipo genérico se define a través de la palabra clave Partial<T>, donde Thay un parámetro de tipo que indica el tipo a procesar.
• [P in keyof T]?: utilice el operador de consulta de tipo de índice keyof Tpara obtener Ttodas las propiedades del tipo y utilice inla palabra clave para iterar sobre estas propiedades. PEs el nombre del atributo durante el proceso transversal, [P in keyof T]lo que significa crear un atributo en el nuevo tipo con el nombre del atributo P.
• ?: T[P]: utilice el operador de atributo opcional ?para hacer que el valor de un atributo sea opcional. T[P]Indica que el tipo del atributo definido en el nuevo tipo Tes el mismo que el tipo del atributo correspondiente del tipo original.

En conjunto, Partial<T>la función es Tconvertir todas las propiedades del tipo en propiedades opcionales, es decir, cada propiedad puede tener un valor o ningún valor. Este tipo se utiliza a menudo en el desarrollo real para actualizar o ampliar parcialmente objetos para facilitar la asignación selectiva de atributos.

Requerido

RequiredSe utiliza para establecer todas las propiedades de un tipo determinado como requeridas. En otras palabras, Requiredpuede crear un nuevo tipo que tenga las mismas propiedades que el tipo original, pero estas propiedades son obligatorias y no se pueden omitir.

Con , Requiredpuede definir fácilmente un objeto a cuyas propiedades se les deben asignar valores. Esto es útil para garantizar la integridad del objeto y la seguridad de tipos.

A continuación se muestra un ejemplo que demuestra cómo utilizar Requiredla herramienta de texto:

interface User {
    
    
  name?: string;
  age?: number;
  email?: string;
}

function createUser(user: Required<User>): void {
    
    
  // 创建用户
  // ...
}

createUser({
    
     name: "John", age: 30, email: "[email protected]" }); // 完整的用户信息
createUser({
    
     name: "John" }); // 缺少必需的属性，会报错

En el ejemplo anterior, definimos una Userinterfaz que tiene nameatributos agey email, pero estos atributos son opcionales, es decir, se pueden omitir. Luego, definimos una createUserfunción que acepta un Required<User>parámetro de tipo, que es un Userobjeto requerido.

Al usar Required<User>, nos aseguramos de que al llamar createUsera una función, Userse debe proporcionar el objeto completo sin omitir ninguna propiedad requerida. Esto ayuda a garantizar que los objetos de usuario se creen con la integridad y seguridad de tipos requeridas.

Echemos un vistazo a su implementación:

/**
 * Make all properties in T required
 */
type Required<T> = {
    
    
    [P in keyof T]-?: T[P];
};

• type Required<T>: typeUn tipo genérico se define a través de la palabra clave Required<T>, donde Thay un parámetro de tipo que indica el tipo a procesar.
• [P in keyof T]-?: utilice el operador de consulta de tipo de índice keyof Tpara obtener Ttodas las propiedades del tipo y utilice inla palabra clave para iterar sobre estas propiedades. PEs el nombre del atributo durante el proceso transversal, [P in keyof T]lo que significa crear un atributo en el nuevo tipo con el nombre del atributo P.
• -?: T[P]: Utilice el operador de atributo requerido -?para hacer que el valor del atributo sea requerido. T[P]Indica que el tipo del atributo definido en el nuevo tipo Tes el mismo que el tipo del atributo correspondiente del tipo original.

En conjunto, Required<T>la función es Tconvertir todos los atributos del tipo en atributos requeridos, es decir, cada atributo debe tener un valor. Este tipo se utiliza a menudo en el desarrollo real para restringir los atributos necesarios de los objetos para garantizar la integridad y corrección de los atributos.

Solo lectura

ReadonlySe utiliza para establecer todas las propiedades de un tipo determinado en solo lectura. En otras palabras, Readonlypuede crear un nuevo tipo que tenga las mismas propiedades que el tipo original, pero estas propiedades son de solo lectura y no se pueden modificar.

El uso Readonlypuede definir fácilmente un objeto de solo lectura cuyas propiedades no se pueden modificar. Esto es útil para garantizar la inmutabilidad de los objetos y la seguridad de tipos.

A continuación se muestra un ejemplo que demuestra cómo utilizar Readonlyla herramienta de texto:

interface User {
    
    
  readonly name: string;
  readonly age: number;
  readonly email: string;
}

function getUser(): Readonly<User> {
    
    
  return {
    
     name: "John", age: 30, email: "[email protected]" };
}

const user: Readonly<User> = getUser();

console.log(user.name); // John
user.name = "John Doe"; // 无法修改只读属性，会报错

En el ejemplo anterior, definimos una Userinterfaz que tiene propiedades y name, pero estas propiedades son de solo lectura, es decir, no se pueden modificar. Luego, definimos una función que devuelve un objeto de usuario de tipo de solo lectura.ageemailgetUserReadonly<User>

Al usar , podemos asegurarnos de que las propiedades del objeto de usuario no se puedan modificar después de Readonly<User>asignarlo a una variable . userEsto ayuda a garantizar la inmutabilidad de los objetos y la seguridad de tipos.

Echemos un vistazo a su implementación:

/**
 * Make all properties in T readonly
 */
type Readonly<T> = {
    
    
    readonly [P in keyof T]: T[P];
};

• type Readonly<T>: typeUn tipo genérico se define a través de la palabra clave Readonly<T>, donde Thay un parámetro de tipo que indica el tipo a procesar.
• readonly [P in keyof T]: T[P]: utilice el operador de consulta de tipo de índice keyof Tpara obtener Ttodas las propiedades del tipo y utilice inla palabra clave para iterar sobre estas propiedades. PEs el nombre del atributo durante el proceso transversal, [P in keyof T]lo que significa crear un atributo en el nuevo tipo con el nombre del atributo P.
• readonly: agregue la palabra clave antes del nombre del atributo readonlypara establecer el valor del atributo en solo lectura.

En conjunto, Readonly<T>su función es Tconvertir todas las propiedades del tipo en propiedades de solo lectura, es decir, el valor de la propiedad no se puede modificar después de la asignación. Este tipo se utiliza a menudo en el desarrollo real para proteger los objetos de modificaciones accidentales o alteraciones de los valores de los atributos.

Elegir

PickSe utiliza para seleccionar propiedades específicas de un tipo determinado y crear un nuevo tipo. En otras palabras, Pickpuede seleccionar propiedades específicas de un tipo de objeto y crear un nuevo tipo que contenga sólo las propiedades especificadas.

El uso Pickfacilita la selección de las partes requeridas de un tipo complejo, lo que reduce la información redundante innecesaria y mejora la legibilidad y flexibilidad del código.

A continuación se muestra un ejemplo que demuestra cómo utilizar Pickla herramienta de texto:

interface User {
    
    
  name: string;
  age: number;
  email: string;
  address: string;
}

type UserBasicInfo = Pick<User, "name" | "age">;

const user: UserBasicInfo = {
    
    
  name: "John",
  age: 30,
};

En el ejemplo anterior, definimos una Userinterfaz con propiedades name, agey . Luego, usamos la herramienta de texto para crear un nuevo tipo que solo contenga las propiedades y .emailaddressPickUserBasicInfonameage

Al usar Pick<User, "name" | "age">, Userseleccionamos los atributos namey agedel tipo y creamos un nuevo tipo UserBasicInfo. Luego podemos usar UserBasicInfoel tipo para definir userun objeto que solo contenga las propiedades namey age.

Echemos un vistazo a su implementación:

/**
 * From T, pick a set of properties whose keys are in the union K
 */
type Pick<T, K extends keyof T> = {
    
    
    [P in K]: T[P];
};

• type Pick<T, K extends keyof T>: typeUn tipo genérico se define a través de la palabra clave Pick<T, K>, donde Tes un parámetro de tipo, que indica el tipo a procesar, Kes un parámetro de tipo, que indica el conjunto de claves de los atributos a seleccionar, K extends keyof Tindica Kque debe ser Tparte del conjunto de claves de tipo. .
• [P in K]: T[P]: KRepresenta el conjunto clave de atributos que se seleccionarán y utiliza inla palabra clave para recorrer estos atributos. Pes el nombre del atributo durante el proceso transversal, [P in K]lo que significa crear un atributo en el nuevo tipo con el nombre del atributo Py solo Klos atributos contenidos en .

En conjunto, Pick<T, K>la función es Tseleccionar los atributos especificados del tipo y generar un nuevo tipo. Este tipo se utiliza a menudo en el desarrollo real cuando es necesario extraer algunos atributos de un tipo grande. Los atributos requeridos se pueden seleccionar con precisión y se puede evitar la introducción de atributos innecesarios.

Registro

RecordSe utiliza para crear un tipo de objeto con un tipo de propiedad específico. RecordAcepta dos parámetros de tipo, el primer parámetro especifica el nombre del atributo y el segundo parámetro especifica el tipo del atributo.

RecordPuede definir fácilmente un tipo de objeto con un tipo de atributo específico usando , lo cual es muy útil para crear estructuras de datos como diccionarios y asignaciones.

A continuación se muestra un ejemplo que demuestra cómo utilizar Recordla herramienta de texto:

type Fruit = "apple" | "banana" | "orange";
type Price = number;

const fruitPrices: Record<Fruit, Price> = {
    
    
  apple: 1.5,
  banana: 0.5,
  orange: 0.8,
};

console.log(fruitPrices.apple); // 1.5
console.log(fruitPrices.banana); // 0.5
console.log(fruitPrices.orange); // 0.8

En el ejemplo anterior, definimos dos tipos Fruity Price, Fruitque es un tipo de unión que representa el nombre de la fruta y Priceun tipo numérico que representa el precio de la fruta.

Luego, usamos para Record<Fruit, Price>crear un tipo de objeto fruitPricesque solo puede contener Fruitpropiedades de tipo, y el valor de la propiedad debe ser Pricede tipo.

Al usar Record<Fruit, Price>, creamos un fruitPricesobjeto llamado que contiene tres atributos de manzana, plátano y naranja, y sus valores corresponden a sus precios respectivamente.

Echemos un vistazo a su implementación:

/**
 * Construct a type with a set of properties K of type T
 */
type Record<K extends keyof any, T> = {
    
    
    [P in K]: T;
};

• type Record<K extends keyof any, T>type: Un tipo genérico se define mediante la palabra clave Record<K, T>, donde Kes un parámetro de tipo, que indica el tipo que se utilizará como clave de atributo, y Tes un parámetro de tipo, que indica el tipo del valor del atributo. K extends keyof anyLos representantes Kdeben ser parte de una colección de claves de cualquier tipo.
• [P in K]: T: Utilice el operador de consulta de tipo de índice keyof anypara obtener todas las claves de cualquier tipo e initerar sobre ellas utilizando la palabra clave. PEs el nombre de la clave durante el proceso transversal, [P in K]lo que significa crear un atributo en el nuevo tipo, siendo el nombre del atributo Py el valor del atributo el tipo T.

En conjunto, Record<K, T>el efecto es crear un nuevo tipo donde la clave de cada atributo es Kun elemento del tipo y el valor de cada atributo es el tipo T. Este tipo se usa a menudo en el desarrollo real cuando es necesario crear objetos con tipos de valores y claves específicos, y estos objetos se pueden definir y manipular fácilmente.

Excluir

ExcludeSe utiliza para excluir tipos específicos de un tipo de unión.

ExcludeAcepta dos parámetros de tipo, el primer parámetro es el tipo que se excluirá y el segundo parámetro es el tipo de unión del que se excluirán los tipos.

A continuación se muestra un ejemplo que demuestra cómo utilizar Excludela herramienta de texto:

type Animal = "dog" | "cat" | "bird";
type ExcludeBird = Exclude<Animal, "bird">;

const myPets: ExcludeBird[] = ["dog", "cat"];

En el ejemplo anterior, definimos un tipo de unión que Animalcontiene tres tipos de animales: y .dogcatbird

Luego Exclude<Animal, "bird">creamos un nuevo tipo usando ExcludeBirdel tipo que excluía el tipo Animalen el tipo bird.

Finalmente, definimos una matriz myPetscuyo tipo de elemento es ExcludeBird, es decir, excluyendo el birdtipo de Animal. Por lo tanto, myPetsla matriz solo puede contener dogy cat.

Al utilizar Excludeherramientas de tipos, podemos excluir fácilmente un tipo específico de un tipo de unión para crear un nuevo tipo que satisfaga necesidades específicas.

Echemos un vistazo a su implementación:

/**
 * Exclude from T those types that are assignable to U
 */
type Exclude<T, U> = T extends U ? never : T;

• type Exclude<T, U>type: Un tipo genérico se define mediante la palabra clave Exclude<T, U>, donde Tes un parámetro de tipo, que indica el tipo a procesar, y Ues un parámetro de tipo, que indica el tipo a excluir.
• T extends U ? never : T: Utilice tipos condicionales para determinar Tsi un tipo se puede asignar a un tipo U. Si la asignación es posible, es decir, Tes Uun subtipo de, entonces neverse devuelve el tipo, lo que indica que el tipo está excluido. Si no es asignable, es decir, Tno es Uun subtipo de , Tse devuelve el tipo en sí.

En conjunto, Exclude<T, U>su función es Texcluir todos Ulos tipos que se pueden asignar a tipo de tipo y generar un nuevo tipo. Este tipo se usa a menudo en el desarrollo real cuando es necesario excluir un tipo específico de un tipo. Puede filtrar tipos innecesarios y mejorar la seguridad de tipos y la flexibilidad del código.

Extracto

ExtractSe utiliza para extraer el tipo especificado de un tipo de unión.

ExtractAcepta dos parámetros de tipo, el primer parámetro es el tipo que se extraerá y el segundo parámetro es el tipo de unión del que se extraerá el tipo.

A continuación se muestra un ejemplo que demuestra cómo utilizar Extractla herramienta de texto:

type Animal = "dog" | "cat" | "bird";
type ExtractBird = Extract<Animal, "bird">;

const myBird: ExtractBird = "bird";

En el ejemplo anterior, definimos un tipo de unión que Animalcontiene tres tipos de animales: y .dogcatbird

Luego Extract<Animal, "bird">creamos un nuevo tipo usando ExtractBirdel tipo que extrajo el tipo Animaldel tipo bird.

Finalmente, definimos una variable myBirdcuyo tipo es ExtractBird, que extrae el birdtipo de Animaltipo . Entonces, myBirdsólo puede ser bird.

Al utilizar Extractherramientas de tipos, podemos extraer fácilmente un tipo específico de un tipo de unión para crear un nuevo tipo que satisfaga necesidades específicas.

Echemos un vistazo a su implementación:

/**
 * Extract from T those types that are assignable to U
 */
type Extract<T, U> = T extends U ? T : never;

• type Extract<T, U>type: Un alias de tipo se define mediante la palabra clave Extract<T, U>, donde Ty Uson parámetros de tipo, que representan el tipo a procesar y el tipo a extraer respectivamente.
• T extends U ? T : never: Este es un tipo condicional, que utiliza juicio condicional de tipo. Si el tipo Tse puede asignar a tipo , Use devuelve el tipo Tmismo , lo que indica que el tipo se va a extraer. Si Tno se puede asignar el tipo a type U, se devuelve type never, lo que indica que el tipo no se extrae.

Este alias de tipo se usa a menudo en escenarios de desarrollo reales donde solo es necesario conservar tipos específicos. Los tipos se pueden filtrar y procesar en función de las relaciones de tipos, lo que mejora la flexibilidad del código y la seguridad de los tipos.

Omitir

OmitSe utiliza para excluir propiedades específicas de un tipo de objeto.

OmitAcepta dos parámetros de tipo, el primer parámetro es el tipo de objeto del cual se excluirá el atributo y el segundo parámetro es el nombre del atributo que se excluirá.

A continuación se muestra un ejemplo que demuestra cómo utilizar Omitla herramienta de texto:

type Person = {
    
    
  name: string;
  age: number;
  gender: string;
};

type OmitAge = Omit<Person, "age">;

const personWithoutAge: OmitAge = {
    
    
  name: "John",
  gender: "male"
};

En el ejemplo anterior, definimos un tipo de objeto con Persontres propiedades: y .nameagegender

Luego Omit<Person, "age">creamos un nuevo tipo usando OmitAge, que excluía la propiedad Persondel tipo age.

Finalmente, definimos una variable personWithoutAgecuyo tipo es OmitAge, lo que excluye el tipo agede propiedad Person. Por lo tanto, personWithoutAgesólo se incluyen los atributos namey .gender

Al utilizar Omitherramientas de tipo, podemos excluir fácilmente propiedades específicas de un tipo de objeto y crear un nuevo tipo para satisfacer necesidades específicas.

Echemos un vistazo a su implementación:

/**
 * Construct a type with the properties of T except for those in type K.
 */
type Omit<T, K extends keyof any> = Pick<T, Exclude<keyof T, K>>;

• type Omit<T, K extends keyof any>type: Un alias de tipo se define a través de la palabra clave Omit<T, K extends keyof any>, donde Ty Kson parámetros de tipo, que representan el tipo a procesar y los atributos a excluir respectivamente.
• Pick<T, Exclude<keyof T, K>>: Esta es una expresión que utiliza dos operadores de tipo. Primero, keyof Tobtenga Tel tipo de unión que consta de todos los nombres de atributos de tipo. Luego, las propiedades especificadas en Exclude<keyof T, K>tipo se excluyen del tipo de unión del nombre de propiedad . KFinalmente, seleccione los atributos excluyendo los atributos especificados Pick<T, Exclude<keyof T, K>>del tipo para crear un nuevo tipo.T

Este alias de tipo se usa a menudo en escenarios de desarrollo reales donde es necesario eliminar atributos específicos de un tipo. Puede controlar de manera flexible la estructura y combinación de tipos y mejorar la reutilización y mantenibilidad del código.

No anulable

NonNullablenullSe utiliza para excluir y de un tipo undefined.

NonNullableAcepta un parámetro de tipo que representa el tipo a excluir nully undefined.

A continuación se muestra un ejemplo que demuestra cómo utilizar NonNullablela herramienta de texto:

type NullableString = string | null | undefined;
type NonNullableString = NonNullable<NullableString>;

const str: NonNullableString = "Hello";

En el ejemplo anterior, definimos un tipo NullableStringque es un tipo de unión que contiene stringy null.undefined

Luego NonNullable<NullableString>creamos un nuevo tipo usando NonNullableString, que excluye y NullableStringen .nullundefined

Finalmente, definimos una variable strcuyo tipo es , que NonNullableStringexcluye nully . Entonces, sólo puede ser tipo.undefinedNullableStringstrstring

Al utilizar NonNullablela herramienta de tipo, podemos excluir cómodamente nully de un tipo undefined, creando un nuevo tipo para garantizar que la variable no sea nullo undefined.

Echemos un vistazo a su implementación:

/**
 * Exclude null and undefined from T
 */
type NonNullable<T> = T & {
    
    };

• type NonNullable<T>: typeUn alias de tipo se define a través de la palabra clave NonNullable<T>, donde Testá el parámetro de tipo, que indica el tipo a procesar.
• T & {}: Esta es una expresión de tipo cruzado. Los tipos de intersección se utilizan para combinar varios tipos en uno solo. Aquí, la operación de intersección Tcon {}(tipo literal de objeto nulo) significa fusionar el tipo Ty el tipo de objeto nulo en un nuevo tipo.

Este alias de tipo se usa a menudo en escenarios de desarrollo reales donde es necesario garantizar que las variables o propiedades no contengan nullo , lo que puede mejorar la solidez y la seguridad de tipos del código.undefined

Parámetros

Parameters<T>Es un tipo de utilidad genérico que se utiliza para obtener Tel tipo de parámetro de un tipo de función. Acepta un tipo de función como parámetro y devuelve un tipo de tupla que contiene el tipo de cada parámetro de la función.

Por ejemplo, supongamos la siguiente definición de función:

function greet(name: string, age: number): void {
    
    
  console.log(`Hello, ${
      
      name}! You are ${
      
      age} years old.`);
}

Puede Parametersobtener los tipos de parámetros de una función usando greet:

type GreetParams = Parameters<typeof greet>;
// GreetParams 的类型为 [string, number]

En este ejemplo, GreetParamsel tipo de se infiere como un tipo de tupla, que contiene greetlos tipos de los dos parámetros de la función.

Echemos un vistazo a su implementación:

/**
 * Obtain the parameters of a function type in a tuple
 */
type Parameters<T extends (...args: any) => any> = T extends (...args: infer P) => any ? P : never;

En TypeScript, inferes una palabra clave que se utiliza para inferir variables de tipo en tipos condicionales. El tipo condicional es una forma de realizar juicios condicionales en el sistema de tipos, que puede seleccionar diferentes tipos según diferentes condiciones. inferLas palabras clave se pueden utilizar en cláusulas de tipos condicionales extendspara inferir el tipo específico de una variable de tipo.

En los tipos condicionales, inferlas palabras clave se utilizan a menudo para vincular variables de tipo al tipo que se va a inferir. De esta forma, cuando se utilizan tipos condicionales, infereste tipo se puede extraer y manipular mediante palabras clave.

En este ejemplo, definimos un Parameters<T>tipo condicional que acepta un tipo de función Tcomo parámetro. A través inferde la palabra clave, Rvinculamos la variable de tipo al parámetro del tipo de función. Si Tes un tipo de función, Parameters<T>se devolverá R, es decir, el tipo de parámetro de la función; en caso contrario, se devolverá never.

inferEl uso de palabras clave nos permite realizar inferencia de tipos en tipos condicionales, lo que nos permite operar y manejar diferentes tipos de situaciones de manera más flexible.

Parámetros del constructor

ConstructorParametersSe utiliza para obtener los tipos de parámetros del constructor.

ConstructorParametersAcepta un tipo de constructor como parámetro y devuelve un tipo de tupla que contiene los tipos de parámetros del constructor.

A continuación se muestra un ejemplo que demuestra cómo utilizar ConstructorParametersla herramienta de texto:

class Person {
    
    
  constructor(name: string, age: number) {
    
    
    // constructor implementation
  }
}

type PersonConstructorParams = ConstructorParameters<typeof Person>;

const params: PersonConstructorParams = ["John", 25];

En el ejemplo anterior, definimos una Personclase que tiene un constructor que acepta un nameparámetro y un ageparámetro.

Luego, usamos para ConstructorParameters<typeof Person>crear un nuevo tipo PersonConstructorParams, que es un tipo de tupla que contiene Personlos tipos de parámetros del constructor.

Finalmente, definimos una variable paramscuyo tipo es una tupla PersonConstructorParamsde Persontipos de parámetros del constructor. Entonces, paramses una tupla que contiene namey .age

Al usar ConstructorParametersherramientas de tipos, podemos obtener fácilmente los tipos de parámetros del constructor y usarlos para declarar variables, parámetros de funciones, etc.

Echemos un vistazo a su implementación:

/**
 * Obtain the parameters of a constructor function type in a tuple
 */
type ConstructorParameters<T extends abstract new (...args: any) => any> = T extends abstract new (...args: infer P) => any ? P : never;

• type ConstructorParameters<T extends abstract new (...args: any) => any>: typeUn alias de tipo se define a través de la palabra clave ConstructorParameters<T extends abstract new (...args: any) => any>, donde Testá el parámetro de tipo, que indica el tipo de constructor abstracto que se procesará.
• T extends abstract new (...args: infer P) => any ? P : never: Esta es una expresión de tipo condicional. Los tipos condicionales se utilizan para seleccionar diferentes tipos según una determinada condición. Aquí T extends abstract new (...args: infer P) => anyhay una condición de que si Tes un tipo de constructor abstracto, entonces Pse inferirá como la matriz de tipo de argumento del constructor. Y ? Psignifica que cuando la condición es verdadera, devuelve P, es decir, la matriz de tipo de parámetro; y : neversignifica que cuando la condición no es verdadera, devuelve neverel tipo.

Este alias de tipo se usa a menudo en escenarios de desarrollo reales donde el tipo de parámetro del constructor debe obtenerse del tipo de constructor abstracto y puede usarse para inferir y usar el tipo de parámetro del constructor.

Tipo de devolución

ReturnType<T>Es un tipo de utilidad genérico que se utiliza para obtener Tel tipo de valor de retorno de un tipo de función. Acepta un tipo de función como parámetro y devuelve el tipo de valor de retorno de la función.

Por ejemplo, supongamos la siguiente definición de función:

function add(a: number, b: number): number {
    
    
  return a + b;
}

Puede obtener el tipo de valor de retorno de una función ReturnTypeusando :add

type AddResult = ReturnType<typeof add>;
// AddResult 的类型为 number

En este ejemplo, AddResultse infiere que el tipo de es addel tipo de valor de retorno de la función, que es numberel tipo de .

Echemos un vistazo a su implementación:

/**
 * Obtain the return type of a function type
 */
type ReturnType<T extends (...args: any) => any> = T extends (...args: any) => infer R ? R : any;

ReturnType<T>Tipo condicional, que acepta un tipo de función Tcomo parámetro. A través inferde la palabra clave, Rvinculamos la variable de tipo al valor de retorno del tipo de función. Si T es un tipo de función, entonces ReturnType<T>se devolverá R, es decir, el tipo de valor de retorno de la función; de lo contrario, se devolverá never.

Tipo de instancia

InstanceTypeSe utiliza para obtener el tipo de instancia del constructor.

InstanceTypeAcepta un tipo de constructor como parámetro y devuelve un tipo de instancia de ese tipo de constructor.

A continuación se muestra un ejemplo que demuestra cómo utilizar InstanceTypela herramienta de texto:

class Person {
    
    
  name: string;
  age: number;

  constructor(name: string, age: number) {
    
    
    this.name = name;
    this.age = age;
  }

  sayHello() {
    
    
    console.log(`Hello, my name is ${
      
      this.name} and I'm ${
      
      this.age} years old.`);
  }
}

type PersonInstance = InstanceType<typeof Person>;

const person: PersonInstance = new Person("John", 25);
person.sayHello();

En el ejemplo anterior, definimos una Personclase que tiene un constructor y algunos métodos de instancia.

Luego, InstanceType<typeof Person>creamos un nuevo tipo usando PersonInstanceel Persontipo de instancia del constructor.

Finalmente, definimos una variable personcuyo tipo es PersonInstanceel Persontipo de instancia del constructor. Creamos new Person("John", 25)una Personinstancia de y se la asignamos person.

Al usar InstanceTypeherramientas de tipos, podemos obtener fácilmente el tipo de instancia del constructor y usarlo para declarar variables, valores de retorno de funciones, etc.

Echemos un vistazo a su implementación:

/**
 * Obtain the return type of a constructor function type
 */
type InstanceType<T extends abstract new (...args: any) => any> = T extends abstract new (...args: any) => infer R ? R : any;

• type InstanceType<T extends abstract new (...args: any) => any>: typeUn alias de tipo se define a través de la palabra clave InstanceType<T extends abstract new (...args: any) => any>, donde Testá el parámetro de tipo, que indica el tipo de constructor abstracto que se procesará.
• T extends abstract new (...args: any) => infer R ? R : any: Esta es una expresión de tipo condicional. Los tipos condicionales se utilizan para seleccionar diferentes tipos según una determinada condición. Aquí T extends abstract new (...args: any) => infer Rhay una condición de que si Tes un tipo de constructor abstracto, Rse inferirá como el tipo de instancia del constructor. Y ? Rsignifica que cuando la condición es verdadera, devuelve Rel tipo de la instancia del constructor; y : anysignifica que cuando la condición no es verdadera, devuelve anyel tipo.

Este alias de tipo se usa a menudo en escenarios de desarrollo reales donde es necesario obtener el tipo de instancia del constructor del tipo de constructor abstracto y se puede usar para inferir y usar el tipo de instancia del constructor.

Mayúsculas

UppercaseSe utiliza para convertir letras de tipo cadena a mayúsculas.

UppercaseAcepta un tipo de cadena como argumento y devuelve una versión en mayúsculas de ese tipo de cadena.

A continuación se muestra un ejemplo que demuestra cómo utilizar Uppercasela herramienta de texto:

type UppercaseString = Uppercase<"hello">;
// UppercaseString 的类型为 "HELLO"

const str: UppercaseString = "HELLO";

En el ejemplo anterior, Uppercase<"hello">creamos un nuevo tipo usando UppercaseString, que es "hello"una versión en mayúsculas del tipo de cadena, "HELLO"es decir

Luego, definimos una variable strcuyo tipo es UppercaseString, la versión mayúscula del tipo cadena. Asignamos "HELLO"la cadena a str.

Al utilizar Uppercaseherramientas de tipo, podemos convertir cómodamente letras de tipo cadena a mayúsculas y usarlas en declaraciones de tipo.

Echemos un vistazo a su implementación:

/**
 * Convert string literal type to uppercase
 */
type Uppercase<S extends string> = intrinsic;

• type Uppercase<S extends string>: typeUn alias de tipo se define a través de la palabra clave Uppercase<S extends string>, donde Sestá el parámetro de tipo, que indica el tipo de cadena a procesar.
• intrinsic: Este es un marcador de posición para el tipo o función incorporado real. Aquí, intrinsicse representa una implementación interna para convertir caracteres en tipos de cadena a mayúsculas.

En conjunto, Uppercase<S>la función es Sconvertir los caracteres del tipo de cadena a mayúsculas y devolver un nuevo tipo.

Cabe señalar que en este código intrinsices solo un marcador de posición para representar una implementación interna, no el código real. En el desarrollo real, podemos utilizar el tipo integrado proporcionado por TypeScript Uppercase<S>para implementar la función de convertir caracteres en tipos de cadena a mayúsculas.

Minúsculas

LowercaseSe utiliza para convertir letras de tipo cadena a minúsculas.

LowercaseAcepta un tipo de cadena como argumento y devuelve una versión en minúscula de ese tipo de cadena.

A continuación se muestra un ejemplo que demuestra cómo utilizar Lowercasela herramienta de texto:

type LowercaseString = Lowercase<"HELLO">;
// LowercaseString 的类型为 "hello"

const str: LowercaseString = "hello";

En el ejemplo anterior, Lowercase<"HELLO">creamos un nuevo tipo usando LowercaseString, que es "HELLO"una versión en minúsculas del tipo cadena, "hello"es decir

Luego, definimos una variable strcuyo tipo es LowercaseString, la versión en minúscula del tipo cadena. Asignamos "hello"la cadena a str.

Al utilizar Lowercaseherramientas de tipo, podemos convertir cómodamente letras de tipo cadena a minúsculas y usarlas en declaraciones de tipo.

Echemos un vistazo a su implementación:

/**
 * Convert string literal type to lowercase
 */
type Lowercase<S extends string> = intrinsic;

• type Lowercase<S extends string>: typeUn alias de tipo se define a través de la palabra clave Lowercase<S extends string>, donde Sestá el parámetro de tipo, que indica el tipo de cadena a procesar.
• intrinsic: Este es un marcador de posición para el tipo o función incorporado real. Aquí, intrinsicse representa una implementación interna para convertir caracteres en tipos de cadena a minúsculas.

Cabe señalar que en este código intrinsices solo un marcador de posición para representar una implementación interna, no el código real. En el desarrollo real, podemos utilizar el tipo integrado proporcionado por TypeScript Lowercase<S>para implementar la función de convertir caracteres en tipos de cadena a minúsculas.

Capitalizar

CapitalizeSe utiliza para convertir el primer carácter de una cadena a mayúscula.

Por ejemplo:

type MyString = 'hello';
type CapitalizedString = Capitalize<MyString>;
// CapitalizedString 的类型为 'Hello'

En el ejemplo anterior, usamos Capitalizela herramienta de texto para MyStringconvertir el primer carácter del tipo de cadena a mayúscula y asignar el resultado al alias de tipo CapitalizedString. Como MyStringel valor de es 'hello', CapitalizedStringel tipo de es 'Hello'.

Tenga en cuenta que esto Capitalizesólo se puede aplicar a tipos de cadenas. Si intenta aplicarlo a otros tipos (como números, booleanos) Capitalize, obtendrá un error en tiempo de compilación.

Echemos un vistazo a su implementación:

/**
 * Convert first character of string literal type to uppercase
 */
type Capitalize<S extends string> = intrinsic;

descapitalizar

UncapitalizeSe utiliza para convertir el primer carácter de una cadena a minúscula.

Por ejemplo:

type MyString = 'Hello';
type UncapitalizedString = Uncapitalize<MyString>;
// UncapitalizedString 的类型为 'hello'

En el ejemplo anterior, usamos Uncapitalizela herramienta de texto para MyStringconvertir el primer carácter del tipo de cadena a minúscula y asignar el resultado al alias de tipo UncapitalizedString. Como MyStringel valor de es 'Hello', UncapitalizedStringel tipo de es 'hello'.

Tenga en cuenta que esto Uncapitalizesólo se puede aplicar a tipos de cadenas. Si intenta aplicarlo a otros tipos (como números, booleanos) Uncapitalize, obtendrá un error en tiempo de compilación.

Echemos un vistazo a su implementación:

/**
 * Convert first character of string literal type to lowercase
 */
type Uncapitalize<S extends string> = intrinsic;