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

JavaScript-in dərinlikləri

Promise və async/await

JavaScript sonradan gələn nəticəni necə ifadə edir: promise-in vəziyyətləri və zəncirləri, async/await və onun mikrotapşırıqları, xətaların emalı, paralel iş və kombinatorlar, AbortController ilə ləğv, UI-da yalnız son sorğunun nəticəsi.

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

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

JuniorKonsepsiya

Promise nədir

hələ hazır olmayan nəticəni təmsil edən obyektdir: şəbəkə cavabı, taymer, faylın oxunması. Asinxron funksiya qəbul etmək əvəzinə dərhal promise qaytarır, sən isə ona reaksiyalar bağlayırsan.

Üç vəziyyət

  • pending (gözləmədə): iş hələ bitməyib;
  • fulfilled (yerinə yetirilib): iş dəyərlə bitib;
  • rejected (rədd edilib): iş səbəblə uğursuz olub, adətən bu səbəb Error obyektidir.

Fulfilled və rejected birlikdə settled (yekunlaşmış) adlanır. Promise ən çoxu bir dəfə yekunlaşır. Bundan sonra onun vəziyyəti və dəyəri bir daha dəyişmir, resolve və ya reject-in sonrakı çağırışları isə nəzərə alınmır.

JavaScript
function delay(ms, value) {
  return new Promise((resolve) => {
    setTimeout(() => resolve(value), ms);
  });
}

delay(500, "ready").then((value) => console.log(value)); // "ready" after 500 ms

new Promise-ə ötürülən funksiya executor adlanır. O, konstruktorun içində sinxron icra olunur və iki funksiya alır: resolve və reject. Executor xəta atsa, promise həmin xəta ilə rədd edilir.

Reaksiyalar həmişə sonra işləyir

then callback-i heç vaxt sinxron işləmir, promise artıq yekunlaşmış olsa belə. O, kimi növbəyə düşür və cari sinxron kod bitəndən sonra icra olunur:

JavaScript
const done = Promise.resolve(42);
done.then((value) => console.log("then " + value));
console.log("sync");
// sync
// then 42

"Həmişə asinxron" qaydası bütöv bir bug sinfini aradan qaldırır: callback-in məlumatın cache-də olub-olmamasından asılı olaraq gah dərhal, gah da sonra işləməsi problemini.

new Promise nə vaxt lazımdır

Nadir hallarda. fetch, response.json(), async funksiyalar və müasir API-lərin çoxu onsuz da promise qaytarır. new Promise yalnız callback və ya hadisə ilə işləyən API-ni bükmək üçündür, yuxarıda delay-in setTimeout-u bükdüyü kimi.

JuniorKonsepsiya

Zəncirləmə: then, catch və finally

then-in hər çağırışı yeni promise qaytarır. Bu yeni promise-in necə yekunlaşacağını callback-in nə etdiyi müəyyən edir:

  • dəyər qaytarır → yeni promise həmin dəyərlə fulfilled olur;
  • promise qaytarır → yeni promise onu izləyir, yəni zəncir gözləyir;
  • xəta atır → yeni promise həmin xəta ilə rejected olur.
JavaScript
fetch("/api/user")
  .then((response) => {
    if (!response.ok) throw new Error("HTTP " + response.status);
    return response.json();
  })
  .then((user) => fetch("/api/teams/" + user.teamId))
  .then((response) => response.json())
  .then((team) => renderTeam(team))
  .catch((error) => showError(error.message))
  .finally(() => hideSpinner());

Xətalar zəncirdə necə hərəkət edir

Rejection catch-ə (və ya then-in ikinci arqumentinə) çatana qədər bütün uğur handler-lərini ötürüb keçir. catch(fn) sadəcə then(undefined, fn) deməkdir. Handler adi qaydada qayıdırsa, zəncir bərpa olunur: növbəti then qaytarılan dəyəri alır. Zəncirin rejected qalmasını istəyirsənsə, xətanı yenidən at.

