Vorbiți despre tipurile utilitare în TypeScript…

Tipurile utilitare în TypeScript sunt tipuri încorporate care permit transformarea tipurilor de date existente în altele noi, efectuând diverse operații utile. Ele ajută la creșterea flexibilității și reutilizării tipurilor, reducând redundanța codului.

Tipurile utilitare principale:

Partial<Type>: Creează un nou tip în care toate proprietățile lui Type devin opționale.

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

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

Readonly<Type>: Creează un nou tip în care toate proprietățile lui Type devin doar pentru citire.

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

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

Pick<Type, Keys>: Creează un tip selectând un set specific de proprietăți Keys din Type.

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

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

Omit<Type, Keys>: Creează un tip excludând un set specific de proprietăți Keys din Type.

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

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

Exclude<Type, ExcludedUnion>: Creează un tip excluzând din Type acele elemente care pot fi atribuite ExcludedUnion. Este folosit pentru unioni.

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

Extract<Type, Union>: Creează un tip selectând din Type acele elemente care pot fi atribuite Union. Este folosit pentru unioni.

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

NonNullable<Type>: Creează un tip excluzând din Type valorile null și undefined.

type MaybeString = string | null | undefined;
type NotNullableString = NonNullable<MaybeString>;
// NotNullableString va fi string

Record<Keys, Type>: Creează un tip de obiect, ale cărui proprietăți au chei din Keys și valori de tip Type.

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

const population: CityPopulation = {
  "Moscova": 12635466,
  "Sankt Petersburg": 5381033,
};

Parameters<Type>: Returnează o tuplă (tuple) a tipurilor parametrilor funcției Type.

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

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

ReturnType<Type>: Returnează tipul valorii returnate de funcția Type.

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

type SumResult = ReturnType<typeof calculateSum>;
// SumResult va fi number

ConstructorParameters<Type>: Returnează o tuplă sau un array a tipurilor parametrilor constructorului clasei Type.

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

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

InstanceType<Type>: Returnează tipul unei instanțe a clasei Type.

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

type AnotherClassInstance = InstanceType<typeof AnotherClass>;
// AnotherClassInstance va fi AnotherClass

Folosirea tipurilor utilitare face codul mai sigur, mai ușor de întreținut și mai expresiv, permițând gestionarea eficientă a tipurilor de date complexe.

Vorbiți despre tipurile utilitare în TypeScript.