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

TypeScript

Generic-lər

Generic-lər funksiyaya və ya tipə daxil olan tiplərlə ondan çıxan tiplər arasındakı əlaqəni necə saxlayır: tip parametrləri və çağırış yerində tipin çıxarılması, məhdudiyyətlər, keyof və indexed access, default-lar, generic klasslar, lazımsız tip parametrləri, const tip parametrləri, NoInfer və variance.

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

Generic-lər nə üçündür

Çox tiplə işləyən funksiya da nə qaytardığını deməlidir. Massivin ilk elementini qaytaran köməkçi funksiyanı götürək. any ilə o, istənilən massivi qəbul edir, amma içəri girənlə çölə çıxan arasındakı əlaqə itir:

TypeScript
function firstAny(items: any[]): any {
  return items[0];
}

const id = firstAny(["a1", "b2"]); // id: any
id.toFixed(2); // compile olunur, icra zamanı TypeError atır

any əvəzinə unknown təhlükəsizdir, amma onda hər çağıran tipini onsuz da bildiyi dəyəri ilə daraltmalı olur. Hər tip üçün ayrıca funksiya yazmaq (firstString, firstNumber) da miqyaslanmır.

bunu tip parametri ilə həll edir: bucaqlı mötərizələrdə yazılan və hər çağırışda doldurulan tip yer tutucusu.

TypeScript
function first<T>(items: T[]): T | undefined {
  return items[0];
}

const a = first(["a1", "b2"]); // a: string | undefined
const n = first([1, 2, 3]); // n: number | undefined

a?.toUpperCase(); // OK
n?.toUpperCase(); // Error: Property 'toUpperCase' does not exist on type 'number'.

İmzanı cümlə kimi oxu: "istənilən T tipi üçün mənə T massivi ver, mən T qaytarım, massiv boşdursa undefined". Funksiya artıq konkret bir tip vəd etmir; arqumentlə nəticə arasında əlaqə vəd edir. any-nin atıb itirdiyi də məhz bu əlaqədir.

| undefined dürüst yazılıb. noUncheckedIndexedAccess açıq deyilsə, items[0] T tipində sayılır, yəni kompilyator qaytarılan tip kimi : T-ni də qəbul edərdi, funksiya isə [] üçün yenə undefined qaytarardı.

Artıq istifadə etdiyin generic-lər

Çoxlu daxili tip generic-dir. string[] Array<string>-in qısa yazılışıdır, fetch() Promise<Response> qaytarır, Map<K, V> və Set<T> isə açar və dəyər tiplərini parametr kimi alır.

Tip parametri nə deyil

T yalnız tip yoxlayıcısı üçün mövcuddur. Hər tip kimi o da kod kompilyasiya olunanda , ona görə funksiyanın gövdəsi T-nin nə olduğunu soruşa bilməz: typeof T yoxdur, first<number> və first<string> isə tam eyni JavaScript-i icra edir. Generic funksiya qəbul etdiyi hər tip üçün işləməlidir.

Qısa imzalarda tək hərf adlar qəbul olunub: tip üçün T, açar üçün K, dəyər üçün V. Uzun imzada isə TItem və ya Item kimi ad daha yaxşı oxunur.

JuniorKonsepsiya

Tip arqumentləri və tipin çıxarılması

Tip arqumentini özün ötürə bilərsən, ya da qoy TypeScript onu özü müəyyən etsin:

TypeScript
first<string>(["a", "b"]); // açıq yazılıb
first(["a", "b"]); // çıxarılıb: T string-dir

Tip arqumentinin çağırışdan müəyyən edilməsi , yəni tipin çıxarılmasıdır. TypeScript hər arqumenti parametrinin tipi ilə tutuşdurur: ["a", "b"] string[]-dir, parametr T[]-dir, deməli T string-dir. Çıxarılmaya üstünlük ver; tip arqumentini yalnız çıxarmaq üçün heç nə olmayanda və ya TypeScript nəzərdə tutmadığın tipi seçəndə yaz.

Çıxarılma callback-lərə də keçir

Bir neçə tip parametri olanda çıxarılma arqumentlər üzrə irəliləyir:

TypeScript
function map<T, U>(items: T[], fn: (item: T) => U): U[] {
  return items.map(fn);
}

