Əsas məzmuna keç
FrontDepth, Ana səhifə

TypeScript

Utility, mapped və conditional tiplər

TypeScript tipləri başqa tiplərdən necə hesablayır: keyof, typeof və indexed access, gündəlik utility tiplər və onların tərifi, modifikatorlar və açarların yenidən adlandırılması ilə mapped tiplər, template literal tiplər, infer və union üzrə paylanma ilə conditional tiplər, həmçinin tip səviyyəsində kodun nə vaxt həddən artıq mürəkkəb olduğu.

MiddleSeniorYenilənib: 16 noyabr 2026

Oxu səviyyəsi

Seçilmiş səviyyəyə qədər olan bölmələr göstərilir.

Başlamazdan əvvəl

Bu mövzu Middle səviyyəsindən başlayır.

MiddleKonsepsiya

keyof, typeof və indexed access tipləri

Tip çevrilmələrinin çoxu artıq mövcud olan bir şeydən başlayır: dəyərdən və ya başqa tipdən. Üç operator tipi ikinci dəfə yazmaq əvəzinə onu törətməyə imkan verir.

  • typeof value tip mövqeyində dəyişənin və ya xassənin tipini verir. Bu, icra zamanı "string" qaytaran JavaScript operatoru yox, tip səviyyəsindəki typeof-dur və TypeScript ondan yalnız identifikatorlar və onların xassələri üzərində istifadəyə icazə verir.
  • keyof T T-nin açarlarının union-ıdır.
  • T[K], yəni indexed access tipi, K xassəsinin tipidir. K union da ola bilər, T[number] isə massivin və ya tuple-ın element tipini verir.
TypeScript
const config = {
  apiUrl: "/api",
  retries: 3,
  features: { search: true },
};

type Config = typeof config; // { apiUrl: string; retries: number; features: { search: boolean } }
type ConfigKey = keyof typeof config; // "apiUrl" | "retries" | "features"
type Features = Config["features"]; // { search: boolean }
type Scalar = Config["apiUrl" | "retries"]; // string | number

Bir siyahı, bir həqiqət mənbəyi

Tez-tez rast gəlinən şablon: icazə verilən dəyərləri proqramın icra zamanı istifadə edə biləcəyi kodda saxla, tipi isə onlardan törət.

TypeScript
const ROLES = ["admin", "editor", "viewer"] as const;
type Role = (typeof ROLES)[number]; // "admin" | "editor" | "viewer"

function isRole(value: string): value is Role {
  return (ROLES as readonly string[]).includes(value);
}

as const olmasa, ROLES string[], Role isə sadəcə string olardı. Massivə "owner" əlavə et, tip də onun ardınca dəyişəcək; əllə yazılmış union isə massivdən ayrı düşərdi. isRole eyni siyahı üzərində qurulmuş , ona görə yoxlama ilə tip bir-birinə zidd ola bilməz.

Obyektlər də eyni cür işləyir. const STATUS = { active: "Active", banned: "Banned" } as const olanda keyof typeof STATUS "active" | "banned", (typeof STATUS)[keyof typeof STATUS] isə "Active" | "Banned" olur.

Dəyərlər və tiplər ayrı yerlərdə yaşayır

Indexed access dəyər yox, tip qəbul edir:

TypeScript
const key = "retries";
type Retries = Config[key]; // Error: Type 'key' cannot be used as an index type.
type Retries2 = Config[typeof key]; // number

typeof kod da icra etmir: typeof createUser("Aysel") sintaksis xətasıdır. Çağırışın nəticəsinin tipi ReturnType<typeof createUser>-dir, aşağıdakı utility tiplərdən biri.

Bu üç operator bu mövzudakı qalan hər şeyin əsasını təşkil edir: daxili utility tiplər keyof və indexed access ilə yazılıb.

MiddleKonsepsiya

Gündəlik utility tiplər

TypeScript-in standart kitabxanasındakı, bir tipdən başqasını quran generic tiplərdir. Onlar qlobaldır, heç nə import etmək lazım deyil. Hər gün rastlaşacağın tiplər:

TypeScript
type User = {
  id: string;
  name: string;
  email?: string;
  readonly createdAt: Date;
};

