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

TypeScript

Datanı sərhəddə yoxlamaq

fetch, JSON.parse, storage, URL, formlar və postMessage-dən gələn data üçün tiplər niyə sadəcə vəddir; as, ! və satisfies icra zamanı niyə heç nəyi yoxlamır; datanı sərhəddə bir dəfə sxem (Zod 4) ilə necə parse etmək, yanlış datanı necə emal etmək və bundan sonra tiplərə necə etibar etmək olar.

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

Tiplərin sadəcə vəd olduğu yerlər

TypeScript sənin yazdığın kodu yoxlayır. Proqram işləyəndə tiplər artıq yoxdur () və dəyərin həqiqətən kodda deyilən tipdə olduğunu heç nə yoxlamır. Öz kodunun içində bu, problem deyil: kompilyator hər mənimsətməni yoxlayıb. Datanın proqramdan kənardan gəldiyi sərhəddə isə kompilyatorun yoxlayacağı heç nə yoxdur və tip başqasının yerinə yetirməli olduğu vəddir.

Data frontend tətbiqinə haradan daxil olur və DOM tipləri sənə nə verir:

  • await response.json(): any
  • JSON.parse(text): any
  • localStorage.getItem(key): string | null, ardınca adətən JSON.parse gəlir
  • new URLSearchParams(location.search).get("page"): string | null
  • new FormData(form).get("qty"): FormDataEntryValue | null, yəni sətir və ya File
  • message event-indəki event.data (postMessage, worker-lər): any
  • üçüncü tərəf skriptlərinin təyin etdiyi qlobal dəyərlər: onları necə elan etmisənsə, elə

Ən təhlükəlisi any-dir. O, istənilən tipə mənimsədilə bilir, ona görə tiplənmiş koda bir dənə də xəta olmadan axır:

TypeScript
type Order = { id: string; total: number; status: "paid" | "shipped" };

async function loadOrder(id: string): Promise<Order> {
  const response = await fetch(`/api/orders/${id}`);
  return response.json(); // any, Order kimi qəbul olunur
}

const order = await loadOrder("42");
console.log(order.total.toFixed(2));

Bu kod kompilyasiya olunur. API "total": "19.90"-ı sətir kimi göndərsə, sahənin adını dəyişsə və ya 404-ə { "error": "Not found" } ilə cavab versə, TypeError loadOrder-dən uzaqda, toFixed-də çıxacaq, ya da yanlış dəyər heç bir xəta olmadan ekrana düşəcək. 404 halına diqqət et: MDN qeyd edir ki, fetch() promise-i HTTP xəta statuslarında reject olmur, ona görə kod response.ok-u özü yoxlamalıdır.

URL-dən, storage-dən və formlardan gələn sətirlərin problemi daha kiçikdir. Onların tipi düzgündür (string | null), amma sətir yenə də ədədə, tarixə və ya union-ın üzvlərindən birinə çevrilməlidir və bu çevirmə uğursuz ola bilər.

Həll daha yaxşı tip yox, yoxlamadır: , yəni proqram işləyərkən dəyərə baxıb ya tiplənmiş dəyər qaytaran, ya da nəyin səhv olduğunu bildirən kod. Bu mövzunun qalan hissəsi həmin yoxlamanı sərhəddə bir dəfə yazmaq və ondan sonra tiplərə etibar etmək haqqındadır.

JuniorKonsepsiya

as yoxlama deyil, iddiadır

kompilyatora deyir: "bu dəyəri bu tipdə say". TypeScript handbook-u bunu açıq yazır: assertion-lar kompilyasiya zamanı silinir, icra zamanı heç bir yoxlama yoxdur və assertion səhv olsa da exception atılmır.

TypeScript
type ViewSettings = { pageSize: number; view: "grid" | "list" };

const settings = JSON.parse(localStorage.getItem("view-settings") ?? "{}") as ViewSettings;
// Kompilyasiya olunur. Storage-də {"pageSize":"20"} varsa, bu, "205" sətridir
const next = settings.pageSize + 5;

