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

TypeScript

Narrowing, type guard-lar və unknown

TypeScript union tipləri adi JavaScript yoxlamalarına (typeof, truthiness, bərabərlik, in, instanceof) əsasən necə dəqiqləşdirir, control-flow analizi onları necə izləyir və harada dayanır, unknown və tutulmuş xətalar, tamlıq yoxlaması ilə discriminated union-lar və yalan deyə bilən type guard-lar.

JuniorMiddleSeniorYenilənib: 16 noyabr 2026

Oxu səviyyəsi

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

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

JuniorKonsepsiya

Union tiplər və narrowing

JavaScript-də dəyərin çox vaxt birdən artıq mümkün tipi olur. Funksiya id-ni string və ya ədəd kimi qəbul edə bilər; document.querySelector element və ya null qaytarır; optional parametr ya dəyərdir, ya da undefined. TypeScript bunu | ilə union tip kimi yazır:

TypeScript
function formatId(id: string | number): string {
  return id.toUpperCase();
  // xəta: Property 'toUpperCase' does not exist on type 'string | number'.
  //   Property 'toUpperCase' does not exist on type 'number'.
}

Union tipli dəyər onun istənilən üzvü ola bilər, ona görə TypeScript yalnız bütün üzvlərin dəstəklədiyi əməliyyatlara icazə verir. id.toString() problem deyil, çünki o, həm string-lərdə, həm də ədədlərdə var; toUpperCase isə yalnız string-lərdədir.

Bir üzvə aid hissələrdən istifadə etmək üçün adi JavaScript ilə dəyərin hansı üzv olduğunu yoxla:

TypeScript
function formatId(id: string | number): string {
  if (typeof id === "string") {
    return id.toUpperCase(); // burada id string-dir
  }
  return id.toFixed(0); // burada id number-dir
}

if-in içində TypeScript id-nin string olduğunu bilir; ondan sonra yalnız number qalır. Elan olunmuş tipin koddakı yoxlamalara əsasən daha konkret tipə endirilməsinə (narrowing), bunu edən yoxlamalara isə deyilir. İcra zamanı yeni heç nə baş vermir: typeof id === "string" adi JavaScript-dir və TypeScript onu sənin oxuduğun kimi oxuyur.

Literal tiplərin union-ları da eyni dərəcədə geniş yayılıb:

TypeScript
type Theme = "light" | "dark" | "system";

function applyTheme(theme: Theme) {
  if (theme === "system") {
    // theme "system"-dir
  } else {
    // theme "light" | "dark"-dır
  }
}

strictNullChecks qoşulu olanda null və undefined digərləri kimi union üzvləridir: string | null dəyərində string metodunu çağırmazdan əvvəl onu daraltmaq lazımdır. Gündəlik kodda daraltmanın çoxu məhz burada baş verir: olmaya biləcək element, optional prop, find-ın nəticəsi.

Mövzunun qalan hissəsi TypeScript-in hansı yoxlamaları başa düşdüyündən, onları kodda necə izlədiyindən və harada izləməyi dayandırdığından bəhs edir.

JuniorKonsepsiya

typeof və truthiness yoxlamaları

typeof sabit sətirlər dəstindən birini qaytarır və TypeScript onların hər biri ilə daraldır: "string", "number", "bigint", "boolean", "symbol", "undefined", "object" və "function".

TypeScript
function padLeft(padding: number | string, input: string): string {
  if (typeof padding === "number") {
    return " ".repeat(padding) + input;
  }
  return padding + input;
}

typeof null tələsi

JavaScript-də typeof null "object"-dir; bu, TypeScript-in də olduğu kimi modelləşdirdiyi tarixi təsadüfdür:

TypeScript
function printAll(items: string[] | null) {
  if (typeof items === "object") {
    for (const item of items) console.log(item);
    // xəta: 'items' is possibly 'null'.
  }
}