JavaScript
Promise.reject(new Error("offline"))
  .then(() => console.log("not called"))
  .catch((error) => {
    console.log("caught: " + error.message);
    return [];
  })
  .then((items) => console.log("items: " + items.length));
// caught: offline
// items: 0

finally

finally(fn) hər iki nəticədə işləyir, heç bir arqument almır və ilkin dəyəri və ya xətanı olduğu kimi ötürür. İstisna: fn xəta atsa və ya rədd edilmiş promise qaytarsa, nəticəni bu yeni xəta əvəz edir. Onu təmizləmə işləri üçün işlət: spinner-i gizlətmək, kilidi açmaq.

Tez-tez edilən səhvlər

  • then-in içində return-ü unutmaq: növbəti addım undefined alır və daxili promise-i gözləmir.
  • Promise-i qaytarıb zənciri davam etdirmək əvəzinə then-in içində yeni then yazmaq.
  • fetch-in 404 və ya 500 cavabında rədd ediləcəyini gözləmək. O, yalnız şəbəkə xətasında rədd edilir; yuxarıdakı kimi response.ok-u özün yoxla.
JuniorKonsepsiya

async/await: promise-lər üzərində sintaksis

ayrıca mexanizm yox, promise-lər üzərində qurulmuş sintaksisdir:

  • async funksiya həmişə promise qaytarır: return value onu fulfilled edir, throw isə rejected;
  • await expression promise-in yekunlaşmasını gözləyir, sonra onun dəyərini qaytarır və ya səbəbini xəta kimi atır.
JavaScript
async function loadTeamName(userId) {
  const userResponse = await fetch("/api/users/" + userId);
  if (!userResponse.ok) throw new Error("HTTP " + userResponse.status);
  const user = await userResponse.json();

  const teamResponse = await fetch("/api/teams/" + user.teamId);
  const team = await teamResponse.json();
  return team.name;
}

loadTeamName(7).then((name) => console.log(name));

Kod yuxarıdan aşağı oxunur, amma bu, əvvəlki bölmədəki promise zəncirinin eynisidir.

await funksiyanın qalan hissəsi ilə nə edir

İlk await-ə qədər olan kod çağırışın bir hissəsi kimi sinxron icra olunur. await-də funksiya dayandırılır: idarə çağırana qayıdır və o, pending vəziyyətində promise alır. Gözlənilən promise yekunlaşanda funksiyanın qalan hissəsi mikrotapşırıq kimi planlaşdırılır. Dəyər artıq hazır olanda da belədir: await null belə funksiyanı cari sinxron kod və ondan əvvəl növbəyə düşmüş mikrotapşırıqlar bitənə qədər saxlayır.

JavaScript
async function task() {
  console.log("2: inside, before await");
  await null;
  console.log("4: after await");
}

console.log("1: before the call");
task();
console.log("3: after the call");

Yalnız async funksiyanın özü dayanır. Proqramın qalan hissəsi işləməyə davam edir, ona görə də çağıranın növbəti sətri "4"-dən əvvəl çap olunur.

try/catch ilə xətalar

Rədd edilən await elə həmin sətirdə xəta atır, ona görə də adi try/catch/finally işləyir:

JavaScript
async function save(draft) {
  setSaving(true);
  try {
    await api.saveDraft(draft);
  } catch (error) {
    showToast(error.message);
  } finally {
    setSaving(false);
  }
}

await yalnız async funksiyaların içində və ES modulların üst səviyyəsində yazıla bilər.

MiddleTipik səhvlər

Xətaların emalı və emal olunmamış rejection-lar

catch promise-i görməlidir

try/catch rejection-u yalnız promise try-ın içində gözlənilirsə tutur:

JavaScript
async function getUser(id) {
  try {
    return fetchUser(id);
  } catch (error) {
    return null;
  }
}

return fetchUser(id) promise-i gözləmədən çölə verir. Funksiya try blokundan dərhal çıxır və promise sonra rədd ediləndə catch heç vaxt işləmir: rejection çağırana çatır. return await fetchUser(id) problemi həll edir. try-dan kənarda return await hiss olunan heç nəyi dəyişmir.

