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

TypeScript

Struktur tipləşdirmə və tiplərin silinməsi

TypeScript nədir və nə deyil: tipləri kod işə düşməzdən əvvəl silinən tip yoxlayıcısı, struktur uyğunluq və artıq xassə yoxlaması, interface və type fərqi, any, unknown və never, vacib strict bayraqları, silinə bilən sintaksis və brendli tiplər.

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.

Başlamazdan əvvəl

İlkin şərt yoxdur.

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

JuniorKonsepsiya

TypeScript nədir

TypeScript tip sintaksisi əlavə olunmuş JavaScript-dir. JavaScript barədə bildiyin hər şey qüvvədə qalır: eyni dəyərlər, eyni operatorlar, eyni runtime. TypeScript isə bu dəyərləri təsvir etmək üçün sintaksis və həmin təsvirləri oxuyan alət əlavə edir.

TypeScript
function greet(user: { name: string }): string {
  return `Hello, ${user.name}`;
}

greet({ name: "Ada" });
greet("Ada"); // xəta: Argument of type 'string' is not assignable to parameter of type '{ name: string; }'.

TypeScript iki ayrı iş görür:

  1. Tip yoxlaması. Tip yoxlayıcısı (type checker) kodu oxuyur və dəyərin öz tipinə uyğun gəlmədiyi yerləri göstərir. Redaktorun da sən yazdıqca eyni yoxlayıcını işə salır; qırmızı alt xətlər oradan gəlir.
  2. JavaScript yaratmaq. Brauzer və Node JavaScript icra edir, ona görə tip sintaksisi aradan götürülməlidir. Tiplər silinir, geriyə adi JavaScript qalır:
JavaScript
function greet(user) {
  return `Hello, ${user.name}`;
}

Bu silinməyə deyilir. TypeScript handbook-u bunu qayda kimi yazır: tip annotasiyaları proqramın icra zamanı davranışını heç vaxt dəyişmir.

Yoxlamaq və silmək ayrı alətlərin işidir

TypeScript kompilyatoru tsc hər iki işi görür. Bir çox alət isə yalnız ikincisini görür: Node .ts faylındakı tipləri boşluqlarla əvəz edib faylı birbaşa işə salır, esbuild və Sucrase kimi transpilyatorlar isə TypeScript-i fayl-fayl JavaScript-ə çevirir. Onlar sürətlidir, çünki tipləri heç vaxt yoxlamırlar.

Shell
npx tsc --noEmit   # layihənin tiplərini yoxla, heç bir fayl yazma
node server.ts     # tipləri sil və işə sal; heç nə yoxlanmır

noEmitOnError qoşulmayıbsa, tsc özü də tip xətası tapanda JavaScript-i yenə yazır. Handbook bunun səbəbini izah edir: JavaScript-dən köçürülən layihə sən onun tiplərini düzəldənə qədər işləməyə davam etməlidir.

Praktik nəticə: tip xətası özü heç nəyi dayandırmır. Tipləri yalnız silən alət kodu hər halda işə salır. Bəzi framework-lər build zamanı yoxlayıcını da işə salır; belə deyilsə, layihəyə ayrıca tip yoxlaması addımı lazımdır, adətən CI-da işləyən tsc --noEmit skripti. Redaktordakı qırmızı alt xətt isə formallıq yox, bug barədə xəbərdir.

JuniorKonsepsiya

Tiplər formanı təsvir edir

Java və ya C#-da klass tipə yalnız elanında bu açıq yazılıbsa uyğun gəlir (class Dog implements Pet). Bu, nominal tipləşdirmədir: adlar və elanlar həlledicidir. TypeScript başqa cür işləyir. Dəyərdə tipin tələb etdiyi bütün üzvlər uyğun tiplərlə varsa, dəyər həmin tipə uyğun gəlir; onun haradan gəldiyi və necə adlandığı fərq etmir. Buna deyilir və bu, JavaScript-in real yazılış tərzinə uyğundur: adi obyektlər ötürülür və içindəkilərə görə istifadə olunur.

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

