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

JavaScript-in dərinlikləri

Event loop

Tək thread-də işləyən JavaScript taymerləri, şəbəkə cavablarını və istifadəçi hərəkətlərini səhifəni dondurmadan necə emal edir: call stack, tapşırıq və mikrotapşırıq növbələri, render, eləcə də bunun React və performans üçün mənası.

JuniorMiddleSeniorYenilənib: 13 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

Event loop nədir və JavaScript-ə nə üçün lazımdır

JavaScript kodu tək bir thread-də icra olunur. Hər an kodun yalnız bir hissəsi işləyir və mühərrik bunu vasitəsilə izləyir: funksiya çağırılanda stack-ə yeni frame əlavə olunur, funksiya qayıdanda həmin frame çıxarılır. Stack-də nəsə olduqca başqa heç nə icra oluna bilməz.

Veb səhifə isə "eyni vaxtda" baş verən çoxlu işlə məşğul olmalıdır: taymerin vaxtı bitir, şəbəkədən cavab gəlir, istifadəçi düyməyə klikləyir, ekran yenidən çəkilməlidir. JavaScript bunların hər birini oturub gözləsəydi, səhifə donardı.

Ona görə də iş iki tərəf arasında bölünür:

  • JavaScript mühərriki (V8, SpiderMonkey, JavaScriptCore) kodu icra edir və call stack-i idarə edir. Dilin özündə nə taymer var, nə şəbəkə, nə də klik.
  • Host mühit — brauzer və ya Node.js — bu imkanları təqdim edir. Brauzerdə onlara deyilir. Gözləmə işini host sənin kodundan kənarda görür, nəticə hazır olanda isə sonradan icra olunmaq üçün növbəyə qoyur.

host-un bu iki tərəfi birləşdirən mexanizmidir. Sadələşdirilmiş psevdokodla:

JavaScript
while (true) {
  const task = queue.takeNext();
  task.run();
}

Hər dövrdə növbədən bir callback götürülür və call stack yenidən boşalana qədər icra olunur. Buna run-to-completion (sona qədər icra) deyilir: işləyən funksiyanı yarı yolda başqa callback kəsə bilməz. Bu, kodu proqnozlaşdırıla bilən edir — iki callback eyni dəyişəni eyni anda dəyişmir. Amma bu həm də o deməkdir ki, bir yavaş funksiya səhifədəki hər şeyi, o cümlədən klikləri və ekranın yenilənməsini bloklayır. Əsl dövrün bir neçə əlavə addımı da var (mikrotapşırıqlar və render); onlara Middle səviyyəsində baxacağıq.

"Tək thread" dedikdə səhifənin nəzərdə tutulur. Web Worker-lər JavaScript-i ayrı thread-lərdə icra edir və hər worker-in öz event loop-u olur.

JuniorVeb platforma

Call stack, Web API-lər və tapşırıq növbəsi

Taymerlə nə baş verdiyini addım-addım izləyək:

JavaScript
console.log("one");
setTimeout(() => console.log("three"), 0);
console.log("two");
  1. console.log("one") əlavə olunur, icra olunur və oradan çıxarılır.
  2. setTimeout brauzerdən taymeri işə salmağı xahiş edir və dərhal qayıdır. Taymerin özü JavaScript deyil və stack-də yer tutmur.
  3. console.log("two") icra olunur. Skript bitir, call stack boşalır.
  4. Bu arada taymerin vaxtı artıq bitib, ona görə brauzer callback üçün tapşırığı qoyub.
  5. call stack-in boş olduğunu görür, tapşırığı götürür və icra edir: three çap olunur.

Deməli, setTimeout(fn, 0) "fn-i indi icra et" demək deyil. Onun mənası budur: "ən azı 0 ms keçəndən sonra fn-i yeni tapşırıq kimi növbəyə qoy". Gecikmə minimumdur, zəmanət deyil: cari kod thread-i 200 ms məşğul saxlasa, callback ən azı o qədər gözləyəcək.

Hər asinxron əməliyyatda eyni hissələr iştirak edir:

HissəKimə aiddirVəzifəsi
Call stackJS mühərrikiKodu icra edir, hər dəfə bir frame
Web API-lərBrauzerTaymerlər, şəbəkə, DOM hadisələri — JavaScript-dən kənarda görülən iş
Tapşırıq növbəsiBrauzerÖz növbəsini gözləyən callback-lər
Event loopBrauzerCall stack boşalan kimi növbəti tapşırığı icra edir