Assertion-ların dürüst istifadələri də var, yəni sənin kompilyatordan çox bildiyin yerlər: məsələn, öz HTML-inin təyin etdiyi element üçün document.getElementById("chart") as HTMLCanvasElement. Dəyər kənardan gələn hər yerdə isə onlar yanlışdır.

TypeScript bəzi assertion-ları rədd edir: o, tipi yalnız daha konkret və ya daha ümumi versiyasına çevirməyə icazə verir. "42" as number xətadır ("neither type sufficiently overlaps"). Bu qaydadan yan keçmək asandır və yan keçmə review-da aydın xəbərdarlıq işarəsidir:

TypeScript
// Xəta: 'string' tipinin 'number' tipinə çevrilməsi səhv ola bilər
const a = "42" as number;
// Kompilyasiya olunur: əvvəl unknown-a, sonra istənilən tipə. b yenə "42" sətridir
const b = "42" as unknown as number;

as unknown as T (və ya as any as T) "kompilyatorun razı olmadığını bilirəm" deməkdir. Test köməkçisində bəzən doğru ola bilər; tətbiq kodunda isə demək olar ki, həmişə çatışmayan çevirməni və ya çatışmayan yoxlamanı gizlədir. Sərhəddə isə üst-üstə düşmə qaydası onsuz da heç nəyi qorumur: any istənilən tiplə üst-üstə düşür, ona görə JSON.parse(text) as User həmişə kompilyasiya olunur.

Gizli assertion-lar

Bəzi kodlar as yazmadan assertion edir:

TypeScript
async function getJson<T>(url: string): Promise<T> {
  const response = await fetch(url);
  return response.json();
}

const user = await getJson<User>("/api/me"); // heç nə yoxlanmır

T yalnız qaytarma tipində görünür, ona görə onu çağıran seçir və heç nə onu data ilə bağlamır: daha gözəl sintaksisli as. Üçüncü tərəf skriptinin window xassəsini tipləyən declare global bloku və JSON.parse(text) as T-ni gizlədən storage köməkçisi də eynidir. Onların hər birinə əslində olduğu kimi, yəni yoxlanmamış iddia kimi yanaş və onları yoxlama aparan kodun yanında saxla.

JuniorKonsepsiya

Annotasiya, satisfies və as

Kodda yazdığın dəyərə tip bağlamağın üç yolu var, ən sərtdən ən yumşağa doğru:

TypeScript
type Route = { path: string; auth: boolean };

// Annotasiya: dəyər uyğun gəlməlidir, dəyişən isə məhz bu tipi alır
const routes: Record<string, Route> = {
  home: { path: "/", auth: false },
  account: { path: "/account", auth: true },
};
const typo = routes.acount; // xəta yoxdur: istənilən sətir açarına icazə var

// satisfies: dəyər uyğun gəlməlidir, dəyişən isə öz, daha dar tipini saxlayır
const routes2 = {
  home: { path: "/", auth: false },
  account: { path: "/account", auth: true },
} satisfies Record<string, Route>;
// Xəta: 'acount' xassəsi yoxdur
const typo2 = routes2.acount;

// as: yalnız tiplərin üst-üstə düşdüyünü yoxlayır
const home = { path: "/" } as Route; // kompilyasiya olunur; icra zamanı home.auth undefined-dir
  • Annotasiya dəyəri tipə qarşı yoxlayır, sonra isə dəyəri unudur: dəyişən məhz annotasiyadakı tipi daşıyır, ona görə yuxarıdakı açarlar "istənilən sətir" olur.
  • satisfies (TypeScript 4.9) dəyəri tipə qarşı yoxlayır və çıxarılmış tipi saxlayır: açarlar home və account kimi qalır, "dark" kimi literal dəyərlər literal qalır, çatışmayan və artıq xassələr isə yenə xətadır.
  • as tiplərdən biri digərinə mənimsədilə bildikcə tipdən az xassəsi olan dəyəri qəbul edir. home-un auth-suz qalması da belə olur.

Onların heç biri icra zamanı heç nə yoxlamır. satisfies mənbə kodunda yazılmış dəyərlər üçündür; JSON.parse-a kömək edə bilməz, çünki o dəyər proqram işə düşənə qədər mövcud deyil. Kənardan gələn dataya icra zamanı işləyən kod lazımdır.