function length(p: Point): number {
  return Math.hypot(p.x, p.y);
}

const reading = { x: 3, y: 4, label: "sensor" };
length(reading); // OK: x və y var

class Vector {
  x = 1;
  y = 2;
}
length(new Vector()); // OK: "implements Point" lazım deyil

reading heç vaxt Point kimi elan olunmayıb və onda artıq label də var. Yenə də uyğun gəlir, çünki Point-in istədiyi hər şey yerindədir.

Assignability

TypeScript bunu bir sözlə ifadə edir: assignable, yəni mənimsədilə bilən. B gözlənilən hər yerdə A tipli dəyəri işlətmək olursa, A tipi B-yə mənimsədilə biləndir. Artıq xassələr problem deyil. Çatışmayan və ya səhv tipli xassə isə xətadır:

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

const draft = { name: "Ada" };
const user: User = draft;
// xəta: Property 'age' is missing in type '{ name: string; }'
// but required in type 'User'.

Qayda obyektlərlə məhdudlaşmır. Çağıranın ötürdüyündən az parametr qəbul edən callback də mənimsədilə biləndir: forEach üç arqument ötürsə də, items.forEach((item) => ...) məhz buna görə tip yoxlamasından keçir.

Klassdakı implements TypeScript-dən klassı yazdığın anda interface-ə qarşı yoxlamağı xahiş edir. O, başqa kodun asılı olduğu bir əlaqə yaratmır: düzgün formalı istənilən obyekt yenə də həmin interface-ə uyğun gəlir.

Deməli, eyni formalı iki tip, adlarından asılı olmayaraq, yoxlayıcı üçün eyni tipdir. Adətən sənə lazım olan da budur. Lazım olmayanda, məsələn, hər ikisi string olan istifadəçi id-si ilə sifariş id-si qarışmamalı olanda, tipləri nominal kimi davranmağa məcbur etməyin yolları var; mövzunun senior hissəsi onlardan bəhs edir.

JuniorTipik səhvlər

Artıq xassə yoxlaması

Artıq xassələrə icazə var, bir yerdən başqa. Obyekt literalını birbaşa tip gözlənilən yerdə yazanda TypeScript onda tipin bilmədiyi xassə olub-olmadığını yoxlayır:

TypeScript
type DrawOptions = { color?: string; width?: number };

function draw(options: DrawOptions) {
  // ...
}

draw({ colour: "red", width: 100 });
// xəta: Object literal may only specify known properties, but 'colour'
// does not exist in type 'DrawOptions'. Did you mean to write 'color'?

Bu, artıq xassə yoxlamasıdır (excess property check) və yalnız təzə (fresh) obyekt literallarına aiddir, yəni elə həmin yerdə — mənimsətmədə, arqumentdə və ya return-də — yazılmış obyektlərə. Belə obyektə başqa heç bir kod müraciət edə bilmir, ona görə tipin tanımadığı xassə demək olar ki, həmişə hərf səhvidir. Handbook qeyd edir ki, artıq xassə xətalarının çoxu real bug-lardır.

Əvvəlcə dəyişənə yazılmış eyni obyekt artıq təzə deyil və yoxlamadan keçir:

TypeScript
const options = { colour: "red", width: 100 };
draw(options); // xəta yoxdur: "colour" səssizcə nəzərə alınmır

options adi struktur qaydasına görə DrawOptions-a mənimsədilə biləndir: onda width var, optional color isə olmaya da bilər. Hərf səhvi yerində qalır və xətt standart rənglə çəkilir. Obyekti literalın içinə spread etmək ({ ...base }) də həmin obyektin artıq xassələrini yoxlamır.

Tiplər xassələri silmir

Eyni qayda çoxlarını təəccübləndirən bir sızmanı da izah edir. Daha dar tip xassələri proqramdan yox, yalnız yoxlayıcıdan gizlədir:

TypeScript
interface User {
  id: number;
  name: string;
  passwordHash: string;
}
type PublicUser = { id: number; name: string };

function toPublic(user: User): PublicUser {
  return user; // OK: User PublicUser-ə mənimsədilə biləndir
}

