JavaScript Değişkenleri ve Veri Tipleri

Jul 10, 2026 OP

Thread Starter #0

JavaScript Değişkenleri ve Veri Tipleri

Bir yazılım dilinin temel yapı taşlarından bahsederken, değişkenler ve veri tipleri hiç şüphesiz listenin başında yer alır. JavaScript gibi dinamik ve esnek bir dilde bu kavramları derinlemesine anlamak, sadece kod yazmakla kalmayıp, aynı zamanda daha temiz, optimize ve hatasız uygulamalar geliştirmek için kritik öneme sahip. Peki, bu temel yapı taşları gerçekten ne anlama geliyor ve JavaScript'in kendine has dünyasında nasıl bir role sahipler? Gelin, bu karmaşık görünen ama aslında oldukça mantıklı dünyayı birlikte keşfedelim...

Değişken Tanımlama Yöntemleri: var, let, const Farkları

JavaScript'te bir değeri saklamak için bir "kutu" veya "etiket" düşünebiliriz; işte bu kutulara değişken diyoruz. Ancak bu kutuları nasıl tanımladığımız, onların davranışlarını ve erişilebilirliklerini doğrudan etkiliyor. Tarihsel olarak var ile başlayan bu yolculuk, ES6 (ECMAScript 2015) ile let ve const anahtar kelimelerinin eklenmesiyle bambaşka bir boyut kazandı.

var: var, JavaScript'in ilk zamanlarından kalma bir anahtar kelime. Fonksiyon kapsamına (function scope) sahip olmasıyla biliniyor. Yani, bir fonksiyonun içinde var ile tanımlanan bir değişken, o fonksiyonun dışından erişilemez. Ancak, blok kapsamı (block scope) diye bir kavram var için geçerli değil. Bir if bloğunun veya for döngüsünün içinde tanımlanan var değişkeni, o bloğun dışından erişilebilir oluyor. Bu durum, özellikle büyük kod tabanlarında beklenmedik davranışlara ve hatalara yol açabiliyor. Mesela, aynı isimde bir değişkeni yanlışlıkla tekrar tanımlamanıza izin vermesi de cabası. Hoisting (yukarı çekilme) özelliği de var için önemli bir detay: Tanımlandığı kapsamın en üstüne taşınır, ancak değeri undefined olarak kalır. Bu da bazen kafa karıştırıcı durumlara yol açabilir.

let: ES6 ile hayatımıza giren let, var'ın birçok sorununa çözüm getirdi. En büyük farkı, blok kapsamına sahip olması. Yani, bir if bloğu, for döngüsü veya süslü parantezlerle tanımlanmış herhangi bir blok içinde let ile tanımlanan bir değişken, sadece o blok içinde geçerlidir. Bloğun dışından erişilemez. Bu, kodun daha öngörülebilir olmasını sağlıyor ve değişken çakışmalarını engelliyor. Ayrıca, let ile tanımlanan bir değişkeni aynı kapsamda tekrar tanımlamanıza izin verilmez; bu da hataları daha erken tespit etmenize yardımcı olur. let de teknik olarak yukarı çekilir ancak "Temporal Dead Zone" (TDZ) adı verilen bir durum nedeniyle tanımlanmadan önce erişilmeye çalışıldığında hata verir. Bu da var'ın "undefined" olma sorununu ortadan kaldırır.

const: Yine ES6 ile gelen const, adından da anlaşılacağı üzere "sabit" (constant) değerler için kullanılır. let gibi blok kapsamına sahiptir ve yukarı çekilme konusunda benzer TDZ davranışını sergiler. const ile tanımlanan bir değişkenin en önemli özelliği, tanımlandığı anda bir değer atanması gerektiği ve bu değerin daha sonra yeniden atanamaz olmasıdır. Yani, bir kere const ile tanımladığınız bir değişkene farklı bir değer atayamazsınız. Ancak burada dikkat edilmesi gereken önemli bir nüans var: Eğer bir nesne veya dizi tanımlamışsanız, const sadece bu nesnenin veya dizinin referansının değiştirilemez olduğunu belirtir. Nesnenin içindeki özelliklerini veya dizinin elemanlarını değiştirebilirsiniz. Bu detay, başlangıçta biraz kafa karıştırıcı olabilir, değil mi? Ama aslında çok güçlü bir güvenlik mekanizması sunar.

CODE

123456789101112131415161718192021222324252627282930313233
// var örneği
function exampleVar() {
  if (true) {
    var count = 10;
    console.log(count); // 10
  }
  console.log(count); // 10 (blok dışından erişilebilir)
}
exampleVar();

// let örneği
function exampleLet() {
  if (true) {
    let count = 20;
    console.log(count); // 20
  }
  // console.log(count); // Hata: count is not defined (blok dışından erişilemez)
}
exampleLet();