"Başlat və unut" çağırışları

Async funksiyanı await, return və ya .catch() olmadan çağırmaq onun xətalarını itirir:

JavaScript
button.addEventListener("click", () => {
  saveDraft();
});

saveDraft rədd edilsə, bunu heç nə emal etmir. .catch()-i işi başlatdığın yerdə əlavə et və ya handler-i async edib içində try/catch yaz.

Emal olunmamış rejection-lar

Promise rədd edilib və cari mikrotapşırıqlar icra olunandan sonra da onun handler-i yoxdursa, brauzer window üzərində unhandledrejection hadisəsi göndərir, DevTools isə "Uncaught (in promise)" yazır. Node.js-də default --unhandled-rejections=throw rejimi (v15-dən bəri) bunu tutulmamış istisnaya çevirir və process.on("unhandledRejection") handler-i yoxdursa, proses dayanır.

JavaScript
window.addEventListener("unhandledrejection", (event) => {
  monitoring.capture(event.reason);
});

Belə qlobal handler-i proqramın axışını idarə etmək üçün yox, xətaları qeydə almaq üçün işlət.

forEach gözləmir

JavaScript
async function saveAll(items) {
  items.forEach(async (item) => {
    await save(item);
  });
  console.log("all saved");
}

forEach callback-in qaytardığı promise-lərə məhəl qoymur. Nəticədə "all saved" heç bir yadda saxlama bitməmiş çap olunur, uğursuz olanlar isə emal olunmamış rejection-a çevrilir. Onları bir-bir icra etmək üçün await ilə for...of, paralel icra etmək üçün isə await Promise.all(items.map(save)) yaz.

Kiçik qaydalar

  • Error obyektləri ilə rədd et. reject("failed")-in stack trace-i olmur.
  • catch istənilən dəyəri ala bilər. error.message-i oxumazdan əvvəl error instanceof Error yoxla (TypeScript-də parametr unknown tiplidir).
  • .catch(() => {}) bug-ları gizlədir. Xətanı yalnız faydalı bir şey edə biləcəyin yerdə tut: mesaj göstər, yenidən cəhd et, ehtiyat variantı işlət. Qalanını yuxarı ötür.
MiddleKonsepsiya

Ardıcıl və paralel iş, Promise kombinatorları

Hər await növbəti sətir işləməzdən əvvəl gözləyir, ona görə də ard-arda gələn iki await ardıcıl işləyir: ümumi vaxt iki sorğunun cəminə bərabərdir.

JavaScript
const user = await getUser(id);
const orders = await getOrders(id);

getOrders-ə user lazım deyilsə, hər ikisini başlat və hər ikisini gözlə:

JavaScript
const [user, orders] = await Promise.all([getUser(id), getOrders(id)]);

İndi ümumi vaxt təxminən ikisindən yavaş olanının vaxtı qədərdir. İş getUser(id) və getOrders(id) çağırılanda başlayır; Promise.all heç nəyi başlatmır, sadəcə gözləyir. Hər ikisini əvvəlcə çağırıb sonra gözləmək də (const a = getUser(id); const b = getOrders(id);) onları paralel işlədir. Amma sən hələ a-nı gözləyərkən b rədd edilsə, o rejection-u hələ heç nə emal etmir: brauzer emal olunmamış rejection barədə xəbər verir, Node.js isə prosesi dayandırır. Promise.all isə bütün input-lara handler-i eyni anda bağlayır.

Dörd kombinator

MetodFulfilled olurRejected olurTipik istifadə
Promise.allhamısı fulfilled olanda: dəyərlər input ardıcıllığı iləilk rejection-dabütün nəticələr lazımdır
Promise.allSettledhamısı yekunlaşanda: hər input üçün { status, value } və ya { status, reason }heç vaxtbir-birindən asılı olmayan tapşırıqlar, hər nəticəni göstərmək
Promise.raceilk yekunlaşan fulfilled olarsailk yekunlaşan rejected olarsailk cavab, sadə timeout
Promise.anyilk fulfilled olandahamısı rədd ediləndə: errors massivi olan AggregateErrorehtiyat mənbələr, fallback