const user: User = { id: 7, name: "Ada", passwordHash: "x9f2" };
const body = JSON.stringify(toPublic(user)); // passwordHash yenə də içindədir

Qaytarma tipi PublicUser deyir, amma dəyər bütöv user obyektidir və JSON.stringify onda olan hər şeyi serializasiya edir. Kənara yalnız bəzi sahələr çıxmalıdırsa — API cavabında, log sətrində və ya client-ə gedən mesajda — məhz həmin sahələrlə yeni obyekt qur: return { id: user.id, name: user.name };.

Artıq xassə xətasını as assertion ilə susdurma. Hərf səhvini düzəlt, ya da xassə həqiqətən oraya aiddirsə, tipi düzəlt.

JuniorTipik səhvlər

Tiplər icra zamanı mövcud deyil

Tiplər silindiyi üçün işləyən proqram onları görə bilmir. Bunun üç nəticəsi TypeScript-ə yeni başlayanları tez-tez çaşdırır.

Dəyəri interface-ə qarşı yoxlamaq olmur. Interface-in və ya type alias-ın JavaScript-də qarşılığı yoxdur, yəni müqayisə ediləcək heç nə yoxdur:

TypeScript
interface Admin {
  role: "admin";
  permissions: string[];
}

function isAdmin(value: unknown) {
  return value instanceof Admin;
  // xəta: 'Admin' only refers to a type, but is being used as a value here.
}

instanceof klasslarla işləyir, çünki klass JavaScript dəyəridir, konstruktor funksiyadır, instanceof isə icra zamanı obyektin prototip zəncirini yoxlayır. Interface üçün yoxlamanı JavaScript əməliyyatları (typeof, in, Array.isArray, müqayisələr) ilə özün yazırsan, TypeScript də həmin yoxlamalardan nəticə çıxarır. Bu, narrowing-dir, növbəti mövzu.

Annotasiya yoxlama deyil, vəddir. Proqrama kənardan gələn datanı heç nə yoxlamır:

TypeScript
interface Product {
  title: string;
  price: number;
}

const product: Product = JSON.parse('{"title":"Kettle","price":"25"}');
const total = product.price + 5; // "255": icra zamanı price string-dir

JSON.parse any qaytarır, ona görə TypeScript annotasiyanı sual vermədən qəbul edir. await response.json() üçün də eyni şey doğrudur; localStorage-dan, URL parametrlərindən və ya form sahələrindən oxunan hər şey isə, sonra ona hansı tipi aid etməyindən asılı olmayaraq, adi string kimi başlayır. Kompilyator sənin yazdığına inanır, data isə buna əhəmiyyət vermir. Kənardan gələn dəyərlər icra zamanı yoxlanmalıdır, əl ilə və ya sxem kitabxanası ilə; ayrıca mövzudur.

Tipin üzvlərini siyahı kimi almaq olmur. Proqram işləyərkən Product-ın hansı xassələri olduğunu soruşmağın yolu yoxdur, məsələn, form və ya cədvəl başlığı qurmaq üçün. Əks istiqamətdə get: icra zamanı mövcud olan dəyərdən başla və tipi ondan çıxar.

TypeScript
const productFields = ["title", "price"] as const;
type ProductField = (typeof productFields)[number]; // "title" | "price"

Massiv yaradılan JavaScript kodunda mövcuddur, tip də onun ardınca gəlir, ona görə ikisi bir-birindən ayrı düşə bilməz.

Eyni qayda yalnız tiplərə aid hər şeyə şamil olunur: type, interface, generic parametrləri, as assertion-ları və ! operatoru yoxa çıxır. Kodun bir parçası yalnız TypeScript-ə nəsə deyirsə, proqram işləyəndə heç nə etmir.

MiddleKonsepsiya

interface, yoxsa type alias?

Hər iki elan obyektin formasına ad verir və obyektlərin çoxu üçün istənilənini işlədə bilərsən:

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

type UserRecord = {
  id: string;
  name: string;
};

