გთხოვთ, მითხრათ 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>: აბრუნებს ფუნქციის დაბრუნების მნიშვნელობის ტიპს.

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

გამოყენებით სასარგებლო ტიპების, კოდი ხდება უფრო უსაფრთხო, ადვილია შენარჩუნება და უფრო გამოხატული, რაც საშუალებას იძლევა ეფექტურად მართოს მონაცემთა რთული ტიპები.

გთხოვთ, მითხრათ TypeScript-ის სასარგებლო ტიპების შესახებ.