Yoxlama items-i string[]-ə yox, string[] | null-a daraltdı. null ilə açıq müqayisə et (items !== null) və ya massivə qədər daraldan Array.isArray(items) işlət.

Truthiness

if (value) da daraldır: true budağında null və undefined qalmır. JavaScript-də falsy dəyərlər false, 0, -0, 0n, "", NaN, null və undefined-dir (üstəgəl köhnə document.all), tələ isə ondadır ki, onların bəziləri düzgün datadır:

TypeScript
function unreadLabel(count: number | undefined): string {
  if (count) return `${count} unread`;
  return "Loading...";
}

unreadLabel(0); // "Loading...", halbuki oxunmamışların sayının 0 olduğunu bilirik

TypeScript bu kodu qəbul edir. False budağında count yenə number | undefined-dir, çünki ədəd falsy ola bilər: tiplər düzgündür, məntiq səhvdir. Dəyərin 0, "" və ya NaN olması normaldırsa, nəyi nəzərdə tutduğunu açıq yaz:

TypeScript
if (count !== undefined) return `${count} unread`;

Default dəyərlərdə də vəziyyət eynidir: count || 10 0-ı 10 ilə əvəz edir, count ?? 10 isə yalnız null və undefined-i.

Truthiness obyektlər və massivlər üçün düzgün yoxlamadır: onlar boş olanda da truthy-dir. user: User | null olanda if (user) etibarlı şəkildə "istifadəçi var" deməkdir. String və ədədlər üçün isə açıq müqayisəyə üstünlük ver.

JuniorKonsepsiya

Bərabərlik, in və instanceof

Bərabərlik. ===, !==, == və ya != ilə müqayisə daraldır. Literal ilə müqayisə həmin literala qədər daraldır, theme === "system"-də olduğu kimi. null ilə müqayisə qeyri-sərt bərabərliyin (==, !=) idiomatik sayıldığı yeganə haldır: value != null həm null-u, həm də undefined-i istisna edir.

TypeScript
function displayName(name: string | null | undefined): string {
  if (name != null) {
    return name.trim(); // string
  }
  return "Anonymous";
}

in operatoru obyektdə xassənin olub-olmadığını yoxlayır və union-ı həmin xassəyə malik üzvlərə qədər daraldır:

TypeScript
type Fish = { name: string; swim(): void };
type Bird = { name: string; fly(): void };

function move(animal: Fish | Bird) {
  if ("swim" in animal) {
    animal.swim(); // Fish
  } else {
    animal.fly(); // Bird
  }
}

Üzvlərdən biri xassəni optional elan edibsə, həmin üzv hər iki budaqda qalır, çünki xassə ola da bilər, olmaya da.

instanceof klassa qədər daraldır: value instanceof Date, error instanceof TypeError, event.target instanceof HTMLInputElement. O, klasslar icra zamanı mövcud olduğu üçün işləyir; mövcud olmayan interface və type alias-lar üçün isə işləmir.

TypeScript
function toDate(input: Date | string): Date {
  return input instanceof Date ? input : new Date(input);
}

function onInput(event: Event) {
  if (event.target instanceof HTMLInputElement) {
    console.log(event.target.value); // event.target HTMLInputElement-dir
  }
}

İki xəbərdarlıq. instanceof prototip zəncirini yoxlayır, ona görə realm-lar arasında işləmir: iframe-də yaradılmış massiv əsas pəncərədə instanceof Array deyil; Array.isArray məhz buna görə var və TypeScript onunla da daraldır. Üstəlik, sadəcə düzgün formaya malik obyekt nümunə (instance) deyil: klass tipi gözlənilən yerə ötürülmüş adi obyekt tip yoxlamasından keçir, amma instanceof-dan keçmir.