Struktur tipləşdirmə sayəsində birinə uyğun gələn dəyər digərinə də uyğun gəlir. Fərqlər onların başqa nələr bacardığındadır.

Type alias istənilən tipə ad verə bilər. Union-lar, literal tiplər, tuple-lar, funksiya tipləri və başqa tiplərdən hesablanan tiplər (mapped və conditional tiplər) üçün type lazımdır:

TypeScript
type Status = "idle" | "loading" | "done";
type Pair = [string, number];
type OnSelect = (id: string) => void;

Interface-lər birləşir. Eyni scope-da eyni adlı iki interface elanı hər ikisinin üzvlərindən ibarət tək interface-ə çevrilir. Buna declaration merging (elanların birləşməsi) deyilir və sənə aid olmayan tiplərə, məsələn, brauzerin qlobal obyektinə və ya kitabxananın interface-inə üzv əlavə etməyin yolu məhz budur:

TypeScript
// globals.d.ts
interface Window {
  analytics?: { track(event: string): void };
}

// tətbiqin istənilən yerində
window.analytics?.track("page_view"); // tip yoxlamasından keçir

Eyni adlı ikinci type isə xətadır: "Duplicate identifier". Birləşmənin digər üzü odur ki, o, səssiz baş verir: eyni qlobal scope-dakı bir-biri ilə əlaqəsiz iki interface Config elanı heç bir xəbərdarlıq olmadan birləşir.

extends konflikti göstərir, & gizlədir. Miras aldığı xassəni uyğunsuz tiplə yenidən elan edən interface elan yerində xəta verir. Eyni konfliktli intersection isə kompilyasiya olunur və xassənin tipi never olur:

TypeScript
interface Base {
  id: string;
}

interface Broken extends Base {
  id: number; // xəta: Interface 'Broken' incorrectly extends interface 'Base'.
}

type Mixed = Base & { id: number }; // xəta yoxdur, amma Mixed["id"] never-dir

Handbook da eyni şeyi deyir: genişləndirmə ilə kəsişmə arasındakı əsas fərq konfliktlərin necə həll olunmasıdır.

Hansını seçməli

Handbook-un sadə qaydası belədir: "type-ın imkanları lazım olana qədər interface işlət". Bir çox komanda isə əksini edir: hər yerdə type yazır, interface-i isə birləşmə üçün saxlayır. Hər ikisi məntiqlidir. Vacib olan kod bazasının bir konvensiyaya əməl etməsidir, yaxşı olar ki, lint qaydası ilə; belə ki, oxucu seçimin nəsə demək olub-olmadığı barədə düşünməsin.

MiddleKonsepsiya

any, unknown və never

TypeScript-in elə ilk həftəsindən üç xüsusi tip qarşına çıxır. Narrowing mövzusu unknown-a daha dərindən baxır; burada isə hər birinin nə demək olduğunu görəcəksən.

any yoxlayıcını söndürür. any dəyər üzərində hər əməliyyata icazə var, any istənilən tipə mənimsədilə bilir, ondan oxuduğun hər şey də yenə any olur:

TypeScript
const data: any = JSON.parse('"hello"');
data.toFixed(2); // kompilyasiya olunur; icra zamanı TypeError atır
const n: number = data; // kompilyasiya olunur; n-də string var

any yayılır: JSON.parse-dan və ya response.json()-dan gələn bir any funksiya çağırışları və obyekt xassələri vasitəsilə tam tipli görünən koda axır. TypeScript tipi çıxara bilmədiyi yerdə, məsələn, annotasiyasız parametrdə də any-yə keçir; noImplicitAny bunu xətaya çevirir: "Parameter 'a' implicitly has an 'any' type."

unknown hər şeyi qəbul edir, heç nəyə icazə vermir. any kimi, hər dəyər unknown-a mənimsədilə bilir. any-dən fərqli olaraq, dəyərin nə olduğunu yoxlamayınca ondan istifadə edə bilməzsən:

TypeScript
const input: unknown = JSON.parse('"hello"');
input.toUpperCase();
// xəta: 'input' is of type 'unknown'.

