Պատմեք ինձ TypeScript-ում օգտակար տեսակների մասին։

Օգտագործումը TypeScript-ի օգտակար տեսակների արդյունավետ կերպով կառավարելու միջոց է: Այս ներքին տեսակները թույլ են տալիս վերափոխել առկա տվյալների տեսակները նորերի, կատարել տարբեր օգտակար գործողություններ և բարձրացնել կոդի ճկունությունը և վերօգտագործելիությունը: Հիմնական օգտակար տեսակներն են՝

• Partial<Type>: Ստեղծում է նոր տեսակ, որտեղ բոլոր Type հատկությունները դառնում են պարտադիր չէ:

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

• Readonly<Type>: Ստեղծում է նոր տեսակ, որտեղ բոլոր Type հատկությունները միայն ընթերցանելի են:

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

• Pick<Type, Keys>: Ստեղծում է տեսակ՝ ընտրելով որոշ հատկություններ Keys-ից Type-ից:

  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>: Ստեղծում է տեսակ՝ բաց թողնելով որոշ հատկություններ Keys-ից Type-ից:

  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>: Ստեղծում է տեսակ՝ բացառելով Type-ից այն տարրերը, որոնք կարող են լինել ExcludedUnion-ին վերագրելի:

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

• Extract<Type, Union>: Ստեղծում է տեսակ՝ ընտրելով Type-ից այն տարրերը, որոնք կարող են լինել Union-ին վերագրելի:

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

• NonNullable<Type>: Ստեղծում է տեսակ՝ բացառելով null և undefined-ը Type-ից:

  type MaybeString = string | null | undefined;
  type NotNullableString = NonNullable<MaybeString>;
  // NotNullableString կլինի string
  

• Record<Keys, Type>: Ստեղծում է օբյեկտի տեսակ, որի հատկությունները ունեն Keys-ից ստացված բանալիներ և Type-ի արժեքներ:

  type CityPopulation = Record<string, number>;
  // CityPopulation կլինի { [key: string]: number }
  
  const population: CityPopulation = {
    "Москва": 12635466,
    "Սանկտ Պետերբուրգ": 5381033,
  };
  

• Parameters<Type>: Վերադարձնում է տիպերի տիպերի տիպը՝ որպես տիպային տիպ:

  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>: Վերադարձնում է ֆունկցիայի Type վերադարձվող արժեքի տիպը:

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

• ConstructorParameters<Type>: Վերադարձնում է կոնստրուկտորի տիպերի տիպը՝ որպես տիպային տիպ:

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

• InstanceType<Type>: Վերադարձնում է Type-ի օրինակային տիպը:

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

Օգտագործելով օգտակար տեսակները, կոդը դառնում է ավելի անվտանգ, հեշտ է պահպանել և ավելի արտահայտիչ, ինչը թույլ է տալիս արդյունավետ կառավարել բարդ տվյալների տեսակները։