// const örneği
function exampleConst() {
  const PI = 3.14;
  // PI = 3.14159; // Hata: Assignment to constant variable.

  const user = { name: "Alice" };
  user.name = "Bob"; // Bu geçerlidir, nesnenin içeriği değişti
  console.log(user.name); // Bob

  // user = { name: "Charlie" }; // Hata: Assignment to constant variable.
}
exampleConst();

Peki, hangisini ne zaman kullanmalıyız? Genel kabul görmüş en iyi uygulama, mümkün olduğunca const kullanmaktır. Eğer bir değişkenin değeri değişmeyecekse const tercih edilmeli. Eğer değeri değişecekse let kullanılmalı. var ise modern JavaScript kodunda neredeyse hiç kullanılmamalı, çünkü let ve const çok daha güvenli ve öngörülebilir bir yapı sunuyor. Kodunuzu geleceğe hazırlamak istiyorsanız, var'dan uzak durmak akıllıca bir hareket olacaktır.

JavaScript'in Dinamik Veri Tipleri

JavaScript, dinamik tipli (dynamically typed) bir dildir. Bu ne anlama geliyor? Bir değişken tanımlarken tipini belirtmek zorunda değilsiniz. JavaScript motoru, değişkene atanan değere göre tipini otomatik olarak belirler. Hatta, aynı değişkene farklı zamanlarda farklı tiplerde değerler atayabilirsiniz. Bu esneklik, hızlı geliştirmeye olanak tanırken, bazen beklenmedik tip hatalarına da davetiye çıkarabilir. JavaScript'te iki ana kategoriye ayrılan veri tipleri bulunur: primitif (ilkel) tipler ve referans (nesne) tipleri.

Primitif Veri Tipleri:
Bu tipler, doğrudan değeri temsil eder ve bellekteki yerleri doğrudan o değeri içerir. Değişkenler arasında kopyalandıklarında, değerin kendisi kopyalanır.