type UserPatch = Partial<Omit<User, "id" | "createdAt">>; // { name?: string; email?: string }
type CompleteUser = Required<User>; // email artıq məcburidir
type UserPreview = Pick<User, "id" | "name">; // { id: string; name: string }
type FrozenUser = Readonly<User>; // bütün xassələr readonly-dir
type CountByStatus = Record<"draft" | "published", number>; // { draft: number; published: number }
type Name = NonNullable<string | null | undefined>; // string
  • Partial<T> bütün xassələri məcburi olmayan edir: yeniləmə payload-ları, form qaralamaları, test factory-lərində override-lar.
  • Required<T> bütün xassələrdən ?-ı silir: default-lar doldurulduqdan sonrakı konfiqurasiya.
  • Readonly<T> bütün xassələri readonly edir: ötürdüyün, amma dəyişməməli olduğun data. O, yalnız tip yoxlayıcısı üçün mövcuddur; obyekti dondurmur.
  • Pick<T, K> sadalanan açarları saxlayır, Omit<T, K> isə qalanların hamısını. Pick böyük tipin kiçik görünüşünü verir, Omit isə "server-in yaratdığı sahələr olmadan eyni şeyi".
  • Record<K, V> açarları K, dəyərləri V olan obyekt tipidir. Literal açarlardan ibarət union ilə hər açar məcburidir, bu da onu bütün halları əhatə edən yaxşı cədvələ (lookup table) çevirir.
  • NonNullable<T> null və undefined-i silir.

Bütün halları əhatə edən cədvəl

TypeScript
type Status = "draft" | "review" | "published";

const statusLabel: Record<Status, string> = { // Error
  draft: "Draft",
  review: "In review",
};

Xəta belədir: "Property 'published' is missing in type '{ draft: string; review: string; }' but required in type 'Record<Status, string>'." Union-a yeni status əlavə et, kod bazasındakı hər Record<Status, …> yeni halı əlavə edənə qədər kompilyasiya olunmayacaq. { [key: string]: string } kimi tiplənmiş adi obyekt bunu heç vaxt deməzdi.

Birləşdir, sonra nəticəyə ad ver

Utility tiplər iç-içə yazılır. Partial<Omit<User, "id" | "createdAt">> içəridən çölə oxunur: "id və createdAt-sız User, hər şey məcburi olmayan". Nəticə birdən çox yerdə işlənirsə, ona UserPatch kimi ad ver ki, hover və xəta mesajları ifadəni yox, adı göstərsin.

Hamısının mənası odur ki, törədilmiş tip orijinalın ardınca gedir. User-ə phone?: string əlavə et: UserPatch telefonu da qəbul edəcək, UserPreview isə açarlarını sadaladığı üçün olduğu kimi qalacaq. Köçürülmüş tip isə səssizcə geridə qalardı.

MiddleKonsepsiya

Funksiyalardan tiplər: ReturnType, Parameters, Awaited

Funksiya artıq bir formanı müəyyən edirsə, tipi ikinci dəfə elan etmək əvəzinə onu funksiyadan törət. Bu utility-lər funksiyanın tipini qəbul edir, ona görə onlara typeof fn ötürürsən:

TypeScript
function createCart(ownerId: string, currency: "AZN" | "EUR" = "AZN") {
  return { ownerId, currency, items: [] as CartItem[], createdAt: new Date() };
}

type Cart = ReturnType<typeof createCart>;
// { ownerId: string; currency: "AZN" | "EUR"; items: CartItem[]; createdAt: Date }

type CartArgs = Parameters<typeof createCart>;
// [ownerId: string, currency?: "AZN" | "EUR"]

type Currency = Parameters<typeof createCart>[1]; // "AZN" | "EUR" | undefined

Parameters tuple verir, ona görə bir parametri almaq üçün onu ədədlə indeksləyirsən. Məcburi olmayan parametrlər məcburi olmayan qalır, Currency-yə undefined-in daxil olmasının səbəbi budur.

Async funksiyalar üçün Awaited

async funksiyanın qaytarma tipi Promise-dir. Awaited<T> onu await-in etdiyi kimi açır: rekursiv şəkildə və promise olmayan dəyərlərə toxunmadan.

TypeScript
async function loadDashboard(userId: string) {
  const [user, orders] = await Promise.all([getUser(userId), getOrders(userId)]);
  return { user, orders };
}