if (typeof input === "string") {
  input.toUpperCase(); // OK: yoxlama onun string olduğunu sübut etdi
}

Buna görə unknown hələ yoxlamadığın hər şey üçün dürüst tipdir: parse olunmuş JSON, başqa pəncərədən gələn mesaj, tutulmuş xəta.

never-in heç bir dəyəri yoxdur. O, normal qayıtmayan, həmişə xəta atan funksiyanın qaytarma tipidir və bütün variantlar istisna olunandan sonra TypeScript-in dəyərə verdiyi tipdir:

TypeScript
function fail(message: string): never {
  throw new Error(message);
}

never istənilən tipə mənimsədilə bilir, never-in özündən başqa heç bir tip isə ona mənimsədilə bilmir. Tamlıq yoxlamaları (exhaustiveness check) məhz ikinci xassəyə əsaslanır: dəyəri never-ə mənimsət, kompilyator unutduğun hər halı göstərəcək.

Text
          accepts any value?    usable without a check?
any       yes                   yes (nothing is checked)
unknown   yes                   no
never     no (it has no values) -

Yaxşı işləyən qayda: datanın daxil olduğu kənarlarda unknown işlət, diff-də gördüyün hər any-yə isə kiminsə izah etməli olduğu qərar kimi bax.

MiddleKonsepsiya

Vacib kompilyator bayraqları

TypeScript-in nə qədər yoxladığı tsconfig.json-dan asılıdır və bunun çox hissəsini bir neçə bayraq həll edir:

JSON
{
  "compilerOptions": {
    "strict": true,
    "noUncheckedIndexedAccess": true
  }
}

strict bütün strict ailəsini qoşur: noImplicitAny, strictNullChecks, strictFunctionTypes, strictBindCallApply, strictPropertyInitialization, noImplicitThis, useUnknownInCatchVariables, alwaysStrict və strictBuiltinIteratorReturn. TypeScript 6.0-dan bəri strict default halda qoşuludur, amma layihədə o yenə də söndürülmüş ola bilər: məsələn, köhnə konfiqurasiyada "strict": false yazılıb, ya da layihə köhnə TypeScript versiyasındadır. Tiplərə güvənməzdən əvvəl konfiqurasiyanı yoxla.

strictNullChecks ən çox bug tutan bayraqdır. Onsuz null və undefined hər tipə daxildir, ona görə kompilyator sənə dəyərin olmaya biləcəyini deyə bilmir. Onunla isə bunlar ayrıca tiplərdir və onları emal etməlisən:

TypeScript
const root = document.querySelector("#app"); // Element | null
root.textContent = "Ready";
// xəta: 'root' is possibly 'null'.

const big = [1, 2, 3].find((n) => n > 5); // number | undefined

Bu xətaların hər biri əks halda icra zamanı baş verəcək bir "Cannot read properties of null"-dur.

noImplicitAny yoxlayıcının səssizcə təslim olmasının qarşısını alır: tipi çıxarıla bilməyən parametr any əvəzinə xəta olur.

noUncheckedIndexedAccess strict-ə daxil deyil. Onsuz massiv elementini və ya record girişini indekslə oxuyanda TypeScript dəyərin həmişə orada olduğunu güman edir:

TypeScript
const scores: Record<string, number> = {};
const ada = scores["ada"]; // number, amma icra zamanı undefined

const names: string[] = [];
const first = names[0]; // string, amma icra zamanı undefined

Bayraq qoşulanda bunlar number | undefined və string | undefined olur, yəni çatışmayan halı emal etməli olursan. Bu, bir az səs-küy əlavə edir (indeksli for dövrü də yoxlama tələb edir, for...of isə yox), amma real bug-lar tapır. strict-dən kənarda qalan başqa bir bayraq exactOptionalPropertyTypes-dır: onunla optional color?: string xassəsini yazmamaq olar, amma tip undefined-i ehtiva etmirsə, { color: undefined } xətadır.