Yoxlamanı seçmək

  • Primitiv (string, number, boolean, undefined): typeof.
  • null və ya literal dəyər: === və ya !==; həm null, həm undefined üçün != null.
  • Xassəsinə görə fərqlənən obyekt tipləri: in, daha yaxşısı isə middle bölmələrində bəhs olunan ortaq literal sahə.
  • Klass nümunələri, daxili obyektlər, DOM elementləri: instanceof.
  • Massivlər: Array.isArray.

Bunların hər biri onsuz da yazacağın adi JavaScript-dir. TypeScript-in töhfəsi nəticəni ardınca gələn kod üçün yadda saxlamaqdır.

MiddleKonsepsiya

Control-flow analizi

TypeScript yalnız ən yaxın if-ə baxmır. O, funksiyadakı hər yolu (return-lər, throw-lar, mənimsətmələr, &&, ||, ?:, dövrlər) izləyir və hər nöqtədə hər dəyişənin tipini hesablayır. Handbook bunu control-flow analysis, yəni idarəetmə axınının analizi adlandırır.

Erkən return-lər özlərindən sonrakı hər şeyi daraldır, bu da əsas yolu düz saxlayır:

TypeScript
function sendWelcome(user: User | null, email: string | undefined) {
  if (!user) return;
  if (email === undefined) throw new Error("No email");

  // burada user User, email isə string-dir
  mailer.send(email, `Welcome, ${user.name}`);
}

Mənimsətmələr elan olunmuş tip daxilində mənimsədilən tipə qədər daraldır:

TypeScript
let input: string | number = readInput();
input = String(input); // bundan sonra input string-dir
input.trim();

Sabitlərdə saxlanan şərtlər də işləyir, bir şərtlə ki, yoxladıqları şey dəyişə bilməsin: const, readonly xassə və ya heç vaxt yenidən mənimsədilməyən parametr.

TypeScript
function shout(value: unknown) {
  const isText = typeof value === "string";
  if (isText) {
    return value.toUpperCase(); // value string-dir
  }
}

&&, || və ?: sağ tərəflərini və budaqlarını daraldır: user !== null && user.name.length > 0 ifadəsində &&-dən sonra user User-dir.

Daraltma referansa aiddir

Hər daraltma bir referansa bağlıdır: dəyişənə, parametrə və ya order.customer.address kimi xassə yoluna. TypeScript həmin yolun daraltmasını ona və ya valideynlərindən birinə nəsə mənimsədilənə qədər saxlayır:

TypeScript
if (order.customer.address !== null) {
  order.customer.address.city; // Address
  order.customer = loadCustomer();
  order.customer.address.city;
  // xəta: 'order.customer.address' is possibly 'null'.
}

order.customer-ə mənimsətmə onun altındakı hər şeyin daraltmasını sıfırlayır və bu, tamamilə düzgündür: yeni müştərinin ünvanı olmaya bilər.

Daraltmanı təbii hiss etdirən də budur: JavaScript-də onsuz da yazacağın yoxlamaları yazırsan, tiplər də ardınca gəlir. Analizin məhdudiyyətlərinin səbəbi də budur. TypeScript hər dəfə bir funksiya üzərində düşünür, çağırdığın funksiyaların və ötürdüyün callback-lərin içinə baxmır, ona görə yoxlama ilə istifadə arasında dəyərə nə baş verdiyini tam bilə bilmir. Növbəti bölmə bunun harada vacib olduğunu göstərir.

MiddleTipik səhvlər

Daraltma harada itir

Üç vəziyyət yoxlama ilə sonrakı istifadə arasındakı əlaqəni qırır. Onlardan ikisində TypeScript sənin gördüyün daraltmanı unudur; üçüncüsündə isə artıq doğru olmayan daraltmanı saxlayır.

1. Callback-in içində oxunan xassə. Callback daha sonra, xassə artıq dəyişmiş ola biləndə işləyə bilər, ona görə TypeScript onun içində xassə yolunun daraltmasını atır:

TypeScript
function notifyAll(session: Session, ids: string[]) {
  if (session.user !== null) {
    ids.forEach((id) => {
      send(id, session.user.name);
      // xəta: 'session.user' is possibly 'null'.
    });
  }
}