Klik də eyni cür işləyir: brauzer kliki qeydə alır, hadisəni göndərən tapşırığı növbəyə qoyur və sənin click listener-in yalnız stack boşalanda işə düşür. Kod uzun bir dövrün ortasındadırsa, klik itmir — sadəcə növbədə gözləyir.

Əslində brauzerdə bir neçə tapşırıq növbəsi var (məsələn, taymerlər və istifadəçi hadisələri üçün) və növbəti dəfə hansına xidmət edəcəyini brauzer özü seçir. Hələlik bunu ardıcıl emal olunan tək növbə kimi təsəvvür et.

JuniorNümunə

Nümunə: icra ardıcıllığını izləyək

JavaScript
console.log("A");

setTimeout(() => {
  console.log("B");
}, 0);

function heavy() {
  const end = Date.now() + 100;
  while (Date.now() < end) {}
  console.log("C");
}

heavy();
console.log("D");

Nəticə: A, C, D, B. Üstəlik, gecikməsi 0 olsa da, B təxminən 100 ms-dən sonra görünür.

Addım-addım:

  1. A sinxron çap olunur.
  2. setTimeout callback-i brauzerin taymerinə ötürür və qayıdır. Hələ heç nə növbəyə düşməyib.
  3. heavy() 100 ms boyunca boş dövr icra edir. Taymerin vaxtı demək olar ki, dərhal bitir və brauzer callback-i tapşırıq növbəsinə qoyur — amma call stack boş deyil, ona görə callback gözləməli olur.
  4. heavy C çap edir və qayıdır.
  5. Skript D çap edir və bitir; call stack artıq boşdur.
  6. Event loop gözləyən tapşırığı götürüb icra edir: B.

Eyni izləmə cədvəl şəklində:

AddımCall stackTapşırıq növbəsiÇap olunan
1skript—A
2skript → setTimeout——
3skript → heavytaymer callback-i—
4skript → heavytaymer callback-iC
5skripttaymer callback-iD
6taymer callback-i—B

Nəyi yadda saxlamalı

  • Sinxron kod həmişə birinci bitir. Taymerlərin və hadisələrin növbəyə qoyduğu callback-lər sonra, bir-bir icra olunur.
  • Taymerin gecikməsi callback-in icra oluna biləcəyi ən erkən andır, mütləq icra olunacağı an deyil.
  • Məşğul kod hər şeyi gecikdirir. Brauzerdə eyni 100 ms-lik dövr klik handler-lərini və ekranın yenilənməsini də ləngidərdi: dövr zamanı edilən kliklər yalnız D çap olunandan sonra emal olunur.
MiddleVeb platforma

Mikrotapşırıqlar və tapşırıqlar

əlavə, hər event loop-un bir dənə mikrotapşırıq növbəsi var. bu mənbələrdən yaranır:

  • reaksiyaları — then, catch və finally-yə ötürülən callback-lər;
  • async funksiyanın await-dən sonrakı davamı;
  • queueMicrotask(fn);
  • MutationObserver callback-ləri.

Tapşırıqlar (onlara çox vaxt makrotapşırıq da deyilir) isə taymerlərdən, istifadəçi hadisələrindən, şəbəkə hadisələrindən, postMessage-dən və s. yaranır.

Qayda

Hər tapşırıqdan sonra brauzer mikrotapşırıq checkpoint-i keçirir: növbə boşalana qədər mikrotapşırıqları icra edir — növbə boşaldılarkən əlavə olunanlar da daxil olmaqla. Yalnız bundan sonra event loop render-ə və ya növbəti tapşırığa keçə bilər. Checkpoint həmçinin hər callback bitib call stack boşalanda baş verir — məsələn, real istifadəçi klikində iki hadisə listener-i arasında.

JavaScript
setTimeout(() => console.log("task"), 0);
Promise.resolve().then(() => console.log("microtask 1"));
queueMicrotask(() => console.log("microtask 2"));
console.log("sync");

Nəticə: sync, microtask 1, microtask 2, task. Hər iki mikrotapşırıq skript bitən kimi icra olunur, taymer callback-i isə növbəti tapşırıq dövrünü gözləyir.

async/await bura necə uyğunlaşır

