Sertifikat olingYANGIW3Schools ilovasiiOS va AndroidSarguzashtni boshlang

TypeScript shartli tiplar

ULASHISH

TypeScript-da shartli turlarni tushunish

TypeScript-dagi shartli turlar JavaScript-da if-else operatorlari qanday ishlashiga o‘xshash boshqa turlarga bog‘liq turlarni yaratishga imkon beradi.

Ular murakkab turdagi transformatsiyalar va turdagi darajadagi dasturlash imkonini beruvchi kuchli xususiyatdir.

Asosiy tushunchalar

  • Type-level logic : Turlar bo‘yicha shartli tekshiruvlarni o‘tkazing
  • Type inference : infer yordamida turlarni ajratib oling va boshqaring
  • Composition : Boshqa TypeScript funksiyalari bilan birlashtiring
  • Utility types : Kuchli turdagi yordamchi dasturlarni yarating

Umumiy foydalanish holatlari

  • Turi-xavfsiz funksiyani haddan tashqari yuklash
  • API javob turini o‘zgartirish
  • Murakkab turdagi tekshiruvlar
  • Qayta foydalanish mumkin bo‘lgan turdagi kommunal xizmatlarni qurish
  • Kengaytirilgan turdagi xulosa

Asosiy shartli tur sintaksisi

Shartli turlar T extends U ? X : Y shaklidan foydalanadi, ya’ni:

"agar T turi U turini kengaytirsa (yoki tayinlanishi mumkin bo‘lsa), X turidan foydalaning, aks holda Y turidan foydalaning ".

Misol

type IsString<T> = T extends string ? true : false;

// Usage examples
type Result1 = IsString<string>; // true
type Result2 = IsString<number>; // false
type Result3 = IsString<"hello">; // true (literal types extend their base types)

// We can use this with variables too
let a: IsString<string>; // a has type 'true'
let b: IsString<number>; // b has type 'false'
O‘zingiz sinab ko‘ring »

Birlashmalar bilan shartli turlar

Tarqatuvchi shartli turlar

Shartli turlar kasaba uyushmalari turlari uchun ayniqsa foydali bo‘lib, ular kasaba uyushma a’zolariga avtomatik ravishda taqsimlanadi:

Misol

type ToArray<T> = T extends any ? T[] : never;

// When used with a union type, it applies to each member of the union
type StringOrNumberArray = ToArray<string | number>;
// This becomes ToArray<string> | ToArray<number>
// Which becomes string[] | number[]

// We can also extract specific types from a union
type ExtractString<T> = T extends string ? T : never;
type StringsOnly = ExtractString<string | number | boolean | "hello">;
// Result: string | "hello"
O‘zingiz sinab ko‘ring »

infer bilan xulosa yozing

Murakkab tuzilmalardan turlarni ajratib olish

infer kalit so‘zi shartli turning shart qismidagi turdagi o‘zgaruvchini e’lon qilish va undan keyin shartning haqiqiy bo‘limida foydalanish imkonini beradi:

Misol

// Extract the return type of a function type
type ReturnType<T> = T extends (...args: any[]) => infer R ? R : never;

// Examples
function greet() { return "Hello, world!"; }
function getNumber() { return 42; }

type GreetReturnType = ReturnType<typeof greet>; // string
type NumberReturnType = ReturnType<typeof getNumber>; // number

// Extract element type from array
type ElementType<T> = T extends (infer U)[] ? U : never;
type NumberArrayElement = ElementType<number[]>; // number
type StringArrayElement = ElementType<string[]>; // string
O‘zingiz sinab ko‘ring »

O‘rnatilgan shartli turlar

Standart kutubxona yordamchi dasturlari

TypeScript o‘zining standart kutubxonasida bir nechta o‘rnatilgan shartli turlarni o‘z ichiga oladi:

Misol

// Extract<T, U> - Extracts types from T that are assignable to U
type OnlyStrings = Extract<string | number | boolean, string>; // string