Yoxlamadan dərhal sonra dəyəri const-a köçür: const user = session.user;. const-a yenidən dəyər mənimsətmək olmur, ona görə onun daraltması hər callback-də qüvvədə qalır.

2. Yenidən mənimsədilən let dəyişəni və ya parametr. TypeScript 5.4-dən bəri let dəyişəninin və ya parametrin daraltması son mənimsətmədən sonra yaradılan closure-a keçir:

TypeScript
function schedule(label: string | undefined) {
  if (label === undefined) label = "untitled";
  setTimeout(() => console.log(label.toUpperCase())); // OK: bundan sonra mənimsətmə yoxdur
}

label-ə setTimeout sətrindən sonra və ya hər hansı daxili funksiyanın içində yenidən dəyər mənimsət, closure yenə string | undefined görəcək. Həll eynidir: const surəti.

3. Yoxladığın şeyi dəyişən funksiya çağırışı. TypeScript funksiya çağırılanda daraltmanı sıfırlamır: hər çağırış hər yoxlamanı ləğv edə bilsəydi, daraltmanın faydası qalmazdı. Ona görə bu kod kompilyasiya olunur və çökür:

TypeScript
function farewell(session: Session): string {
  if (session.user !== null) {
    signOut(session); // session.user = null edir
    return `Bye, ${session.user.name}`; // kompilyasiya olunur; icra zamanı TypeError
  }
  return "Nobody to sign out";
}

Handbook bunu açıq deyir: TypeScript kompilyasiya zamanı təhlükəsiz olduğu bilinməyən bəzi əməliyyatlara icazə verir, yəni tip sistemi sound deyil. Burada da çarə çağırışdan əvvəl alınmış const surəti və ya ortaq state-i oxucudan xəbərsiz dəyişməyən koddur.

Nə etməməli

İlk iki halda cazibədar "düzəliş" non-null assertion-dır: session.user!.name. O, heç nəyi sübut etmədən xətanı yox edir, üçüncü halda isə bug-ı hətta gizlədərdi. TypeScript daraltmanı itirəndə soruş: yoxlama ilə istifadə arasında dəyəri nə dəyişə bilər? Cavab "heç nə"dirsə, onu const-a köçür; "nəsə"dirsə, düzəldilməli bug elə odur.

MiddleKonsepsiya

unknown və tutulmuş xətalar

unknown any-nin tip baxımından təhlükəsiz qarşılığıdır. Hər ikisi istənilən dəyəri qəbul edir; any ilə sonra hər şeyi edə bilərsən, unknown ilə isə daraldana qədər heç nəyi. Buna görə forması hələ yoxlanmamış dəyərlər üçün düzgün tip unknown-dur: parse olunmuş JSON, postMessage datası, catch blokundakı dəyər.

unknown-u daraltmaq eyni yoxlamalarla, addım-addım aparılır:

TypeScript
function readName(data: unknown): string | undefined {
  if (
    typeof data === "object" &&
    data !== null &&
    "name" in data &&
    typeof data.name === "string"
  ) {
    return data.name; // string
  }
  return undefined;
}

typeof data === "object" object | null saxlayır (yenə typeof null tələsi), data !== null object saxlayır, TypeScript 4.9-dan bəri isə "name" in data tipi unknown olan name xassəsi əlavə edir, sonuncu yoxlama da onu string-ə qədər daraldır. Bir-iki sahədən böyük hər şey üçün bu, uzun alınır və sxem kitabxanası daha yaxşı alətə çevrilir; ayrıca mövzudur.

Tutulmuş xətalar

JavaScript-də hər şeyi throw etmək olar: Error, string, ədəd, kitabxananın öz obyekti. strict rejimində (dəqiq desək, TypeScript 4.4-də əlavə olunan useUnknownInCatchVariables ilə) catch blokunun dəyişəni unknown-dur:

TypeScript
async function save(draft: Draft) {
  try {
    await saveDraft(draft);
  } catch (error) {
    console.error(error.message);
    // xəta: 'error' is of type 'unknown'.

    const message = error instanceof Error ? error.message : String(error);
    showToast(`Could not save: ${message}`);
  }
}

Adi daraltma instanceof Error-dur, öz xəta klasslarını yoxlamaq (error instanceof HttpError) isə hər növü ayrıca emal etməyə imkan verir. Dəyişəni Error kimi annotasiya edə bilməzsən: TypeScript orada yalnız any və ya unknown qəbul edir ("Catch clause variable type annotation must be 'any' or 'unknown' if specified."), çünki nəyin throw olunduğuna heç nə zəmanət vermir. catch (error: any) bir blok üçün bu qaydadan imtina edir və yoxlanmamış xassə müraciətini geri qaytarır: string throw olunubsa, error.message sadəcə undefined olur, error.message.includes(...) isə xəta handler-inin özündə çökür.

any, yoxsa unknown?

any dəyərə etibar edir və heç nəyi yoxlamır; unknown heç nəyə etibar etmir və səni yoxlamağa məcbur edir. Kənardan daxil olan hər dəyər üçün unknown işlət, onu sərhəddə bir dəfə daralt və irəli dəqiq tiplər ötür. any yalnız yoxlamanın niyə mümkünsüz və ya mənasız olduğunu şərhdə izah edə bildiyin yerdə qəbul edilə bilər.

MiddleNümunə

Discriminated union-lar və tamlıq yoxlaması

State üçün geniş yayılmış forma bir neçə variantdır; hər variantda onun hansı variant olduğunu deyən literal sahə olur:

TypeScript
type RequestState =
  | { status: "loading" }
  | { status: "success"; data: string[] }
  | { status: "error"; error: Error };

Union-ın bütün üzvlərində literal tipli ortaq xassə olanda TypeScript onu kimi qəbul edir və həmin xassəni yoxlamaq bütöv obyekti daraldır:

TypeScript
function render(state: RequestState): string {
  switch (state.status) {
    case "loading":
      return "Loading...";
    case "success":
      return state.data.join(", "); // burada state-də data var
    case "error":
      return state.error.message; // burada isə error
  }
}

switch-dən kənarda state.data xətadır ("Property 'data' does not exist on type 'RequestState'") və məqsəd də elə budur. Bunu optional sahələrdən ibarət tək obyektlə müqayisə et: { loading: boolean; data?: string[]; error?: Error }. O, "yüklənir, həm data, həm də xəta var" vəziyyətinə icazə verir və hər yerdə hər sahəni yoxlamağa məcbur edir. Union isə belə mümkünsüz vəziyyətləri yazmağı mümkünsüz edir.

Tamlıq yoxlaması

Yeni variant əlavə olunanda union üzərindəki hər switch onu emal etməlidir. Qoy onları kompilyator tapsın:

TypeScript
function assertNever(value: never): never {
  throw new Error(`Unhandled value: ${JSON.stringify(value)}`);
}

function render(state: RequestState): string {
  switch (state.status) {
    case "loading":
      return "Loading...";
    case "success":
      return state.data.join(", ");
    case "error":
      return state.error.message;
    default:
      return assertNever(state);
  }
}

default-da bütün variantlar artıq istisna olunub, ona görə state never-dir və çağırış kompilyasiya olunur. Union-a { status: "idle" } əlavə et, çağırış xətaya çevriləcək: "Argument of type '{ status: "idle"; }' is not assignable to parameter of type 'never'." Handbook bunun əvəzinə dəyişənə mənimsədir (const _exhaustiveCheck: never = state;), state satisfies never; da işləyir. default olmadan çatışmayan halı təkcə qaytarma tipi də tutur: "Function lacks ending return statement and return type does not include 'undefined'."

