JavaScript Dilinde Değişken (Variable) Kullanımı

JavaScript, dinamik ve esnek bir programlama dili olarak, veri depolama ve işleme yeteneklerini değişkenler aracılığıyla sunar. Bir değişken (variable), bellekte bir değeri tutmak için kullanılan sembolik bir isim veya bir kapsayıcıdır. Bu değer, programın yürütülmesi sırasında değiştirilebilir. JavaScript'te değişkenler, programın karmaşıklığını yönetmek, verileri geçici olarak saklamak ve daha okunabilir kod yazmak için temel bir yapıdır. Bu makale, JavaScript'teki değişkenlerin tanımını, farklı bildirim yöntemlerini ve en iyi uygulama prensiplerini detaylı bir şekilde ele almaktadır.

Değişken Nedir?

Bir değişken, bir programa ait verileri depolamak için kullanılan ve bellekte belirli bir konumu temsil eden bir isimdir. JavaScript'te bir değişken bildirildiğinde, bu değişkene bir değer atanabilir. Atanan değerin türü (sayı, metin, boolean vb.) çalışma zamanında dinamik olarak belirlenir ve aynı değişkenin değeri ve hatta türü programın farklı noktalarında değiştirilebilir.

Temel Değişken Tanımlama Yöntemleri

JavaScript'te değişken tanımlamak için üç anahtar kelime kullanılır:

• var: ES6 öncesinde kullanılan geleneksel yöntem.

• let: ES6 ile tanıtılan, blok kapsamlı değişken bildirimi.

• const: ES6 ile tanıtılan, blok kapsamlı ve sabit (değeri değiştirilemez) değişken bildirimi.

Sözdizimi

JavaScript'te bir değişken bildirmenin genel sözdizimi aşağıdaki gibidir:

anahtar_kelime değişken_adı = değer;

Bu sözdizimindeki her bir parçanın anlamı şunlardır:

• anahtar_kelime: Değişkenin nasıl davranacağını (kapsam, yeniden atama/bildirim yeteneği) belirleyen var, let veya const anahtar kelimelerinden biridir.

• değişken_adı: Değişkeni tanımlayan benzersiz bir isimdir. JavaScript değişken adlandırma kurallarına uymalıdır.

• =: Atama operatörüdür. Değişkenin sağındaki değeri solundaki değişkene atar.

• değer: Değişkene atanan veridir (sayı, metin, boolean, nesne vb.). Değişken bildirimi sırasında bir değer atanması isteğe bağlıdır, ancak const için zorunludur.

• ;: İfadenin sonunu belirtir. JavaScript'te genellikle isteğe bağlıdır (otomatik noktalı virgül ekleme - ASI), ancak kodun okunabilirliği ve potansiyel hataları önlemek için kullanılması önerilir.

var Anahtar Kelimesi

var ile bildirilen değişkenler, fonksiyon kapsamlıdır (function-scoped). Bu, değişkenin bildirildiği fonksiyonun tamamında erişilebilir olduğu anlamına gelir. Eğer bir fonksiyon dışında bildirilirse, global kapsamlı olur. var ile bildirilen değişkenler yeniden bildirilebilir ve yeniden atanabilir. Ayrıca, hoisting (yukarı taşınma) özelliğine sahiptirler; yani bildirimleri kodun en üstüne taşınır, ancak değer atamaları yerinde kalır. Bu durum, beklenmedik davranışlara yol açabilir.

function ornekVarKullanimi() {
    var sayi = 10;
    console.log(sayi); // 10

    if (true) {
        var sayi = 20; // Yeniden bildirim ve atama (fonksiyon kapsamlı)
        console.log(sayi); // 20
    }
    console.log(sayi); // 20 (if bloğunun dışından da erişilebilir ve değeri değişmiş)

    var sayi = 30; // Tekrar bildirim yapılabilir
    console.log(sayi); // 30
}
ornekVarKullanimi();

console.log(mesaj); // undefined (hoisting nedeniyle hata vermez, ama değer atanmamış)
var mesaj = "Merhaba Dünya";
console.log(mesaj); // Merhaba Dünya

let Anahtar Kelimesi

let ile bildirilen değişkenler, blok kapsamlıdır (block-scoped). Bu, değişkenin sadece bildirildiği kod bloğu ({} ile tanımlanmış her yer; if, for, while veya fonksiyon bloğu) içinde erişilebilir olduğu anlamına gelir. let ile aynı isimde bir değişkeni aynı kapsamda yeniden bildirmek mümkün değildir, ancak değeri yeniden atanabilir. let de hoisting'e tabidir, ancak "Temporal Dead Zone" (TDZ) adı verilen bir mekanizma nedeniyle bildirimden önce erişilirse hata verir.

function ornekLetKullanimi() {
    let ad = "Ali";
    console.log(ad); // Ali

    if (true) {
        let ad = "Veli"; // Farklı bir 'ad' değişkeni (blok kapsamlı)
        console.log(ad); // Veli
    }
    console.log(ad); // Ali (if bloğunun dışındaki 'ad' değişmedi)

    // let ad = "Ayşe"; // SyntaxError: 'ad' already been declared
    ad = "Ayşe"; // Yeniden atama yapılabilir
    console.log(ad); // Ayşe
}
ornekLetKullanimi();

// console.log(deneme); // ReferenceError: Cannot access 'deneme' before initialization (TDZ nedeniyle)
let deneme = "Test";

const Anahtar Kelimesi