type DashboardPromise = ReturnType<typeof loadDashboard>; // Promise<{ user: User; orders: Order[] }>
type Dashboard = Awaited<ReturnType<typeof loadDashboard>>; // { user: User; orders: Order[] }

type Nested = Awaited<Promise<Promise<number>>>; // number
type Mixed = Awaited<boolean | Promise<number>>; // number | boolean

Nə vaxt işlətməli

  • Qaytarma tipi export olunmayan kitabxana funksiyası: formasını köçürmək əvəzinə ReturnType<typeof createClient>.
  • Arqumentləri dəyişmədən ötürən wrapper: function withRetry(...args: Parameters<typeof send>).
  • Forması onu quran kodla müəyyən olunan factory və ya store.

İki qeyd. Overload olunmuş funksiya üçün ReturnType və Parameters handbook-un qeyd etdiyi kimi yalnız sonuncu imzanı görür; overload-u sənin yerinə seçə bilmir. Bir də, implementasiyadan törədilmiş tip implementasiya dəyişəndə, heç kim bunu qərara almadan dəyişir. Daxili köməkçi üçün bu rahatdır. Başqa modulların asılı olduğu funksiya üçün isə açıq yazılmış, adlı qaytarma tipi qəsdən dəyişdirdiyin müqavilədir və gövdədə onu pozan dəyişiklik elə edildiyi yerdə xəta verir.

MiddleKonsepsiya

Mapped tiplər

obyekt tipini açarlar union-ı üzrə dövr edərək qurur, map-in massiv üzrə dövr etdiyi kimi. Partial, Required, Readonly, Pick və Record mapped tiplərdir. Standart kitabxana onlardan üçünü belə təyin edir:

TypeScript
type Partial<T> = { [P in keyof T]?: T[P] };
type Required<T> = { [P in keyof T]-?: T[P] };
type Readonly<T> = { readonly [P in keyof T]: T[P] };

[P in keyof T]: T[P]-ni belə oxu: "T-nin hər P açarı üçün eyni tipli P xassəsi". Hissələri:

  • P in Keys union üzrə dövr edir: keyof T və ya istənilən sətir literalları union-ı, Record<K, T>-nin [P in K]: T ilə etdiyi kimi.
  • ? və readonly hər xassəyə modifikator əlavə edir. - prefiksi isə onu silir: -? xassələri məcburi, -readonly isə yazıla bilən edir. Prefiks yoxdursa, + nəzərdə tutulur.
  • Açarlar keyof T-dən gələndə mövcud modifikatorlar saxlanır. Məcburi olmayan email-i olan tip üzrə map etsən, -? yazmadıqca email məcburi olmayan qalır.
TypeScript
type Mutable<T> = { -readonly [K in keyof T]: T[K] };

type FieldErrors<T> = { [K in keyof T]?: string };
type SignupErrors = FieldErrors<{ email: string; password: string }>;
// { email?: string; password?: string }

as ilə açarların yenidən adlandırılması

TypeScript 4.1-dən bəri as ifadəsi map edərkən açarların adını dəyişir. Template literal tiplə birlikdə yeni adlar yarada bilir:

TypeScript
type Getters<T> = {
  [K in keyof T & string as `get${Capitalize<K>}`]: () => T[K];
};

type UserGetters = Getters<{ name: string; age: number }>;
// { getName: () => string; getAge: () => number }

keyof T & string yalnız sətir açarlarını saxlayır, çünki Capitalize sətir tələb edir, keyof-da isə number və symbol açarları da ola bilər.

Açarı never-ə çevirmək onu atır, bu da mapped tipi filtrə çevirir:

TypeScript
type StringFields<T> = {
  [K in keyof T as T[K] extends string ? K : never]: T[K];
};

type Text = StringFields<{ id: number; title: string; body: string }>;
// { title: string; body: string }

T[K] extends string ? K : never conditional tipdir: xassə sətirdirsə açarı saxlayır, əks halda never verir.

Bir tip digərini açar-açar izləməlidirsə, mapped tiplər düzgün alətdir: hər form sahəsi üçün xəta, hər event üçün handler, hər resurs üçün yüklənmə bayrağı. Sənə yalnız bir neçə sabit açar lazımdırsa, onları sadəcə yaz.