Code review-da çıxan detallar

  • Promise.all tez uğursuz olur, amma heç nəyi ləğv etmir. Digər sorğular işləməyə davam edir, onların nəticəsi isə atılır. Onları dayandırmaq üçün AbortSignal ötür (növbəti bölmə).
  • Promise.race ilə yazılmış timeout sorğunu yox, yalnız gözləməni dayandırır. fetch üçün AbortSignal.timeout(ms) sorğunu həqiqətən bitirir.
  • Boş input: Promise.all([]) [] ilə fulfilled olur, Promise.any([]) AggregateError ilə rədd edilir, Promise.race([]) isə həmişəlik pending qalır.
  • 500 elementlik Promise.all(items.map(upload)) 500 sorğunu birdən başladır. Eyni vaxtda işləyən sorğuların sayını məhdudlaşdır, məsələn, partiyalarla:
JavaScript
async function inBatches(items, size, worker) {
  const results = [];
  for (let i = 0; i < items.length; i += size) {
    const batch = items.slice(i, i + size);
    results.push(...(await Promise.all(batch.map(worker))));
  }
  return results;
}
MiddleVeb platforma

AbortController və fetch ilə ləğv etmək

Promise-in cancel() metodu yoxdur: yaradılandan sonra o, öz-özünə yekunlaşır. Ləğv edə biləcəyin şey onun arxasındakı işdir. Veb platformada bunun aləti AbortController-dir: onun abort() metodu və signal xassəsi var, siqnalı isə onu dəstəkləyən API-lərə ötürürsən: fetch, addEventListener və Node.js-in bir çox API-si.

JavaScript
const controller = new AbortController();

fetch("/api/report", { signal: controller.signal })
  .then((response) => response.json())
  .then(showReport)
  .catch((error) => {
    if (error.name === "AbortError") return;
    showError(error);
  });

cancelButton.addEventListener("click", () => controller.abort());

abort()-dan sonra fetch promise-i AbortError adlı DOMException ilə, ya da abort(reason)-a ötürdüyün səbəblə rədd edilir. Ləğv istifadəçiyə göstəriləcək xəta deyil, ona görə də onu catch-də ayır. Controller yalnız bir dəfə abort edir və sıfırlana bilmir: hər əməliyyat üçün yenisini yarat.

Timeout-lar və birləşdirilmiş siqnallar

  • AbortSignal.timeout(ms) müəyyən vaxtdan sonra özü TimeoutError ilə abort edən siqnal qaytarır (Baseline, geniş əlçatandır; aprel 2024-dən bütün əsas brauzerlərdə var).
  • AbortSignal.any([a, b]) siqnallarından hər hansı biri abort edən kimi həmin siqnalın səbəbi ilə abort edir (mart 2024-dən bütün əsas brauzerlərdə var).
JavaScript
async function getJSON(url, signal) {
  const signals = [AbortSignal.timeout(8000)];
  if (signal) signals.push(signal);

  const response = await fetch(url, { signal: AbortSignal.any(signals) });
  if (!response.ok) throw new Error("HTTP " + response.status);
  return response.json();
}

Öz funksiyalarını ləğv edilə bilən etmək

signal qəbul et, siqnal artıq abort olunubsa, dərhal dayan və onun abort hadisəsini dinlə:

JavaScript
function delay(ms, signal) {
  return new Promise((resolve, reject) => {
    if (signal?.aborted) return reject(signal.reason);
    const id = setTimeout(resolve, ms);
    signal?.addEventListener(
      "abort",
      () => {
        clearTimeout(id);
        reject(signal.reason);
      },
      { once: true },
    );
  });
}

Abort yalnız klient tərəfini dayandırır. Server-ə artıq çatmış POST yenə də emal oluna bilər, ona görə də yazma əməliyyatlarını təkcə abort() ilə yox, server tərəfində də qorumaq lazımdır (idempotency açarları, versiya yoxlaması).

