Inventário de tipos integrados do TypeScript

Inventário de tipos integrados do TypeScript

Conhecer e compreender os tipos integrados é uma etapa importante quando os desenvolvedores começam a aprender TypeScript. TypeScript fornece uma série de tipos integrados que nos ajudam a definir e usar melhor variáveis, funções e objetos.

Primeiro, o TypeScript fornece tipos primitivos básicos, incluindo number, string, e . Esses tipos podem ser usados ​​para declarar os tipos de dados básicos de variáveis.booleannullundefined

Além disso, o TypeScript também fornece alguns tipos integrados mais avançados, como Array, e . Tipos são usados ​​para definir arrays, tipos são usados ​​para definir arrays com comprimento fixo e um tipo específico. Os tipos são usados ​​para definir tipos de enumeração, o que nos permite dar um nome mais amigável a um grupo de constantes relacionadas. Tipos são tipos de nível superior em TypeScript, que nos permitem compilar sem verificação de tipo.TupleEnumAnyArrayTupleEnumAny

O TypeScript também apresenta alguns tipos integrados mais complexos, como Object, Functione Promise. ObjectOs tipos são usados ​​para descrever variáveis ​​de tipos não primitivos, Functionos tipos são usados ​​para descrever funções e Promiseos tipos são usados ​​para lidar com os resultados de operações assíncronas.

Além disso, o TypeScript fornece alguns tipos integrados úteis, como Date, RegExpe Error. DateOs tipos são usados ​​para lidar com datas e horas, RegExpos tipos são usados ​​para lidar com expressões regulares e Erroros tipos são usados ​​para lidar com erros.

Por fim, o TypeScript também oferece suporte a alguns operadores de tipo avançados e inferência de tipo, como union,, e . Esses recursos tornam a definição e o uso de tipos complexos em TypeScript mais flexíveis e poderosos.intersectiontype assertiontype inference

Compreender e familiarizar-se com esses tipos integrados é fundamental para escrever código TypeScript robusto, de fácil manutenção e com segurança de tipo. Ao usar esses tipos com sabedoria, podemos detectar melhor os erros durante o desenvolvimento, melhorar a qualidade do código e reduzir o tempo de depuração.

Este artigo orientará você no uso de alguns tipos avançados de TypeScript e sua implementação.

Parcial

PartialUsado para tornar opcionais todas as propriedades de um determinado tipo. Em outras palavras, Partialvocê pode criar um novo tipo que tenha as mesmas propriedades do tipo original, mas essas propriedades são opcionais.

O uso Partialpode definir facilmente um objeto cujas propriedades podem receber valores opcionalmente atribuídos. Isso é útil para situações em que você precisa definir dinamicamente as propriedades do objeto com base no contexto ou quando deseja atualizar apenas uma parte das propriedades de um objeto.

Aqui está um exemplo que demonstra como usar Partiala ferramenta de digitação:

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]" }); // 仅更新年龄和邮箱

No exemplo acima, definimos uma Userinterface que possui propriedades namee . Definimos então uma função que aceita um parâmetro do tipo , que é um objeto parcialmente concluído.ageemailupdateUserPartial<User>User

Ao utilizá-lo Partial<User>, podemos updateUserpassar apenas as propriedades que precisam ser atualizadas ao chamar a função sem fornecer o Userobjeto completo. Isso torna mais fácil atualizar apenas algumas propriedades do usuário sem precisar modificar outras propriedades.

Resumindo, Partiala ferramenta de tipo é uma ferramenta útil em TypeScript, que pode nos ajudar a definir tipos de objetos com propriedades opcionais e atualizar facilmente algumas propriedades do objeto quando necessário.

Vamos dar uma olhada em sua implementação:

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

