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

JavaScript-in dərinlikləri

Closure-lar

Funksiya yarandığı scope-un dəyişənlərinə çıxışı necə saxlayır: sayğac və callback-lərdən tutmuş scope zəncirinə, yaddaşın saxlanmasına və React-dəki stale closure-lara qədər.

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

Closure nədir

funksiya ilə onun yarandığı scope-dakı dəyişənlərə çıxışın birləşməsidir. JavaScript-də hər funksiya closure-dur: funksiya yaradılan anda ətrafındakı yadda saxlayır və xarici funksiya işini bitirdikdən sonra da bu çıxışı itirmir.

JavaScript
function makeGreeting(greeting) {
  return function (name) {
    return greeting + ", " + name + "!";
  };
}

const hello = makeGreeting("Hello");
const salam = makeGreeting("Salam");

console.log(hello("Ada")); // "Hello, Ada!"
console.log(salam("Ada")); // "Salam, Ada!"

hello("Ada") çağırılanda makeGreeting artıq işini bitirib, amma daxili funksiya greeting-i yenə də oxuyur. makeGreeting-in hər çağırışı öz greeting dəyişənini yaradır, ona görə də hello və salam bir-birinə qarışmır.

Leksik scope

JavaScript qaydası ilə işləyir: funksiyanın hansı dəyişənləri görəcəyi onun harada çağırılmasından yox, kodda harada yazılmasından asılıdır.

JavaScript
const message = "global";

function printMessage() {
  console.log(message);
}

function run() {
  const message = "local";
  printMessage();
}

run(); // "global"

printMessage faylın üst səviyyəsində yazılıb, ona görə də message-i elə orada axtarır. run onu çağırsa da, run-ın içindəki message printMessage üçün görünmür.

Əsas məqamlar

  • Closure xüsusi sintaksis deyil. Funksiya xarici scope-dakı dəyişəndən istifadə edəndə o, öz-özünə yaranır.
  • Daxili funksiya xarici dəyişənləri həm oxuya, həm də dəyişə bilir.
  • Daxili scope xarici scope-u görür, xarici scope isə daxildəkiləri görmür.
JuniorNümunə

Gündəlik kodda closure-lar

Closure-lardan hər gün, çox vaxt fərqinə varmadan istifadə edirsən. Ən çox rast gəlinən hallar bunlardır.

Gizli (private) state. Fabrik funksiya elə funksiyalar qaytarır ki, onlar kənardan heç kimin çata bilmədiyi ortaq dəyişəni bölüşür.

JavaScript
function createCounter() {
  let count = 0;
  return {
    increment() {
      count += 1;
      return count;
    },
    getValue() {
      return count;
    },
  };
}

const counter = createCounter();
counter.increment();
counter.increment();
console.log(counter.getValue()); // 2
console.log(counter.count); // undefined

count obyektin xassəsi deyil, createCounter-in scope-unda yaşayır. Onu yalnız increment vasitəsilə dəyişmək olar. createCounter()-i bir də çağırsan, tamamilə müstəqil yeni sayğac alacaqsan.

Hadisə handler-ləri. Handler qurulduğu andakı məlumatı yadda saxlayır:

JavaScript
function setupLikeButton(button, postId) {
  let likes = 0;
  button.addEventListener("click", () => {
    likes += 1;
    button.textContent = "Likes: " + likes;
    console.log("Liked post " + postId);
  });
}

Bu yolla qurulan hər düymənin öz likes və öz postId dəyişəni olur.

Callback-lər. filter, map, setTimeout və ya then-ə ötürülən funksiyalar ətrafdakı kodun dəyişənlərini oxuyur:

JavaScript
function filterByMinPrice(products, minPrice) {
  return products.filter((product) => product.price >= minPrice);
}

Buradakı arrow funksiya həm , həm də minPrice üzərində qurulmuş closure-dur.

React komponentləri. Komponentdəki hər inline handler onu yaradan render-in props və state-i üzərində closure-dur:

TSX
import { useState } from "react";

function LikeButton() {
  const [likes, setLikes] = useState(0);
  return <button onClick={() => setLikes(likes + 1)}>Likes: {likes}</button>;
}

Bu kod ona görə işləyir ki, hər render cari likes-ı görən yeni handler yaradır. Köhnə handler öz render-indən uzun yaşayanda nə baş verdiyini mövzunun Senior hissəsində görəcəksən.

MiddleVeb platforma

Closure-lar necə işləyir: mühitlər və scope zənciri

ECMAScript spesifikasiyası closure-ları Environment Record anlayışı ilə təsvir edir; məqalələrdə və spesifikasiyanın köhnə nəşrlərində bu struktur adlanır. Hər mühit bir scope-un binding-lərini (dəyişənlərini) və xarici mühitə istinadı saxlayır.

Demək olar ki, hər şeyi üç qayda izah edir:

  1. Hər çağırış yeni mühit yaradır. Funksiya çağırılanda onun parametrləri və lokal dəyişənləri üçün təzə mühit yaranır. İçində let, const və ya class elanı olan blokların da öz mühiti olur.
  2. Funksiya harada yarandığını yadda saxlayır. Funksiya obyekti yaradılanda mühərrik cari mühiti həmin obyektin gizli daxili sahəsinə yazır (spesifikasiyada bu sahə Environment adlanır). Funksiya sonradan çağırılanda yeni mühitin xarici istinadı çağıranın mühitinə yox, məhz bu saxlanmış mühitə yönəlir.
  3. Axtarış zəncir boyunca gedir. Adı tapmaq üçün mühərrik əvvəlcə cari mühitə, sonra onun xarici mühitinə baxır və beləcə qlobal mühitə qədər qalxır. Heç yerdə elan olunmamış adı oxumaq ReferenceError atır.

Mühitlərin bu zənciri scope zənciridir (scope chain). Closure isə sadəcə saxladığı mühit sayəsində bu zənciri xarici funksiya qayıtdıqdan sonra da yaşadan funksiyadır.

Dəyəri yox, binding-i tutur

Closure dəyişənin o anki dəyərinin surətini yox, dəyişənin özünü tutur. Eyni çağırış zamanı yaranan closure-lar bir mühiti bölüşür:

JavaScript
function makeBox() {
  let value = 0;
  const get = () => value;
  const set = (next) => {
    value = next;
  };
  return { get, set };
}

const a = makeBox();
const b = makeBox();
a.set(5);
console.log(a.get(), b.get()); // 5 0

a.get və a.set eyni mühiti bölüşür, b isə ayrı çağırışdan yarandığı üçün öz mühitinə malikdir.

Hoisting və TDZ

Axtarış funksiya yaradılanda yox, icra olunanda baş verir. Buna görə closure aşağıda elan olunan dəyişənə də müraciət edə bilər:

JavaScript
const read = () => late;
const late = "ready";
console.log(read()); // "ready"

read()-i const late sətrindən əvvəl çağırsaydıq, ReferenceError alardıq: sayəsində binding artıq mövcuddur, amma hələ qalır.

MiddleTipik səhvlər

Tələlər: dövrdə var və ortaq binding-lər

Müsahibələrin klassik sualı:

JavaScript
for (var i = 0; i < 3; i++) {
  setTimeout(() => console.log(i), 0);
}
// 3, 3, 3

var funksiya (və ya qlobal) scope-una aiddir, yəni bütün dövr üçün bir i var. Üç callback-in üçü də həmin binding-i tutur. taymer callback-lərini yalnız cari skript bitəndən sonra işə salır — o vaxta dövr artıq tamamlanıb və i 3-ə bərabərdir.

let ilə nəticə 0, 1, 2 olur:

JavaScript
for (let i = 0; i < 3; i++) {
  setTimeout(() => console.log(i), 0);
}
// 0, 1, 2