Köhnə kod bazasında strict-i qoşmaq yüzlərlə xəta verə bilər. Bayraqları bir-bir qoş, əvvəlcə strictNullChecks-i, və hər xətaya sual kimi bax: bu dəyər burada həqiqətən olmaya bilərmi?

SeniorVeb platforma

Silinə bilməyən sintaksis

TypeScript sintaksisinin demək olar ki, hamısı yalnız tiplərə aiddir və silinəndə yoxa çıxır. Bir neçə köhnə imkan isə fərqlidir: onlar öz JavaScript kodunu yaradır.

TypeScript
enum Status {
  Active,
  Banned,
}

namespace Config {
  export const retries = 3;
}

class User {
  constructor(public name: string) {} // parameter property
}

tsc kompilyatoru enum-u addan rəqəmə və rəqəmdən ada girişləri olan obyektə, namespace-i obyekti dolduran funksiyaya, parameter property-ni isə sahəyə və konstruktordakı this.name = name sətrinə çevirir. Bunların heç birini simvolları silməklə almaq olmur, ona görə tipləri yalnız silən alət onları emal edə bilmir. Node-un daxili type stripping-i proqramı işə salmaqdan imtina edir:

Text
SyntaxError [ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX]: TypeScript enum is not supported in strip-only mode

Eyni şey import x = require("...") və export = üçün də keçərlidir. Yalnız tiplərdən ibarət namespace isə problem deyil, çünki tam silinir. esbuild və Sucrase kimi transpilyatorlar enum-ları çevirir; bu məhdudiyyət yalnız tipləri silən alətlərə aiddir.

erasableSyntaxOnly

TypeScript 5.8 erasableSyntaxOnly bayrağını əlavə etdi. Onunla tsc bu konstruksiyaları proqram işə düşməyəndə yox, elə redaktorda göstərir ("This syntax is not allowed when 'erasableSyntaxOnly' is enabled."). Buraxılış qeydləri onu verbatimModuleSyntax ilə birlikdə işlətməyi tövsiyə edir; bu bayraq yalnız tip olan importlar üçün import type tələb edir. Bu da eyni səbəbdən vacibdir: tipləri silən alət hər dəfə bir fayla baxır və import olunan adın yalnız tip olduğunu bilə bilmir. Node-un sənədləri xəbərdarlıq edir ki, type açar sözü olmadan o, importu dəyər importu kimi qəbul edir və bu, icra zamanı xəta verir.

Silinə bilən əvəzləyicilər adi JavaScript-dir:

TypeScript
// enum əvəzinə: obyekt və ondan çıxarılan union tip
const Status = { Active: "active", Banned: "banned" } as const;
type Status = (typeof Status)[keyof typeof Status]; // "active" | "banned"

// parameter property əvəzinə: sahə və mənimsətmə
class User {
  name: string;
  constructor(name: string) {
    this.name = name;
  }
}

Dəyərləri olan namespace əvəzinə ES modulu və onun export-larını işlət.

Bu o demək deyil ki, tsc və ya enum-u dəstəkləyən transpilyatorla build olunan layihədə enum işlətmək səhvdir. Amma Node-da type stripping Node 25.2-dən stabildir və silinə bilən sintaksislə yazılmış kod istənilən alətlə, tipləri yalnız silənlər də daxil olmaqla, işləyir.

SeniorNümunə

Brendlərlə nominal davranan tiplər

Struktur tipləşdirmənin bir bədəli var: eyni formalı iki tipi bir-birindən ayırmaq olmur. Type alias-lar kömək etmir, çünki alias eyni tip üçün sadəcə yeni addır:

TypeScript
type UserId = string;
type OrderId = string;

declare function cancelOrder(id: OrderId): void;
declare const userId: UserId;

cancelOrder(userId); // kompilyasiya olunur: hər ikisi sadəcə string-dir

Belə dəyərləri qarışdırmaq real riskdirsə (müxtəlif növ obyektlərin id-ləri, müxtəlif valyutalarda məbləğlər, yoxlanmış və yoxlanmamış string), tipləri brend ilə uyğunsuz edə bilərsən: brend yalnız tipdə mövcud olan bir xassə ilə intersection-dır.