const ile bildirilen değişkenler de let gibi blok kapsamlıdır. En önemli farkı, bir kez değer atandıktan sonra bu değerin değiştirilememesidir. Yani, const ile bildirilen bir değişkene yeniden atama yapılamaz ve aynı isimle yeniden bildirim yapılamaz. const ile bir değişken bildirildiğinde, başlangıç değeri hemen atanmak zorundadır. Nesneler ve diziler için const kullanıldığında, değişkenin referansı sabittir, ancak nesnenin veya dizinin içindeki elemanlar değiştirilebilir.

function ornekConstKullanimi() {
    const PI = 3.14;
    console.log(PI); // 3.14

    // PI = 3.14159; // TypeError: Assignment to constant variable.
    // const PI = 3.0; // SyntaxError: 'PI' has already been declared

    if (true) {
        const SABIT_METIN = "Merhaba";
        console.log(SABIT_METIN); // Merhaba
    }
    // console.log(SABIT_METIN); // ReferenceError: SABIT_METIN is not defined (blok kapsamlı)

    const ayarlar = {
        tema: "koyu"
    };
    ayarlar.tema = "açık"; // Nesnenin içeriği değiştirilebilir
    console.log(ayarlar.tema); // açık

    // ayarlar = { tema: "mavi" }; // TypeError: Assignment to constant variable. (referans değiştirilemez)
}
ornekConstKullanimi();

Pratik Kullanım Örnekleri

Aşağıdaki örnekler, farklı değişken bildirim yöntemlerinin gerçek dünya senaryolarında nasıl kullanılabileceğini göstermektedir.

// Örnek 1: Basit Değişken Atamaları
let kullaniciAdi = "john.doe"; // Değişebilir bir kullanıcı adı
const vergiOrani = 0.18;      // Sabit bir vergi oranı
var eskiSistemID = "A123";    // Eski sistemlerde var kullanımı

console.log(`Kullanıcı Adı: ${kullaniciAdi}`);    // Kullanıcı Adı: john.doe
console.log(`Vergi Oranı: ${vergiOrani}`);        // Vergi Oranı: 0.18

kullaniciAdi = "jane.doe"; // let ile bildirilen değer değiştirilebilir
console.log(`Yeni Kullanıcı Adı: ${kullaniciAdi}`); // Yeni Kullanıcı Adı: jane.doe
// vergiOrani = 0.20; // Hata verir: Assignment to constant variable.


// Örnek 2: Döngülerde let kullanımı
for (let i = 0; i < 3; i++) {
    console.log(`Döngü içindeki i: ${i}`); // 0, 1, 2
}
// console.log(i); // Hata verir: i is not defined (let blok kapsamlıdır)

for (var j = 0; j < 3; j++) {
    console.log(`Döngü içindeki j: ${j}`); // 0, 1, 2
}
console.log(`Döngü dışındaki j: ${j}`); // Döngü dışındaki j: 3 (var fonksiyon/global kapsamlıdır)


// Örnek 3: Nesne ve Dizi ile const
const kullaniciBilgileri = {
    isim: "Mehmet",
    yas: 30,
    aktif: true
};

kullaniciBilgileri.yas = 31; // Nesnenin özelliği değiştirilebilir
kullaniciBilgileri.sehir = "Ankara"; // Yeni özellik eklenebilir
console.log(kullaniciBilgileri); // { isim: 'Mehmet', yas: 31, aktif: true, sehir: 'Ankara' }

// kullaniciBilgileri = { isim: "Ayşe" }; // Hata verir: Assignment to constant variable. (referans değiştirilemez)

const sayilar = [1, 2, 3];
sayilar.push(4); // Diziye eleman eklenebilir
console.log(sayilar); // [1, 2, 3, 4]

// sayilar = [5, 6]; // Hata verir: Assignment to constant variable. (referans değiştirilemez)

Önemli Notlar

• Adlandırma Kuralları: Değişken adları harf, sayı, alt çizgi (_) veya dolar işareti ($) ile başlayabilir. Sayı ile başlayamazlar. JavaScript anahtar kelimeleri (function, if, for vb.) değişken adı olarak kullanılamaz. Genellikle camelCase (kullaniciAdi) tercih edilir.

• let ve const Kullanımı: Modern JavaScript geliştirmesinde, var yerine let ve const kullanılması şiddetle tavsiye edilir. Bu, kodun daha öngörülebilir olmasını sağlar, kapsam hatalarını azaltır ve "Temporal Dead Zone" sayesinde bildirim öncesi erişimi engeller.

• const ile Sabit Referans: Bir değişkeni const ile bildirmek, o değişkenin değerinin sabit olduğu anlamına gelmez, referansının sabit olduğu anlamına gelir. İlkel tipler (sayı, metin, boolean) için bu aynı anlama gelirken, nesne ve diziler için referans sabittir ancak içindeki özellikler veya elemanlar değiştirilebilir.

• Bildirim Olmadan Atama: Strict mode ("use strict";) kullanılmadığında, bir değişkeni var, let veya const olmadan doğrudan atamak mümkündür (x = 5;). Bu, otomatik olarak global bir değişken oluşturur ve genellikle kötü bir pratiktir, hatalara yol açabilir. Her zaman değişkenlerinizi bildirin.

• Hoisting ve TDZ: var ile bildirilen değişkenler, kodun en üstüne taşınır ve başlangıç değeri undefined olarak atanır. let ve const de hoisting'e tabidir ancak "Temporal Dead Zone" (TDZ) nedeniyle bildirimden önce erişilemezler, bu da daha güvenli bir kullanım sunar.