for dövrünün başlığında let ilə elan olunan dəyişən üçün spesifikasiya hər iterasiyada yeni binding yaradır və artırma icra olunmazdan əvvəl cari dəyəri ona köçürür. Beləliklə, hər callback ayrı i tutur. let və ya const ilə yazılmış for...of və for...in dövrləri də hər iterasiyada təzə binding alır. (Klassik for (const i = 0; i < 3; i++) isə ilk i++-da TypeError atır, çünki const-a yenidən dəyər mənimsətmək olmaz.)

ES2015-dən əvvəl bu problem hər iterasiya üçün yeni scope yaradan ilə həll olunurdu:

JavaScript
for (var i = 0; i < 3; i++) {
  (function (j) {
    setTimeout(() => console.log(j), 0);
  })(i);
}

i arqument kimi ötürüləndə onun cari dəyəri yeni j parametrinə köçürülür.

Digər tələlər

  • Snapshot gözləmək. Closure dəyişənin dəyərini icra olunduğu anda oxuyur. Closure yaradılandan çağırılana qədər dəyişən dəyişibsə, yeni dəyəri görəcəksən. Dəyəri "dondurmaq" istəyirsənsə, onu arqument kimi ötür və ya yeni scope-dakı const-a köçür.
  • Ortaq və ayrı state. Bir çağırışdan qayıdan funksiyalar mühiti bölüşür, müxtəlif çağırışlardan qayıdanlar isə bölüşmür. Bunu qarışdıranda "bu sayğac niyə dəyişdi?" tipli bug-lar yaranır.
  • Adi funksiyalar this-i tutmur. Adi function-un this-i onun necə çağırılmasından asılıdır, ona görə də setTimeout(function () { ... }) içində this sənin obyektin olmayacaq. Arrow funksiyaların öz this-i yoxdur: onlar xarici scope-un this-ini, eynilə tutulmuş dəyişən kimi, istifadə edir.
MiddleNümunə

Faydalı şablonlar: once, memoize, debounce, modul

Bir çox kiçik utilit closure üzərində qurulub. Onların əksəriyyəti : funksiya qəbul edir və gizli state-i closure-da saxlayan yeni funksiya qaytarır.

once — funksiyanı ən çoxu bir dəfə icra etmək:

JavaScript
function once(fn) {
  let called = false;
  let result;
  return function (...args) {
    if (!called) {
      called = true;
      result = fn.apply(this, args);
    }
    return result;
  };
}

Qaytarılan funksiya adi function-dur, buna görə this və arqumentlər olduğu kimi ötürülür.

memoize — keşi closure-da yaşayan :

JavaScript
function memoize(fn) {
  const cache = new Map();
  return (arg) => {
    if (!cache.has(arg)) {
      cache.set(arg, fn(arg));
    }
    return cache.get(arg);
  };
}

Diqqət et: bu keş heç vaxt kiçilmir. Senior hissədə yaddaşdan danışanda buna qayıdacağıq.

debounce — gözləyən taymerin id-sini çağırışlar arasında saxlayır ki, hər yeni çağırış əvvəlkini ləğv edə bilsin:

JavaScript
function debounce(fn, delay) {
  let timeoutId;
  return (...args) => {
    clearTimeout(timeoutId);
    timeoutId = setTimeout(() => fn(...args), delay);
  };
}

da eyni prinsiplə işləyir, sadəcə taymer id-si əvəzinə son icranın vaxtını (və ya "gözləmə" bayrağını) saxlayır.

Modul şablonu — ES modullarından əvvəl implementasiya detallarını gizlətməyin standart yolu IIFE idi:

JavaScript
const counterModule = (function () {
  let count = 0;
  return {
    increment() {
      count += 1;
      return count;
    },
    reset() {
      count = 0;
    },
  };
})();