TypeScript
type UserId = string & { readonly __brand: "UserId" };
type OrderId = string & { readonly __brand: "OrderId" };

declare function cancelOrder(id: OrderId): void;
declare const userId: UserId;

function toOrderId(raw: string): OrderId {
  if (!/^ord_\d+$/.test(raw)) throw new Error(`Not an order id: ${raw}`);
  return raw as OrderId;
}

cancelOrder(toOrderId("ord_17")); // OK
cancelOrder("ord_17"); // xəta: Argument of type 'string' is not assignable to parameter of type 'OrderId'.
cancelOrder(userId); // xəta: Argument of type 'UserId' is not assignable to parameter of type 'OrderId'.

Adi string-də __brand yoxdur, iki brendin isə literal tipləri fərqlidir, ona görə heç biri digərinə çevrilmir. Brendli dəyər yenə də string-dir: string gözlənilən hər yerə ötürülə bilir və bütün string metodları ondadır.

Brend sırf tip məlumatıdır. İcra zamanı dəyər elə ilkin string-dir, __brand mövcud deyil və onu heç nə yoxlamır. Ona görə yeganə as toOrderId kimi əvvəlcə yoxlayan funksiyanın içində olmalıdır: kompilyatora "mənə inan" dediyin yeganə yer odur, deməli, iddianı orada doğru et. Brendlər serializasiyadan da sağ çıxmır: JSON.parse-dan və ya serverdən qayıdan id-lər adi string-dir və yenə həmin funksiyadan keçməlidir.

Klasslar isə real nominal yoxlama verir. private və ya #private üzvü olan klass yalnız öz nümunələri (instance) və alt klasslarının nümunələri ilə uyğundur, eyni formalı başqa klassla yox; #field in value isə icra zamanı klassı yoxlayır:

TypeScript
class Cents {
  #value: number;
  constructor(value: number) {
    this.#value = value;
  }
  static is(x: object): x is Cents {
    return #value in x;
  }
}

Brendlər dəyərlərin yaradıldığı yerlərdə bir az əlavə iş tələb edir. Onları hər string üçün yox, qarışıqlığın baha başa gələcəyi və review-da gözdən qaça biləcəyi yerlərdə işlət.

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

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

30 saniyəlik cavab. "TypeScript JavaScript üstəgəl tip yoxlayıcısıdır. Kod JavaScript-ə çevriləndə tiplər silinir, ona görə onlar proqramın nə etdiyini heç vaxt dəyişmir və icra zamanı datanı heç vaxt yoxlamır. Uyğunluq struktur əsaslıdır: dəyərdə tələb olunan üzvlər varsa, adından asılı olmayaraq tipə uyğun gəlir; bir əlavə qayda ilə: təzə obyekt literalları tanınmayan xassələrə görə yoxlanır. tsc yoxlayır; Node-un type stripping-i, esbuild və ya Sucrase isə yalnız tipləri silir, ona görə tip yoxlaması CI-da ayrıca addım olmalıdır."

Gözlənilən suallar

  • Struktur, yoxsa nominal, və fərq nədir? Adını heç vaxt çəkmədiyi interface-ə uyğun gələn klass göstər, sonra nominal davranış almağın yolu kimi brendləri xatırlat.
  • Artıq xassəsi olan obyekt niyə burada xəta verir, orada isə yox? Artıq xassə yoxlaması yalnız təzə obyekt literallarına aiddir.
  • Dəyərin User olduğunu icra zamanı yoxlamaq olarmı? Interface ilə yox: o silinir. typeof və in ilə yoxlama yaz və ya sxem işlət; instanceof yalnız klasslarla işləyir.
  • interface, yoxsa type? Union-lar və hesablanan tiplər type tələb edir; interface-lər birləşir və extends konfliktlərini göstərir. Komandanın konvensiyasını və onun səbəbini de.
  • any, yoxsa unknown? any yoxlamanı söndürür; unknown istifadədən əvvəl yoxlamağa məcbur edir.
  • node app.ts bu enum-u niyə qəbul etmir? Node yalnız tipləri silir; enum-lar, dəyərli namespace-lər və parameter property-lər yaradılan kod tələb edir. erasableSyntaxOnly onları redaktorda göstərir.