Sadə qayda: funksiya parametrlərinə və qaytarma tiplərinə annotasiya yaz; dəqiq formasını saxlamaq istədiyin literal obyektlər, məsələn, konfiqurasiya, axtarış cədvəlləri və route xəritələri üçün satisfies istifadə et; as-ı isə həqiqətən kompilyatordan çox bildiyin nadir hal üçün saxla və səbəbini şərhdə yaz.

MiddleKonsepsiya

Validate etmə, parse et

Bu ideyaya ad Alexis King-in 2019-da yazdığı "Parse, don't validate" məqaləsindən gəlir. Validator datanı yoxlayır və "hə" və ya "yox" cavabı verir, kodun qalanı isə yoxlanmamış tiplə işləməyə davam edir. Parser isə onun sözləri ilə "daha az strukturlu girişi qəbul edib daha strukturlu nəticə verir", ya da uğursuz olur. TypeScript dilində: unknown və ya sətir qəbul et, tiplənmiş dəyər qaytar.

TypeScript
// Validate edir: çağıranda hələ də sətir qalır və onu haradasa yenidən çevirir
function isValidPage(value: string | null): boolean {
  return value !== null && /^[1-9]\d*$/.test(value);
}

// Parse edir: çağıran düzgün olduğu bilinən ədəd alır
function parsePage(value: string | null): number {
  if (value === null) return 1;
  if (!/^[1-9]\d*$/.test(value)) throw new RangeError(`Invalid page: ${value}`);
  return Number(value);
}

isValidPage true qaytarandan sonra kodda yenə sətir qalır və onu istifadə edən hər yer onu yenidən, bəlkə də fərqli şəkildə çevirir. parsePage-dən sonra isə yalnız ədəd var. Yoxlamanın baş verdiyinin sübutu tiplə birlikdə ötürülür.

Obyektlər üçün any-dən yox, həmişə unknown-dan başla. unknown olanda TypeScript hər müraciəti yoxlamadan keçirməyə məcbur edir ():

TypeScript
type Line = { sku: string; qty: number };

function parseLine(input: unknown): Line {
  if (typeof input !== "object" || input === null) {
    throw new TypeError("line: expected an object");
  }
  if (!("sku" in input) || typeof input.sku !== "string") {
    throw new TypeError("line.sku: expected a string");
  }
  if (!("qty" in input) || typeof input.qty !== "number" || !Number.isInteger(input.qty) || input.qty < 1) {
    throw new TypeError("line.qty: expected an integer >= 1");
  }
  return { sku: input.sku, qty: input.qty };
}

Funksiya yalnız məlum sahələri olan yeni obyekt qaytarır, ona görə serverdən gələn artıq data irəli sızmır.

Bu işləyir, amma tez böyüyür: iç-içə obyektlər, massivlər, optional sahələr, yalnız birinci xəta yox, bütün xətalar, üstəlik əl ilə sinxron saxladığın tip və yoxlamalar dəsti. -ın (input is Line) da eyni zəifliyi var: gövdəsi tipinin vəd etdiyindən az yoxlayırsa, o da as kimi yalan danışır, kompilyator isə ona etibar edir. Ona görə layihələrin çoxu həm yoxlamanı, həm də tipi bir tərifdən çıxaran sxem kitabxanasından istifadə edir.

MiddleFramework

Zod 4 ilə sxemlər

Sxem kitabxanası gözlənilən formanı bir dəfə, dəyər kimi təsvir edir. İcra zamanı datanı bu dəyərə qarşı parse edir, kompilyasiya zamanı isə sənə tipi verir. Zod geniş yayılmış seçimdir və nümunələr Zod 4-dən istifadə edir (import * as z from "zod").

TypeScript
import * as z from "zod";

const Order = z.object({
  id: z.string(),
  total: z.number().nonnegative(),
  status: z.enum(["paid", "shipped", "cancelled"]),
  customerEmail: z.email(),
  note: z.string().optional(),
});

