Fale sobre os tipos utilitários em TypeScript…

Os tipos utilitários em TypeScript são tipos incorporados que permitem transformar tipos de dados existentes em novos tipos, realizando várias operações úteis. Eles ajudam a aumentar a flexibilidade e a reutilização de tipos, reduzindo a redundância do código.

Tipos utilitários principais:

Partial<Type>: Cria um novo tipo em que todas as propriedades de Type se tornam opcionais.

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

type PartialUser = Partial<User>;
// PartialUser será { id?: number; name?: string; age?: number; }

Readonly<Type>: Cria um novo tipo em que todas as propriedades de Type se tornam somente leitura.

interface Point {
  x: number;
  y: number;
}

type ReadonlyPoint = Readonly<Point>;
// ReadonlyPoint será { readonly x: number; readonly y: number; }

Pick<Type, Keys>: Cria um tipo selecionando um conjunto específico de propriedades Keys de Type.

interface Product {
  id: number;
  name: string;
  price: number;
  description: string;
}

type ProductSummary = Pick<Product, 'id' | 'name' | 'price'>;
// ProductSummary será { id: number; name: string; price: number; }

Omit<Type, Keys>: Cria um tipo excluindo um conjunto específico de propriedades Keys de Type.

interface Order {
  id: number;
  productId: number;
  quantity: number;
  timestamp: string;
}

type OrderDetails = Omit<Order, 'timestamp'>;
// OrderDetails será { id: number; productId: number; quantity: number; }

Exclude<Type, ExcludedUnion>: Cria um tipo excluindo de Type aqueles elementos que podem ser atribuídos a ExcludedUnion. Usado para uniões (union types).

type Colors = 'red' | 'green' | 'blue' | 'yellow';
type PrimaryColors = Exclude<Colors, 'yellow'>;
// PrimaryColors será 'red' | 'green' | 'blue'

Extract<Type, Union>: Cria um tipo selecionando de Type aqueles elementos que podem ser atribuídos a Union. Usado para uniões.

type AllAnimals = 'dog' | 'cat' | 'fish' | 'bird';
type PetAnimals = Extract<AllAnimals, 'dog' | 'cat'>;
// PetAnimals será 'dog' | 'cat'

NonNullable<Type>: Cria um tipo excluindo de Type os valores null e undefined.

type MaybeString = string | null | undefined;
type NotNullableString = NonNullable<MaybeString>;
// NotNullableString será string

Record<Keys, Type>: Cria um tipo de objeto cujas propriedades têm chaves de Keys e valores do tipo Type.

type CityPopulation = Record<string, number>;
// CityPopulation será { [key: string]: number }

const population: CityPopulation = {
  "Moscow": 12635466,
  "Saint Petersburg": 5381033,
};

Parameters<Type>: Retorna uma tupla (tuple) dos tipos dos parâmetros da função Type.

function greet(name: string, age: number): string {
  return `Hello, ${name}! You are ${age}.`;
}

type GreetParams = Parameters<typeof greet>;
// GreetParams será [name: string, age: number]

ReturnType<Type>: Retorna o tipo do valor de retorno da função Type.

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

type SumResult = ReturnType<typeof calculateSum>;
// SumResult será number

ConstructorParameters<Type>: Retorna uma tupla ou matriz de tipos dos parâmetros do construtor da classe Type.

class MyClass {
  constructor(name: string, id: number) {}
}

type MyClassParams = ConstructorParameters<typeof MyClass>;
// MyClassParams será [name: string, id: number]

InstanceType<Type>: Retorna o tipo da instância da classe Type.

class AnotherClass {
  value: string;
  constructor(v: string) {
    this.value = v;
  }
}

type AnotherClassInstance = InstanceType<typeof AnotherClass>;
// AnotherClassInstance será AnotherClass

O uso de tipos utilitários torna o código mais seguro, suportável e expressivo, permitindo gerenciar tipos de dados complexos de forma eficaz.

Fale sobre os tipos utilitários em TypeScript.