// Exclude<T, U> - Excludes types from T that are assignable to U
type NoStrings = Exclude<string | number | boolean, string>; // number | boolean

// NonNullable<T> - Removes null and undefined from T
type NotNull = NonNullable<string | null | undefined>; // string

// Parameters<T> - Extracts parameter types from a function type
type Params = Parameters<(a: string, b: number) => void>; // [string, number]

// ReturnType<T> - Extracts the return type from a function type
type Return = ReturnType<() => string>; // string
O‘zingiz sinab ko‘ring »

Ilg‘or naqshlar va texnikalar

Rekursiv shartli turlar

Murakkab turdagi transformatsiyalarni yaratish uchun shartli turlardan rekursiv foydalanish mumkin:

Misol

// Deeply unwrap Promise types
type UnwrapPromise<T> = T extends Promise<infer U> ? UnwrapPromise<U> : T;

// Examples
type A = UnwrapPromise<Promise<string>>; // string
type B = UnwrapPromise<Promise<Promise<number>>>; // number
type C = UnwrapPromise<boolean>; // boolean
O‘zingiz sinab ko‘ring »

Turi darajasidagi If-Else zanjirlari

Murakkab turdagi mantiq uchun bir nechta shartlarni birlashtiring:

Misol

type TypeName<T> =
  T extends string ? "string" :
  T extends number ? "number" :
  T extends boolean ? "boolean" :
  T extends undefined ? "undefined" :
  T extends Function ? "function" :
  "object";

// Usage
type T0 = TypeName<string>; // "string"
type T1 = TypeName<42>; // "number"
type T2 = TypeName<true>; // "boolean"
type T3 = TypeName<() => void>; // "function"
type T4 = TypeName<Date[]>; // "object"
O‘zingiz sinab ko‘ring »

Shartli turlar umumiy yordamchi dasturlar va turdagi xavfsiz kutubxonalarni yaratishda kuchli hisoblanadi:

Misol

// A function that returns different types based on input type
function processValue<T>(value: T): T extends string
  ? string
  : T extends number
  ? number
  : T extends boolean
  ? boolean
  : never {

  if (typeof value === "string") {
    return value.toUpperCase() as any; // Type assertion needed due to limitations
  } else if (typeof value === "number") {
    return (value * 2) as any;
  } else if (typeof value === "boolean") {
    return (!value) as any;
  } else {
    throw new Error("Unsupported type");
  }
}

// Usage
const stringResult = processValue("hello"); // Returns "HELLO" (type is string)
const numberResult = processValue(10); // Returns 20 (type is number)
const boolResult = processValue(true); // Returns false (type is boolean)
O‘zingiz sinab ko‘ring »

Eng yaxshi amaliyotlar

Qilish:

  • Murakkab turdagi transformatsiyalar uchun shartli turlardan foydalaning
  • Turni ajratib olish uchun infer bilan birlashtiring
  • Qayta foydalanish mumkin bo‘lgan turdagi yordamchi dasturlarni yarating
  • Hujjat kompleksining shartli turlari
  • Turingizdagi ta’riflardagi chekka holatlarni sinab ko‘ring

Qilmang:

  • Oddiy turlar yetarli bo‘lganda murakkab shartli turlardan ortiqcha foydalaning
  • Tushunish qiyin bo‘lgan chuqur joylashtirilgan shartli turlarni yarating
  • Juda murakkab turlar bilan ishlash oqibatlarini unuting
  • Ish vaqti mantig‘i uchun shartli turlardan foydalaning

Ishlash bo‘yicha mulohazalar

  • Chuqur joylashtirilgan shartli turlar kompilyatsiya vaqtini oshirishi mumkin
  • Oraliq natijalar uchun turdagi taxalluslardan foydalanishni ko‘rib chiqing
  • TypeScript-ning rekursiya chuqurligi chegaralarini yodda tuting

‹ OrqagaKeyingisi

W3Schools Pathfinder

Yutuqlaringizni kuzating – bu bepul!

Ro'yxatdan o'tishKirish