type Order = z.infer<typeof Order>;
// { id: string; total: number; status: "paid" | "shipped" | "cancelled";
//   customerEmail: string; note?: string | undefined }
  • Order.parse(data) tiplənmiş dəyər qaytarır və ya ZodError atır. Dəyər yeni obyektdir (zod.dev: dərin klon), sxemin sadalamadığı açarlar isə default halda silinir.
  • Order.safeParse(data) xəta atmır. O, { success: true, data } və ya { success: false, error } qaytarır, bu, discriminated union-dır, error.issues isə hər problemi path və message ilə sadalayır.
  • Zod 4-də sətir formatları üst səviyyəli funksiyalardır (z.email(), z.url(), z.uuid()); köhnə z.string().email() hələ işləyir, amma deprecated-dir.
TypeScript
async function loadOrder(id: string): Promise<Order> {
  const response = await fetch(`/api/orders/${id}`);
  if (!response.ok) throw new Error(`GET /api/orders/${id}: HTTP ${response.status}`);
  return Order.parse(await response.json());
}

URL-dən və ya formdan gələn sətirləri əvvəlcə çevirmək lazımdır. z.coerce.number() yoxlamadan əvvəl Number(input) işlədir:

TypeScript
const ListParams = z.object({
  page: z.coerce.number().int().min(1).default(1),
  sort: z.enum(["newest", "price"]).catch("newest"),
});

const params = ListParams.parse(Object.fromEntries(new URLSearchParams(location.search)));
// ?page=3&sort=name nəticədə { page: 3, sort: "newest" } verir

.default(1) açar olmayanda tətbiq olunur. .catch("newest") uğursuz olmaq əvəzinə yanlış dəyəri əvəz edir, bu da insanların əl ilə dəyişdiyi URL parametrlərinə yaraşır. Number()-in nə etdiyinə diqqət et: boş ?page= 0 olur (burada .min(1) onu rədd edir).

Transform-lar nəticənin tipini dəyişir: z.iso.datetime().transform((s) => new Date(s)) ISO sətri qəbul edir və Date verir. z.input<typeof S> və z.output<typeof S> iki tərəfi adlandırır; z.infer nəticə tipidir.

MiddleKonsepsiya

Yanlış datanı necə emal etməli

Parse etmək yalnız uğursuzluq qəsdən emal olunanda kömək edir, düzgün reaksiya isə datanın haradan gəldiyindən asılıdır.

API cavabları: mənbəyə yaxın yerdə açıq-aşkar xəta ver. Sxemə uyğun gəlməyən cavab ya bug-dır, ya da client ilə server arasındakı müqavilənin dəyişməsidir. Sərhəddə endpoint-i və problemləri adlandıran mesajla xəta at, xəta vəziyyətini error boundary və ya data kitabxanası göstərsin, xətanı da report et. Yanlış olduğunu bildiyin datadan səhifənin yarısını render etmək daha pisdir.

TypeScript
async function getJson<T>(url: string, schema: z.ZodType<T>): Promise<T> {
  const response = await fetch(url);
  if (!response.ok) throw new Error(`${url}: HTTP ${response.status}`);
  const result = schema.safeParse(await response.json());
  if (!result.success) {
    throw new Error(`${url}: unexpected response\n${z.prettifyError(result.error)}`);
  }
  return result.data;
}

Burada T sxemə bağlıdır, ona görə qaytarma tipi iddia yox, qazanılmış nəticədir. z.prettifyError problemləri "✖ Invalid input: expected number, received string → at total" kimi sətirlərə çevirir.

Saxlanmış data: ehtiyat dəyərə keç. localStorage-dəki datanı tətbiqin köhnə versiyası yaza və ya kimsə əl ilə dəyişə bilər. Onu parse et, uğursuz olsa, default dəyərlərdən istifadə et: istifadəçi səhifəni yox, bir seçimini itirir.

TypeScript
const ViewSettings = z.object({ pageSize: z.int().min(10).max(100), view: z.enum(["grid", "list"]) });
const DEFAULT_VIEW = { pageSize: 20, view: "grid" } satisfies z.infer<typeof ViewSettings>;