SeniorFramework

UI-da race condition: yalnız son sorğu qalib gəlir

Axtarış sahəsi hər dəyişiklikdə sorğu göndərir: r, re, rea, reac, react. Şəbəkə ardıcıllığı qorumur. rea sorğusu yavaş olsa və onun cavabı ən sonda gəlsə, input-da react yazıldığı halda siyahıda rea-nın nəticələri görünəcək. Təkcə debounce bunu düzəltmir: o, sorğuların sayını azaldır, amma yavaş cavab yenə də yenisini ötüb keçə bilər. Platformadakı search-race incident-i bunu işləyən tətbiqdə debug etməyə imkan verir.

Qayda belədir: cavabı yalnız son sorğuya aiddirsə tətbiq et.

1. Köhnəlmiş cavabları nəzərə alma

react.dev effektdə təmizləmə bayrağı (flag) işlətməyi tövsiyə edir:

JSX
useEffect(() => {
  let ignore = false;
  searchProducts(query).then((items) => {
    if (!ignore) setResults(items);
  });
  return () => {
    ignore = true;
  };
}, [query]);

query dəyişəndə React əvvəlki effektin cleanup funksiyasını çağırır, ona görə də köhnə cavab ən sonda gəlsə belə atılır.

2. Əvvəlki sorğunu ləğv et

Eyni quruluş AbortController ilə həm də trafikə və server resurslarına qənaət edir:

JSX
useEffect(() => {
  const controller = new AbortController();
  searchProducts(query, { signal: controller.signal })
    .then(setResults)
    .catch((error) => {
      if (error.name !== "AbortError") setError(error);
    });
  return () => controller.abort();
}, [query]);

3. Bu işi query kitabxanasına həvalə et

TanStack Query hər nəticəni öz queryKey-i altında saxlayır. Platformadakı "TanStack Query: the life of useQuery" turu (v5.107.1) bu yolu QueryObserver və Query vasitəsilə izləyir.

JSX
const { data, isPending, error } = useQuery({
  queryKey: ["search", query],
  queryFn: ({ signal }) => searchProducts(query, { signal }),
  enabled: query.length > 1,
});

Hər axtarış sözü ayrıca query-dir və komponent öz cari açarının yazısını oxuyur. Ona görə də gecikən rea cavabı rea yazısına düşür və react nəticələrini heç vaxt əvəz etmir. queryFn signal-ı ötürdüyü üçün query köhnələndə (out-of-date) və ya aktiv olmayanda sorğu abort olunur. Siqnal ötürülməsə, sorğu sona qədər işləyir və onun məlumatı cache-ə yazılır.

React-dən kənarda

JavaScript
function latestOnly(request) {
  let controller = null;
  return (...args) => {
    controller?.abort();
    controller = new AbortController();
    return request(controller.signal, ...args);
  };
}

Eyni race route loader-lərdə, autosave-də və pagination-da da yaranır: köhnə asinxron nəticənin yenisindən sonra gələ biləcəyi hər yerdə.

SeniorVeb platforma

Pərdə arxasında: mikrotapşırıq ardıcıllığı, thenable-lar, withResolvers

Mikrotapşırıq addımlarını saymaq

Hər reaksiya bir mikrotapşırıqdır. Promise-i başqa promise ilə resolve etmək (then-dən promise qaytarmaq, async funksiyada return somePromise, resolve(somePromise)) iki əlavə addım tələb edir: spesifikasiya əvvəlcə daxili promise-in then-ini çağıran job-u növbəyə qoyur və xarici promise-i yalnız həmin reaksiya yekunlaşdırır. Native promise-ə await isə onu birbaşa, bir addımda işlədir.

JavaScript
async function direct() {
  return "direct";
}
async function wrapped() {
  return Promise.resolve("wrapped");
}

wrapped().then((value) => console.log(value));
direct().then((value) => console.log(value));
Promise.resolve()
  .then(() => console.log("tick 1"))
  .then(() => console.log("tick 2"));