promise-lər üzərində qurulmuş sintaksisdir. İlk await-ə qədər olan kod sinxron icra olunur; funksiyanın qalan hissəsi isə gözlənilən dəyər yekunlaşandan sonra mikrotapşırıq kimi davam edir:

JavaScript
async function save() {
  console.log("before");
  await write();
  console.log("after");
}

Bu funksiya təxminən belə işləyir:

JavaScript
function save() {
  console.log("before");
  return Promise.resolve(write()).then(() => {
    console.log("after");
  });
}

Məhz buna görə artıq hazır olan dəyəri gözləyəndə belə — hətta await null yazanda — funksiya cari sinxron kod bitənə qədər dayanır.

Nəyi kim müəyyən edir

ECMAScript spesifikasiyası promise job-larını müəyyən edir, event loop-u isə yox. Dövrü host müəyyən edir: brauzerlərdə HTML spesifikasiyası promise job-larını mikrotapşırıq kimi icra edir. Node.js-in öz dövrü var, lakin promise callback-ləri bir-birinə nisbətən eyni ardıcıllıqla işləyir.

MiddleVeb platforma

Render harada baş verir: kadrlar və requestAnimationFrame

Brauzer hər tapşırıqdan sonra render etmir. O, render imkanı (rendering opportunity) yarananda render edir. Bu, adətən ekranın yenilənmə tezliyinə uyğun gəlir (60 Hz ekranda ən çox təxminən 16,7 ms-dən bir), səhifə ayaqlaşa bilmədikdə daha seyrək olur, gizli tabda isə xeyli seyrəkləşir və ya ümumiyyətlə baş vermir. Belə imkan yarananda event loop tapşırıqların arasında "render-i yenilə" addımını icra edir. Sadələşdirsək, bu addımda brauzer:

  1. resize və scroll hadisələrini göndərir;
  2. callback-lərini icra edir;
  3. stilləri yenidən hesablayır və aparır;
  4. edir və yeni kadrı ekrana çıxarır.

Bundan üç nəticə çıxır.

Tapşırığın ortasında və ya mikrotapşırıqlar icra olunarkən heç nə çəkilmir. Bir tapşırıq ərzində edilən bütün DOM dəyişiklikləri ekranda birlikdə görünür:

JavaScript
box.style.display = "block";
box.style.display = "none";

İstifadəçi qutunu heç vaxt görmür, çünki bu iki sətir arasında render baş verə bilməz.

Vizual yeniləmələrin yeri requestAnimationFrame-dir. setTimeout ilə qurulan dövr kadrlarla uzlaşmır: callback iki kadr arasında iki dəfə işləyə (boş yerə görülən iş) və ya bir kadrı ötürə bilər (gözə çarpan titrəmə, yəni jank). requestAnimationFrame isə hər kadrda bir dəfə, stil və layout hesablanmazdan dərhal əvvəl işləyir və callback-ə timestamp ötürür — animasiyanı ona əsaslanaraq qurmaq olar:

JavaScript
function step(timestamp) {
  box.style.transform = `translateX(${(timestamp / 10) % 300}px)`;
  requestAnimationFrame(step);
}
requestAnimationFrame(step);

Uzun tapşırıqlar input-u və paint-i bloklayır. tapşırıq icra olunduqca brauzer nə klik handler-ini işə sala, nə də yeni kadr göstərə bilir. Main thread-i 50 ms və ya daha çox məşğul saxlayan tapşırıq brauzerin performans API-lərində long task (uzun tapşırıq) sayılır. Klik handler-i 300 ms çəkirsə, səhifə ən azı 300 ms ərzində heç bir vizual reaksiya göstərə bilmir — Core Web Vitals metriki olan INP (Interaction to Next Paint) məhz bu cür gecikməni ölçür.

MiddleTipik səhvlər

Tez-tez rast gəlinən səhvlər

Mikrotapşırıq aclığı (starvation)

Checkpoint növbəni tam boşalana qədər icra edir. Ona görə də daim yeni mikrotapşırıq əlavə edən mikrotapşırıq event loop-un irəliləməsinə heç vaxt imkan vermir:

JavaScript
function loop() {
  queueMicrotask(loop);
}
loop();