function readViewSettings(): z.infer<typeof ViewSettings> {
  try {
    const result = ViewSettings.safeParse(JSON.parse(localStorage.getItem("view-settings") ?? "null"));
    return result.success ? result.data : DEFAULT_VIEW;
  } catch {
    return DEFAULT_VIEW; // JSON.parse səhv formatlı mətndə xəta atır
  }
}

İstifadəçi daxiletməsi: problemləri göstər. Formda problemləri sahələrə bağla: z.flattenError(error).fieldErrors { email: ["Enter a valid email"] } verir, öz mesajların isə error parametrinə yazılır, məsələn, z.email({ error: "Enter a valid email" }). Serverdə də yoxla: client tərəfdəki yoxlama istifadəçinin rahatlığı üçündür və server ona etibar edə bilməz.

Başqa pəncərələrdən gələn mesajlar: əvvəlcə göndərəni yoxla. MDN-in postMessage üçün məsləhəti event.origin-i yoxlamaq, sonra isə mesajın sintaksisini yenə də yoxlamaqdır. Uyğun gəlməyəni at.

Səssiz ara yoldan qaç: API cavabının hər sahəsinə .catch() və ya ?? 0 qoymaq pozulmuş müqaviləni log-larda heç bir iz olmadan ekranda yanlış rəqəmlərə çevirir.

MiddleTipik səhvlər

Digər yoxlanmamış iddialar: !, definite assignment, guard-lar

as kompilyatora onun yoxlaya bilmədiyi nəyisə deməyin yeganə yolu deyil. Bunların hamısı da icra zamanı yox olur.

Non-null assertion !. value! tipdən null və undefined-i çıxarır; handbook onu mahiyyətcə type assertion adlandırır. Sərhəddə o, çatışmayan dəyəri səssiz bug-a çevirir:

TypeScript
const orderId = new URLSearchParams(location.search).get("order")!;
// URL-də ?order= yoxdursa, bu, /api/orders/null sorğusu göndərir
fetch(`/api/orders/${orderId}`);

Template literal-ın içində null "null" mətninə çevrilir, ona görə aydın xəta əvəzinə tətbiq serverdən mövcud olmayan sifarişi istəyir. Yoxla və bu halı emal et: if (!orderId) return showNotFound();.

Definite assignment !:. let config!: Config və ya client!: ApiClient klass sahəsi TypeScript-ə deyir ki, dəyər kimsə onu oxumazdan əvvəl təyin olunacaq, ona görə o, "used before being assigned" yoxlamasını etmir:

TypeScript
let config!: { apiUrl: string };

export function initConfig(apiUrl: string) {
  config = { apiUrl };
}

export function ordersUrl() {
  return `${config.apiUrl}/orders`; // initConfig hələ işləməyibsə, TypeError
}

Çağırışların sırası dəyişsə, config undefined olur. Onu elan edərkən ilkin dəyər ver, parametr kimi ötür və ya Config | undefined kimi tiplə və yoxla.

Vəd etdiyindən az yoxlayan type guard-lar.

TypeScript
function isOrder(x: unknown): x is Order {
  return typeof x === "object" && x !== null && "id" in x;
}

isOrder(data)-dan sonra kompilyator data-nı tam Order sayır, halbuki yalnız id yoxlanıb. Bu predikat funksiyaya bükülmüş assertion-dır.

Qlobal dəyərlər üçün elanlar. Üçüncü tərəf skriptinin window-a yazdığı xassə üçün declare global yazısı nəzarət etmədiyin kod barədə vəddir; skript bloklana və ya hələ yüklənməmiş ola bilər. Onu optional kimi tiplə və çağırmazdan əvvəl yoxla.

İndeksləmə. noUncheckedIndexedAccess olmadan items[0] və byId[key] olmayanda da mövcud kimi tiplənir. Bu seçim aktiv olanda onların tipinə undefined daxil olur.

Review-da dayanmalı olduğun yerlər bunlardır: !., !:, x is T, declare global və as. Onların hər birinin yalnız kompilyasiya zamanı yox, icra zamanı da doğru qalan səbəbi olmalıdır.

SeniorKonsepsiya