MiddleTipik səhvlər

Daxili utility tiplərin tələləri

Daxili utility tiplər qısa təriflərdir və onların kənar halları elə bu təriflərdən irəli gəlir.

Omit açarlarını yoxlamır

TypeScript
type Post = { id: string; title: string; publishedAt: Date };

type Draft = Omit<Post, "publishedAtt">; // xəta yoxdur: publishedAt hələ də var
type Preview = Pick<Post, "titel">; // Error: Type '"titel"' does not satisfy the constraint 'keyof Post'.

Pick<T, K extends keyof T> açarları yoxlayır; Omit<T, K extends keyof any> isə istənilən sətri qəbul edir, ona görə yazı səhvi və ya adı dəyişdirilmiş sahə heç nəyi silmir və bunu heç kim görmür. Kod bazana bu yoxlama lazımdırsa, bir sətirlik type StrictOmit<T, K extends keyof T> = Omit<T, K> onu əlavə edir.

Pick və Omit union-ları düzləşdirir

TypeScript
type Shape =
  | { kind: "circle"; radius: number; id: string }
  | { kind: "square"; size: number; id: string };

type NewShape = Omit<Shape, "id">; // { kind: "circle" | "square" }

Union-ın keyof-u yalnız bütün üzvlərin ortaq açarlarını ehtiva edir, ona görə Omit kind-ı saxlayır, radius və size-ı isə itirir. yox olur. Omit-i hər üzvə ayrıca tətbiq et, union-ın hər üzvü üçün bir dəfə işləyən conditional tiplə:

TypeScript
type DistributiveOmit<T, K extends PropertyKey> = T extends unknown ? Omit<T, K> : never;

type NewShape2 = DistributiveOmit<Shape, "id">;
// { kind: "circle"; radius: number } | { kind: "square"; size: number }

Readonly dayazdır və yalnız tipdir

Readonly<Settings> settings.theme = "light" yazmağa imkan vermir, amma settings.tags.push("x") yenə kompilyasiya olunur, çünki Readonly dayazdır (shallow): yalnız yuxarı səviyyəli xassələri əhatə edir, içəridəki massiv isə readonly deyil. İcra zamanı da heç nə dəyişmir: obyekt dondurulmur və onu adi Settings kimi alan kod dəyişə bilər. İç-içə massivlər üçün readonly string[] və ya ReadonlyArray, icra zamanı qorunma lazımdırsa Object.freeze işlət (o da dayazdır).

Partial undefined qəbul edir

strict rejimində belə Partial<User> { email: undefined } qəbul edir. İstifadəçi obyektinə spread olunanda o, email-in üzərinə undefined yazır, nəticə isə yenə User kimi tiplənir. strict-in daxil etmədiyi exactOptionalPropertyTypes seçimi "yoxdur" ilə "undefined"-i fərqləndirir və belə çağırış kompilyasiya olunmur.

Record<string, T> hər açarın mövcud olduğunu iddia edir

const prices: Record<string, number> olanda armud olmasa belə prices["pear"] number-dir. Partial<Record<string, number>> (oxunuş number | undefined verir), Map işlət və ya noUncheckedIndexedAccess-i aç.

SeniorKonsepsiya

Template literal tiplər

Template literal tiplər JavaScript-in template sətir sintaksisini tip mövqeyində işlədir. Literal tiplərlə yeni literallar qurur, union-larla isə bütün kombinasiyaları:

TypeScript
type Size = "sm" | "md" | "lg";
type Tone = "primary" | "danger";

type ButtonClass = `btn-${Tone}-${Size}`;
// "btn-primary-sm" | "btn-primary-md" | "btn-primary-lg" | "btn-danger-sm" | ...

type Px = `${number}px`;
const width: Px = "12px"; // OK
const height: Px = "12em"; // Error: Type '"12em"' is not assignable to type '`${number}px`'.

type UserPath = `/users/${string}`;

${number} və ${string} şablondur: istənilən ədəd, istənilən sətir. Union bir neçə mövqedə olanda bütün kombinasiyalar alınır, ButtonClass-da göründüyü kimi: 2 ton və 3 ölçü 2 × 3 = 6 üzv verir.