const lengths = map(["a", "bb"], (s) => s.length); // number[]

T massivdən gəlir, ona görə callback-in s parametri annotasiyasız da string olur (callback kontekstə görə tiplənir), U isə callback-in qaytardığından gəlir.

Çıxarılma başqa tip seçəndə

TypeScript
function combine<T>(a: T[], b: T[]): T[] {
  return a.concat(b);
}

combine([1, 2], ["x"]); // Error: Type 'string' is not assignable to type 'number'.
combine<string | number>([1, 2], ["x"]); // OK: nə istədiyini açıq dedin

T birinci massivdən number kimi çıxarılır, ikinci massiv isə sonra number[] ilə yoxlanır. Tipləri qarışdırmaq həqiqətən niyyətindirsə, bunu açıq tip arqumenti ilə bildir.

Çıxarmaq üçün heç nə olmayanda

TypeScript
const byId = new Map(); // Map<any, any>: içində saxlanan heç nə yoxlanmır
const tags = new Set(); // Set<unknown>
const users = new Map<string, User>(); // içinə nə qoyulacağını de

Boş kolleksiya çıxarılmaya heç bir namizəd vermir, ona görə tip any-yə və ya unknown-a düşür. Tip arqumentlərini kolleksiyanı yaradanda ötür.

Bilməyə dəyən iki detal

  • Açıq tip arqumentləri ya hamısı, ya heç biri prinsipi ilə işləyir: map<string>(…) "Expected 2 type arguments, but got 1." xətası verir, çatışmayanların default-u yoxdursa.
  • Literal tiplər harada işləndiyindən asılı olaraq ya saxlanır, ya genişlənir. const x = identity("hi") (identity<T>(value: T): T ilə) "hi" verir, let x = identity("hi") string verir, first(["a", "b"]) isə "a" | "b" | undefined yox, string | undefined verir.
JuniorKonsepsiya

extends ilə məhdudiyyətlər

Generic funksiyanın içində T istənilən tip ola bilər, ona görə T ilə yalnız hər tip üçün keçərli olanı edə bilərsən:

TypeScript
function longest<T>(a: T, b: T): T {
  return a.length >= b.length ? a : b; // Error: Property 'length' does not exist on type 'T'.
}

Məhdudiyyət (constraint) T-nin hansı tipləri qəbul etdiyini daraldır, əvəzində funksiyanın gövdəsinə nəyə arxalana biləcəyini deyir:

TypeScript
function longest<T extends { length: number }>(a: T, b: T): T {
  return a.length >= b.length ? a : b;
}

longest("apple", "fig"); // OK: sətirlərin length-i var
longest([1, 2], [3]); // OK: T number[]-dir
longest(10, 20); // Error: Argument of type 'number' is not assignable to parameter of type '{ length: number; }'.

Burada extends klass irsiyyəti yox, "mənimsədilə bilir" (assignable) deməkdir. İstənilən tip məhdudiyyət ola bilər: T extends string, T extends object, T extends readonly unknown[], T extends (...args: never[]) => unknown.

Niyə parametri sadəcə məhdudiyyət tipi ilə yazmayaq?

TypeScript
function longestLoose(a: { length: number }, b: { length: number }) {
  return a.length >= b.length ? a : b;
}

longestLoose("apple", "fig").toUpperCase(); // Error: Property 'toUpperCase' does not exist on type '{ length: number; }'.
longest("apple", "fig").toUpperCase(); // OK

Tip parametri olmayan versiya eyni arqumentləri qəbul edir, amma { length: number } qaytarır: çağıran sətir ötürüb, geri isə artıq sətir olmayan nəsə alır. Məhdudiyyət T-də nə olmalı olduğunu deyir, tip parametri isə onda olan qalan hər şeyi saxlayır.

Klassik səhv: yalnız məhdudiyyətə uyğun gələni qaytarmaq

TypeScript
function minimumLength<T extends { length: number }>(obj: T, minimum: number): T {
  if (obj.length >= minimum) return obj;
  return { length: minimum }; // Error
}