Bir dəfə, sərhəddə yoxla

Validasiyanın yeri datanın proqrama daxil olduğu yerdir və yalnız oradır. İçəridə tiplər doğrudur, çünki kompilyator hər addımı yoxlayıb; hər komponentdə yenidən yoxlamaq kod və vaxt aparır, növbəti oxucuya isə heç kimin tiplərə etibar etmədiyini deyir.

Tətbiqi nazik sərhədin içindəki tiplənmiş nüvə kimi təsəvvür et:

Text
fetch, storage, URL, form, postMessage
        |  unknown, any or string
        v
  edge: parse with a schema  --fail-->  error state, report, fallback
        |  Order, ViewSettings, ListParams
        v
  typed core: components, hooks, state (no casts, no re-checks)

Praktikada bu nə deməkdir:

  • fetch-in sahibi bir API moduludur. Hər endpoint funksiyası parse olunmuş data qaytarır, məsələn, getJson(url, Order), komponentlər isə response.json()-u özləri heç vaxt çağırmır. TanStack Query kimi data kitabxanası ilə parse-ı query funksiyasının içində et ki, keşdə yalnız düzgün data saxlanılsın.
  • JSON.parse və get storage və URL köməkçilərinə aiddir. readViewSettings() və ya useListParams() hook-u tiplənmiş dəyərlər qaytarır; xam sətirlərə başqa heç nə toxunmur.
  • Tiplər sxemlərdən gəlir. Sxemin yanında əl ilə yazılmış tip əvəzinə type Order = z.infer<typeof Order>: eyni formanın iki tərifi zamanla bir-birindən ayrılır.
  • Generasiya olunmuş tiplər də vəddir. API təsvirindən generasiya olunan və ya TypeScript backend-i ilə ortaq istifadə olunan tiplər serverin nə göndərməli olduğunu təsvir edir. İşləyən server deploy ardıcıllığı, proxy-nin xəta səhifəsi və ya keşdə qalmış köhnə cavab üzündən yenə də fərqli ola bilər, ona görə cavablar yenə sərhəddə parse olunur.
  • Hər mənbənin öz reaksiyası var. API cavabları açıq-aşkar xəta verir, saxlanmış data default-lara keçir, istifadəçi daxiletməsi mesaj göstərir, başqa origin-lərdən gələn mesajlar isə origin və forma uyğun gəlmirsə, atılır.

Bunun qiyməti

Parse bütün dəyəri başdan-sona yoxlayır, ona görə onun qiyməti datanın ölçüsü ilə artır. Adi cavablarda bu, şəbəkə ilə müqayisədə kiçikdir, amma hər render-də yox, hər cavab üçün bir dəfə parse et və böyük payload-u optimallaşdırmazdan əvvəl ölç. Bundle ölçüsü də önəmlidir: Zod Mini (zod/mini) Zod-un funksional API-li, tree-shaking-ə uyğun variantıdır və hər kilobaytın vacib olduğu səhifələr üçündür.

Nəticədə as və ! elə nadir olur ki, dərhal gözə çarpır. Nüvədəki dəyərin tipi varsa, o tipi ya kompilyator hesablayıb, ya da parser yaradıb, arada isə heç nə səndən ona sadəcə inanmağı istəmir.

SeniorKonsepsiya

Data dəyişəndə sxemlər

Sərhəddəki data dəyişir. Server yeni sahə əlavə edir və ya birinin adını dəyişir, tətbiqinin köhnə versiyası isə storage-ə başqa formada yazıb. Belə olanda nə baş verəcəyinə sxem qərar verir.

Naməlum açarlar. z.object sadalamadığı açarları silir, ona görə serverdən gələn yeni sahəyə məhəl qoyulmur və heç nə pozulmur. z.strictObject naməlum açarları rədd edir: konfiqurasiya faylı kimi tam sənə məxsus data üçün doğrudur, amma API cavablarında serverdəki hər əlavəni client-də uğursuzluğa çevirir. z.looseObject naməlum açarları saxlayır və onun tipi onlara icazə verir.