Səhifə donur: nə taymerlər işləyir, nə input emal olunur, nə də render baş verir. Rekursiv promise zənciri də eyni nəticəyə gətirir. setTimeout ilə yazılmış variant isə səhifəni dondurmur, çünki hər callback ayrıca tapşırıqdır və brauzer onların arasında render edə, input-u emal edə bilir.

Promise ağır işi fona keçirmir

Ağır işi promise-ə bükmək onu main thread-dən çıxarmır. new Promise(...)-in executor funksiyası sinxron icra olunur, then callback-i isə mikrotapşırıq kimi işləyir — yenə də növbəti render-dən əvvəl. Səhifənin cavab verməyə davam etməsi üçün işi bir neçə tapşırığa böl və ya Web Worker-ə köçür (Senior səviyyəsinə bax).

Taymerlər dəqiq deyil

  • Gecikmə minimumdur; məşğul main thread bütün taymerləri təxirə salır.
  • HTML spesifikasiyası iç-içə taymerləri məhdudlaşdırır: setTimeout çağırışları beş səviyyədən dərin iç-içə olanda 4 ms-dən kiçik gecikmələr 4 ms-ə qaldırılır.
  • Brauzerlər fon tablarında taymerləri yavaşladır (throttling), dəqiq qaydalar isə brauzerdən brauzerə fərqlənir.

Animasiyalar üçün requestAnimationFrame, keçən vaxtı ölçmək üçün isə callback-ləri saymaq əvəzinə performance.now() istifadə et.

İtən rejection-lar

JavaScript
async function init() {
  try {
    loadConfig();
  } catch (error) {
    showError(error);
  }
}

loadConfig async funksiyadırsa, await unudulduğu üçün catch onun rejection-unu heç vaxt tutmur. Promise handler-siz rədd ediləndə brauzer mikrotapşırıq checkpoint-indən sonra onu yoxlayır və promise hələ də emal olunmayıbsa, sonrakı tapşırıqda window üzərində unhandledrejection hadisəsi göndərir. Node.js-də (v15-dən bəri) emal olunmamış rejection default olaraq prosesi çökdürür. catch-i (və ya try daxilində await-i) promise-i yaradan elə həmin sinxron kodda əlavə et.

SeniorFramework

React və event loop

Avtomatik batching

set funksiyasını çağırmaq dərhal re-render-ə səbəb olmur — o, yeniləməni növbəyə qoyur. React yeniləmələri növbəyə qoyan kod (məsələn, hadisə handler-i) bitənə qədər gözləyir, sonra onları birlikdə, bir render-də emal edir. React 18-dən etibarən createRoot ilə bu yeniləmələrin haradan gəlməsindən asılı olmayaraq işləyir: React hadisə handler-ləri, setTimeout, promise-lər və ya native hadisə listener-ləri.

TSX
function handleClick() {
  fetchUser().then((user) => {
    setUser(user);
    setLoading(false);
  });
}

Hər iki yeniləmə tək bir re-render yaradır. Lakin React istifadəçinin ayrı-ayrı, qəsdli hərəkətlərini birləşdirmir: iki klik ayrıca emal olunur. Onu da nəzərə al ki, setter-i çağırdıqdan dərhal sonra state-i oxusan, köhnə dəyəri alacaqsan, çünki yeni dəyər yalnız növbəti render-də mövcud olur.

flushSync: son çarə

Bəzən DOM növbəti sətir icra olunmamış yenilənməlidir — məsələn, yenicə əlavə etdiyin elementə scroll etmək üçün:

TSX
import { flushSync } from "react-dom";

function handleAdd(text: string) {
  flushSync(() => {
    setTodos((prev) => [...prev, text]);
  });
  listRef.current?.lastElementChild?.scrollIntoView();
}

flushSync React-i yeniləmələri emal edib DOM-u sinxron yeniləməyə məcbur edir. react.dev onu nadir hallarda lazım olan alət adlandırır və xəbərdarlıq edir ki, o, performansa ciddi zərər vura və Suspense sərhədlərini fallback göstərməyə məcbur edə bilər.

Effect-lər və paint