count-a kənardan çatmaq mümkün deyil, ona yalnız increment və reset toxuna bilər. Bu gün hər ES modul faylının öz scope-u olduğundan IIFE-yə nadir hallarda ehtiyac yaranır. Amma ideya — funksiyaları kənara açmaq, state-i closure-da gizlətmək — fabrik funksiyalarda və bir çox kitabxananın API-sində hələ də istifadə olunur.

SeniorVeb platforma

Yaddaş, garbage collection və performans

Closure öz mühitini əlçatan saxlayır, isə yalnız əlçatmaz olanı təmizləyir. Deməli, dəyişən ona çata bilən hansısa funksiya yaşadıqca yaşayır — o funksiyanın bir daha çağırılıb-çağırılmayacağından asılı olmayaraq.

Sızmaların tipik mənbələri

Closure ilə bağlı çoxu closure-u uzunömürlü bir şeyin saxlamasından yaranır:

  • Event listener-lər. window, document və ya qlobal store-a bağlanmış listener silinənə qədər öz closure-unu və onun istinad etdiyi hər şeyi yaşadır.
  • Taymerlər. setInterval callback-i tutduğu hər şeylə birlikdə clearInterval çağırılana qədər yaddaşda qalır.
  • Closure-dakı keşlər. Yuxarıdakı memoize heç nəyi unutmur. Ölçü limiti qoy və ya obyekt açarları üçün WeakMap işlət ki, yazılar açarla birlikdə təmizlənə bilsin.
  • DOM-dan ayrılmış node-lar. Silinmiş elementə istinad edən closure onu bütün alt ağacı ilə birlikdə yaddaşda saxlayır.

Listener-in ömrünü onu yaradan funksionallığa bağla. AbortController öz siqnalı ilə qeydə alınmış bütün listener-ləri bir çağırışla silir:

JavaScript
function trackClicks(button) {
  const clicks = [];
  const controller = new AbortController();

  button.addEventListener("click", (event) => clicks.push(event.timeStamp), {
    signal: controller.signal,
  });

  return () => controller.abort();
}

Əslində nə saxlanılır

Spesifikasiya modelində closure bütün mühit zəncirini saxlayır. Mühərriklər bunu optimallaşdırır və adətən yalnız daxili funksiyaların həqiqətən istinad etdiyi dəyişənləri saxlayır, lakin bu optimallaşdırmanın da hüdudları var. V8-də (Chrome, Node.js) scope-dakı hər hansı daxili funksiyanın tutduğu dəyişənlər adətən həmin scope üçün bir ortaq kontekst obyektində saxlanılır və o scope-da yaranan bütün closure-lar bu obyektə istinad edir:

JavaScript
function setup() {
  const bigData = new Array(1_000_000).fill(0);
  const id = 42;

  function logSize() {
    console.log(bigData.length);
  }
  logSize();

  return () => id;
}

const getId = setup();

getId yalnız id-dən istifadə edir, amma logSize bigData-nı tutduğu üçün hər ikisi eyni kontekstdədir və bigData getId yaşadıqca yaddaşda qala bilər. Bu, spesifikasiyanın yox, mühərrikin detalıdır və versiyadan versiyaya dəyişə bilər. Böyük obyekt qısa müddətə lazımdırsa, onu uzunömürlü scope-da tutma və ya let ilə elan edib işin bitəndə null mənimsət.

Sızmanı tapmaq üçün Chrome DevTools-un Memory panelində heap snapshot götür və yaddaşdan getməli olan obyektin Retainers siyahısına bax.

Performans

Closure yaratmaq funksiya obyekti (dəyişən tutursa, həm də kontekst) üçün yaddaş ayırmaq deməkdir. Bu ucuzdur və çox "isti" kod hissələrindən kənarda nadir hallarda hiss olunur. React-də isə real xərc adətən funksiyanın hər render-də aldığı yeni referansdır: bu, memo-nu faydasız edə və ya effektləri yenidən işə sala bilər.

SeniorFramework

React hook-ları və stale closure

