Meséljen a TypeScript segédtípusairól.

A TypeScript segédtípusai beépített típusok, amelyek lehetővé teszik a meglévő adattípusok új típusokká alakítását különböző hasznos műveletek végrehajtásával. Segítenek növelni a típusok rugalmasságát és újrahasznosíthatóságát, csökkentve a kód redundanciáját.

Fő segédtípusok:

• Partial<Type>: Új típust hoz létre, amelyben a Type összes tulajdonsága opcionális.

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

• Readonly<Type>: Új típust hoz létre, amelyben a Type összes tulajdonsága csak olvasható.

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

• Pick<Type, Keys>: Kiválaszt egy adott Keys tulajdonságokat tartalmazó típust a Type-ból.

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

• Omit<Type, Keys>: Kizár egy adott Keys tulajdonságokat tartalmazó típust a Type-ból.

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

• Exclude<Type, ExcludedUnion>: Kizárja az ExcludedUnion-nak megfelelő elemeket a Type-ból. Unió típusokhoz használható.

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

• Extract<Type, Union>: Kiválasztja a Type-ból azokat az elemeket, amelyek megfelelnek a Union-nak. Unió típusokhoz használható.

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

• NonNullable<Type>: Kizárja a null és undefined értékeket a Type-ból.

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

• Record<Keys, Type>: Objektumtípust hoz létre, amelynek tulajdonságai a Keys-ből származó kulcsokat és a Type-ból származó értékeket tartalmazzák.

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

• Parameters<Type>: Visszaadja a Type függvény paramétereinek tuple-ját.

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

• ReturnType<Type>: Visszaadja a Type függvény visszatérési értékének típusát.

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

• ConstructorParameters<Type>: Visszaadja a Type osztály konstruktorának paraméter típusainak tuple-ját vagy tömbjét.

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

• InstanceType<Type>: Visszaadja az Type osztály példányának típusát.

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

A segédtípusok használata biztonságosabbá, karbantarthatóbbá és kifejezőbbé teszi a kódot, lehetővé téve összetett adattípusok hatékony kezelését.