assertNever-dəki throw vacibdir, çünki tiplər silinir. Server union-da olmayan status göndərsə, kod icra zamanı default-a çatır və aydın xəta səssizcə səhv göstərilən ekrandan yaxşıdır.

SeniorKonsepsiya

Type guard-lar, assertion funksiyaları və onlar necə yalan deyir

Yoxlama uzundursa və ya ada ehtiyacı varsa, onu type predicate qaytaran funksiyaya köçür:

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

function isUser(value: unknown): value is User {
  return (
    typeof value === "object" &&
    value !== null &&
    "id" in value &&
    typeof value.id === "number" &&
    "name" in value &&
    typeof value.name === "string"
  );
}

if (isUser(data)) {
  data.name; // data User-dir
}

const users = rows.filter(isUser); // User[]

value is User belə deməkdir: bu funksiya true qaytarırsa, value User-dir; false qaytarırsa, deyil. Çağırış daxili yoxlama kimi daraldır, filter isə predicate-dən massivi daraltmaq üçün istifadə edir.

Assertion funksiyası false qaytarmaq əvəzinə xəta ataraq daraldır:

TypeScript
function assertIsUser(value: unknown): asserts value is User {
  if (!isUser(value)) throw new Error("Expected a user");
}

assertIsUser(data);
data.name; // scope-un qalan hissəsində data User-dir

Digər forma, asserts condition, Node-un assert-i kimi işləyir: assert(root !== null, "No #root")-dan sonra root daralmış olur. Bir qayda çoxlarını təəccübləndirir: assertion funksiyası açıq tipi olan ad vasitəsilə çağırılmalıdır. Tip annotasiyası olmayan const-a mənimsədilmiş arrow funksiya və ya tipsiz obyekt literalının metodu belə xəta verir: "Assertions require every name in the call target to be declared with an explicit type annotation."

Guard bir iddiadır

TypeScript guard-ın gövdəsinin onun predicate-ini sübut edib-etmədiyini yoxlamır. Bu kod kompilyasiya olunur:

TypeScript
function isUser(value: unknown): value is User {
  return typeof value === "object" && value !== null; // id və name unudulub
}

İndi null olmayan hər obyekt User kimi keçir, çökmə isə çox uzaqda, hansısa kodun user.name.trim() çağırdığı yerdə baş verir. TypeScript 5.5-in buraxılış qeydləri bunu birbaşa deyir: açıq yazılmış type predicate-lər type assertion-dan daha təhlükəsiz deyil. Kompilyatorun yoxladığı yeganə şey predicate tipinin parametrin tipinə mənimsədilə bilməsidir.

Ona görə əl ilə yazılmış guard-a as kimi yanaş. Guard-ları az və kiçik saxla, tipin vəd etdiyi hər sahəni yoxla (və ya yoxlamanı da, tipi də bir sxemdən çıxar) və hər guard-ı uğursuz olmalı olan girişlə test et: sahəsi çatışmayan obyekt, səhv tipli sahə, null, string.

SeniorKonsepsiya

Çıxarılan type predicate-lər

TypeScript 5.5-dən əvvəl undefined-ləri filtrləmək massivin tipini dəyişmirdi:

TypeScript
const nicknames = users.map((u) => u.nickname); // (string | undefined)[]
const present = nicknames.filter((n) => n !== undefined);
// TypeScript 5.5 və sonra: string[]
// 5.5-dən əvvəl: (string | undefined)[]

5.5-dən bəri TypeScript (n) => n !== undefined kimi funksiya üçün type predicate-i özü çıxarır, sanki (n): n is string => ... yazmısan. Buraxılış qeydləri şərtləri sadalayır:

  1. Funksiyanın açıq qaytarma tipi və ya type predicate annotasiyası yoxdur.
  2. Onun tək return ifadəsi var və gizli (implicit) return yoxdur.
  3. O, parametrini dəyişmir.
  4. O, parametrin daraldılmasına bağlı boolean ifadə qaytarır.