• type Partial<T>: typeUm tipo genérico é definido através da palavra-chave Partial<T>, onde Té um parâmetro de tipo que indica o tipo a ser processado.
• [P in keyof T]?: use o operador de consulta de tipo de índice keyof Tpara obter Ttodas as propriedades do tipo e use ina palavra-chave para iterar sobre essas propriedades. PÉ o nome do atributo durante o processo de travessia, [P in keyof T]o que significa criar um atributo no novo tipo com o nome do atributo P.
• ?: T[P]: use o operador de atributo opcional ?para tornar opcional o valor de um atributo. T[P]Indica que o tipo do atributo definido no novo tipo Té igual ao tipo do atributo correspondente do tipo original.

Em conjunto, Partial<T>a função é Tconverter todas as propriedades do tipo em propriedades opcionais, ou seja, cada propriedade pode ter um valor ou nenhum valor. Este tipo é frequentemente usado no desenvolvimento real para atualizar ou estender parcialmente objetos para facilitar a atribuição seletiva de atributos.

Obrigatório

RequiredUsado para definir todas as propriedades de um determinado tipo como obrigatórias. Em outras palavras, Requiredvocê pode criar um novo tipo que tenha as mesmas propriedades do tipo original, mas essas propriedades são obrigatórias e não podem ser omitidas.

Usando , Requiredvocê pode definir facilmente um objeto cujas propriedades devem receber valores atribuídos. Isso é útil para garantir a integridade do objeto e a segurança do tipo.

Aqui está um exemplo que demonstra como usar Requireda ferramenta de digitação:

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" }); // 缺少必需的属性，会报错

No exemplo acima, definimos uma Userinterface, que possui atributos name, agee , mas esses atributos são opcionais, ou seja, podem ser omitidos. emailEntão, definimos uma createUserfunção que aceita um Required<User>parâmetro do tipo, que é um Userobjeto obrigatório.

Ao usar Required<User>, garantimos que ao chamar createUseruma função, o objeto completo Userdeve ser fornecido sem omitir nenhuma propriedade necessária. Isso ajuda a garantir que os objetos do usuário sejam criados com a integridade e a segurança de tipo necessárias.

Vamos dar uma olhada em sua implementação:

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

• type Required<T>: typeUm tipo genérico é definido através da palavra-chave Required<T>, onde Té um parâmetro de tipo que indica o tipo a ser processado.
• [P in keyof T]-?: use o operador de consulta de tipo de índice keyof Tpara obter Ttodas as propriedades do tipo e use ina palavra-chave para iterar sobre essas propriedades. PÉ o nome do atributo durante o processo de travessia, [P in keyof T]o que significa criar um atributo no novo tipo com o nome do atributo P.
• -?: T[P]: use o operador de atributo obrigatório -?para tornar o valor do atributo obrigatório. T[P]Indica que o tipo do atributo definido no novo tipo Té igual ao tipo do atributo correspondente do tipo original.

Em conjunto, Required<T>a função é Tconverter todos os atributos do tipo em atributos obrigatórios, ou seja, cada atributo deve ter um valor. Este tipo é frequentemente usado no desenvolvimento real para restringir atributos necessários de objetos para garantir a integridade e correção dos atributos.

Somente leitura

ReadonlyUsado para definir todas as propriedades de um determinado tipo como somente leitura. Em outras palavras, Readonlyvocê pode criar um novo tipo que tenha as mesmas propriedades do tipo original, mas essas propriedades são somente leitura e não podem ser modificadas.

O uso Readonlypode definir facilmente um objeto somente leitura cujas propriedades não podem ser modificadas. Isso é útil para garantir a imutabilidade do objeto e a segurança do tipo.

Aqui está um exemplo que demonstra como usar Readonlya ferramenta de digitação:

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"; // 无法修改只读属性，会报错

No exemplo acima, definimos uma Userinterface que possui propriedades name, agee , mas essas propriedades são somente leitura, ou seja, não podem ser modificadas. emailEm seguida, definimos uma getUserfunção que retorna um Readonly<User>objeto de usuário do tipo somente leitura.

Usando , podemos garantir que as propriedades do objeto de usuário não possam ser modificadas após ele Readonly<User>ser atribuído a uma variável . userIsso ajuda a garantir a imutabilidade do objeto e a segurança do tipo.