Komponentin hər render-i bir funksiya çağırışıdır. Bu çağırış yeni props, yeni state sabitləri və yeni funksiyalar yaradır; həmin render zamanı yaranan hər effekt, handler və callback məhz o render-in dəyərləri üzərində closure olur. react.dev state-i məhz buna görə "snapshot" adlandırır. Problem köhnə render-dən qalan funksiya işləməyə davam edəndə başlayır — buna deyilir.

TSX
import { useEffect, useState } from "react";

function Timer() {
  const [count, setCount] = useState(0);

  useEffect(() => {
    const id = setInterval(() => {
      setCount(count + 1);
    }, 1000);
    return () => clearInterval(id);
  }, []);

  return <p>{count}</p>;
}

Effekt bir dəfə icra olunur, ona görə də interval callback-i count-un 0 olduğu ilk render-ə aiddir. Hər tikdə setCount(0 + 1) çağırılır: sayğac 1 göstərir və orada ilişib qalır.

Həll yolları: sadədən mürəkkəbə

  1. Funksional yeniləmə. Sənə yalnız əvvəlki state lazımdırsa, onu closure-dan oxuma: setCount((c) => c + 1). Ən son dəyəri React özü ötürür, effekt [] ilə qalır və interval bir dəfə yaradılır.
  2. Düzgün asılılıqlar. count-u dependency array-ə əlavə etsən, effekt təzə closure ilə yenidən icra olunacaq. Bu düzgündür, amma bu nümunədə interval hər dəyişiklikdə silinib yenidən yaradılır. react-hooks/exhaustive-deps xəbərdarlığını susdurma: çatışmayan asılılıq adətən gec-tez üzə çıxacaq stale closure deməkdir. Eyni qayda useCallback və useMemo-ya da aiddir — useCallback(fn, []) ilk render-in dəyərlərini "dondurur".
  3. Ref-lər. Ref bütün render-lərin bölüşdüyü dəyişkən qutudur, ona görə də ref.current-i oxuyan uzunömürlü callback həmişə son dəyəri alır. Ref-i render zamanı yox, effektdə və ya event handler-də yenilə.
  4. useEffectEvent (React 19.2-dən stabildir) — effektin içində son props və ya state-i görməli olan, amma effektin yenidən sinxronlaşmasına səbəb olmamalı olan məntiq üçün:
TSX
import { useEffect, useEffectEvent, useState } from "react";

function Ticker({ step }: { step: number }) {
  const [count, setCount] = useState(0);

  const onTick = useEffectEvent(() => {
    setCount((c) => c + step);
  });

  useEffect(() => {
    const id = setInterval(() => onTick(), 1000);
    return () => clearInterval(id);
  }, []);

  return <p>{count}</p>;
}

onTick həmişə cari step-i görür, step-in dəyişməsi isə intervalı yenidən başlatmır. Effect Event-lər dependency array-ə yazılmır, yalnız effektlərin içindən çağırılır və başqa komponentlərə və ya hook-lara ötürülmür. Effekti həqiqətən yenidən işə salmalı olan asılılıqları gizlətmək üçün onlardan istifadə etmə.

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

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

30 saniyəlik tərif. "Closure funksiya ilə onun yarandığı scope-un dəyişənlərinin birləşməsidir. JavaScript dəyişənləri leksik qaydada həll edir, ona görə də xarici funksiya qayıtdıqdan sonra da funksiya bu dəyişənlərə çıxışını saxlayır." Ardınca sayğac fabrikini yaz: bu, ideyanı sadəcə əzbərləmədiyini, tətbiq edə bildiyini göstərir.