Brauzer yalnız render addımında, cari JavaScript bitəndən sonra paint edir. İki effect hook-u arasındakı fərqi də məhz bu izah edir:

  • useLayoutEffect React DOM-a commit edəndən sonra və brauzer ekranı yenidən çəkməzdən əvvəl işləyir. Onun kodu və içindən planlaşdırılan state yeniləmələri paint-i bloklayır, ona görə elementi ölçüb yerini dəyişmək mümkündür və istifadəçi titrəmə görmür. Ondan həddən artıq istifadə tətbiqi yavaşladır.
  • useEffect: Effect istifadəçinin hərəkəti (interaction) nəticəsində yaranmayıbsa, React adətən əvvəlcə brauzerə paint etməyə imkan verir. Klik kimi interaction nəticəsində yaranıbsa, React onu paint-dən əvvəl də icra edə bilər. İşi paint-dən sonraya saxlamaq lazımdırsa (məsələn, alert()), react.dev setTimeout istifadə etməyi təklif edir.
SeniorVeb platforma

Uzun işin planlaşdırılması, React scheduler-i və Node.js

Event loop-a növbə ver

İşləyən tapşırığı heç nə kəsə bilmir. Ona görə ağır iş zamanı səhifənin cavab verməyə davam etməsinin yeganə yolu işi könüllü dayandırıb yeni tapşırıqda davam etdirməkdir (buna yielding deyilir). Mikrotapşırıqla növbə vermək (await Promise.resolve()) kömək etmir: render və input mikrotapşırıq növbəsi boşalana qədər gözləyir.

JavaScript
function yieldToMain() {
  if (globalThis.scheduler?.yield) {
    return scheduler.yield();
  }
  return new Promise((resolve) => setTimeout(resolve, 0));
}

async function processAll(items, handleItem) {
  let sliceStart = performance.now();
  for (const item of items) {
    handleItem(item);
    if (performance.now() - sliceStart > 10) {
      await yieldToMain();
      sliceStart = performance.now();
    }
  }
}

scheduler.yield() davamı prioritetli tapşırıq kimi planlaşdırır, lakin MDN onu məhdud dəstəklənən (limited availability) API kimi qeyd edir, ona görə əvvəlcə mövcudluğunu yoxla. Hər hissəni 50 ms-lik long task həddindən xeyli aşağı saxla. Mənalı şəkildə bölünə bilməyən, CPU-nu yükləyən işin yeri Web Worker-dir — onun öz thread-i və event loop-u var.

React scheduler-i

React də eyni ideyanı tətbiq edir. Onun scheduler paketi işi makrotapşırıqlar şəklində icra edir — brauzerlərdə MessageChannel vasitəsilə; bu üsul iç-içə setTimeout-dan fərqli olaraq 4 ms-lik məhdudiyyətə tabe deyil. Concurrent render zamanı (startTransition, useDeferredValue) React iş vahidləri arasında bir neçə millisaniyəlik vaxt payının bitib-bitmədiyini yoxlayır; bitibsə, brauzerə növbə verir və işi yeni tapşırıqda davam etdirir. Transition render-ini daha təcili yeniləmə, məsələn, input-a mətn yazılması da kəsə bilər. DOM-a commit isə hissələrə bölünmür.

Node.js-dəki fərqlər

  • Dövr libuv tərəfindən həyata keçirilir və fazalarla işləyir: timers → pending callbacks → poll (I/O) → check (setImmediate) → close callbacks.
  • process.nextTick callback-lərinin öz növbəsi var. CommonJS kodunda və callback-lərin içində bu növbə promise mikrotapşırıqlarından əvvəl boşaldılır; ES modulun yuxarı səviyyəli kodunda isə əvvəlcə promise callback-ləri işləyir. Node.js sənədləri, nextTick-in xüsusi imkanları lazım deyilsə, queueMicrotask istifadə etməyi tövsiyə edir.
  • Əsas moduldan çağırılanda setTimeout(fn, 0) və setImmediate(fn)-in ardıcıllığı qeyri-müəyyəndir; I/O callback-inin içində isə setImmediate həmişə birinci işləyir.
  • Rekursiv nextTick çağırışları I/O-nu "ac qoyur" (starvation) — eynilə rekursiv mikrotapşırıqların səhifəni dondurduğu kimi.
SeniorMüsahibə məsləhətləri

Müsahibə üçün tövsiyələr

İzahı strukturlaşdır

Cavabı aşağıdan yuxarı qur: bir thread və → host asinxron işi Web API-lər vasitəsilə görür → bitmiş iş tapşırıq kimi növbəyə düşür → hər tapşırıqdan sonra mikrotapşırıq növbəsi boşaldılır → brauzer render imkanı olanda render edir. Promise job-larını ECMAScript-in, event loop-u isə HTML spesifikasiyasının müəyyən etdiyini qeyd etsən, mövzunu dərindən bildiyini göstərərsən.