// direct, tick 1, tick 2, wrapped

Müsahibələrdə belə tapmacaları sevirlər, amma production kodu iki müstəqil zəncirin arasında neçə tick olmasından heç vaxt asılı olmamalıdır. B-yə A lazımdırsa, onu zəncirlə və ya gözlə.

Thenable-lar

await, Promise.resolve() və then-dən qaytarılan dəyər then metodu olan istənilən obyekti (thenable) qəbul edir və həmin metodu mikrotapşırıqda çağırır. Müxtəlif kitabxanaların promise-ləri bir-biri ilə məhz belə işləyir. Bunun tərs tərəfi də var: then metodu olan hər obyekt promise kimi qəbul olunur. Belə obyekti async funksiyadan qaytarsan, onun then-i çağırılacaq, ona görə də promise olmayan obyektə then adlı metod vermə.

JavaScript
const task = {
  then(resolve) {
    resolve("done");
  },
};

console.log(await task); // "done"

Dövrdə await

for (const id of ids) await load(id) qəsdən ardıcıl işləyir. Hər addıma əvvəlkinin nəticəsi lazımdırsa və ya server-ə birdən çox sorğu göndərmək olmazsa, bu doğrudur; addımlar bir-birindən asılı deyilsə, səhvdir. ESLint-in no-await-in-loop qaydası səni bu seçimi açıq şəkildə etməyə məcbur edir. for await...of isə async generator-lar kimi async iterable-ları oxuyur.

Promise.withResolvers

Promise.withResolvers() { promise, resolve, reject } qaytarır. Promise-i yekunlaşdıran kod executor-dan kənarda yaşayanda lazım olur: hadisələr, növbələr, testlər. Mart 2024-dən bütün brauzerlərdə (Chrome 119, Firefox 121, Safari 17.4) və Node.js 22-də mövcuddur.

JavaScript
function nextMessage(socket) {
  const { promise, resolve, reject } = Promise.withResolvers();
  const controller = new AbortController();
  const options = { signal: controller.signal };
  socket.addEventListener("message", (event) => resolve(event.data), options);
  socket.addEventListener("error", () => reject(new Error("socket error")), options);
  return promise.finally(() => controller.abort());
}

Promise.try(fn) (Baseline 2025) onun daha yeni qohumudur: fn-i sinxron çağırır və qaytarılan dəyəri, atılan xətanı və ya qaytarılan promise-i bir promise-ə çevirir.

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

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

30 saniyəlik cavab. "Promise sonradan gələn nəticəni təmsil edir. O, pending vəziyyətindən bir dəfə və yalnız bir dəfə ya dəyərlə fulfilled, ya da səbəblə rejected vəziyyətinə keçir. then yeni promise qaytarır, ona görə də dəyərlər və xətalar zəncir boyunca aşağı axır. async/await eyni mexanizm üzərində sintaksisdir: await funksiyanı dayandırır və promise yekunlaşanda onu mikrotapşırıq kimi davam etdirir."

Gözlənilən suallar

  • Bu kod nə çap edəcək? Sinxron kod, then callback-ləri, await və setTimeout qarışığı. Addım-addım izah et: əvvəl sinxron kod, sonra növbə ardıcıllığı ilə mikrotapşırıqlar, sonra tapşırıqlar. Executor-un sinxron işlədiyini də qeyd et.
  • Promise.all, allSettled, race və any arasında fərq nədir? Hər birinin nə vaxt fulfilled və rejected olduğunu de, konkret hal üçün birini seç: bir-birindən asılı olmayan widget-lərdən ibarət dashboard üçün allSettled, istifadəçi və icazələr olmadan açıla bilməyən səhifə üçün all.
  • Bu sorğular niyə yavaşdır? Bir-birindən asılı olmayan işlərin ardıcıl gözlənilməsi. Promise.all variantını göstər və eyni vaxtda işləyən sorğuların limitini xatırlat.
  • Sorğunu necə ləğv edirsən? AbortController və signal, AbortError-un ayrılması və promise-in özünün ləğv edilə bilmədiyi.
  • Köhnə axtarışın nəticələri görünür. Cavablar ardıcıllığı pozulmuş gəlir. Köhnəlmiş cavab bayrağı, abort() və ya sorğuya görə açarlanan query kitabxanası ilə həll et. Təkcə debounce-un niyə kifayət etmədiyini izah et.