Bal itirdən səhvlər

  • TypeScript-in kodu "icra zamanı təhlükəsiz" etdiyini və ya API cavablarını yoxladığını demək. O, kodunu sənin öz iddialarına qarşı yoxlayır; kənardan gələn data sən yoxlayana qədər yoxlanmamış qalır.
  • Daha dar qaytarma tipini filtr saymaq. O, xassələri JSON.stringify-dan yox, yalnız yoxlayıcıdan gizlədir.
  • Layihə build olunursa, tip yoxlamasından da keçdiyini güman etmək. tsc-ni nəyin işə saldığını soruş.
  • Strict ailəsini əzbər sadalayıb hansı bayraqların daha vacib olduğunu bilməmək: strictNullChecks, noImplicitAny və strict-ə daxil olmayan noUncheckedIndexedAccess.

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

Tiplərin harada dayandığından danış: datanın daxil olduğu sərhədlər, yoxlayıcını yan keçən as və any, nə qədər yoxlanacağını həll edən tsconfig bayraqları və ümumiyyətlə yoxlanıb-yoxlanmayacağını həll edən pipeline. Böyük kod bazasında id-lər və ya pul üçün brendləri nə vaxt tətbiq edəcəyini və onların qiymətini, yəni belə dəyərlərin yaradıldığı hər yerdə yoxlayan funksiyanı göstər.

JuniorYoxlama siyahısı

TypeScript tiplərini 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. Tip səhvləri açıq-aşkar üzə çıxmır: kod yenə JavaScript-ə çevrilir və işləyir, səhv fərziyyə isə sonra production-da pis data və ya çökmə kimi görünür.

  • CI-da tip yoxlayıcısını nəsə işə salırmı? Tipləri yalnız silən alətlər (Node, esbuild, Sucrase) tip xətaları ilə dolu kodu da build edir və işə salır. Pipeline-da tsc --noEmit-i və ya tipləri yoxlayan framework build-ini axtar; bir dəfə tipi qəsdən poz və pipeline-ın düşdüyünə əmin ol.
  • Kənardan gələn data yoxlanmış kimi annotasiya olunubmu? const user: User = await response.json() və ya JSON.parse(text) as Config heç kimin yoxlamadığı vəddir. Parse olunmuş JSON, storage və URL dəyərləri üzərindəki annotasiyaları və as ifadələrini axtar: icra zamanı yoxlama və ya sxem onları təsdiqləyənə qədər onlar unknown qalmalıdır.
  • API-yə, loga göndərilən və ya JSON.stringify ilə çevrilən obyektdə yalnız tipində sadalanan sahələr varmı? Daha dar tip xassələri silmir, ona görə bütöv User-i PublicUser kimi qaytarmaq hər şeyi göndərir. Belə obyektlərin sahə-sahə qurulduğunu yoxla və real payload-a network panelində və ya logda bax.
  • Diff any, as any, @ts-ignore və ya @ts-expect-error əlavə edirmi? Onların hər biri yoxlayıcını bir dəyər və ya sətir üçün söndürür. Diff-də onları axtar; hər biri şərhdə yazılmış səbəb tələb edir, əvəzində isə adətən unknown və yoxlama işlətmək mümkündür.
  • tsconfig.json dəyişibmi? strict, strictNullChecks və ya noImplicitAny-ni söndürmək xətaları yalnız dəyişən fayllarda yox, bütün layihədə gizlədir. Konfiqurasiyadakı hər dəyişikliyi oxu və tsc --noEmit-i köhnə və yeni parametrlərlə işə sal.
  • Layihə type stripping ilə işləyirsə, kodda enum, dəyərli namespace və ya parameter property varmı? Node-un daxili stripping-i onlarda başlanğıcda ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX ilə dayanır. Faylı Node ilə işə sal və ya erasableSyntaxOnly-ni qoş ki, tsc onları göstərsin.

Ö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