Xəta belədir: "'{ length: number; }' is assignable to the constraint of type 'T', but 'T' could be instantiated with a different subtype of constraint '{ length: number; }'." İmza length-i olan istənilən obyekti yox, içəri girən tipin özünü qaytarmağı vəd edir. number[] ötürən çağıran geri number[] kimi tiplənmiş { length: 6 } alardı və .slice() çağıranda proqram çökərdi. TypeScript handbook-u məhz bu nümunəni göstərir.

Düzəliş ya həqiqi T qaytarmaq, ya da qaytarılan tipi { length: number } etməkdir. as T əlavə etmək xətanı yox edir, çöküşü isə yerində saxlayır.

MiddleKonsepsiya

Generic funksiyalarda keyof və indexed access

İki tip operatoru generic-ləri obyektlər üçün faydalı edir: keyof T T-nin xassə adlarının union-ıdır, T[K] isə, yəni indexed access tipi, K xassəsinin tipidir. Bir tip parametrini digərinə bağlayan məhdudiyyətlə birlikdə onlar tip baxımından təhlükəsiz xassə oxuyan funksiya verir. TypeScript handbook-unun nümunəsi budur:

TypeScript
function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
  return obj[key];
}

const user = { id: 7, name: "Aysel", email: null as string | null };

getProperty(user, "id"); // number
getProperty(user, "email"); // string | null
getProperty(user, "phone"); // Error: Argument of type '"phone"' is not assignable to parameter of type '"id" | "name" | "email"'.

K extends keyof T "K T-nin açarlarından biridir" deməkdir. Çağırış zamanı T user-dən, K isə ötürdüyün sətirdən "id" literal tipi kimi çıxarılır, ona görə qaytarılan T[K] tipi number olur.

Niyə iki tip parametri

TypeScript
function getLoose<T>(obj: T, key: keyof T) {
  return obj[key];
}

getLoose(user, "id"); // string | number | null

key: keyof T olanda funksiya hansı açarın ötürüldüyünü artıq bilmir, ona görə nəticə T[keyof T] olur: bütün xassə tiplərinin union-ı. Əlavə K məhz konkret açarı yadda saxlamaq üçündür. Eyni şablon setter-i də tipləyir, burada dəyər açara uyğun gəlməlidir:

TypeScript
function setProperty<T, K extends keyof T>(obj: T, key: K, value: T[K]): void {
  obj[key] = value;
}

setProperty(user, "id", "7"); // Error: Argument of type 'string' is not assignable to parameter of type 'number'.

Eyni yolla T[K][] qaytaran pluck(items, key), açara görə sıralayan və ya qruplaşdıran köməkçilər, setValue("email", value) çağırışında dəyəri sahəyə görə yoxlayan form kitabxanaları tiplənir.

Açarlar haqqında bilməli olduğun iki şey

  • Object.keys(obj) (keyof T)[] yox, string[] qaytarır. TypeScript-də tipləmə , ona görə obyektin tipində sadalanandan çox xassəsi ola bilər və TypeScript hər açarın keyof T olduğuna zəmanət vermir. Belə açarla obj-yə müraciət strict rejimində xəta verir: "Element implicitly has an 'any' type because expression of type 'string' can't be used to index type …". Gözlədiyin açarların tiplənmiş siyahısı üzərində dövr et, artıq açar ola bilməyəcəyini bildiyin yerdə isə bir dəfə assertion yaz (as (keyof T)[]) və səbəbini şərhdə izah et.
  • Index signature-un keyof-una number da daxildir. { [key: string]: number } üçün keyof string | number-dir, çünki JavaScript rəqəmli xassə açarlarını sətirə çevirir.
MiddleKonsepsiya

Generic interface-lər, klasslar və default-lar

Tip parametrləri interface-lərə, type alias-lara və klasslara da yazılır. Generic tip şablondur: harada işlədilirsə, orada tip arqumentləri lazımdır.

TypeScript
interface ApiResponse<T> {
  data: T;
  status: number;
}

type Result<T, E = Error> = { ok: true; value: T } | { ok: false; error: E };

const response: ApiResponse<User[]> = { data: [], status: 200 };
const parsed: Result<number> = { ok: false, error: new Error("Not a number") };
let broken: ApiResponse; // Error: Generic type 'ApiResponse<T>' requires 1 type argument(s).

Default tip parametrləri