Beləliklə, const isNumber = (x: unknown) => typeof x === "number"; indi (x: unknown) => x is number tipinə malikdir və guard kimi işləyir.

true T deməkdir, false isə T deyil

Predicate hər iki istiqamətdə vəd verir: true dəyərin T olduğunu, false isə olmadığını bildirir. Ədədlər üzərində truthiness filtrinin predicate almamasının səbəbi budur:

TypeScript
const scores = [90, 0, undefined, 75];
const counted = scores.filter((s) => !!s);
// yenə (number | undefined)[]: false 0 demək də ola bilər

TypeScript imtina edir, çünki funksiya number olan 0 üçün false qaytarır. Bu, həm də real bug-dır: sıfır bal nəticədən yox olur. Nəzərdə tutduğun yoxlamanı, s !== undefined-i yaz, onda sıfırı saxlayan number[] alırsan. Heç bir dəyəri falsy olmayan obyekt tiplərində truthiness yoxlaması predicate çıxarır: maybeUsers.filter((u) => !!u) User[] verir. filter(Boolean) isə yenə daraltmır; boolean qaytarmayan (x) => x də daraltmır.

Tip çıxarılmasının yan təsirləri

Daha dəqiq tiplər köhnə tiplərə güvənən kodu poza bilər. Buraxılış qeydlərindəki nümunə: [1, 2, 3, null, 5].filter((x) => x !== null) əvvəllər (number | null)[] idi, indi number[]-dir, ona görə sonrakı push(null) artıq kompilyasiya olunmur. Daha geniş tip istəyirsənsə, dəyişəni annotasiya et.

Açıq yazılmış predicate-lər əvvəlki kimi davranır. TypeScript onları özünün çıxaracağı predicate ilə müqayisə etmir, ona görə əl ilə yazılmış x is T yenə yalan deyə bilər; çıxarılan isə deyə bilməz, çünki o, kodun özündən alınır.

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

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

30 saniyəlik cavab. "Narrowing TypeScript-in union-ı koddakı yoxlamalara əsasən dəqiqləşdirməsidir: typeof, truthiness, bərabərlik, in, instanceof və diskriminant xassələr. Control-flow analizi return-ləri və mənimsətmələri izləyir, amma callback-lərin içində xassələrin daraltmasını atır və funksiya çağırışlarından sonra onu sıfırlamır. unknown yoxlanmamış data və tutulmuş xətalar üçün təhlükəsiz tipdir. never yoxlaması olan discriminated union-lar emal olunmamış halları kompilyatora tapdırır. Proqramçının özünün yazdığı guard-lar və assertion funksiyaları daraltmanı genişləndirir, amma kompilyator onların gövdəsinə inanır, ona görə səhv guard as kimi yalan deyir."

Gözlənilən suallar

  • typeof items === "object"-dən sonra items niyə hələ də string[] | null-dur? Çünki typeof null "object"-dir; null ilə müqayisə et və ya Array.isArray işlət.
  • if (count)-da nə səhvdir? O, 0-ı (və NaN-ı) olmayan dəyər kimi qəbul edir; undefined ilə müqayisə et.
  • null-u yoxlamışam, TypeScript niyə bu forEach-in içində şikayət edir? Callback-lərdə xassə daraltması atılır; dəyəri const-a köçür.
  • catch dəyişəninin tipi nədir? strict rejimində unknown (useUnknownInCatchVariables); instanceof Error ilə daralt.
  • Union-ın hər halının emal olunduğuna necə əmin olursan? Discriminated union, default-da never yoxlaması və icra zamanı onsuz da gələ biləcək dəyərlər üçün throw.
  • x is T, yoxsa asserts x is T? Predicate boolean qaytarır və budağın içində daraldır; assertion xəta atır və scope-un qalanını daraldır.
  • TypeScript 5.5-də filter üçün nə dəyişdi? Çıxarılan type predicate-lər: filter((x) => x !== undefined) indi massivi daraldır.