TypeScript-də kompilyatorun özünün reallaşdırdığı dörd daxili sətir tipi də var: Uppercase, Lowercase, Capitalize və Uncapitalize. Onlar adlandırma qaydalarını yoxlanıla bilən edir:

TypeScript
type HandlerName<E extends string> = `on${Capitalize<E>}`;
type Handlers = HandlerName<"click" | "focus">; // "onClick" | "onFocus"

infer ilə sətirləri hissələrə ayırmaq

Conditional tipdə template literal şablon kimi işləyir, infer isə hissələri tutur. Bu tip, tiplənmiş router-lərin etdiyi kimi, marşrut yolundan parametr adlarını oxuyur:

TypeScript
type RouteParams<S extends string> =
  S extends `${string}:${infer Param}/${infer Rest}`
    ? Param | RouteParams<`/${Rest}`>
    : S extends `${string}:${infer Param}`
      ? Param
      : never;

type Params = RouteParams<"/users/:userId/posts/:postId">; // "userId" | "postId"
type None = RouteParams<"/about">; // never

Tip rekursivdir: hər addımda ilk :param-ı götürür və yolun qalanı üçün özünü çağırır.

Union-ları kiçik saxla

Kombinasiyaların sayı sürətlə artır. Hər birində on variant olan üç mövqe 1000 üzv verir və tip yoxlayıcısı dəyərləri onların hamısı ilə müqayisə edir. Müəyyən həddən sonra TypeScript "Expression produces a union type that is too complex to represent." xətası ilə dayanır. Handbook böyük sətir union-larını tiplərdə hesablamaq əvəzinə əvvəlcədən generasiya etməyi tövsiyə edir; template literal tiplər bir neçə üzvlə ən yaxşı işləyir: class adı variantları, event və handler adları, marşrut şablonları, CSS vahidləri.

SeniorKonsepsiya

Conditional tiplər və infer

iki tip arasında seçim edir: T extends U ? X : Y T U-ya mənimsədilə bilirsə X, əks halda Y olur. Konkret tiplə dərhal həll olunur; tip parametri ilə isə parametr məlum olana qədər gözləyir.

TypeScript
type IsString<T> = T extends string ? "yes" : "no";

type A = IsString<"hello">; // "yes"
type B = IsString<number>; // "no"

Tək başına bu, tip səviyyəsində if-dir. Conditional tiplər infer ilə faydalı olur.

infer: tiplər üzərində şablon uyğunluğu

extends hissəsinin içində infer X tip dəyişəni elan edir və TypeScript onu uyğunluqdan doldurur. Standart kitabxana tipləri hissələrə belə ayırır:

TypeScript
type ReturnType<T extends (...args: any) => any> = T extends (...args: any) => infer R ? R : any;
type Parameters<T extends (...args: any) => any> = T extends (...args: infer P) => any ? P : never;

"T funksiyadırsa, onun qaytarma tipini R adlandır və mənə R-i ver." Eyni şablon sənin öz tiplərin üçün də işləyir:

TypeScript
type ElementType<T> = T extends readonly (infer U)[] ? U : T;
type E1 = ElementType<string[]>; // string
type E2 = ElementType<string>; // string

type PropsOf<C> = C extends (props: infer P) => unknown ? P : never;
type ButtonProps = PropsOf<typeof Button>; // funksiya komponentinin props tipi

type Unwrap<T> = T extends Promise<infer V> ? V : T;
type U1 = Unwrap<Promise<Promise<number>>>; // Promise<number>: yalnız bir səviyyə

Unwrap bir səviyyədən sonra dayanır, çünki özünü çağırmır; daxili Awaited isə rekursivdir, ona görə Awaited<Promise<Promise<number>>> number-dir.

Hədd: conditional qaytarma tipli generic funksiyalar

Conditional qaytarma tipi dəqiq imza kimi görünür, amma funksiyanın gövdəsi onu ödəyə bilmir:

TypeScript
function label<T extends string | number>(value: T): T extends string ? "text" : "number" {
  return typeof value === "string" ? "text" : "number"; // Error: Type '"text"' is not assignable to type 'T extends string ? "text" : "number"'.
}