E = Error default-dur: onu yazmasan, Result<number> Result<number, Error> deməkdir. Handbook-un sadaladığı qaydalar, qısaca:

  • default-u olan tip parametri məcburi deyil, məcburi parametrlər isə ondan sonra gələ bilməz: <T = string, U> "Required type parameters may not follow optional type parameters." xətası verir;
  • default məhdudiyyəti ödəməlidir: <T extends string = number> xətadır;
  • tip arqumentlərini ötürəndə yalnız məcburi olanları yazmaq kifayətdir;
  • çağırışda çıxarılma heç bir namizəd tapmayanda unknown əvəzinə default işlədilir.

Generic klasslar

TypeScript
class Cache<K, V> {
  #items = new Map<K, V>();

  get(key: K): V | undefined {
    return this.#items.get(key);
  }

  set(key: K, value: V): this {
    this.#items.set(key, value);
    return this;
  }
}

const prices = new Cache<string, number>();
prices.set("apple", 1.2);
prices.set("pear", "cheap"); // Error: Argument of type 'string' is not assignable to parameter of type 'number'.

Klassın tip parametrləri onun instance-larına aiddir: hər new Cache<…>() həmin obyekt üçün K və V-ni təyin edir. Static üzvləri bütün instance-lar bölüşür, ona görə onlar bu parametrlərdən istifadə edə bilməz: static empty: V "Static members cannot reference class type parameters." xətası verir. Tip arqumenti olmayanda və çıxarmaq üçün heç nə olmayanda new Cache() Cache<unknown, unknown> olur.

Klassa, yoxsa metoda?

Bütün metodlar tip parametrini bölüşürsə, onu klassa yaz, qiymətlər keşində olduğu kimi. Hər çağırış müstəqildirsə, metoda yaz:

TypeScript
class Logger {
  tap<T>(value: T): T {
    console.log(value);
    return value;
  }
}

const order = new Logger().tap({ id: 1 }); // { id: number }

Logger<T> səbəbsiz yerə hər tip üçün ayrıca logger yaratmağa məcbur edərdi.

MiddleTipik səhvlər

Generic nə vaxt lazım deyil

Tip parametri yerini iki şeyi bir-birinə bağlamaqla qazanır: arqumentlə nəticəni, iki arqumenti, açarla onun dəyərini. TypeScript handbook-u bunu qayda kimi deyir: tip parametri yalnız bir yerdə görünürsə, ona həqiqətən ehtiyac olub-olmadığını ciddi şəkildə yenidən düşün. Çıxarılan qaytarma tipi də yer sayılır.

Bir dəfə işlənib: sadəcə tipi yaz

TypeScript
function greet<S extends string>(name: S): void {
  console.log("Hello, " + name);
}

S heç nəyi bağlamır, greet(name: string) isə eyni şeyi daha sadə deyir. format<T extends string | number>(value: T): string də belədir: union tipli parametr işi görür.

Yalnız qaytarma tipində: maskalanmış yoxlanmayan cast

TypeScript
async function fetchJson<T>(url: string): Promise<T> {
  const response = await fetch(url);
  return response.json(); // any, T kimi qəbul olunur
}

const me = await fetchJson<User>("/api/me");

T yalnız qaytarma tipində görünür, ona görə onu data ilə heç nə bağlamır. response.json() Promise<any> qaytarır, any istənilən T-yə mənimsədilə bilir və kompilyator çağıranın istədiyi hər tipi qəbul edir. Çağırış tiplənmiş API kimi görünür, amma əslində bir neçə əlavə addımla yazılmış (as User): server { "error": "expired" } cavabı versə, me.name undefined olur və bunu heç bir tip tutmur. parseJson<T>(text), storage.get<T>(key) və oxşar köməkçilərin də problemi eynidir.

Bunun əvəzinə unknown qaytar və sərhəddə yoxla, ya da validator-u parametr kimi al ki, tip parametri real nəyisə bağlasın:

TypeScript
async function fetchJson<T>(url: string, parse: (data: unknown) => T): Promise<T> {
  const response = await fetch(url);
  return parse(await response.json());
}

const me = await fetchJson("/api/me", parseUser); // T User-dir, parseUser-dən çıxarılıb

İndi T parser-dən gəlir və data kimsə ondan istifadə etməzdən əvvəl yoxlanır.

Tip parametrlərini aşağı endir, sayını azalt