Bal itirdən səhvlər

  • Type guard-ı "tipin yoxlanması" adlandırmaq. O, gövdəsi nəyi yoxlayırsa, onu yoxlayır; TypeScript bunun tiplə üst-üstə düşdüyünü heç vaxt yoxlamır.
  • Daraltma xətasını yoxlama və ya const surəti əvəzinə ! və ya as ilə "düzəltmək".
  • Vərdiş üzündən ədəd və string-lərdə truthiness işlətmək.
  • İcra zamanı budağı olmayan tam switch-in serverdən gələn gözlənilməz dataya qarşı qoruduğuna inanmaq.

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

State-i optional sahələrlə dolu obyektlər kimi yox, discriminated union-lar kimi modelləşdir. Əl ilə yazılmış guard-ları az, kiçik və test olunmuş saxla, ya da onları sxemlərdən yarat. Analizin harada sound olmadığını (funksiya çağırışları, guard-lar, assertion-lar, as, !) bil ki, "tip baxımından təhlükəsiz" proqram çökəndə əvvəlcə haraya baxacağını biləsən.

JuniorYoxlama siyahısı

Narrowing və type guard-ları review edərkən nəyi yoxlamalı

Yazmadığın TypeScript kodunu — komanda yoldaşının pull request-ini, kitabxananın nümunəsini və ya AI assistentin təklifini — review edəndə bu siyahıdan istifadə et. Daraltma səhvləri təmiz kompilyasiya olunur. Yoxlamalar düzgün görünür, bug isə yalnız heç kimin sınamadığı dəyərdə üzə çıxır: sıfırda, boş string-də, serverin sonradan əlavə etdiyi statusda.

  • Truthiness yoxlamaları ədədlər və ya string-lər üzərində aparılırmı? if (count), if (!title) və value || fallback 0-ı, boş string-i və NaN-ı olmayan dəyər kimi qəbul edir. Onları diff-də tap və sıfırın və ya boş string-in orada düzgün dəyər olub-olmadığını soruş; əgər belədirsə, undefined və ya null ilə müqayisə et, ya da ?? işlət.
  • typeof x === "object" yoxlamasından sonra null yoxlaması varmı? typeof null "object"-dir, ona görə təkcə bu yoxlama null-u buraxır. Yanında x !== null axtar və ya tipin null ehtiva edə bilmədiyinə əmin ol.
  • Union üzərindəki hər switch və ya if zənciri tamlıq yoxlaması ilə bitirmi? Dəyəri never parametrə ötürən və xəta atan default axtar. Öz kompüterində union-a üzv əlavə et və tsc-nin dəyişməli olan hər yeri göstərdiyinə əmin ol.
  • Əl ilə yazılmış hər type guard predicate-inin vəd etdiyi hər şeyi yoxlayırmı? x is User funksiyasının gövdəsini User tipi ilə sahə-sahə müqayisə et: bir sahəni yoxlayan guard hamısına zəmanət verir. Onu sahəsi çatışmayan obyektlə çağır və false qaytardığına əmin ol.
  • Daraltma xətası ! və ya as ilə susdurulubmu? TypeScript-in qəbul etmədiyi yoxlamadan sonra yazılmış session.user!.name və ya data as User adətən real halı gizlədir: sonra işləyən callback-i, dəyəri dəyişən funksiya çağırışını, heç vaxt yoxlanmamış datanı. Bunun əvəzinə yoxlamadan sonra const surəti və ya real guard istə.
  • Tutulmuş xətalar daraltmadan istifadə olunurmu? catch (error: any) və ya error as Error ilə handler string və ya adi obyekt ola biləcək şeydən error.message oxuyur. Xətanın xassələrindən istifadə etməzdən əvvəl kodun error instanceof Error-u (və ya öz xəta klasslarını) yoxladığına əmin ol.

Ö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.

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

  • Quiz

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

    7 sual