String (Metin): Metinsel verileri saklamak için kullanılır. Tek tırnak ('), çift tırnak (") veya backtick (`) ile tanımlanabilir. Backtick'ler, "template literals" (şablon değişmezleri) olarak bilinir ve daha gelişmiş özellikler sunar; örneğin, değişkenleri doğrudan metin içine gömebilir ve çok satırlı metinler yazabilirsiniz.
CODE
```
12345
let name = 'Ahmet';
let greeting = "Merhaba, " + name + "!";
let templateLiteral = [icode]Merhaba, ${name}! Nasılsın?[/icode]; // ES6 template literal
console.log(templateLiteral); // Merhaba, Ahmet! Nasılsın?
```
Number (Sayı): Hem tam sayıları hem de ondalıklı sayıları temsil eder. JavaScript'te sayılar, çift duyarlıklı 64-bit kayan nokta formatında saklanır. Bu, bazı durumlarda hassasiyet sorunlarına yol açabilir (örneğin, 0.1 + 0.2 != 0.3). NaN (Not-a-Number) ve Infinity gibi özel sayı değerleri de vardır.
CODE
```
123456
let age = 30;
let price = 19.99;
let result = 10 / 'elma'; // NaN (bir sayıyı metne bölemezsin)
console.log(result); // NaN
console.log(typeof NaN); // number
```
Boolean (Mantıksal): Sadece iki olası değeri vardır: true (doğru) veya false (yanlış). Genellikle koşullu ifadelerde (if/else) ve döngülerde mantıksal kararlar vermek için kullanılır.
CODE
```
123456
let isActive = true;
let hasPermission = false;
if (isActive) {
  console.log("Kullanıcı aktif.");
}
```
Undefined (Tanımsız): Bir değişkene değer atanmadığında veya bir nesne özelliği mevcut olmadığında otomatik olarak atanan tiptir.
CODE
```
1234
let myVariable;
console.log(myVariable); // undefined
console.log(typeof myVariable); // undefined
```
Null (Boş): Bilinçli olarak "hiçbir değer" veya "boş değer" atamak istediğimizde kullanılır. undefined'dan farklı olarak, null programcı tarafından açıkça atanır. typeof null'ın object döndürmesi, JavaScript'in ilk versiyonlarından kalma bir hatadır ve düzeltilememiştir; bu bir primitif tiptir.
CODE
```
1234
let emptyValue = null;
console.log(emptyValue); // null
console.log(typeof emptyValue); // object (dikkat! bu bir bug)
```
Symbol (Sembol) (ES6): ES6 ile tanıtılan bu tip, her zaman benzersiz ve anonim bir değer oluşturmak için kullanılır. Nesne özelliklerinin çakışmasını önlemek için faydalıdır.
CODE
```
1234
const id1 = Symbol('id');
const id2 = Symbol('id');
console.log(id1 === id2); // false (her zaman benzersiz)
```
BigInt (Büyük Tam Sayı) (ES2020): JavaScript'in Number tipi, belirli bir aralığın dışındaki tam sayıları tam olarak temsil edemez. BigInt, bu sınırı aşarak çok büyük tam sayıları temsil etmeye olanak tanır. Bir sayının sonuna n ekleyerek tanımlanır.
CODE
```
1234
const bigNumber = 1234567890123456789012345678901234567890n;
console.log(bigNumber);
console.log(typeof bigNumber); // bigint
```

Referans Veri Tipleri (Nesneler):
Bu tipler, değeri doğrudan değil, bellekteki bir referansı (adresi) tutar. Bir değişkenden diğerine kopyalandıklarında, değerin kendisi değil, o değere işaret eden referans kopyalanır. Bu yüzden, iki değişken aynı nesneye referans veriyorsa, birindeki değişiklik diğerini de etkiler.

Object (Nesne): Anahtar-değer çiftlerinden (key-value pairs) oluşan, karmaşık veri yapılarını saklamak için kullanılır. JavaScript'teki hemen hemen her şey aslında bir nesnedir veya nesne gibi davranır.
CODE
```
12345678
let user = {
  firstName: "Ayşe",
  lastName: "Yılmaz",
  age: 28,
  isAdmin: false
};
console.log(user.firstName); // Ayşe
```

Array (Dizi): Sıralı bir öğe koleksiyonudur. Teknik olarak bir nesne türüdür ve özel metotlara sahiptir.

CODE

12345
let colors = ["red", "green", "blue"];
console.log(colors[0]); // red
colors.push("yellow");
console.log(colors); // ["red", "green", "blue", "yellow"]

Function (Fonksiyon): Çalıştırılabilir kod bloklarıdır. JavaScript'te fonksiyonlar "first-class citizens" olarak kabul edilir, yani değişkenlere atanabilir, argüman olarak başka fonksiyonlara geçirilebilir ve fonksiyonlardan döndürülebilirler. Fonksiyonlar da aslında Object tipindedir.
CODE
```
1234567
function greet(name) {
  return [icode]Merhaba, ${name}![/icode];
}
let sayHello = greet;
console.log(sayHello("Dünya")); // Merhaba, Dünya!
console.log(typeof greet); // function (teknik olarak object'tir, ama typeof 'function' döner)
```

Tip Dönüşümleri (Type Coercion): JavaScript'in Sürprizleri

JavaScript'in dinamik tipli doğası, tip dönüşümlerini (type coercion) kaçınılmaz kılar. Bu, JavaScript'in farklı veri tiplerini otomatik olarak birbirine dönüştürmeye çalışması anlamına gelir. Bu dönüşümler örtük (implicit) veya açık (explicit) olabilir.

Örtük Tip Dönüşümleri: JavaScript motorunun kendi başına yaptığı dönüşümlerdir. Genellikle aritmetik operatörler (+, -, *, /) veya karşılaştırma operatörleri (==, !=, <, >) kullanıldığında ortaya çıkar.

CODE

123456
console.log(5 + "5"); // "55" (Sayı string'e dönüştürülüp birleştirildi)
console.log(5 - "3"); // 2 (String sayıya dönüştürülüp çıkarma yapıldı)
console.log(true == 1); // true (Boolean sayıya dönüştürüldü)
console.log(null == undefined); // true (Özel bir durum)
console.log(0 == false); // true

Özellikle == operatörü, değerleri karşılaştırmadan önce tipleri eşleştirmeye çalışır. Bu durum, bazen beklenmedik sonuçlara yol açabilir ve hatalara davetiye çıkarabilir. Bu yüzden, çoğu zaman hem değer hem de tip kontrolü yapan katı eşitlik operatörü === kullanmak daha güvenlidir.

Açık Tip Dönüşümleri: Programcı tarafından bilinçli olarak yapılan dönüşümlerdir. Bunun için çeşitli global fonksiyonlar ve metotlar mevcuttur.

Number(): Herhangi bir değeri sayıya dönüştürmeye çalışır.

CODE

1234
console.log(Number("123")); // 123
console.log(Number("123a")); // NaN
console.log(Number(true)); // 1

String(): Herhangi bir değeri string'e dönüştürür.

CODE

123
console.log(String(123)); // "123"
console.log(String(true)); // "true"

Boolean(): Herhangi bir değeri boolean'a dönüştürür. JavaScript'te bazı değerler "falsy" (yanlış gibi) kabul edilir: false, 0, "" (boş string), null, undefined, NaN. Diğer tüm değerler "truthy" (doğru gibi) kabul edilir.
CODE
```
1234
console.log(Boolean(0)); // false
console.log(Boolean("Hello")); // true
console.log(Boolean("")); // false
```
parseInt(), parseFloat(): String'leri sayılara dönüştürmek için kullanılır. parseInt tam sayıları, parseFloat ondalıklı sayıları ayrıştırır. Metinde sayısal olmayan bir karakterle karşılaştıklarında dururlar.
CODE
```
1234
console.log(parseInt("100px")); // 100
console.log(parseFloat("12.5em")); // 12.5
console.log(parseInt("a100")); // NaN
```

Tip dönüşümleri, özellikle kullanıcı girdilerini işlerken veya API'lerden gelen

Similar threads

Report Content