Output-u təxmin etmə sualları

Üç sütun saxla: çap olunanlar, mikrotapşırıq növbəsi, tapşırıq növbəsi.

  1. Bütün sinxron kodu icra et və hər sətrin nəyi növbəyə qoyduğunu qeyd et.
  2. Mikrotapşırıq növbəsini əvvəldən axıra boşalt. Bu zaman əlavə olunanlar növbənin sonuna düşür və elə həmin keçiddə icra olunur.
  3. Bir tapşırıq icra et, sonra mikrotapşırıqları yenidən boşalt. Təkrarla.

Klassik tələlərə diqqət et: ilk await-ə qədər olan kod sinxrondur; artıq resolve olunmuş promise-in then-i dərhal növbəyə düşür, zəncirdəki növbəti then isə yalnız əvvəlki callback bitəndə; hər taymer callback-i ayrıca tapşırıqdır.

Fərqləndirən detallar

  • Real istifadəçi klikində eyni elementin iki listener-i arasında mikrotapşırıqlar icra olunur, çünki onların arasında call stack boşalır. element.click() skriptdən çağırılanda isə stack boş olmur, ona görə əvvəl hər iki listener, sonra mikrotapşırıqlar işləyir.
  • Nəzəriyyəni praktika ilə əlaqələndir: long task-lar INP-ni pisləşdirir, ağır iş hissələrə bölünüb aralarda növbə verməlidir, React yeniləmələri batch edir, useLayoutEffect isə paint-i bloklayır.

Qaçınmalı olduğun yanlış fikirlər

  • "setTimeout(fn, 0) dərhal icra olunur."
  • "Promise-lər başqa thread-də işləyir."
  • "async funksiyanı paralel icra edir."
  • "Brauzer hər tapşırıqdan sonra ekranı yenidən çəkir."
JuniorYoxlama siyahısı

Kodu event loop baxımından 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, kod bloklayıb klikləri və ekranın yenilənməsini ləngidə, ya da xətaları itirib callback-ləri heç kimin planlaşdırmadığı ardıcıllıqla icra edə bilər.

  • Handler və ya dövr ağır işi bir dəfəyə görürmü? Tapşırıq icra olunduqca brauzer nə kliki emal edə, nə də paint edə bilir. Əməliyyatı DevTools-un Performance panelində record et — panel long task-ları qırmızı üçbucaqla işarələyir; işin setTimeout və ya scheduler.yield() ilə növbə verən hissələrə bölünməsini, ya da Web Worker-ə köçürülməsini gözlə.
  • Kod promise-in və ya async-in işi thread-dən kənara çıxardığını güman edirmi? new Promise-in executor-u sinxron icra olunur, then callback-ləri isə növbəti render-dən əvvəl kimi işləyir. Ona görə də await Promise.resolve() nə paint-ə, nə də input-a yol açır.
  • try içindəki hər async çağırış await ilə gözlənilirmi? await olmasa, catch rejection-u heç vaxt görmür: brauzer unhandledrejection hadisəsi göndərir, Node.js isə (v15-dən bəri) default olaraq prosesi dayandırır.
  • Mikrotapşırıq özünü yenidən növbəyə qoya bilirmi? Özünü durmadan yenidən planlaşdıran queueMicrotask və ya promise zənciri event loop-un taymerlərə, input-a və render-ə keçməsinə heç vaxt imkan vermir və səhifə donur. Təkrarlanan işin yeri setTimeout-dur: o, brauzerə arada render etməyə imkan verir.
  • Kod taymerin dəqiq gecikməsinə arxalanırmı? Gecikmə minimumdur: məşğul thread callback-i təxirə salır, fon tablarında isə brauzer taymerləri yavaşladır. Keçən vaxtı callback-ləri saymaqla yox, performance.now() ilə ölç.
  • Animasiyalar requestAnimationFrame ilə qurulubmu? Taymer dövrləri kadrlarla uzlaşmır: iki kadr arasında iki dəfə işləyə və ya bir kadrı ötürə bilər. isə hər kadrda bir dəfə, stil və layout hesablanmazdan dərhal əvvəl işləyir.

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

    6 sual

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

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