Gözlənilən suallar

  • Bu dövr nə çap edəcək? var/let + setTimeout tapmacası. Səbəbini izah et: bir ortaq binding və hər iterasiya üçün yeni binding.
  • once, memoize və ya debounce yaz. State-in harada yaşadığını (closure-da) de və detallara diqqət et: this-in və arqumentlərin ötürülməsi, əvvəlki taymerin təmizlənməsi.
  • Məlumatı necə gizli saxlamaq olar? Closure-larla (fabrik funksiya və ya modul şablonu); siniflər üçün müasir alternativ kimi #private sahələrini də qeyd et.
  • Closure yaddaş sızmasına səbəb ola bilərmi? Bəli, çünki o, öz mühitini əlçatan saxlayır. Konkret mənbələr say: unudulmuş listener-lər, təmizlənməyən intervallar, limitsiz keşlər.
  • Effekt niyə köhnə dəyəri görür? Hər render-in öz closure-ları var. Həll yolları: asılılıqlar, funksional yeniləmə, ref-lər, useEffectEvent.

Bal itirdən səhvlər

  • Closure-un dəyişənləri "kopyaladığını" demək. O, binding-ləri tutur, ona görə yaradılandan sonrakı dəyişikliklər də görünür.
  • Closure-un yalnız funksiya qaytarılanda yarandığını demək. Hər funksiya öz scope-u üzərində closure-dur; onu qaytarmaq və ya başqa yerə ötürmək sadəcə bu effekti görünən edir.
  • Scope ilə this-i qarışdırmaq. Closure dəyişənləri tutur, adi funksiyada this isə çağırışdan asılıdır.
  • Closure-ları təbiətcə yavaş və ya sızma yaradan hesab etmək. Onların xərci bir yaddaş ayrılmasıdır və istinad etdikləri şeyləri yalnız özləri əlçatan qaldıqca saxlayırlar.

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

Nəzəriyyəni təcrübə ilə bağla: sızmanı necə tapardın (heap snapshot, Retainers), sabit funksiya referansı memo və effekt asılılıqları üçün niyə vacibdir, funksional yeniləməni, ref-i və ya useEffectEvent-i nə vaxt seçərdin.

JuniorYoxlama siyahısı

Closure-ları 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, köhnə dəyərləri oxuyan callback-lər, ya da funksionallıq çoxdan yox olsa da yaddaşı tutan listener və keşlər production-a çıxacaq.

  • Render-indən uzun yaşayan callback state-i və ya props-u birbaşa oxuyurmu? Interval callback-i, [] ilə yazılmış effekt və ya useCallback(fn, []) onu yaradan render-in dəyərlərini saxlayır — buna deyilir. setCount((c) => c + 1) kimi funksional yeniləmə, düzgün asılılıqlar və ya ref gözlə; react-hooks/exhaustive-deps xəbərdarlığı isə susdurulmamalıdır.
  • window, document və ya qlobal store-a bağlanan hər listener silinirmi, hər setInterval təmizlənirmi? Bu baş verənə qədər nə closure-u, nə də onun istinad etdiyi şeyləri təmizləyə bilir. Uyğun removeEventListener, clearInterval və ya controller.abort() çağırışını tap.
  • Callback yaradan dövr var işlədirmi? for (var i = 0; i < 3; i++) ilə üç taymer callback-i bir i-ni bölüşür və 3, 3, 3 çap edir. Dövrün başlığında let, for...of-da isə const gözlə.
  • Kod closure-un yarandığı andakı dəyəri gözləyirmi? Closure dəyərin surətini yox, dəyişənin özünü tutur və onu icra olunanda oxuyur. Dəyəri "dondurmaq" üçün onu arqument kimi ötür və ya const-a köçür.
  • Adi function callback-i this işlədirmi? setTimeout(function () { ... }) içində this sənin obyektin olmayacaq: closure dəyişənləri tutur, this-i yox. Arrow funksiya, once kimi wrapper-lərdə isə fn.apply(this, args) gözlə.
  • Closure-dakı keş yalnız böyüyürmü? Map üzərində qurulmuş memoize heç nəyi unutmur. Ölçü limiti qoyulmasını, açarlar obyektdirsə, WeakMap işlədilməsini tələb et.

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