Papaskinkite apie naudingus tipus TypeScript…

Naudojant TypeScript naudingus tipus yra efektyvus būdas valdyti sudėtingus duomenų tipus. Šie įmontuoti tipai leidžia perkurti esamus tipus naujais, atlikti įvairias naudingas operacijas ir pagerinti kodo lankstumą bei pakartotinį naudojimą. Pagrindiniai naudingieji tipai yra:

Partial<Type>: Kuria naują tipą, kuriame visi Type savybės yra neprivalomos.

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

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

Readonly<Type>: Kuria naują tipą, kuriame visos Type savybės yra tik skaitymui.

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

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

Pick<Type, Keys>: Sukuria tipą pasirinkdami tam tikras Keys savybes iš Type.

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

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

Omit<Type, Keys>: Sukuria tipą, išskyrus tam tikras Keys savybes iš Type.

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

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

Exclude<Type, ExcludedUnion>: Sukuria tipą, išskyrus Type elementus, kurie gali būti priskirti ExcludedUnion.

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

Extract<Type, Union>: Sukuria tipą, pasirinkdami iš Type tų elementų, kurie gali būti priskirti Union.

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

NonNullable<Type>: Sukuria tipą, išskyrus null ir undefined iš Type.

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

Record<Keys, Type>: Sukuria objekto tipą, kurio savybės turi Keys ir reikšmes Type.

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

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

Parameters<Type>: Grąžina funkcijos parametrų tipų sąrašą (tuple).

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

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

ReturnType<Type>: Grąžina funkcijos grąžinamosios reikšmės tipą.

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

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

ConstructorParameters<Type>: Grąžina klasės konstruktoriaus parametrų tipų sąrašą.

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

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

InstanceType<Type>: Grąžina Type klasės egzemplioriaus tipą.

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

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

Naudojant naudingus tipus, kodas tampa saugesnis, lengviau prižiūrimas ir išraiškingesnis, leidžiantis efektyviai valdyti sudėtingus duomenų tipus.

Papaskinkite apie naudingus tipus TypeScript.