Bal itirdən səhvlər

  • await-in thread-i blokladığını demək. O, yalnız async funksiyanı dayandırır, event loop işləməyə davam edir.
  • Promise.all-un promise-ləri paralel işlətdiyini demək. İş promise-lər yaradılanda artıq başlamışdı, all sadəcə gözləyir.
  • async-in kodu fon thread-ində işlətdiyini demək. Promise-lərin işi yenə də main thread-də gedir; CPU-nu yükləyən iş üçün Web Worker lazımdır.
  • try { return promise } catch {} və forEach(async ...): hər ikisi xətaları itirir.

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

Sintaksisdən yox, dizayndan danış: ləğvi kim idarə edir, komponent yalnız son nəticəni necə zəmanət altına alır, uğursuz sorğu yazma əməliyyatını təkrarlamadan necə yenidən göndərilir və production-da emal olunmamış rejection-lar harada qeydə alınır.

JuniorYoxlama siyahısı

Promise və async/await kodunu review edərkən nəyi yoxlamalı

Bu siyahını yazmadığın kodu review edəndə işlət: komanda yoldaşının pull request-i, kitabxananın issue tracker-indəki snippet və ya AI assistentin təklifi. Bu yoxlamaları etməsən, iz qoymadan itən xətalar, səbəbsiz yerə bir-birini gözləyən sorğular və yeni cavabların üstündən yazılan köhnə cavablar gözdən qaçacaq.

  • Hər promise await olunur, qaytarılır, ya da ona .catch() bağlanırmı? Click handler-də tək başına yazılmış save();, items.forEach(async ...) və ya try { return fetchUser(id) } xətaları itirir: rejection-u heç bir catch görmür. try-ın içində return await, forEach əvəzinə isə for...of və ya Promise.all gözlə.
  • fetch kodu response.ok-u yoxlayırmı? fetch yalnız şəbəkə xətasında rədd edilir, ona görə də 404 və ya 500 cavabı uğurlu nəticə kimi emal olunur.
  • Hər then callback-i öz promise-ini qaytarırmı? return olmasa, növbəti addım undefined alır və daxili promise-i gözləmir.
  • Köhnə sorğunun cavabı yenisindən sonra tətbiq oluna bilərmi? Şəbəkə ardıcıllığı qorumur. Effekt hər prop dəyişəndə sorğu göndərirsə, ignore bayrağını və ya cleanup-da abort edilən AbortController-i axtar.
  • Bir-birindən asılı olmayan sorğular ard-arda gözlənilirmi? Ard-arda gələn iki await-in vaxtları toplanır. Promise.all gözlə, yüzlərlə element olanda isə eyni vaxtda işləyən sorğuların sayına limit də qoyulmalıdır.
  • Ləğv ləğv kimi emal olunurmu? catch AbortError-u istifadəçiyə göstərmək əvəzinə ayırmalıdır, hər əməliyyata isə yeni controller lazımdır. Promise.race ilə yazılmış timeout yalnız gözləməni dayandırır, AbortSignal.timeout(ms) isə sorğunu həqiqətən bitirir.
  • Xətalar səssizcə gizlədilirmi? .catch(() => {}) bug-ları gizlədir, reject("failed")-in isə stack trace-i olmur. Xətanı yalnız kodun mesaj göstərə, yenidən cəhd edə və ya ehtiyat variantı işlədə bildiyi yerdə tut.

Ö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ı · 3 açıq sual

  • Quiz

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

    6 sual

Bu mövzudan istifadə edən praktiki işlər.

Özün qur

Həftəlik çağırışlar

Frontend tarixi

Buna əsaslanan real kitabxanaların mənbə kodu üzrə bələdçili turlar.