typeof value === "string" T-ni yox, value-nu daraldır, ona görə TypeScript hansı budağın keçərli olduğuna qərar verə bilmir və tip funksiyanın içində həll olunmamış qalır. Adi cavablar: hər hal üçün bir funksiya overload-u və ya yaxşı test olunmuş yerdə tək bir assertion. Bu qədər kiçik funksiya üçün çağıranların bu dəqiqliyə ümumiyyətlə ehtiyacı olub-olmadığını soruş; "text" | "number" qaytarma tipi dürüstdür və heç bir hiylə tələb etmir.

SeniorKonsepsiya

Union-lar üzrə paylanma

Yoxlanılan tip sadə tip parametri olanda və ona union ötürəndə, conditional tip hər üzvə ayrıca tətbiq olunur və nəticələr yeni union-da birləşir:

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

type A = ToArray<string | number>; // string[] | number[], (string | number)[] yox

Handbook bunu distributive conditional tip adlandırır və Exclude ilə Extract-ı işlədən də budur:

TypeScript
type Exclude<T, U> = T extends U ? never : T;
type Extract<T, U> = T extends U ? T : never;

type Events = "click" | "focus" | "blur";
type NoBlur = Exclude<Events, "blur">; // "click" | "focus"

Hər üzv ayrıca yoxlanılır; never-ə çevrilənlər yox olur, çünki never boş union-dır.

Paylanmanı söndürmək

Paylanma yalnız yoxlanılan tip bükülməmiş (naked) tip parametri olanda baş verir. Union-ı bütöv yoxlamaq üçün extends-in hər iki tərəfini bir elementli tuple-a sar:

TypeScript
type ToArrayAll<T> = [T] extends [unknown] ? T[] : never;
type B = ToArrayAll<string | number>; // (string | number)[]

type IsString<T> = T extends string ? "yes" : "no";
type IsOnlyString<T> = [T] extends [string] ? "yes" : "no";

type C = IsString<string | number>; // "yes" | "no"
type D = IsOnlyString<string | number>; // "no"

İki sürpriz

  • boolean true | false-dur, ona görə o da paylanır: paylanan mövqedə boolean extends true ? … : … hər iki budağı verir.
  • never boş union-dır, ona görə onun üzrə paylanma budaqlardan heç birini yox, never verir:
TypeScript
type IsNever<T> = T extends never ? true : false;
type E = IsNever<never>; // never

type IsNeverFixed<T> = [T] extends [never] ? true : false;
type F = IsNeverFixed<never>; // true

Hansı sənə lazımdır

Hər üzvü çevirəndə paylanma düzgündür: Exclude, Extract, discriminated union-ı bütöv saxlayan Omit, hər event üçün handler tipi. Tip haqqında bütövlükdə sual verəndə parametri [ ]-yə sar: o never-dirmi, dəqiq string-dirmi, ümumiyyətlə union-dırmı. Əllə yazılmış conditional tiplərin çaşdırıcı nəticələrinin çoxu tipin bu ikisindən hansını etdiyini unutmaqdan yaranır; nəticə səni təəccübləndirirsə, yoxlanılan tipin sadə tip parametri olub-olmadığına bax.

SeniorTipik səhvlər

Tip səviyyəsində kod nə vaxt həddən artıq mürəkkəbləşir

Tip səviyyəsində kod da koddur. Kimsə onu oxumalı, kompilyator onu icra etməli olur, yaratdığı xətalar isə başqalarının qarşısına çıxır. Düzgün tiplər də pis seçim ola bilər.

Qiyməti nədir

  • Oxunaqlılıq. Bu tip obyektin bütün nöqtəli yollarını verir, məsələn "a" | "a.b" | "a.b.c":
TypeScript
type Paths<T> = T extends object
  ? { [K in keyof T & string]: K | `${K}.${Paths<T[K]>}` }[keyof T & string]
  : never;