Handbook-dan daha iki tövsiyə:

TypeScript
function firstElement1<T>(arr: T[]) {
  return arr[0]; // T qaytarır
}

function firstElement2<T extends any[]>(arr: T) {
  return arr[0]; // any qaytarır
}

firstElement2([1, 2, 3]) any qaytarır, çünki gövdə element tipini gözləmək əvəzinə any[] məhdudiyyətinin indeksinə müraciət edir. Tip parametri səni maraqlandıran şey olsun, burada bütöv arqument yox, element. Func extends (arg: T) => boolean kimi heç nəyi bağlamayan tip parametri isə tip arqumentlərini açıq yazan çağıranlara sadəcə bir arqument artıq yazdırır.

MiddleNümunə

Nümunə: tiplənmiş event emitter

Tiplənmiş event emitter indiyədək gördüyümüz hər şeyi birləşdirir: məhdudiyyət, keyof, indexed access, klassda və onun metodlarında tip parametrləri. Bir tip bütün event-ləri və onların payload-larını təsvir edir; on və emit səhv adları və səhv payload-ları rədd edir.

TypeScript
type AppEvents = {
  login: { userId: string };
  logout: undefined;
  "cart:add": { productId: string; quantity: number };
};

type Handler<T> = (payload: T) => void;

class Emitter<Events extends Record<string, unknown>> {
  #handlers: { [K in keyof Events]?: Set<Handler<Events[K]>> } = {};

  on<K extends keyof Events>(type: K, handler: Handler<Events[K]>): () => void {
    const handlers = (this.#handlers[type] ??= new Set());
    handlers.add(handler);
    return () => handlers.delete(handler);
  }

  emit<K extends keyof Events>(type: K, payload: Events[K]): void {
    this.#handlers[type]?.forEach((handler) => handler(payload));
  }
}
  • Events emitter yaradılanda bir dəfə təyin olunur: new Emitter<AppEvents>().
  • K hər çağırışda event adından çıxarılır, ona görə Events[K] məhz həmin event-in payload-udur.
  • #handlers mapped tipdir (onların ayrıca mövzusu var): hər event üçün məcburi olmayan bir handler Set-i, hər biri həmin event-in payload-una görə tiplənib, heç bir any olmadan.
  • on abunəlikdən çıxma funksiyası qaytarır, ona görə çağıranlar handler-i yadda saxlamalı olmur.
TypeScript
const events = new Emitter<AppEvents>();

const off = events.on("cart:add", (item) => {
  console.log(item.quantity); // item: { productId: string; quantity: number }
});

events.emit("login", { userId: "u1" });
events.emit("login", { id: "u1" }); // Error: Object literal may only specify known properties, and 'id' does not exist in type '{ userId: string; }'.
events.emit("signup", {}); // Error: Argument of type '"signup"' is not assignable to parameter of type 'keyof AppEvents'.
events.emit("logout"); // Error: Expected 2 arguments, but got 1.
off();

Review edən nəyi soruşardı

  • Məhdudiyyət interface-ləri rədd edir. interface AppEvents { … } olsa, new Emitter<AppEvents>() "Index signature for type 'string' is missing in type 'AppEvents'" xətası verir: interface-lər gizli (implicit) index signature almır, type alias-lar isə alır. type istifadə et, ya da hər ikisini qəbul edən Events extends object məhdudiyyətini yaz.
  • Payload-u olmayan event-lər üçün də emit("logout", undefined) yazmaq lazımdır. İkinci arqumenti yalnız belə event-lər üçün məcburi olmayan etmək conditional tip tələb edir.
  • Tiplər payload-un haradan gəldiyi barədə heç nə demir. Kənardan gələn data (WebSocket mesajı, postMessage) emit olunmazdan əvvəl yoxlanmalıdır; emitter onu sadəcə ötürür.
SeniorKonsepsiya

const tip parametrləri və NoInfer

const tip parametrləri

Default olaraq çıxarılma massiv və obyektlərin içindəki literalları genişləndirir, çünki belə dəyərlər adətən sonradan dəyişir:

TypeScript
function createNavigator<T extends readonly string[]>(paths: T) {
  return (path: T[number]) => location.assign(path);
}

const navigate = createNavigator(["/", "/about", "/pricing"]);
navigate("/abuot"); // xəta yoxdur: T string[]-dir, deməli T[number] string-dir

Köhnə həll hər çağırandan as const istəmək idi. TypeScript 5.0-dan bəri funksiya bunu özü istəyə bilir, tip parametrinə const modifikatoru yazmaqla:

TypeScript
function createNavigator<const T extends readonly string[]>(paths: T) {
  return (path: T[number]) => location.assign(path);
}

const navigate = createNavigator(["/", "/about", "/pricing"]);
// T readonly ["/", "/about", "/pricing"]-dir
navigate("/about"); // OK
navigate("/abuot"); // Error: Argument of type '"/abuot"' is not assignable to parameter of type '"/" | "/about" | "/pricing"'.

T[number] number ilə indexed access-dir: tuple elementlərinin tiplərinin union-ı. Buraxılış qeydlərindən iki qayda:

  • const yalnız çağırışın içində yazılmış literallara təsir edir. const paths = ["/", "/about"]; createNavigator(paths) yenə string[] verir, çünki paths elan olunanda artıq genişlənib.
  • Məhdudiyyəti buraxılış qeydlərinin tövsiyə etdiyi kimi readonly string[] yaz: const çıxarılması readonly tuple-lar yaradır, readonly məhdudiyyət isə onları qəbul edir.

NoInfer

Tip parametri bir neçə parametrdə görünəndə onların hər biri çıxarılma üçün namizəddir. Bəzən parametrlərdən biri həqiqət mənbəyi olmalı, qalanları isə yalnız onunla yoxlanmalıdır:

TypeScript
function createStreetLight<C extends string>(colors: C[], defaultColor?: C) {}

createStreetLight(["red", "yellow", "green"], "blue"); // qəbul olunur: C "red" | "yellow" | "green" | "blue"-dur

TypeScript 5.4 NoInfer<T> utility tipini əlavə etdi. Parametrin tipini onunla bükmək həmin mövqeyi tip çıxarılmasından kənarlaşdırır; tipin özü isə C olaraq qalır:

TypeScript
function createStreetLight<C extends string>(colors: C[], defaultColor?: NoInfer<C>) {}

createStreetLight(["red", "yellow", "green"], "blue"); // Error: Argument of type '"blue"' is not assignable to parameter of type '"red" | "yellow" | "green" | undefined'.

5.4-dən əvvəl çıxış yolu yalnız bir dəfə işlənən ikinci tip parametri, D extends C, idi.

Hər iki nümunədə literal tiplər yalnız C extends string sayəsində saxlanır: primitiv tipi ehtiva edən məhdudiyyət "red" kimi literal namizədləri saxlayır. Məhdudiyyətsiz C isə sadəcə string kimi çıxarılardı və "blue" NoInfer ilə də keçərdi.

SeniorKonsepsiya

Variance-a qısa baxış

Dog Animal-a mənimsədilə bilirsə, Box<Dog> Box<Animal>-a mənimsədilə bilərmi? Bu, Box-un öz tip parametri ilə nə etdiyindən asılıdır. Bu xüsusiyyət variance adlanır və TypeScript onu tipin strukturuna baxıb özü müəyyən edir:

TypeScript
type Animal = { name: string };
type Dog = Animal & { bark(): string };

interface Getter<T> { get: () => T } // T yalnız çölə çıxır
interface Setter<T> { set: (value: T) => void } // T yalnız içəri girir

declare const getDog: Getter<Dog>;
declare const setAnimal: Setter<Animal>;
declare const setDog: Setter<Dog>;

const g: Getter<Animal> = getDog; // OK: kovariant
const s1: Setter<Dog> = setAnimal; // OK: kontravariant
const s2: Setter<Animal> = setDog; // Error: Type 'Setter<Dog>' is not assignable to type 'Setter<Animal>'.
  • Kovariant (T çıxış mövqeyində): generic tip T ilə eyni istiqamətdə gedir. It verən şey heyvan da verir.
  • Kontravariant (T giriş mövqeyində): istiqamət çevrilir. İstənilən heyvanı qəbul edən şey iti də qəbul edir, amma it handler-inə pişik vermək olmaz.
  • İnvariant: T həm içəri girir, həm çölə çıxır, ona görə heç bir istiqamət təhlükəsiz deyil.

TypeScript-in qəsdən güzəştə getdiyi yerlər

Metod sintaksisi. strict-in tərkibində olan strictFunctionTypes parametrləri bu ciddiliklə yalnız funksiya sintaksisində yoxlayır. tsconfig reference-i deyir ki, metodlar kənarda saxlanılıb, çünki mövcud klass iyerarxiyalarının çoxu, DOM-dakıların bir qismi də daxil, pozulardı:

TypeScript
interface Formatter<T> { format(value: T): string } // metod sintaksisi
interface StrictFormatter<T> { format: (value: T) => string } // property sintaksisi

declare const upper: Formatter<string>;
declare const strictUpper: StrictFormatter<string>;

const loose: Formatter<string | number> = upper; // qəbul olunur: loose.format(42) çökə bilər
const checked: StrictFormatter<string | number> = strictUpper; // Error

Massivlər. Massivlər dəyişkən olsa da, Dog[] Animal[]-a mənimsədilə bilir: push metoddur, ona görə onun parametri güzəştli qaydada müqayisə olunur. const animals: Animal[] = dogs; animals.push({ name: "Tom" }) kompilyasiya olunur və dogs-un içində bark-ı olmayan obyekt qoyur.

Bununla nə etməli

