Closure Nedir? Programlamada Kapsam (Scope) ve Fonksiyonel Yaklaşımlar

uslame · 11 Ağu 2025

Programlamada, özellikle JavaScript gibi fonksiyonların "birinci sınıf vatandaş" olduğu dillerde, Closure kavramı merkezi bir rol oynar. Bu kavram, bir fonksiyonun kendi leksik çevresini -yani tanımlandığı yerdeki değişkenleri ve fonksiyonları- hatırlaması ve bunlara erişebilmesi durumunu ifade eder. Bir iç fonksiyon, dış fonksiyonun çalışması tamamlandıktan çok sonra bile, tanımlandığı dış kapsamdaki değişkenlere erişebilir ve onları manipüle edebilir. Bu yetenek, güçlü ve esnek programlama paradigmalarına olanak tanır.

Leksik Kapsam (Lexical Scope) Nedir?

Leksik kapsam, bir fonksiyonun kodda nerede tanımlandığına göre değişkenlere erişimini belirleyen bir mekanizmadır. Yani, bir fonksiyonun hangi değişkenlere erişebileceği, o fonksiyonun yazıldığı yer ve iç içe geçtiği diğer fonksiyonların hiyerarşisi tarafından belirlenir. Closure tam da bu leksik kapsamın bir sonucudur. İç fonksiyon, kendisini çevreleyen (dış) fonksiyonun kapsamını 'kapatır' veya 'üzerinde bir kapanış' yapar ve bu sayede dış fonksiyonun değişkenlerine kalıcı bir bağlantı sürdürür.

Closure Nasıl Çalışır?

Bir fonksiyon tanımlandığında, sadece kod değil, aynı zamanda o fonksiyonun "leksik ortamı" da kaydedilir. Bu leksik ortam, fonksiyonun kendisinin ve çevresindeki kapsamların (dış fonksiyonlar ve genel kapsam) o anki değişkenlerini ve iç içe fonksiyonlarını içerir. Dış fonksiyon çalışmayı bitirip çağırma yığınından (call stack) çıkarılsa bile, eğer bu dış fonksiyondan bir iç fonksiyon döndürülmüşse ve bu iç fonksiyon dış kapsamdaki değişkenleri kullanıyorsa, JavaScript motoru bu değişkenleri çöp toplama (garbage collection) işleminden korur. İşte bu korunan değişkenler ve iç fonksiyonun kendisi birlikte bir Closure oluşturur.

Neden Closure Kullanmalıyız? Temel Faydaları:

Veri Gizleme (Encapsulation) ve Özel Değişkenler: Closure'lar, değişkenleri doğrudan global kapsamdan veya modül dışından erişimden korumak için mükemmel bir yöntem sunar. Bu, bir tür veri gizleme veya encapsulation sağlar ve böylece bir nesnenin veya modülün iç durumunu dışarıdan istenmeyen erişim ve değişikliklerden korur. Bu desene Modül Deseni de denir.
Durum Yönetimi (State Management): Fonksiyon çağrıları arasında belirli bir durumu sürdürmek için closure'lar kullanılabilir. Örneğin, bir sayacı veya bir ayar yapılandırmasını hatırlayan fonksiyonlar oluşturabilirsiniz.
Fonksiyon Fabrikaları (Function Factories): Belirli bir yapılandırmaya sahip, özelleştirilmiş yeni fonksiyonlar oluşturmak için closure'lar kullanılabilir. Bu, aynı temel mantığa sahip ancak farklı başlangıç değerleri veya parametreleri olan birçok benzer fonksiyon üretmek gerektiğinde oldukça kullanışlıdır.
Geri Çağırım Fonksiyonları (Callbacks): Asenkron işlemler (örneğin, olay işleyicileri, zamanlayıcılar, ağ istekleri) genellikle geri çağırım fonksiyonları gerektirir. Closure'lar, bu geri çağırım fonksiyonlarının, asenkron işlemin tamamlanmasından sonra bile, tanımlandıkları kapsamdaki verilere erişmesini sağlar.
Currying ve Kısmi Uygulama (Partial Application): Fonksiyonları daha küçük, yeniden kullanılabilir parçalara bölmek ve fonksiyonlara belirli argümanları önceden bağlamak için de closure'lardan faydalanılır.

JavaScript'te Closure Örnekleri:

İşte closure'ın çeşitli kullanım senaryolarını gösteren bazı detaylı örnekler:

1. Basit Bir Sayaç Örneği (Durum Yönetimi):

Aşağıdaki örnekte, `createCounter` fonksiyonu bir sayaç oluşturur. Her çağrıldığında `count` değişkenini bir artıran bir iç fonksiyon döndürür. `count` değişkeni, `createCounter` fonksiyonu sona erdikten sonra bile, döndürülen fonksiyon tarafından 'hatırlanır'.