Vamos dar uma olhada em sua implementação:

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

• type Readonly<T>: typeUm tipo genérico é definido através da palavra-chave Readonly<T>, onde Té um parâmetro de tipo que indica o tipo a ser processado.
• readonly [P in keyof T]: T[P]: use o operador de consulta de tipo de índice keyof Tpara obter Ttodas as propriedades do tipo e use ina palavra-chave para iterar sobre essas propriedades. PÉ o nome do atributo durante o processo de travessia, [P in keyof T]o que significa criar um atributo no novo tipo com o nome do atributo P.
• readonly: adicione a palavra-chave antes do nome do atributo readonlypara definir o valor do atributo como somente leitura.

Em conjunto, Readonly<T>sua função é Tconverter todas as propriedades do tipo em propriedades somente leitura, ou seja, o valor da propriedade não pode ser modificado após a atribuição. Este tipo é frequentemente usado no desenvolvimento real para proteger objetos contra modificações acidentais ou adulteração de valores de atributos.

Escolha

PickUsado para selecionar propriedades especificadas de um determinado tipo e criar um novo tipo. Em outras palavras, Pickvocê pode selecionar propriedades especificadas de um tipo de objeto e criar um novo tipo que contenha apenas as propriedades especificadas.

O uso Pickfacilita a seleção das peças necessárias de um tipo complexo, reduzindo informações redundantes desnecessárias e melhorando a legibilidade e flexibilidade do código.

Aqui está um exemplo que demonstra como usar Picka ferramenta de digitação:

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

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

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

No exemplo acima, definimos uma Userinterface com propriedades name, agee . Em seguida, usamos a ferramenta de tipo para criar um novo tipo que contém apenas as propriedades e .emailaddressPickUserBasicInfonameage

Usando Pick<User, "name" | "age">, Userselecionamos os atributos namee agedo tipo e criamos um novo tipo UserBasicInfo. Podemos então usar UserBasicInfoo tipo para definir userum objeto que contém apenas as propriedades namee age.

Vamos dar uma olhada em sua implementação:

/**
 * 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>: typeUm tipo genérico é definido através da palavra-chave Pick<T, K>, onde Té um parâmetro de tipo, indicando o tipo a ser processado, Ké um parâmetro de tipo, indicando o conjunto de chaves dos atributos a serem selecionados, K extends keyof Tindicando Kque devem fazer Tparte do conjunto de chaves do tipo .
• [P in K]: T[P]: Krepresenta o conjunto chave de atributos a serem selecionados e usa ina palavra-chave para percorrer esses atributos. Pé o nome do atributo durante o processo de travessia, [P in K]o que significa criar um atributo no novo tipo com o nome do atributo Pe apenas Kos atributos contidos em .

Em conjunto, Pick<T, K>a função é Tselecionar os atributos especificados do tipo e gerar um novo tipo. Este tipo é frequentemente usado no desenvolvimento real quando é necessário extrair alguns atributos de um tipo grande.Os atributos necessários podem ser selecionados com precisão e a introdução de atributos desnecessários pode ser evitada.

Registro

RecordUsado para criar um tipo de objeto com um tipo de propriedade especificado. RecordAceita dois parâmetros de tipo, o primeiro parâmetro especifica o nome do atributo e o segundo parâmetro especifica o tipo do atributo.

RecordVocê pode definir facilmente um tipo de objeto com um tipo de atributo especificado usando , o que é muito útil para criar estruturas de dados como dicionários e mapeamentos.

Aqui está um exemplo que demonstra como usar Recorda ferramenta de digitação:

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

No exemplo acima, definimos dois tipos Fruite Price, Fruitque é um tipo de união que representa o nome da fruta e Priceum tipo numérico que representa o preço da fruta.

Em seguida, usamos para Record<Fruit, Price>criar um tipo de objeto fruitPricesque só pode conter Fruitpropriedades do tipo, e o valor da propriedade deve ser Pricedo tipo.

Usando Record<Fruit, Price>, criamos um fruitPricesobjeto nomeado que contém três atributos de maçã, banana e laranja, e seus valores correspondem aos seus preços respectivamente.

Vamos dar uma olhada em sua implementação:

/**
 * 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: Um tipo genérico é definido através da palavra-chave Record<K, T>, onde Ké um parâmetro de tipo, indicando o tipo a ser usado como chave do atributo, e Té um parâmetro de tipo, indicando o tipo do valor do atributo. K extends keyof anyAs representações Kdevem fazer parte de uma coleção de chaves de qualquer tipo.
• [P in K]: T: use o operador de consulta do tipo de índice keyof anypara obter todas as chaves de qualquer tipo e initerar sobre elas usando a palavra-chave. PÉ o nome da chave durante o processo de travessia, [P in K]o que significa criar um atributo no novo tipo, sendo o nome do atributo Pe o valor do atributo o tipo T.

Juntos, Record<K, T>o efeito é criar um novo tipo onde a chave de cada atributo é Kum elemento do tipo e o valor de cada atributo é o tipo T. Este tipo é frequentemente usado no desenvolvimento real quando é necessário criar objetos com tipos específicos de chave e valor, e esses objetos podem ser facilmente definidos e manipulados.

Excluir

ExcludeUsado para excluir tipos especificados de um tipo de união.

ExcludeAceita dois parâmetros de tipo, o primeiro parâmetro é o tipo a ser excluído e o segundo parâmetro é o tipo de união do qual os tipos devem ser excluídos.

Aqui está um exemplo que demonstra como usar Excludea ferramenta de digitação:

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

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

No exemplo acima, definimos um tipo de união Animalque contém três tipos de animais dog: cate bird.

Em seguida, Exclude<Animal, "bird">criamos um novo tipo usando ExcludeBirdo tipo que excluiu o tipo Animalno type bird.

Finalmente, definimos um array myPetscujo tipo de elemento é ExcludeBird, ou seja, excluindo o birdtipo de Animal. Portanto, myPetsa matriz só pode conter doge cat.

Ao usar Excludeferramentas de tipo, podemos facilmente excluir um tipo específico de um tipo de união para criar um novo tipo que atenda a necessidades específicas.

Vamos dar uma olhada em sua implementação:

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

• type Exclude<T, U>type: Um tipo genérico é definido através da palavra-chave Exclude<T, U>, onde Té um parâmetro de tipo, indicando o tipo a ser processado, e Ué um parâmetro de tipo, indicando o tipo a ser excluído.
• T extends U ? never : T: Use tipos condicionais para determinar Tse um tipo pode ser atribuído a um tipo U. Se a atribuição for possível, ou seja, Tfor Uum subtipo de , então nevertype será retornado, indicando que o tipo foi excluído. Se não for atribuível, ou seja, Tnão for Uum subtipo de , então To próprio tipo será retornado.

Em conjunto, Exclude<T, U>sua função é Texcluir do tipo todos Uos tipos que podem ser atribuídos ao tipo e gerar um novo tipo. Este tipo é frequentemente utilizado no desenvolvimento real quando um tipo específico precisa de ser excluído de um tipo.Pode filtrar tipos desnecessários e melhorar a segurança do tipo e a flexibilidade do código.

Extrair

ExtractUsado para extrair o tipo especificado de um tipo de união.

ExtractAceita dois parâmetros de tipo, o primeiro parâmetro é o tipo a ser extraído e o segundo parâmetro é o tipo de união do qual o tipo deve ser extraído.

Aqui está um exemplo que demonstra como usar Extracta ferramenta de digitação:

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

const myBird: ExtractBird = "bird";

No exemplo acima, definimos um tipo de união Animalque contém três tipos de animais dog: cate bird.

Em seguida, Extract<Animal, "bird">criamos um novo tipo usando ExtractBirdo tipo que extraiu o tipo Animaldo tipo bird.

Por fim, definimos uma variável myBirdcujo tipo é ExtractBird, que extrai o birdtipo de Animaltype . Então, myBirdsó pode ser bird.

Usando Extractferramentas de tipo, podemos extrair facilmente um tipo específico de um tipo de união para criar um novo tipo para atender a necessidades específicas.

Vamos dar uma olhada em sua implementação:

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

• type Extract<T, U>type: Um alias de tipo é definido através da palavra-chave Extract<T, U>, onde Te Usão parâmetros de tipo, representando o tipo a ser processado e o tipo a ser extraído respectivamente.
• T extends U ? T : never: Este é um tipo condicional, que usa julgamento condicional de tipo. Se type Tfor atribuível a type , o próprio type Userá retornado , indicando que o tipo deve ser extraído. TSe type Tnão puder ser atribuído a type U, type será retornado never, indicando que o tipo não foi extraído.

Este alias de tipo é frequentemente utilizado em cenários de desenvolvimento reais onde apenas tipos específicos precisam de ser retidos.Os tipos podem ser filtrados e processados ​​com base em relações de tipo,melhorando a flexibilidade do código e a segurança do tipo.

Omitir

OmitUsado para excluir propriedades especificadas de um tipo de objeto.

OmitAceita dois parâmetros de tipo, o primeiro parâmetro é o tipo de objeto do qual o atributo deve ser excluído e o segundo parâmetro é o nome do atributo a ser excluído.

Aqui está um exemplo que demonstra como usar Omita ferramenta de digitação:

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

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

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

No exemplo acima, definimos um tipo de objeto com Persontrês propriedades: e .nameagegender

Em seguida, Omit<Person, "age">criamos um novo tipo usando OmitAge, que excluiu a propriedade Persondo tipo age.

Por fim, definimos uma variável personWithoutAgecujo tipo é OmitAge, o que exclui o tipo ageda propriedade Person. Portanto, personWithoutAgeapenas os atributos namee genderestão incluídos.

Usando Omitferramentas de tipo, podemos facilmente excluir propriedades específicas de um tipo de objeto e criar um novo tipo para atender a necessidades específicas.

Vamos dar uma olhada em sua implementação:

/**
 * 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: Um alias de tipo é definido através da palavra-chave Omit<T, K extends keyof any>, onde Te Ksão parâmetros de tipo, representando o tipo a ser processado e os atributos a serem excluídos respectivamente.
• Pick<T, Exclude<keyof T, K>>: esta é uma expressão que usa dois operadores de tipo. Primeiro, keyof Tobtenha To tipo de união que consiste em todos os nomes de atributos do tipo. Em seguida, as propriedades especificadas em Exclude<keyof T, K>type são excluídas do nome da propriedade union type . KFinalmente, selecione os atributos excluindo os atributos especificados Pick<T, Exclude<keyof T, K>>do tipo para construir um novo tipo.T

Este alias de tipo é frequentemente usado em cenários reais de desenvolvimento onde atributos específicos precisam ser excluídos de um tipo.Ele pode controlar de forma flexível a estrutura e a combinação de tipos e melhorar a capacidade de reutilização e manutenção do código.

Não anulável

NonNullablenullUsado para excluir e de um tipo undefined.

NonNullableAceita um parâmetro de tipo que representa o tipo a ser excluído nulle undefined.

Aqui está um exemplo que demonstra como usar NonNullablea ferramenta de digitação:

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

const str: NonNullableString = "Hello";

No exemplo acima, definimos um tipo NullableStringque é um tipo de união contendo string, nulle .undefined

Em seguida, NonNullable<NullableString>criamos um novo tipo usando NonNullableString, que exclui o e NullableStringem .nullundefined

Por fim, definimos uma variável strcujo tipo é , que NonNullableStringexclui nulle . Então, só pode ser tipo.undefinedNullableStringstrstring

Usando NonNullablea ferramenta de tipo, podemos excluir convenientemente nulle de um tipo undefined, criando um novo tipo para garantir que a variável não será nullou undefined.

Vamos dar uma olhada em sua implementação:

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

• type NonNullable<T>: typeUm alias de tipo é definido através da palavra-chave NonNullable<T>, onde Té o parâmetro type, indicando o tipo a ser processado.
• T & {}: Esta é uma expressão de tipo cruzado. Os tipos de interseção são usados ​​para combinar vários tipos em um único tipo. Aqui, a operação de interseção Tcom {}(tipo literal de objeto nulo) significa mesclar o tipo Te o tipo de objeto nulo em um novo tipo.

Esse alias de tipo é frequentemente usado em cenários reais de desenvolvimento onde é necessário garantir que variáveis ​​ou propriedades não contenham nullou , o que pode melhorar a robustez e a segurança de tipo do código.undefined

Parâmetros

Parameters<T>É um tipo de utilitário genérico usado para obter To tipo de parâmetro de um tipo de função. Ele aceita um tipo de função como parâmetro e retorna um tipo de tupla contendo o tipo de cada parâmetro da função.

Por exemplo, suponha a seguinte definição de função:

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

Você pode Parametersobter os tipos de parâmetros de uma função usando greet:

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

Neste exemplo, GreetParamso tipo de é inferido como um tipo de tupla, que contém greetos tipos dos dois parâmetros da função.

Vamos dar uma olhada em sua implementação:

/**
 * 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;

No TypeScript, inferé uma palavra-chave usada para inferir variáveis ​​de tipo em tipos condicionais. O tipo condicional é uma forma de fazer julgamentos condicionais no sistema de tipos, que pode selecionar diferentes tipos de acordo com diferentes condições. inferPalavras-chave podem ser usadas em cláusulas de tipos condicionais extendspara inferir o tipo específico de uma variável de tipo.

Em tipos condicionais, inferpalavras-chave são frequentemente usadas para vincular variáveis ​​de tipo ao tipo a ser inferido. Desta forma, ao utilizar tipos condicionais, infereste tipo pode ser extraído e manipulado através de palavras-chave.

Neste exemplo, definimos um Parameters<T>tipo condicional que aceita um tipo de função Tcomo parâmetro. Através inferda palavra-chave, Rvinculamos a variável de tipo ao parâmetro do tipo de função. Se Tfor um tipo de função, então Parameters<T>será retornado R, ou seja, o tipo de parâmetro da função; caso contrário, será retornado never.

inferO uso de palavras-chave nos permite realizar inferência de tipos em tipos condicionais, permitindo-nos operar e tratar diferentes tipos de situações com mais flexibilidade.

Parâmetros do Construtor

ConstructorParametersUsado para obter os tipos de parâmetros do construtor.

ConstructorParametersAceita um tipo de construtor como parâmetro e retorna um tipo de tupla contendo os tipos de parâmetro do construtor.

Aqui está um exemplo que demonstra como usar ConstructorParametersa ferramenta de digitação:

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

type PersonConstructorParams = ConstructorParameters<typeof Person>;

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

No exemplo acima, definimos uma Personclasse que possui um construtor que aceita um nameparâmetro e um ageparâmetro.

Em seguida, usamos para ConstructorParameters<typeof Person>criar um novo tipo PersonConstructorParams, que é um tipo de tupla contendo Personos tipos de parâmetros do construtor.

Finalmente, definimos uma variável paramscujo tipo é uma tupla PersonConstructorParamsde Persontipos de parâmetros do construtor. Então, paramsé uma tupla contendo namee .age

Usando ConstructorParametersferramentas de tipo, podemos obter facilmente os tipos de parâmetros do construtor e usá-los para declarar variáveis, parâmetros de função, etc.

Vamos dar uma olhada em sua implementação:

/**
 * 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>: typeUm alias de tipo é definido através da palavra-chave ConstructorParameters<T extends abstract new (...args: any) => any>, onde Té o parâmetro type, indicando o tipo de construtor abstrato a ser processado.
• T extends abstract new (...args: infer P) => any ? P : never: Esta é uma expressão de tipo condicional. Os tipos condicionais são usados ​​para selecionar diferentes tipos com base em uma determinada condição. Aqui T extends abstract new (...args: infer P) => anyestá uma condição de que, se Tfor um tipo de construtor abstrato, Pserá inferido como o array de tipo de argumento do construtor. E ? Psignifica que quando a condição for verdadeira, retorne P, ou seja, o tipo de parâmetro array; e : neversignifica que quando a condição não for verdadeira, retorne nevero tipo.

Este alias de tipo é frequentemente usado em cenários de desenvolvimento reais onde o tipo de parâmetro do construtor precisa ser obtido do tipo de construtor abstrato e pode ser usado para inferir e usar o tipo de parâmetro do construtor.

Tipo de Retorno

ReturnType<T>É um tipo de utilitário genérico usado para obter To tipo de valor de retorno de um tipo de função. Ele aceita um tipo de função como parâmetro e retorna o tipo de valor de retorno da função.

Por exemplo, suponha a seguinte definição de função:

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

Você pode obter o tipo de valor de retorno de uma função ReturnTypeusando :add

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

Neste exemplo, AddResulto tipo de é inferido como addo tipo de valor de retorno da função, que é numbero tipo de .

Vamos dar uma olhada em sua implementação:

/**
 * 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 aceita um tipo de função Tcomo parâmetro. Através inferda palavra-chave, Rvinculamos a variável de tipo ao valor de retorno do tipo de função. Se T for um tipo de função, então ReturnType<T>será retornado R, ou seja, o tipo de valor de retorno da função; caso contrário, será retornado never.

Tipo de instância

InstanceTypeUsado para obter o tipo de instância do construtor.

InstanceTypeAceita um tipo de construtor como parâmetro e retorna um tipo de instância desse tipo de construtor.

Aqui está um exemplo que demonstra como usar InstanceTypea ferramenta de digitação:

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();

No exemplo acima, definimos uma Personclasse, que possui um construtor e alguns métodos de instância.

Em seguida, InstanceType<typeof Person>criamos um novo tipo usando PersonInstanceo Persontipo de instância do construtor.

Finalmente, definimos uma variável personcujo tipo é PersonInstanceo Persontipo de instância do construtor. Criamos new Person("John", 25)uma Personinstância e a atribuímos a person.

Usando InstanceTypeferramentas de tipo, podemos obter facilmente o tipo de instância do construtor e usá-lo para declarar variáveis, valores de retorno de função, etc.

Vamos dar uma olhada em sua implementação:

/**
 * 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>: typeUm alias de tipo é definido através da palavra-chave InstanceType<T extends abstract new (...args: any) => any>, onde Té o parâmetro type, indicando o tipo de construtor abstrato a ser processado.
• T extends abstract new (...args: any) => infer R ? R : any: Esta é uma expressão de tipo condicional. Os tipos condicionais são usados ​​para selecionar diferentes tipos com base em uma determinada condição. Aqui T extends abstract new (...args: any) => infer Restá uma condição de que, se Tfor um tipo de construtor abstrato, Rserá inferido como o tipo da instância do construtor. E ? Rsignifica que quando a condição for verdadeira, retorne Ro tipo da instância do construtor; e : anysignifica que quando a condição não for verdadeira, retorne anyo tipo.

Esse alias de tipo é frequentemente usado em cenários de desenvolvimento reais onde o tipo de instância do construtor precisa ser obtido do tipo de construtor abstrato e pode ser usado para inferir e usar o tipo de instância do construtor.

Maiúsculas

UppercaseUsado para converter letras do tipo string em maiúsculas.

UppercaseAceita um tipo de string como argumento e retorna uma versão em maiúscula desse tipo de string.

Aqui está um exemplo que demonstra como usar Uppercasea ferramenta de digitação:

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

const str: UppercaseString = "HELLO";

No exemplo acima, Uppercase<"hello">criamos um novo tipo usando UppercaseString, que é "hello"uma versão em maiúscula do tipo string, "HELLO"ou seja ,

Em seguida, definimos uma variável strcujo tipo é UppercaseString, a versão maiúscula do tipo string. Atribuímos "HELLO"a string a str.

Usando Uppercaseferramentas de tipo, podemos converter convenientemente letras do tipo string em maiúsculas e usá-las em declarações de tipo.

Vamos dar uma olhada em sua implementação:

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

• type Uppercase<S extends string>: typeUm alias de tipo é definido através da palavra-chave Uppercase<S extends string>, onde Sé o parâmetro type, indicando o tipo de string a ser processada.
• intrinsic: Este é um espaço reservado para o tipo ou função interna real. Aqui, intrinsicuma implementação interna é representada para converter caracteres de tipos string em letras maiúsculas.

Em conjunto, Uppercase<S>a função é Sconverter os caracteres do tipo string em letras maiúsculas e retornar um novo tipo.

Deve-se notar que neste código intrinsicé apenas um espaço reservado para representar uma implementação interna, não o código real. No desenvolvimento real, podemos usar o tipo integrado fornecido pelo TypeScript Uppercase<S>para implementar a função de conversão de caracteres em tipos de string para letras maiúsculas.

Minúsculas

LowercaseUsado para converter letras do tipo string em minúsculas.

LowercaseAceita um tipo de string como argumento e retorna uma versão minúscula desse tipo de string.

Aqui está um exemplo que demonstra como usar Lowercasea ferramenta de digitação:

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

const str: LowercaseString = "hello";

No exemplo acima, Lowercase<"HELLO">criamos um novo tipo usando LowercaseString, que é "HELLO"uma versão em minúscula do tipo string, "hello"ou seja,

Em seguida, definimos uma variável strcujo tipo é LowercaseString, a versão minúscula do tipo string. Atribuímos "hello"a string a str.

Usando Lowercaseferramentas de tipo, podemos converter convenientemente letras do tipo string em minúsculas e usá-las em declarações de tipo.

Vamos dar uma olhada em sua implementação:

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

• type Lowercase<S extends string>: typeUm alias de tipo é definido através da palavra-chave Lowercase<S extends string>, onde Sé o parâmetro type, indicando o tipo de string a ser processada.
• intrinsic: Este é um espaço reservado para o tipo ou função interna real. Aqui, intrinsicuma implementação interna é representada para converter caracteres do tipo string em letras minúsculas.

Deve-se notar que neste código intrinsicé apenas um espaço reservado para representar uma implementação interna, não o código real. No desenvolvimento real, podemos usar o tipo integrado fornecido pelo TypeScript Lowercase<S>para implementar a função de conversão de caracteres em tipos de string para letras minúsculas.

Capitalizar

CapitalizeUsado para converter o primeiro caractere de uma string em letras maiúsculas.

Por exemplo:

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

No exemplo acima, usamos Capitalizea ferramenta de tipo para MyStringconverter o primeiro caractere do tipo string em maiúscula e atribuir o resultado ao tipo alias CapitalizedString. Como MyStringo valor de is 'hello', CapitalizedStringo tipo de is 'Hello'.

Observe que isso Capitalizesó pode ser aplicado a tipos de string. Se você tentar aplicá-lo a outros tipos (como números, booleanos) Capitalize, receberá um erro em tempo de compilação.

Vamos dar uma olhada em sua implementação:

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

Descapitalizar

UncapitalizeUsado para converter o primeiro caractere de uma string em minúsculas.

Por exemplo:

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

No exemplo acima, usamos Uncapitalizea ferramenta de tipo para MyStringconverter o primeiro caractere do tipo string para minúsculo e atribuir o resultado ao tipo alias UncapitalizedString. Como MyStringo valor de is 'Hello', UncapitalizedStringo tipo de is 'hello'.

Observe que isso Uncapitalizesó pode ser aplicado a tipos de string. Se você tentar aplicá-lo a outros tipos (como números, booleanos) Uncapitalize, receberá um erro em tempo de compilação.

Vamos dar uma olhada em sua implementação:

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