  • Öz tiplərindəki callback-ləri property sintaksisi ilə elan et, onChange: (value: T) => void, ki ciddi yoxlama işləsin.
  • Funksiya massivi yalnız oxuyursa, readonly T[] qəbul etsin: readonly Animal[] parametri Dog[]-u təhlükəsiz qəbul edir, çünki ona heç nə push etmək olmur.
  • Variance annotasiyaları TypeScript 4.7-dən var (interface Producer<out T>, interface Consumer<in T>), amma handbook onları çox spesifik problemlər üçün qabaqcıl imkan adlandırır: onlar struktur yoxlamanı dəyişmir və yalnız strukturun onsuz da malik olduğu variance-ı ifadə etməlidir. Gündəlik kodda qoy TypeScript onu özü çıxarsın.
SeniorMüsahibə məsləhətləri

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

30 saniyəlik cavab. "Generic-lər funksiyaya və ya tipə tip parametrləri qəbul etməyə imkan verir: o, çox tiplə işləyir və onlar arasındakı əlaqəni saxlayır. first<T>(items: T[]): T | undefined aldığı istənilən massivin element tipini qaytarır, any isə bu tipi itirərdi. TypeScript tip arqumentlərini adətən çağırışdan özü çıxarır. T extends { length: number } kimi məhdudiyyət tipdə nə olmalı olduğunu deyir, K extends keyof T və T[K] isə açarı onun dəyərinin tipinə bağlayır. Yalnız bir dəfə görünən tip parametri şübhəli əlamətdir; yalnız qaytarma tipindədirsə, maskalanmış cast-dır."

Gözlənilən suallar

  • Generic-lər, any və unknown arasında fərq? any yoxlamanı söndürür, unknown onu saxlayır, amma çağıranı narrowing etməyə məcbur edir, generic isə çağıranın öz tipini saxlayır.
  • getProperty, pluck və ya tiplənmiş event emitter yaz. İki tip parametri, K extends keyof T, T[K] qaytar; emitter üçün klassda event xəritəsi tipi və hər çağırışda çıxarılan K.
  • minimumLength niyə kompilyasiya olunmur? İmza çağıranın öz T-sini vəd edir, yalnız məhdudiyyətə uyğun gələn dəyər isə T deyil.
  • Tipin çıxarılması necə işləyir və tip arqumentlərini nə vaxt ötürürsən? Arqumentlərdən, oradan da callback-lərə; açıq şəkildə yalnız çıxarmaq üçün heç nə olmayanda (new Map<string, User>()) və ya çıxarılan tip nəzərdə tutduğun tip olmayanda.
  • const tip parametrləri və NoInfer nə edir? Çağırış yerində as const olmadan literal çıxarılması (TypeScript 5.0); parametri tip çıxarılmasından kənarlaşdırmaq ki, o yalnız yoxlansın (TypeScript 5.4).
  • Variance nədir? Verənlər (producer) kovariant, qəbul edənlər (consumer) kontravariant, hər ikisini edən tiplər invariantdır; metod parametrləri və massivlər qəsdən güzəştli yerlərdir.

Bal itirdən səhvlər