Kod:

function createCounter() {
    let count = 0; // Bu değişken, döndürülen fonksiyon için 'kapalı' bir değişkendir.

    // İç fonksiyon bir closure'dır.
    return function() {
        count++; // Dış kapsamdaki 'count' değişkenine erişir ve onu değiştirir.
        console.log("Sayaç değeri: " + count);
        return count;
    };
}

const counter1 = createCounter();
counter1(); // Sayaç değeri: 1
counter1(); // Sayaç değeri: 2

const counter2 = createCounter(); // Yeni bir sayaç oluşturur, kendi 'count' değişkenine sahiptir.
counter2(); // Sayaç değeri: 1
counter1(); // Sayaç değeri: 3 (counter1 kendi durumunu koruyor)

Bu örnekte, `counter1` ve `counter2` bağımsız sayaçlardır çünkü her `createCounter` çağrısı, kendine ait ayrı bir `count` değişkenine sahip yeni bir closure oluşturur.

2. Veri Gizleme ve Modül Deseni:

Closure'lar, bir nesnenin veya modülün iç detaylarını gizlemek için kullanılabilir. Bu, JavaScript'teki temel modül deseni yaklaşımını oluşturur.

Kod:

const userProfile = (function() {
    let _username = "misafir"; // Bu özel bir değişkendir, dışarıdan doğrudan erişilemez.
    let _email = "misafir@example.com";

    function _displayInfo() { // Bu özel bir metottur.
        console.log(`Kullanıcı Adı: ${_username}, E-posta: ${_email}`);
    }

    return {
        // Bu metotlar, özel değişkenlere ve metotlara erişim sağlayan genel arayüzlerdir.
        setUsername: function(newUsername) {
            _username = newUsername;
            console.log(`Kullanıcı adı güncellendi: ${_username}`);
        },
        getEmail: function() {
            return _email;
        },
        showProfile: function() {
            _displayInfo(); // Özel metodu çağırır.
        }
    };
})();

userProfile.showProfile(); // Kullanıcı Adı: misafir, E-posta: misafir@example.com
userProfile.setUsername("ayse.yildiz"); // Kullanıcı adı güncellendi: ayse.yildiz
userProfile.showProfile(); // Kullanıcı Adı: ayse.yildiz, E-posta: misafir@example.com
// console.log(userProfile._username); // Tanımsız - _username'e doğrudan erişilemez!

Yukarıdaki IIFE (Immediately Invoked Function Expression) ve closure kombinasyonu, `_username`, `_email` ve `_displayInfo`'yu dış dünyadan gizlerken, `setUsername`, `getEmail` ve `showProfile` gibi kamuya açık metotlar aracılığıyla kontrollü erişim sağlar.

3. Döngülerde Karşılaşılan Yaygın Hatalar ve Closure Çözümü:

`var` anahtar kelimesiyle tanımlanan değişkenlerin fonksiyon kapsamlı olması, döngülerde beklenmedik davranışlara yol açabilir. `let` veya `const` ile bu sorun büyük ölçüde çözülse de, `var` ile bir closure çözümü nasıl yapılacağını görmek önemlidir.

Kod:

// Hatalı örnek: var kullanıldığında i'nin son değeri alınır
for (var i = 0; i < 3; i++) {
    setTimeout(function() {
        console.log("var ile: " + i);
    }, 100 * i); // Çıktı: 3, 3, 3 (çünkü i'nin son değeri 3 olur)
}

// Doğru örnek 1: let kullanarak (let blok kapsamlıdır ve her iterasyonda yeni bir i oluşturur)
for (let j = 0; j < 3; j++) {
    setTimeout(function() {
        console.log("let ile: " + j);
    }, 100 * j); // Çıktı: 0, 1, 2
}

// Doğru örnek 2: Closure kullanarak (IIFE ile her iterasyon için yeni bir 'index' değeri kapatılır)
for (var k = 0; k < 3; k++) {
    (function(index) { // Anında çalışan fonksiyon ifadesi (IIFE)
        setTimeout(function() {
            console.log("closure (IIFE) ile: " + index);
        }, 100 * index);
    })(k); // Her iterasyonda k'nin o anki değerini 'index' parametresine geçiririz.
} // Çıktı: 0, 1, 2

Bu örnek, closure'ın döngü içindeki değişkenlerin her iterasyon için doğru bir şekilde 'yakalanmasını' nasıl sağladığını açıkça göstermektedir.

4. Olay İşleyicilerinde Kullanım:

DOM elementlerine olay işleyicileri atarken, closure'lar, her işleyicinin doğru verilere erişmesini sağlamak için çok önemlidir.

Kod:

<button id="btn1">Button 1</button>
<button id="btn2">Button 2</button>
<button id="btn3">Button 3</button>

<script>
    const buttons = document.querySelectorAll('button');

    for (let i = 0; i < buttons.length; i++) {
        // Her döngü iterasyonunda, 'i' için yeni bir blok kapsam oluşturulur (let sayesinde).
        // Bu, iç fonksiyonun her zaman kendi 'i' değerine sahip olmasını sağlar.
        buttons[i].addEventListener('click', function() {
            console.log(`Buton ${i+1} tıklandı.`);
        });
    }

    // Closure kullanarak bir olay işleyici 'fabrikası' oluşturalım:
    function createButtonClickHandler(buttonNumber) {
        return function() {
            console.log(`Fabrika metodu ile: Buton ${buttonNumber} tıklandı.`);
        };
    }

    // Bu şekilde de her buton için ayrı bir closure oluşturulur.
    document.getElementById('btn1').addEventListener('click', createButtonClickHandler(1));
    document.getElementById('btn2').addEventListener('click', createButtonClickHandler(2));
    document.getElementById('btn3').addEventListener('click', createButtonClickHandler(3));

</script>

Bu kod parçacığı, her butonun kendi özel `i` değerini veya `buttonNumber`'ını hatırlayarak doğru çıktıyı vermesini sağlar.

Görsel Temsil:

Closure'ın soyut yapısını anlamak bazen zor olabilir. Aşağıdaki resimde, bir dış fonksiyonun (parent scope) ve onun içindeki bir iç fonksiyonun (child function/closure) leksik ortamlarının nasıl iç içe geçtiği ve iç fonksiyonun dış kapsamdaki değişkenlere olan referansını nasıl koruduğu görselleştirilebilir:

Bu diyagram, `outerFunction`'ın `outerVariable`'ı ve `innerFunction`'ın bu değişkene nasıl eriştiğini ve `innerFunction` dışarı döndürüldüğünde bile `outerVariable`'ın bellekte kalmaya devam ettiğini gösterir.

Alıntı ve Felsefi Yaklaşım:

"JavaScript'te closure'lar, fonksiyonların sadece kod değil, aynı zamanda yaratıldıkları çevreyle birlikte düşünülmesi gerektiğini vurgular. Bu, daha modüler, test edilebilir ve yeniden kullanılabilir kod yazmamızı sağlayan temel bir yapı taşıdır."

Bu alıntı, closure'ın sadece bir teknik özellik olmadığını, aynı zamanda fonksiyonel programlama felsefesinin önemli bir parçası olduğunu vurgular.

Kaynaklar ve Ek Bilgiler:

Closure hakkında daha derinlemesine bilgi edinmek için aşağıdaki resmi dokümantasyonları ve güvenilir kaynakları inceleyebilirsiniz:
MDN Web Docs - Closures
W3Schools - JavaScript Closures

Potansiyel Dezavantajlar ve Dikkat Edilmesi Gerekenler:

Closure'lar güçlü olsa da, yanlış kullanıldığında bazı olumsuz sonuçlara yol açabilir:

Bellek Tüketimi: Closure'lar, referans verdikleri dış kapsamdaki değişkenlerin bellekte kalmasına neden olur. Eğer bir closure gereksiz yere büyük veri yapılarına referans veriyorsa ve bu closure uzun süre bellekte kalıyorsa, bu durum potansiyel bellek sızıntılarına veya yüksek bellek kullanımına yol açabilir. Özellikle DOM elementlerine referans veren olay işleyicilerinde dikkatli olunmalıdır.
Performans: Çoğu modern JavaScript motoru closure'ları çok verimli bir şekilde optimize etse de, aşırı ve düşüncesiz closure kullanımı, bazı durumlarda hafif performans düşüşlerine neden olabilir. Ancak bu genellikle mikro-optimizasyon seviyesinde bir endişedir ve closure'ların sunduğu faydalar genellikle bu potansiyel maliyeti aşar.

Özet:

Closure, JavaScript gibi dillerde fonksiyonel programlamanın temel taşlarından biridir. Bir fonksiyonun tanımlandığı leksik ortamdaki değişkenlere kalıcı olarak erişimini sağlayarak veri gizleme, durum yönetimi, fonksiyon fabrikaları ve daha birçok karmaşık programlama desenini mümkün kılar. Doğru anlaşıldığında ve kullanıldığında, daha esnek, modüler ve bakımı kolay kod yazmamızı sağlayan inanılmaz derecede güçlü bir araçtır. Modern web geliştirmenin ve karmaşık uygulama mimarilerinin vazgeçilmez bir parçasıdır. Closure'ları ustaca kullanmak, bir geliştiricinin yetkinliğini önemli ölçüde artıran bir beceridir.