// JavaScript örneği
function ornekFonksiyon() {
    let mesaj = "Merhaba Dünya!"; // Bu değişken fonksiyon kapsamındadır.

    if (true) {
        let dahiliMesaj = "Bu bir blok kapsamıdır."; // Bu değişken sadece if bloğunda geçerlidir.
        console.log(mesaj); // 'mesaj' değişkenine erişilebilir
        console.log(dahiliMesaj); // 'dahiliMesaj' değişkenine erişilebilir
    }

    // console.log(dahiliMesaj); // Hata verir: 'dahiliMesaj' burada tanımlı değil
    console.log(mesaj); // 'mesaj' değişkenine hala erişilebilir
}
ornekFonksiyon();

• Değişken Çakışmalarını Önleme: Farklı kod bloklarında aynı isimde değişkenler kullanılsa bile, birbirleriyle çakışmazlar.
• Bellek Yönetimi: Bir blok sona erdiğinde, o blok içinde tanımlanan değişkenler bellekten kaldırılabilir, bu da kaynakların daha verimli kullanılmasını sağlar.
• Kod Okunabilirliği ve Bakımı: Kapsamın daraltılması, kodun daha modüler ve anlaşılır olmasını sağlar, yan etkileri azaltır.

"Bir kapanış, iç içe geçmiş bir fonksiyonun, dıştaki (üst) fonksiyonun değişkenlerine erişebilme yeteneğidir." - Mozilla Developer Network (MDN) tanımına benzer bir yaklaşım.

Genişletmek için tıkla ...

function disFonksiyon(disDegisken) {
    return function icFonksiyon(icDegisken) {
        console.log("Dış değişken: " + disDegisken);
        console.log("İç değişken: " + icDegisken);
    };
}

const kapanisInstance = disFonksiyon("Merhaba");
kapanisInstance("Dünya"); // Çıktı: Dış değişken: Merhaba, İç değişken: Dünya
// 'disDegisken'e hala erişilebiliyor, çünkü 'icFonksiyon' kendi kapanış ortamında onu tutuyor.

const baskaKapanisInstance = disFonksiyon("Güle güle");
baskaKapanisInstance("Java"); // Çıktı: Dış değişken: Güle güle, İç değişken: Java

• Veri Gizliliği (Encapsulation) ve Modül Deseni: Kapanışlar, özel değişkenler oluşturarak dışarıdan doğrudan erişimi engeller. Bu, nesne yönelimli programlamadaki 'private' üyelerin simülasyonunu sağlar. JavaScript'teki modül deseni, bu prensibi temel alır. Örneğin, bir sayaç fonksiyonu:
  
  Kod:

  function sayacOlusturucu() {
      let sayac = 0; // Özel değişken
  
      return {
          arttir: function() {
              sayac++;
              console.log("Sayaç: " + sayac);
          },
          azalt: function() {
              sayac--;
              console.log("Sayaç: " + sayac);
          },
          degerGetir: function() {
              return sayac;
          }
      };
  }
  
  const benimSayacim = sayacOlusturucu();
  benimSayacim.arttir(); // Sayaç: 1
  benimSayacim.arttir(); // Sayaç: 2
  console.log(benimSayacim.degerGetir()); // 2
  // console.log(benimSayacim.sayac); // Tanımsız - 'sayac' değişkenine dışarıdan erişilemez.

  Bu yapı, `sayac` değişkenini dış dünyadan koruyarak sadece tanımlanan `arttir`, `azalt` ve `degerGetir` metotları aracılığıyla erişilmesini sağlar. Bu, yazılım tasarımında veri bütünlüğünü ve güvenliğini artırır.
  
• Fonksiyon Fabrikaları ve Currying: Kapanışlar, belirli parametreleri önceden ayarlanmış yeni fonksiyonlar üretmek için kullanılabilir. Bu, fonksiyonel programlamadaki currying (kısmi uygulama) kavramının temelini oluşturur.
  
  Kod:

  function carpiciOlusturucu(carpan) {
      return function(sayi) {
          return sayi * carpan;
      };
  }
  
  const ikiIleCarp = carpiciOlusturucu(2);
  const besIleCarp = carpiciOlusturucu(5);
  
  console.log(ikiIleCarp(10)); // 20
  console.log(besIleCarp(10)); // 50