Versiyalı saxlanmış data. Datanın yanında versiya nömrəsi saxla, discriminated union ilə parse et, sonra cari formaya miqrasiya et:

TypeScript
const SettingsV1 = z.object({ version: z.literal(1), compact: z.boolean() });
const SettingsV2 = z.object({ version: z.literal(2), density: z.enum(["compact", "comfortable"]) });
const StoredSettings = z.discriminatedUnion("version", [SettingsV1, SettingsV2]);

function migrate(stored: z.infer<typeof StoredSettings>): z.infer<typeof SettingsV2> {
  if (stored.version === 2) return stored;
  return { version: 2, density: stored.compact ? "compact" : "comfortable" };
}

Heç bir versiyaya uyğun gəlməyən data default-lara keçir. Versiya sahəsi olmadan hansı formanı oxuduğunu ancaq təxmin edə bilərsən.

null, undefined və olmayan açar. JSON-da null var, undefined isə yoxdur. "note": null göndərən API z.string().optional()-dan keçmir, çünki o, yalnız undefined-i və ya olmayan açarı qəbul edir. null üçün .nullable(), hər ikisi üçün .nullish() istifadə et və kodun qalanının ümumiyyətlə null görüb-görməməli olduğuna qərar ver; sərhəddəki transform onu bir dəfə undefined-ə çevirə bilər.

Giriş və nəticə tipləri. Coercion, transform və default-lar olanda gələn data (z.input) ilə kodunun saxladığı data (z.output) fərqlənir: formun girişində sətirlər, nəticəsində isə ədədlər və tarixlər olur. Xam tərəflə işləyən funksiyalara, məsələn, test fixture-larına və ya formun ilkin dəyərlərinə giriş tipi lazımdır.

Mock-lar da köhnəlir. API cavabının əl ilə yazılmış mock-u real API dəyişəndən sonra da keçməyə davam edir. Fixture-lar eyni sxemlərlə parse olunursa və ya z.input<typeof Order> kimi tiplənibsə, sxem dəyişən kimi köhnəlmiş fixture uğursuz olur. Beləliklə sxem müqaviləni həm kodun, həm də testlərin oxuduğu bir yerdə sənədləşdirir.

Zod 4 burada Zod 3 ilə müqayisədə bəzi detalları dəyişib, məsələn, .default() undefined-də parse-ı dərhal dayandırır, z.coerce sxemlərinin giriş tipi isə unknown olub. Versiyanı yeniləyəndə yaddaşa güvənmə, zod.dev-dəki miqrasiya bələdçisini oxu.

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

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

30 saniyəlik cavab. "TypeScript-in tipləri silinir, ona görə onlar yalnız kompilyatorun gördüyü datanı təsvir edir. Kənardan gələn hər şey, məsələn, fetch().json(), JSON.parse, storage, URL parametrləri, formlar və postMessage, any, unknown və ya sətir kimi gəlir, as isə sadəcə kompilyatoru susdurur. Həmin datanı sərhəddə bir dəfə sxemlə parse edirəm, məsələn, Zod ilə: o, dəyəri icra zamanı yoxlayır və tipi z.infer ilə verir. Yanlış data mənbəyə görə emal olunur: API xətaları açıq-aşkar üzə çıxarılır, saxlanmış data default-a keçir, form daxiletməsi mesaj göstərir. Sərhəddən sonra tiplərə etibar edirəm və cast-lardan qaçıram."

Gözlənilən suallar

  • as, annotasiya və satisfies arasında fərq nədir? Annotasiya yoxlayır və annotasiyadakı tipə genişləndirir; satisfies yoxlayır və çıxarılmış tipi saxlayır; as yalnız tiplərin üst-üstə düşməsini tələb edir. Onların heç biri icra zamanı işləmir.
  • as unknown as T niyə təhlükə siqnalıdır? O, as-ın yeganə yoxlamasından yan keçir. Hansı çevirmənin və ya validasiyanın çatışmadığını soruş.
  • fetch wrapper-ini necə tipləyirsən? Gizli cast olan getJson<T>(url): Promise<T> kimi yox, sxem qəbul edib onun nəticə tipini qaytaran funksiya kimi.
  • parse, yoxsa safeParse? parse xəta atır, bu da uğursuzluğun istisna olduğu və onu error boundary-nin emal etdiyi yerlərə yaraşır; safeParse isə formlar və storage kimi yerində reaksiya verən yerlər üçün nəticə qaytarır.
  • Harada validate edirsən? Bir dəfə, datanın daxil olduğu yerdə: API modulunda, storage və URL köməkçilərində, mesaj listener-lərində. Hər komponentdə yox.
  • ! icra zamanı nə edir? Heç nə. O, yalnız tipdən null və undefined-i çıxarır.

