JavaScript’te “var – let – const” Anahtar Kelimeleri

JavaScript’te değişkenlerin tanımlanmasında kullanılan “var“, “let” ve “const” anahtar kelimeleri arasındaki farkları anlamak, dilde etkili bir şekilde kod yazmak için önemlidir.

JavaScript ile Değişken Oluşturma ve Tanımlama

İlk zamanlar JavaScript ile değişken oluşturma (declaration) ve tanımlama (initialization) için İngilizce variable (değişken) kelimesinin kısaltması olan “var” anahtar kelimesi kullanılmaktaydı.

ES6 (ECMASCRIPT 2015) güncellemesi ile beraber dile “let” ve “const” anahtar kelimeleri kazandırılmış ve bunlar sayesinde değişken oluşturma ve tanımlamanın yeni yolları mümkün hale gelmiştir. Sırayla JavaScript’te kullanılan “var”, “let” ve “const” anahtar kelimelerinin kullanımını inceleyelim.

JavaScript’te “var” Kullanarak Değişken Oluşturma ve Tanımlama

JavaScript’te bir değişkeni tanımlamak ve oluşturmak için “var” anahtar kelimesini kullanabilirsiniz. “var” ile oluşturulan değişkenin tipi dinamik olarak atandığı için aynı değişken farklı türde değerlere sahip olabilir. Örneğin:

var name;

Yukarıdaki kod, “name” adında bir değişken oluşturur, ancak henüz herhangi bir değer atanmamıştır. İşte bu duruma “değişken oluşturma” (declaration) denir. JavaScript’te “var” anahtar kelimesi ile yapılan değişken oluşturmayı “undefined” olarak tanımlar.

Oluşturulan bir değişkene değer atamak için ise eşitlik işareti (=) kullanılır ve bu tarz bir değişkene string, number, boolean, nesne veya diğer veri türlerinden bir değer atayabiliriz.

var name = "John";
var age = 30;

Yukarıdaki kod parçasında, “name” adında bir değişkene “John” değerini ve “age” adında bir değişkene de 30 değeri atanmıştır.

JavaScript’te var ile değişken oluşturulduğunda bu değişkenler sonradan var anahtarı ya da bizzat değişkenin adı kullanılarak yeni bir değer atanabilir. Her yeni tanımlama değişkenin sahip olduğu değer ezilir (Overriding Variables).

var name = "John";
console.log(name); // Çıktı: John

name = "Jane";
console.log(name); // Çıktı: Jane

var name = "Doe"; // Aynı değişkeni tekrar 'var' ile tanımladık.
console.log(name); // Çıktı: Doe

Bu örnekte, ilk olarak “John” değerine sahip “name” adında bir değişken tanımladık. Sonrasında bu değişkenin değerini “Jane” olarak güncelledik. Daha sonra, aynı “name” değişkenini tekrar “var” anahtar kelimesiyle “Doe” değeriyle tanımladık. Her aşamada değişkenin son değeri üzerine yazıldı.

Ancak belirtmek isterim ki, modern JavaScript uygulamaları yazarken, aynı isimdeki değişkenleri birden fazla kez “var” anahtar kelimesi ile tanımlamak iyi bir uygulama olarak kabul edilmez. Zira bu durum, kodun okunabilirliğine zarar verir.

Gelelim “var” anahtar kelimesinin nevi şahsına münhasır özelliğine. JavaScript’te “var” ile tanımlanan değişkenler fonksiyon bazında bir kapsama (function scope) sahiptir. Yani, bir fonksiyonun içinde “var” ile oluşturulan bir değişken, yalnızca o fonksiyonun içinde erişilebilir hale gelir. Ancak, bir değişken fonksiyonun dışında tanımlanırsa, bu değişken global kapsama sahip olur ve kodun her yerinden erişilebilir hale gelir.

Bunun yanında “var” ile tanımlanan değişkenler “hoisting” adlı bir özelliğin etkisindedir. Pratikte, bu demektir ki “var” ile tanımlanan bir değişken, kodda fiziksel olarak tanımlandığı yerden bağımsız olarak, yorumlama sırasında fonksiyonun veya kod bloğunun başına “taşınır”. Ancak bu “taşıma” sadece değişkenin tanımlanması için geçerlidir, başlangıç değeri taşınmaz ve undefined olarak ayarlanır. Örneğin:

console.log(sehir); // undefined
var sehir; // değişken tanımlandı fakat bir değer atanmadı
console.log(sehir); // undefined

sehir = "İstanbul";
console.log(sehir); // İstanbul

Örneğimizde “sehir” adında bir değişkeni çağırıyoruz. Bu aşamada değişken tanımlanmış olsa da bir değeri yok, bu yüzden “undefined” sonucunu alıyoruz. Ardından, “sehir” değişkenini tanımlıyoruz ama hemen bir değer atamıyoruz. Bu sefer de “undefined” sonucuyla karşılaşıyoruz. En son adımda “sehir”e “İstanbul” değerini atıyoruz. Artık değişkeni çağırdığımızda “İstanbul” sonucunu elde ediyoruz.

JavaScript’te “let” Kullanarak Değişken Oluşturma ve Tanımlama

JavaScript’te “let” anahtar kelimesi, “var”ın getirdiği bazı kavramsal sorunları gidermek ve değişken tanımlamalarını daha öngörülebilir ve güvenli hale getirmek için ES6 (ECMAScript 2015) ile tanıtılmıştır. “let” kullanarak oluşturulan değişkenler, blok kapsamında (block-scoped) çalışır. Yani bu, bir değişkenin sadece tanımlandığı blok içinde erişilebilir olduğu anlamına gelir.

for (let i = 0; i < 3; i++) {
    let mesaj = "Merhaba " + i;
    console.log(mesaj);
}

// console.log(mesaj); // Hata verir. Çünkü 'mesaj' değişkeni sadece döngü bloğu içerisinde tanımlı ve erişilebilir.

Yukarıdaki örneğimizde “mesaj” adında bir değişkeni döngü içinde “let” ile tanımladık. Döngünün her adımında “mesaj” değişkeni yeni bir değere sahip olur ve bu değer sadece döngü bloğu içerisinde geçerlidir. Döngü bloğu dışında “mesaj” değişkenine erişmeye çalıştığımızda, bu değişkenin tanımlı olmadığı için bir hata alırız. İşte bu, “let” anahtar kelimesiyle tanımlanan değişkenlerin blok kapsamında çalıştığının bir göstergesidir.

“let” ile tanımlanan değişkenlerin bir diğer önemli özelliği de “hoisting”ten etkilenmelerine rağmen, tanımlanmadan önce kullanılamaz olmalarıdır. Yani, “let” ile tanımladığımız bir değişkeni, tanımlama satırından önce kullanmaya çalıştığımızda bir hata alırız. Örneğin:

console.log(il); // Hata verir: il is not defined
let il; // değişken tanımlandı fakat bir değer atanmadı
console.log(il); // undefined

il = "Ankara";
console.log(il); // Ankara

Örneğimizde ilk olarak “il” adında bir değişkeni çağırıyoruz. Ancak bu çağırma sırasında bir hata alıyoruz çünkü “let” ile tanımlanan değişkenler, tanımlama satırından önce kullanılamaz. Daha sonrasında “il” değişkenini tanımlıyoruz, ancak bir değer atamıyoruz. Bu yüzden ikinci çağırma işleminde “undefined” sonucuyla karşılaşıyoruz. En sonunda “il”e “Ankara” değerini atıyoruz. Bu değer atanmasının ardından değişkeni çağırdığımızda “Ankara” sonucunu görüyoruz.

JavaScript’te let ile bir değişken tanımlandığında, aynı kapsam içerisinde o değişkeni “var” anahtar kelimesinde olduğu gibi “let” ile tekrardan tanımlayamayız (yani ezemeyiz). Eğer bunu yapmaya çalışırsak, bir hata alırız.

let isim = "John";
let isim = "Jane";  // Hata: "isim" değişkeni bu kapsamda zaten tanımlı.

let ad = "John";
ad = "Jane";  // Bu tamamen geçerlidir. "ad" şimdi "Jane" değerine sahip.