O, eyni anda conditional tip, mapped tip, indexed access, template literal və rekursiya işlədir. Komanda yoldaşlarının çoxu onu çağıra bilər; azı onu təhlükəsiz dəyişə bilər.

  • Xəta mesajları. Səhv çağırış niyyəti yox, hesablanmış tipi göstərir: Paths<Config> gözlənilən yerə "a.b.x" ötürmək xəta verir, çünki o, bütün düzgün yolların union-ına mənimsədilə bilmir. Kiçik konfiqurasiya üçün bu normaldır; böyük konfiqurasiyada isə mesaj yollardan ibarət divara çevrilir.
  • Kompilyasiya vaxtı və hədlər. Hər instantiation tip yoxlayıcısı üçün işdir və redaktor bunu hər düymə basılanda təkrarlayır. Dərin rekursiya "Type instantiation is excessively deep and possibly infinite." xətası ilə dayanır. tsc --extendedDiagnostics instantiation sayını və yoxlama vaxtını çap edir, tsc --generateTrace <dir> isə hansı tiplərin yavaş olduğunu göstərən trace yazır.
  • Yalançı əminlik. Hesablanmış tip icra zamanı kodun nə etməli olduğunu təsvir edir; onlar arasındakı əlaqə çox vaxt return out as Getters<T> kimi cast olur və onu heç nə yoxlamır. İmplementasiyadakı səhv dəqiq görünən tipin arxasında gözdən qaçır.

Əvəzində nə etməli

  • Tipin hansı bug-ın qarşısını aldığını soruş. Beş marşrutdan ibarət əllə yazılmış union, sadə string üstəgəl bir icra zamanı yoxlaması və ya adlı obyekt tipi eyni səhvləri tutursa, onu seç.
  • Mürəkkəb tipləri bir yerdə saxla, adətən ortaq modulda və ya kitabxana sərhədində, tətbiq kodu isə onları adla işlətsin.
  • Hər şeyi bir ifadəyə yığmaq əvəzinə aralıq addımlara ad ver (type Keys = …, type Mapped = …) və giriş-çıxış nümunəsi olan şərh yaz.
  • Tipləri test et: kompilyasiya olunmalı çağırışlar və olunmamalı, // @ts-expect-error ilə işarələnmiş çağırışlar, CI-da tsc ilə yoxlanılsın. Cast-ın arxasındakı icra zamanı kodu da test et.

Bir çox komanda üçün işləyən sərhəd belədir və bu, dilin qaydası yox, mühakimə məsələsidir: real səhvləri tutduğu kənarlarda dəqiq tiplər, insanların hər gün kodu oxuyub dəyişdiyi ortada isə sadə tiplər.

SeniorMüsahibə məsləhətləri

Müsahibə üçün məsləhətlər

30 saniyəlik cavab. "TypeScript tipləri başqa tiplərdən hesablaya bilir. typeof, keyof və indexed access tipləri dəyərlərdən və bir-birindən törədir. Partial, Pick, Omit, Record və ReturnType kimi utility tiplər standart kitabxanadakı generic tiplərdir, əksəriyyəti mapped tiplərdir: açarlar üzrə dövr edir, readonly və ? əlavə edə və ya silə, as ilə açarların adını dəyişə bilirlər. Conditional tiplər T extends U ? X : Y ilə tip seçir, infer uyğunluqdan tipləri çıxarır, union üzərində isə parametri tuple-a sarmasan, üzv-üzv paylanır. Mən onları bir həqiqət mənbəyi saxlamaq üçün işlədirəm və komandanın oxuya biləcəyi qədər sadə saxlayıram."

Gözlənilən suallar

  • Partial, Readonly, Pick və ya Record-u reallaşdır. keyof T (və ya K) üzrə düzgün modifikatorlu mapped tip; Pick-ə K extends keyof T lazımdır.
  • ReturnType, Parameters və ya ElementType reallaşdır. Uyğun mövqedə infer olan conditional tip.
  • Pick ilə Omit-in fərqi nədir? "Saxla və ya sil"-dən əlavə: Omit açarlarını yoxlamır və hər ikisi union-ları düzləşdirir.
  • IsString<string | number> nə verir və niyə? Hər iki budağı, çünki conditional tip paylanır; [T] extends [string] union-ı bütöv yoxlayır.
  • Dəyərlər massivindən union tipi necə alırsan? as const üstəgəl (typeof ARR)[number].
  • Awaited nə üçündür? Promise-in dəyər tipi, rekursiv açılmış; async funksiya üçün adətən Awaited<ReturnType<typeof fn>>.