  • <T>-ni yalnız bir dəfə göründüyü funksiyalara əlavə etmək.
  • fetchJson<T>() və ya JSON.parse(text) as T-ni tip təhlükəsizliyi kimi təqdim etmək.
  • Generic xətasını imzanı düzəltmək əvəzinə as T və ya as any ilə susdurmaq.
  • Məhdudiyyətdəki extends-i klass irsiyyəti kimi başa düşmək.
  • Funksiyanın icra zamanı T-yə görə budaqlana biləcəyini demək. Tiplər silinir; yalnız dəyərləri yoxlamaq olar.

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

Çağıranlardan danış. Yaxşı generic API çıxarılmaya əsaslanır: çağıranlar tip arqumentlərini nadir hallarda yazır, xətalar isə tipin dərinliyini yox, səhv arqumenti göstərir. Generic-i nə vaxt ümumiyyətlə yazmayacağını de (bir konkret tip və ya sadə union), ortaq köməkçinin tiplərini necə test edəcəyini izah et: kompilyasiya olunmalı çağırışlar, üstəgəl // @ts-expect-error ilə işarələnmiş, kompilyasiya olunmamalı çağırışlar. Və zəmanətin harada bitdiyini de: sərhəddə generic yalnız arxasındakı yoxlama qədər doğrudur.

JuniorYoxlama siyahısı

Generic kodu review edərkən nəyi yoxlamalı

Yazmadığın generic kodu — komanda yoldaşının pull request-ini, kitabxananın nümunəsini, AI assistentin təklifini — review edəndə bu siyahıdan istifadə et. Səhv generic də kompilyasiya olunur; bunun qiyməti sonra üzə çıxır: çağıranlara sızan any kimi və ya heç kimin yoxlamadığı "tiplənmiş" nəticə kimi.

  • Hər tip parametri imzada, qaytarma tipi də daxil olmaqla, ən azı iki dəfə görünürmü? Bir dəfə görünən parametr heç nəyi bağlamır: onu məhdudiyyəti və ya konkret tiplə əvəz et və bax, hansısa çağırış yeri tipini itirirmi.
  • Tip parametri yalnız qaytarma tipində işlənibmi, fetchJson<T>() və ya parse<T>(text) kimi? Onda T-ni çağıran seçir və datanı heç bir kod yoxlamır: bu, yoxlanmayan cast-dır. unknown nəticə və yoxlama, ya da T-nin çıxarıldığı validator parametri axtar.
  • Gövdənin kompilyasiya olunması üçün as T, as any və ya @ts-ignore lazımdırmı? Adətən bu, imzanın gövdənin verə biləcəyindən çoxunu vəd etdiyini göstərir, çağıranın öz T-sini vəd edən funksiyadan { length: minimum } qaytarmaq kimi. Xətanı yox, imzanı və ya gövdəni düzəlt.
  • Funksiya məhdudiyyəti yox, tip parametrinin özünü qaytarırmı? T tipli arqument üçün { length: number } qaytarma tipi çağıranın tipini atır. Redaktorda çağırışın üzərinə gəl: sətir arqumenti geri sətir verməlidir.
  • Açar parametrləri K extends keyof T, dəyərlər isə T[K] ilə yazılıbmı? Cast ilə işlənən key: string və ya bütün xassə tiplərinin union-ını qaytaran key: keyof T açarla onun dəyəri arasındakı əlaqəni qırır. Çağırış yerində səhv yazılmış açar kompilyasiya olunmamalıdır.
  • Boş kolleksiyalara tip arqumentləri verilibmi? new Map() Map<any, any>-dir, yəni içində saxlanan heç nə yoxlanmır. Diff-də tip arqumentsiz new Map() və new Set() axtar.
  • Massivi yalnız oxuyan funksiyalar readonly T[] qəbul edirmi, öz tiplərindəki callback-lər property sintaksisi ilə yazılıbmı? Massivlər və metod parametrləri güzəştli yoxlanır; bu iki vərdiş kompilyatora daha geniş tip vasitəsilə edilən yazmaları və az şey qəbul edən handler-ləri tutmağa imkan verir.

Ö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