Bal itirdən səhvlər

  • TypeScript-in API cavablarını "validate etdiyini" və ya generic tip parametrinin fetch-i tip baxımından təhlükəsiz etdiyini demək.
  • API sahə əlavə edəndə nə olacağını müzakirə etmədən üçüncü tərəf API cavabları üçün strictObject təklif etmək.
  • Yanlış datanı hər yerdə default-larla udmaq: ekrandakı yanlış rəqəmləri debug etmək xətadan daha çətindir.

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

Sərhəddən dizayn qərarı kimi danış: hər mənbənin sahibi hansı moduldur, sxemlər serverlə necə bölüşdürülür və ya onun təsvirindən necə generasiya olunur, fixture-lar necə sinxron saxlanılır, uğursuzluqlar necə report olunur və böyük payload-larda validasiya bundle ölçüsü və CPU vaxtı baxımından nəyə başa gəlir.

JuniorYoxlama siyahısı

Kənardan gələn datanı emal edən kodu review edərkən nəyi yoxlamalı

Proqramdan kənardan gələn datanı oxuyan, amma sənin yazmadığın kodu — 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. Yoxlanmamış data yoxlanmış data kimi kompilyasiya olunur, ona görə problem sonra üzə çıxır: səbəbdən uzaqda çökmə və ya ekranda yanlış dəyər kimi.

  • fetch, JSON.parse, storage, URL, form və ya postMessage-dən gələn hər dəyər tiplənmiş kod onu istifadə etməzdən əvvəl parser-dən keçirmi? .json(), JSON.parse, getItem(, .get( və event.data-nı axtar və hər dəyəri izlə: növbəti addım as, annotasiya və ya Promise<T> qaytarmasıdırsa, onun tipi yoxlanmayıb.
  • Hər as, as unknown as, ! və !: icra zamanı doğru olan nə iləsə əsaslandırılıbmı? Şərh iddianın niyə doğru olduğunu deməlidir; as unknown as T və URL parametrində və ya storage dəyərində ! adətən çatışmayan yoxlama deməkdir.
  • Body parse olunmazdan əvvəl HTTP statusu yoxlanırmı? fetch 404 və ya 500-də də resolve olur; response.ok olmadan kod xəta səhifəsini və ya xəta obyektini data kimi parse edir.
  • Tiplər sxemlərin yanında yazılmayıb, onlardan çıxarılırmı (z.infer, z.input)? Eyni formanın iki tərifi zamanla ayrılır; Order sxeminin yanında əl ilə yazılmış type Order axtar.
  • Sətir çevirmələri qəsdən edilibmi? Boş sətrin Number("") və z.coerce.number() ilə çevrilməsi 0 verir, olmayan URL parametri null-dur, FormData.get isə File qaytara bilər; hər halın .min(1), default və ya xəta kimi qaydası olduğunu yoxla.
  • Hər uğursuzluq yolu görünən nəsə edirmi? API uyğunsuzluğu endpoint adı ilə xəta atmalı və ya report olunmalı, saxlanmış data default-lara keçməli, form xətaları isə sahələrə çatmalıdır; cavab datasında səssiz .catch() və ya ?? 0 pozulmuş müqaviləni gizlədir.
  • message listener-ləri event.data-nı oxumazdan əvvəl event.origin-i yoxlayırmı? MDN-in məsləhəti əvvəlcə göndərəni, sonra mesajın sintaksisini yoxlamaqdır; origin yoxlaması olmayan listener istənilən pəncərədən data qəbul edir.

Ö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