Bal itirdən səhvlər

  • Readonly<T>-ni dəyişməzlik saymaq: o dayazdır və icra zamanı heç bir təsiri yoxdur.
  • Discriminated union-a Omit tətbiq edib variant sahələrinin hara getdiyinə təəccüblənmək.
  • as const-u unudub törədilmiş tipin niyə string olduğuna təəccüblənmək.
  • Əllə yazılmış beş üzvlü union-ın kifayət etdiyi yerdə dərin rekursiv tip yazmaq.
  • never-in never-ə paylandığını bilməmək.

Senior səviyyəni göstərən məqamlar

Trade-off-lardan danış. Tipləri köçürmək yox, törətdiyini göstər, eyni zamanda törətmənin nə vaxt həddən artıq bağlılıq yaratdığını da bildiyini: export olunan API adlı, açıq yazılmış tipə layiqdir. Ağıllı tiplərin qiymətini (oxunmayan xətalar, tip yoxlayıcısının vaxtı, tipi icra zamanına bağlayan cast) və onları necə məhdudlaşdıracağını qeyd et: bir modul, adlı aralıq tiplər, CI-da tip testləri. DistributiveOmit yaza bilirsənsə, ona niyə T extends unknown lazım olduğunu bir cümlə ilə izah et.

MiddleYoxlama siyahısı

Tip çevrilmələrini review edərkən nəyi yoxlamalı

Özün yazmadığın tipləri review edəndə bu siyahıdan istifadə et: komanda yoldaşının pull request-i, kitabxananın nümunəsi, AI assistentin təklifi. Törədilmiş və hesablanmış tiplər səssizcə sınır; qiyməti sonra ortaya çıxır: artıq dataya uyğun gəlməyən tip və ya heç kimin oxuya bilmədiyi xəta mesajı kimi.

  • Tip mənbəyindən törədilib, yoxsa ondan köçürülüb? API tipinin, funksiyanın qaytardığı dəyərin və ya icazə verilən dəyərlər siyahısının əllə yazılmış surəti orijinal dəyişən kimi ondan ayrı düşür. İkinci tərif görünən yerdə typeof, keyof, ReturnType və as const massivləri axtar.
  • Omit-ə ötürülən açarlar mövcuddurmu? Omit istənilən sətri qəbul edir, ona görə yazı səhvi və ya adı dəyişdirilmiş sahə heç nəyi silmir. Redaktorda nəticənin üzərinə hover et, ya da naməlum açarları rədd edən Pick və ya açarları yoxlayan Omit işlət.
  • Omit və ya Pick union-a tətbiq olunub? Onlar yalnız bütün üzvlərin ortaq açarlarını saxlayır, ona görə discriminated union variant sahələri olmayan tək obyektə çevrilir. Nəticənin üzərinə hover et; union qalmalıdırsa, distributive versiyanı işlət.
  • Readonly və ya Partial verdiyindən çoxunu vəd edir? Readonly dayazdır və icra zamanı heç nə etmir; Partial çağıranlara açıq şəkildə undefined ötürməyə imkan verir. İç-içə massiv və obyektləri, partial obyektin spread-inin məcburi sahələrə nə etdiyini yoxla.
  • Hesablanmış tip icra zamanı koda cast ilə bağlanıb? Açarları yenidən adlandırılan mapped tiplər və conditional qaytarma tipləri çox vaxt as SomeType ilə bitir. İmplementasiyanı tiplə yanaşı oxu və ya işə sal, yaradılan açar və dəyərlərin həqiqətən uyğun gəldiyini yoxla.
  • Conditional tip paylanmamalı olduğu yerdə paylanır, yoxsa əksinə? Qısa tip testində ona union və never ver: IsString kimi "sual" tipinə adətən [T] extends [U] lazımdır.
  • Komanda yoldaşı tipi və onun yaratdığı xətaları oxuya bilirmi? Çağırış yerində qəsdən səhv et və mesajı oxu. O, generasiya olunmuş üzvlərdən ibarət divardırsa və ya tsc --extendedDiagnostics instantiation sayının sıçradığını göstərirsə, sadələşdir və ya addımlara ad ver.

Özünü yoxla

  • Məşq

    Kodun nəticəsini təxmin et, açıq müsahibə suallarına cavab ver və özünü qiymətləndir.

    3 nəticə sualı · 4 açıq sual

  • Quiz

    İzahlı test sualları və yekun nəticə.

    7 sual