Rääkige mulle TypeScripti kasulikest tüüpidest…

TypeScripti kasulikud tüübid on tõhus viis keerukate andmetüüpide haldamiseks. Need sisseehitatud tüübid võimaldavad olemasolevaid tüüpe ümber kujundada uuteks, teha erinevaid kasulikke operatsioone ning parandada koodi paindlikkust ja korduvkasutatavust. Peamised kasulikud tüübid on:

Partial<Type>: loob uue tüübi, kus kõik Type omadused on valikulised.

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

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

Readonly<Type>: loob uue tüübi, kus kõik Type omadused on ainult lugemiseks.

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

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

Pick<Type, Keys>: loob tüübi, valides teatud Keys omadused Type-st.

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

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

Omit<Type, Keys>: loob tüübi, välja jättes teatud Keys omadused Type-st.

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

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

Exclude<Type, ExcludedUnion>: loob tüübi, välja jättes Type-st elemendid, mis võivad kuuluda ExcludedUnion-ile.

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

Extract<Type, Union>: loob tüübi, valides Type-st elemendid, mis võivad kuuluda Union-ile.

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

NonNullable<Type>: loob tüübi, välja jättes null ja undefined väärtused Type-st.

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

Record<Keys, Type>: loob objekti tüübi, mille omadused on Keys-st ja väärtused Type.

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

const population: CityPopulation = {
  "Moskva": 12635466,
  "Sankt-Peterburg": 5381033,
};

Parameters<Type>: tagastab funktsiooni parameetrite tüübi järjendi (tuple).

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

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

ReturnType<Type>: tagastab funktsiooni tagastatava väärtuse tüübi.

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

type SumResult = ReturnType<typeof calculateSum>;
// SumResult on number

ConstructorParameters<Type>: tagastab klassi konstruktorparameetrite tüübi järjendi (tuple) või massiivina.

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

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

InstanceType<Type>: tagastab Type klassi eksemplari tüübi.

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

type AnotherClassInstance = InstanceType<typeof AnotherClass>;
// AnotherClassInstance on AnotherClass

Tippe kasutades muutub kood turvalisemaks, lihtsamaks hooldada ja väljendusrikkamaks, võimaldades tõhusalt hallata keerukaid andmetüüpe.

Rääkige mulle TypeScripti kasulikest tüüpidest.