Opowiedz o typach użytkowych w TypeScript.

Typy pomocnicze w TypeScript to wbudowane typy, które pozwalają na przekształcanie istniejących typów danych w nowe typy, wykonując różne przydatne operacje. Pomagają zwiększyć elastyczność i ponowne użycie typów, zmniejszając redundancję kodu.

Główne typy pomocnicze:

• Partial<Type>: Tworzy nowy typ, w którym wszystkie właściwości Type stają się opcjonalne.

  interface User {
    id: number;
    name: string;
    age: number;
  }
  
  type PartialUser = Partial<User>;
  // PartialUser będzie { id?: number; name?: string; age?: number; }
  

• Readonly<Type>: Tworzy nowy typ, w którym wszystkie właściwości Type są tylko do odczytu.

  interface Point {
    x: number;
    y: number;
  }
  
  type ReadonlyPoint = Readonly<Point>;
  // ReadonlyPoint będzie { readonly x: number; readonly y: number; }
  

• Pick<Type, Keys>: Tworzy typ wybierając określony zestaw właściwości Keys z Type.

  interface Product {
    id: number;
    name: string;
    price: number;
    description: string;
  }
  
  type ProductSummary = Pick<Product, 'id' | 'name' | 'price'>;
  // ProductSummary będzie { id: number; name: string; price: number; }
  

• Omit<Type, Keys>: Tworzy typ, wykluczając określony zestaw właściwości Keys z Type.

  interface Order {
    id: number;
    productId: number;
    quantity: number;
    timestamp: string;
  }
  
  type OrderDetails = Omit<Order, 'timestamp'>;
  // OrderDetails będzie { id: number; productId: number; quantity: number; }
  

• Exclude<Type, ExcludedUnion>: Tworzy typ, wykluczając z Type te elementy, które mogą być przypisane do ExcludedUnion. Używany dla unii (union types).

  type Colors = 'red' | 'green' | 'blue' | 'yellow';
  type PrimaryColors = Exclude<Colors, 'yellow'>;
  // PrimaryColors będzie 'red' | 'green' | 'blue'
  

• Extract<Type, Union>: Tworzy typ, wybierając z Type te elementy, które mogą być przypisane do Union. Używany dla unii.

  type AllAnimals = 'dog' | 'cat' | 'fish' | 'bird';
  type PetAnimals = Extract<AllAnimals, 'dog' | 'cat'>;
  // PetAnimals będzie 'dog' | 'cat'
  

• NonNullable<Type>: Tworzy typ, wykluczając z Type wartości null i undefined.

  type MaybeString = string | null | undefined;
  type NotNullableString = NonNullable<MaybeString>;
  // NotNullableString będzie string
  

• Record<Keys, Type>: Tworzy typ obiektu, którego właściwości mają klucze z Keys i wartości typu Type.

  type CityPopulation = Record<string, number>;
  // CityPopulation będzie { [key: string]: number }
  
  const population: CityPopulation = {
    "Moscow": 12635466,
    "Saint Petersburg": 5381033,
  };
  

• Parameters<Type>: Zwraca krotkę (tuple) typów parametrów funkcji Type.

  function greet(name: string, age: number): string {
    return `Hello, ${name}! You are ${age}.`;
  }
  
  type GreetParams = Parameters<typeof greet>;
  // GreetParams będzie [name: string, age: number]
  

• ReturnType<Type>: Zwraca typ wartości zwracanej przez funkcję Type.

  function calculateSum(a: number, b: number): number {
    return a + b;
  }
  
  type SumResult = ReturnType<typeof calculateSum>;
  // SumResult będzie number
  

• ConstructorParameters<Type>: Zwraca krotkę lub tablicę typów parametrów konstruktora klasy Type.

  class MyClass {
    constructor(name: string, id: number) {}
  }
  
  type MyClassParams = ConstructorParameters<typeof MyClass>;
  // MyClassParams będzie [name: string, id: number]
  

• InstanceType<Type>: Zwraca typ instancji klasy Type.

  class AnotherClass {
    value: string;
    constructor(v: string) {
      this.value = v;
    }
  }
  
  type AnotherClassInstance = InstanceType<typeof AnotherClass>;
  // AnotherClassInstance będzie AnotherClass
  

Użycie typów pomocniczych sprawia, że kod jest bezpieczniejszy, łatwiejszy w utrzymaniu i bardziej wyrazisty, umożliwiając skuteczne zarządzanie złożonymi typami danych.