Burada ilk örnekte, aynı kapsam içinde “isim” değişkenini tekrar let ile tanımlamaya çalışıyoruz ve bu bir hata verir. İkinci örnekte ise “ad” değişkenini sadece değerini değiştiriyoruz, bu yüzden hata almadan işlem gerçekleşir.

Bu özellik, “let” ile tanımlanan değişkenlerin aynı kapsam içerisinde yanlışlıkla tekrar tanımlanmasını engellemeye yardımcı olur. Haliyle, yazdığımız kodun daha güvenilir olmasına katkıda bulunur.

JavaScript’te “const” Kullanarak Değişken Oluşturma ve Tanımlama

JavaScript’te const anahtar kelimesi, bir değişkenin değerinin değiştirilemez olması gerektiğini belirtmek için kullanılır. Başka bir deyişle, sabit anlamına gelen “constant” kelimesinden türetilen “const” ile tanımlanan bir değişkenin, bir kez atanmış bir değeri vardır ve bu değer sonrasında değiştirilemez. Buna (Bir değişkeninin değerinin sonradan değiştirilememesine) literatürde “immutable” (değişmez) adı verilir.

Tıpkı “let” gibi blok kapsamında (block-scoped) çalışır. Yani, bir kez “const” ile tanımlanan bir değişkene bir değer atadığımızda, bu değeri sonrasında değiştiremeyiz. Bu kavram, değişkenin değerinin sonradan değiştirilmemesi gerektiği durumlar için idealdir.

const pi = 3.141592;  // pi adında bir değişken tanımlanıyor ve değeri atanıyor.
const pi;  // Hata: "pi" isimli değişken zaten tanımlandı ve değeri atanmış durumda.

pi = 3.15;  // Hata: "pi" değişkeninin değeri değiştirilemez, çünkü const ile tanımlandı.

Yukarıdaki örnekte, ilk satırda “pi” adında bir değişkeni “const” ile tanımlıyoruz ve değerini atanarak sabitliyoruz. İkinci satırda aynı isimde bir değişkeni tekrar tanımlamaya çalıştığımızda JavaScript bize aynı isimde bir değişken zaten tanımlı olduğu için hata veriyor. Üçüncü satırda “pi” değişkeninin değerini değiştirmeye çalıştığımızda “const” ile tanımlanan değişkenlerin değerleri değiştirilememesi nedeniyle hata alıyoruz.

JavaScript’te const anahtar kelimesiyle tanımlanan değişkenlerin değerleri yeniden atanamaz. Ancak bu, değişkenlerin değerlerinin değiştirilemez olduğu anlamına gelmez. İlkel veri tipleri (sayı, metin vb.) için bu, onların değerinin değiştirilemez olduğu anlamına gelir. Ancak, referans tipli değerler (dizi, nesne vb.) için bu, yalnızca referansın (yani değişkenin işaret ettiği bellek adresi) değiştirilemez olduğu anlamına gelir. Referans tipli değerlerin içeriği (const ile tanımlansalar bile) değiştirilebilir. Örneğin:

const numara = 42;
// numara = 43;  // Hata: "numara" değişkeninin değeri değiştirilemez.

const dizi = [1, 2, 3];
dizi.push(4);  // Bu sorunsuz çalışır.
// dizi = [4, 5, 6];  // Hata: "dizi" değişkeninin referansı değiştirilemez.

Bu yüzden “const” kullanırken dikkatli olmalıyız. Bir değişkenin tamamen değiştirilemez olduğunu düşünmek yerine, sadece referansının değiştirilemez olduğunu bilmeliyiz. Eğer değişken değiştirilebilir bir yapıya (nesne veya dizi gibi) işaret ediyorsa, bu yapının içeriği değiştirilebilir.

Sonuç olarak, JavaScript’te “var”, “let” ve “const” kullanabiliriz. Ancak modern JavaScript’te, “var” anahtar kelimesinin kullanımı günümüzde pek tercih edilmemektedir ve bazı olumsuz yönleri nedeniyle genellikle tercih edilmez. Değişkenin değerinin değişip değişmeyeceğine bağlı olarak “let” veya “const” anahtar kelimelerini tercih etmek, kodun daha temiz, anlaşılır ve hata yapmaya daha az müsait olmasını sağlar.