[NODE JS] var, let ve const Arasındaki Farklar

Silverhand · Pazartesi saat 09:58'de

[NODE JS] var, let ve const Arasındaki Farklar

Selam arkadaşlar. Bu konu JavaScript öğrenen herkesin kafasını karıştıran ve mülakatların olmazsa olmazı bir konu. var, let ve const arasındaki farkları detaylıca anlatacağım. Ben başlarda sadece var kullanıyordum çünkü let ve const henüz yoktu. ES6 çıktığında let ve const'a geçiş sancılı oldu ama şimdi geriye dönüp bakınca var kullanmak istemiyorum bile.

Scope (Kapsam) Farkı

En temel fark scope konusunda. var function-scoped, let ve const ise block-scoped. Ne demek bu? var ile tanımlanan bir değişken en yakın fonksiyonun tamamında erişilebilir, let ve const ise sadece tanımlandığı blok içinde. Blok derken if, for, while gibi süslü parantezlerle çevrili alanlardan bahsediyoruz.

Bu fark pratikte nasıl sorun çıkarır? Ben bir keresinde var kullandığım bir for döngüsünde setTimeout ile zamanlayıcı kurmuştum ve tüm zamanlayıcılar aynı değeri yazdırıyordu. Saatlerce debug ettim, sonunda var'ın scope davranışı olduğunu anladım. let ile değiştirdiğimde sorun çözüldü.

JavaScript:

// === SCOPE FARKI ===

// var: function-scoped
function varOrnegi() {
    console.log('--- var scope ---');

    if (true) {
        var mesaj = 'if bloğunda tanımlandım';
    }
    console.log(mesaj); // Çalışır! var function-scoped

    for (var i = 0; i < 3; i++) {
        // döngü devam ediyor
    }
    console.log('i değeri:', i); // 3 - var döngü dışında da erişilebilir
}
varOrnegi();

// let: block-scoped
function letOrnegi() {
    console.log('
--- let scope ---');

    if (true) {
        let mesaj = 'if bloğunda tanımlandım';
        console.log('Blok içinde:', mesaj); // Çalışır
    }
    // console.log(mesaj); // ReferenceError! let block-scoped

    for (let j = 0; j < 3; j++) {
        // döngü devam ediyor
    }
    // console.log('j değeri:', j); // ReferenceError!
}
letOrnegi();

// const: block-scoped (let ile aynı scope kuralı)
function constOrnegi() {
    console.log('
--- const scope ---');

    if (true) {
        const PI = 3.14159;
        console.log('PI:', PI); // Çalışır
    }
    // console.log(PI); // ReferenceError!
}
constOrnegi();

// Klasik var sorunu: setTimeout ile döngü
console.log('
--- Klasik var sorunu ---');

// var ile (yanlış davranış)
for (var k = 0; k < 3; k++) {
    setTimeout(() => {
        console.log('var ile k:', k); // Hepsi 3 yazdırır!
    }, 100);
}

// let ile (doğru davranış)
setTimeout(() => {
    console.log('');
    for (let m = 0; m < 3; m++) {
        setTimeout(() => {
            console.log('let ile m:', m); // 0, 1, 2 yazdırır
        }, 100);
    }
}, 500);

Hoisting (Yukarı Taşınma) Farkı

var ile tanımlanan değişkenler hoisting'e uğrar, yani tanımlanmadan önce erişilebilir (ama değeri undefined olur). let ve const da hoisting'e uğrar ama "Temporal Dead Zone" denen bir bölgede kalır ve tanımlanmadan önce erişmeye çalışırsanız hata alırsınız. Bu aslında iyi bir şey çünkü hataları erken yakalamanızı sağlar.

Yeni başlayanlar bunu çok yanlış yapıyor. Değişkeni kullanıp sonra tanımlıyorlar ve var ile sorun çıkmadığı için fark etmiyorlar. Ama bu çok tehlikeli bir pratik, kodun okunabilirliğini düşürür ve beklenmedik buglara yol açar.

JavaScript:

// === HOİSTİNG FARKI ===

// var: hoisting ile yukarı taşınır (değeri undefined)
console.log('
--- Hoisting ---');
console.log('var deger:', typeof varDeger); // undefined (hata yok!)
var varDeger = 'merhaba';
console.log('var deger:', varDeger); // 'merhaba'

// let: Temporal Dead Zone (TDZ)
// console.log(letDeger); // ReferenceError: Cannot access before initialization
let letDeger = 'merhaba';
console.log('let deger:', letDeger);

// const: Aynı TDZ davranışı
// console.log(constDeger); // ReferenceError
const constDeger = 'merhaba';
console.log('const deger:', constDeger);

// === YENİDEN TANIMLAMA ve ATAMA ===

// var: hem yeniden tanımlama hem yeniden atama mümkün
var x = 1;
var x = 2; // Hata yok! (tehlikeli)
x = 3;     // Hata yok

// let: yeniden atama mümkün, yeniden tanımlama yasak
let y = 1;
// let y = 2; // SyntaxError: already been declared
y = 3; // Sorun yok

// const: ne yeniden tanımlama ne yeniden atama
const z = 1;
// const z = 2; // SyntaxError
// z = 3;       // TypeError: Assignment to constant variable

// AMA! const ile tanımlanan obje/array içeriği değiştirilebilir
const kullanici = { isim: 'Ahmet', yas: 25 };
kullanici.yas = 26;           // Sorun yok! İçerik değişebilir
kullanici.email = 'a@b.com';  // Yeni property eklenebilir
console.log(kullanici);

// Referansın kendisi değiştirilemez
// kullanici = { isim: 'Başka' }; // TypeError!

const dizi = [1, 2, 3];
dizi.push(4);        // Sorun yok
dizi[0] = 99;        // Sorun yok
console.log(dizi);   // [99, 2, 3, 4]
// dizi = [5, 6, 7]; // TypeError!

// Object.freeze ile gerçek değişmezlik sağlanabilir
const sabitler = Object.freeze({
    MAX_DENEME: 3,
    TIMEOUT: 5000,
    API_URL: 'https://api.example.com'
});
// sabitler.MAX_DENEME = 10; // Sessizce başarısız olur (strict mode'da TypeError)
console.log(sabitler.MAX_DENEME); // Hala 3

// Pratikte hangisini kullanmalı?
// 1. Önce const deneyin
// 2. Değer değişecekse let kullanın
// 3. var kullanmayın (eski kod hariç)

// Gerçek dünya örneği
const AYARLAR = Object.freeze({
    veritabani: {
        host: 'localhost',
        port: 5432,
        isim: 'uygulamam'
    },
    sunucu: {
        port: 3000,
        maxBaglanti: 100
    }
});

let aktifBaglanti = 0;
let sonIstek = null;

function baglantiKur() {
    aktifBaglanti++; // let olduğu için değiştirilebilir
    sonIstek = new Date();
    console.log(`Aktif bağlantı: ${aktifBaglanti}`);
}

baglantiKur();
baglantiKur();

Özetleyecek olursam: const varsayılan tercihiniz olsun, let gerektiğinde kullanın, var'a dokunmayın. Bu basit kural sizi birçok potansiyel bug'dan kurtarır. Ve evet, mülakata giriyorsanız bu konuyu çok iyi bilin çünkü en sevilen sorulardan biri bu. Kolay gelsin.

devemoji · Dün 21:36 da

Paylaşım için teşekkür ederiz.

[NODE JS] var, let ve const Arasındaki Farklar

Silverhand