• Zamanlayıcılar ve Olay İşleyiciler: Asenkron işlemler ve olay işleyicilerinde, kapanışlar beklenmedik davranışları önlemek için hayati öneme sahiptir. Özellikle döngüler içinde `setTimeout` gibi fonksiyonlarla çalışırken, döngü değişkeninin doğru değerini korumak için kapanışlar kullanılır.
  
  Kod:

  for (var i = 1; i <= 3; i++) {
      // Bu hatalı kullanımdır, i döngü bitince 4 olur ve tüm setTimeout'lar 4 basar.
      // setTimeout(function() { console.log("Hatalı i: " + i); }, i * 1000);
  
      // Doğru kullanım: Kapanış ile i'nin o anki değerini yakala
      (function(currentI) {
          setTimeout(function() {
              console.log("Doğru i: " + currentI);
          }, currentI * 1000);
      })(i);
  }
  // Alternatif ve daha modern çözüm: let kullanmak (blok kapsamı sayesinde)
  for (let j = 1; j <= 3; j++) {
      setTimeout(function() {
          console.log("Let ile doğru j: " + j);
      }, j * 1000 + 500); // Zaman çakışmasını önlemek için gecikmeyi arttırdık
  }

  Bu örnek, 'var' ile oluşan yaygın bir kapanış problematiğini ve bunu çözmenin geleneksel yolunu (IIFE - Immediately Invoked Function Expression kullanarak kapanış oluşturma) ve modern 'let' anahtar kelimesiyle nasıl daha basit hale getirildiğini göstermektedir. Bu aynı zamanda bloklar ve kapanışların birbiriyle nasıl ilişkili olduğunu ve modern dillerde blok kapsamının kapanış mekanizmalarını nasıl daha sezgisel hale getirdiğini net bir şekilde ortaya koymaktadır.
  
• Memoizasyon: Pahalı hesaplamaların sonuçlarını önbelleğe almak için kapanışlar kullanılabilir, bu da performansı artırır.
  
  Kod:

  function memoize(fn) {
      const cache = {}; // Kapanış içinde tutulan önbellek
  
      return function(...args) {
          const key = JSON.stringify(args);
          if (cache[key]) {
              console.log("Önbellekten alındı: " + key);
              return cache[key];
          } else {
              console.log("Hesaplandı ve önbelleğe alındı: " + key);
              const result = fn(...args);
              cache[key] = result;
              return result;
          }
      };
  }
  
  const toplama = (a, b) => a + b;
  const memoizeEdilmisToplama = memoize(toplama);
  
  memoizeEdilmisToplama(10, 20); // Hesaplandı ve önbelleğe alındı: [10,20]
  memoizeEdilmisToplama(10, 20); // Önbellekten alındı: [10,20]
  memoizeEdilmisToplama(5, 5);  // Hesaplandı ve önbelleğe alındı: [5,5]
  memoizeEdilmisToplama(10, 20); // Önbellekten alındı: [10,20]

  Bu `memoize` fonksiyonu, `cache` objesini bir kapanış içinde tutarak, aynı argümanlarla yapılan sonraki çağrılarda önceki sonuçları yeniden hesaplamak yerine önbellekten dönmesini sağlar.
  
  Bloklar ve Kapanışlar Arasındaki İlişki
  
  Bloklar ve kapanışlar birbirinden bağımsız kavramlar gibi görünse de, aslında iç içe geçmiş bir ilişki içindedirler. Bloklar, değişkenlerin yaşam döngüsünü ve görünürlüğünü tanımlayarak sözlüksel ortamı oluştururlar. Kapanışlar ise tam da bu sözlüksel ortamı 'yakalayarak' ve fonksiyon dışarıda çağrılsa bile bu ortamdaki değişkenlere erişim sağlayarak çalışırlar.
  
  Modern JavaScript'te 'let' ve 'const' ile gelen blok kapsamı, birçok durumda manuel kapanış oluşturma ihtiyacını (özellikle döngülerdeki `var` problemi gibi) ortadan kaldırarak kodu daha temiz ve anlaşılır hale getirmiştir. Ancak bu, kapanışların önemini azaltmaz; aksine, daha güçlü ve güvenli desenlerin doğal bir parçası haline gelmelerini sağlar.
  
  Performans ve Bellek Yönetimi Üzerindeki Etkiler
  
  Kapanışlar, büyük faydalar sunsa da, bellek yönetimi açısından dikkatli kullanılmalıdır. Bir kapanış, referans verdiği dış kapsamdaki değişkenleri bellekte tutmaya devam eder. Eğer bir kapanış uzun süre bellekte kalır ve büyük nesnelere referans veriyorsa, bu durum bellek sızıntılarına veya gereksiz bellek kullanımına yol açabilir. Bu nedenle, artık ihtiyaç duyulmayan kapanış referanslarını null'lamak veya olay işleyicilerini temizlemek gibi yaklaşımlar önemlidir.
  
  Kapanışlar hakkında daha fazla bilgi edinmek için burayı ziyaret edebilirsiniz.
  
  Sonuç
  
  Bloklar ve kapanışlar, modern programlama dillerinde değişken kapsamı ve veri yönetimi için temel yapı taşlarıdır. Bloklar, kodun okunabilirliğini ve değişkenlerin yaşam döngüsünü düzenlerken, kapanışlar programcılara veri gizliliği, fonksiyonel programlama desenleri ve karmaşık asenkron akışları yönetme gibi güçlü yetenekler sunar. Bu iki konsepti derinlemesine anlamak, daha verimli, güvenli ve bakımı kolay yazılımlar geliştirmek için vazgeçilmezdir. Özellikle JavaScript gibi dinamik dillerde çalışan her geliştiricinin bu mekanizmaları ustalıkla kullanabilmesi beklenir.
  
  Blok kapsamının getirdiği yenilikler ve kapanışların sağladığı esneklik, günümüzün karmaşık yazılım projelerinde temiz ve etkili kod yazımının anahtarlarından biridir.