[NODE JS] Node.js'te Değişken Tanımlama ve Veri Tipleri

Silverhand · Pazartesi saat 09:57'de

[NODE JS] Node.js'te Değişken Tanımlama ve Veri Tipleri

Selam arkadaşlar. Node.js serimizin bu bölümünde temel ama aynı zamanda çok kritik bir konuya gireceğiz: değişkenler ve veri tipleri. Yeni başlayanlar genellikle bu konuyu hızlıca geçip "asıl konulara" geçmek istiyor ama tecrübeme göre temeli sağlam atmayan developerlar ileride ciddi buglarla karşılaşıyor. Geçen sene bir junior developer'ın yazdığı kodda type coercion yüzünden ödeme tutarları yanlış hesaplanıyordu, sadece bu konu yüzünden.

Değişken Tanımlama Yöntemleri

JavaScript'te ve dolayısıyla Node.js'te değişken tanımlamanın üç yolu var: var, let ve const. var eski usul, let ve const ise ES6 ile gelen modern yöntemler. Ben günlük kodlamada neredeyse hiç var kullanmıyorum. Genellikle const tercih ediyorum, değeri değişecekse let kullanıyorum. var'ı sadece eski kodları okurken veya bakım yaparken görüyorum.

const kullanmak şu açıdan önemli: kodunuzu okuyan kişi bir değişkenin const olduğunu görünce "bu değer değişmeyecek" diye anlıyor ve kodu takip etmesi kolaylaşıyor. Benim tavsiyem: önce her şeyi const ile tanımlayın, gerçekten değiştirmeniz gerektiğinde let'e çevirin.

Primitive (İlkel) Veri Tipleri

JavaScript'te yedi tane primitive veri tipi var: string, number, boolean, null, undefined, symbol ve bigint. Node.js'te bunların hepsini kullanabilirsiniz. Gelin detaylıca bakalım.

JavaScript:

// === PRİMİTİVE VERİ TİPLERİ ===

// 1. String (Metin)
const isim = 'Ahmet';
const soyisim = "Yılmaz";
const tamIsim = `${isim} ${soyisim}`; // Template literal
const cokSatirli = `Bu birinci satır
Bu ikinci satır
Bu üçüncü satır`;

console.log('String örnekleri:');
console.log(typeof isim);        // "string"
console.log(isim.length);        // 5
console.log(isim.toUpperCase()); // "AHMET"
console.log(isim[0]);            // "A"
console.log(isim.includes('hm')); // true

// 2. Number (Sayı)
const tamSayi = 42;
const ondalikli = 3.14;
const negatif = -17;
const buyukSayi = 1_000_000; // Okunabilirlik için _ kullanımı
const sonsuz = Infinity;
const belirsiz = NaN; // Not a Number

console.log('
Number örnekleri:');
console.log(typeof tamSayi);      // "number"
console.log(Number.isInteger(tamSayi));   // true
console.log(Number.isFinite(sonsuz));     // false
console.log(Number.isNaN(belirsiz));      // true
console.log(Number.MAX_SAFE_INTEGER);     // 9007199254740991
console.log(0.1 + 0.2);                  // 0.30000000000000004 (!)
console.log((0.1 + 0.2).toFixed(2));     // "0.30"

// 3. Boolean
const aktif = true;
const silindi = false;

console.log('
Boolean örnekleri:');
console.log(typeof aktif);  // "boolean"
// Falsy değerler: false, 0, '', null, undefined, NaN
// Truthy: bunların dışında her şey
console.log(Boolean(0));           // false
console.log(Boolean(''));          // false
console.log(Boolean(null));        // false
console.log(Boolean(undefined));   // false
console.log(Boolean(NaN));         // false
console.log(Boolean('merhaba'));   // true
console.log(Boolean(42));          // true
console.log(Boolean([]));          // true (boş array bile truthy!)
console.log(Boolean({}));          // true (boş obje bile truthy!)

// 4. null ve undefined
let tanimsiz;              // undefined - değer atanmamış
const bos = null;          // null - bilinçli olarak boş bırakılmış

console.log('
null ve undefined:');
console.log(typeof tanimsiz);  // "undefined"
console.log(typeof bos);       // "object" (JavaScript'in eski bir bug'ı!)
console.log(tanimsiz == bos);  // true  (loose equality)
console.log(tanimsiz === bos); // false (strict equality)

// 5. Symbol (ES6)
const id1 = Symbol('id');
const id2 = Symbol('id');
console.log('
Symbol:');
console.log(id1 === id2);  // false - her Symbol benzersizdir
console.log(typeof id1);   // "symbol"

// 6. BigInt (ES2020)
const cokBuyukSayi = 9007199254740991n;
const digerBuyuk = BigInt('123456789012345678901234567890');
console.log('
BigInt:');
console.log(typeof cokBuyukSayi);  // "bigint"
console.log(cokBuyukSayi + 1n);   // 9007199254740992n

Referans Veri Tipleri

Primitive tiplerin dışında referans tipleri var: Object, Array ve Function. Bu tiplerin en önemli farkı bellekte saklanma biçimleri. Primitive değerler doğrudan stack'te saklanır, referans tipleri ise heap'te saklanır ve değişken sadece referansı tutar. Bu fark, kopyalama ve karşılaştırma işlemlerinde çok önemli sonuçlar doğurur.

Production'da bu farkı bilmemek ciddi buglara yol açıyor. Mesela bir objeyi başka bir değişkene atadığınızı düşünün, aslında aynı objeyi işaret eden iki referansınız oluyor. Birini değiştirdiğinizde diğeri de değişiyor. Bu durum özellikle state management'ta büyük sorunlara neden olur.

JavaScript:

// === REFERANS VERİ TİPLERİ ===

// Object (Nesne)
const kullanici = {
    isim: 'Mehmet',
    yas: 28,
    aktif: true,
    adres: {
        sehir: 'İstanbul',
        ilce: 'Kadıköy'
    },
    hobiler: ['kodlama', 'oyun', 'yüzme']
};

console.log('Object örnekleri:');
console.log(typeof kullanici);        // "object"
console.log(kullanici.isim);          // "Mehmet"
console.log(kullanici['yas']);        // 28
console.log(kullanici.adres.sehir);  // "İstanbul"

// Array (Dizi)
const sayilar = [1, 2, 3, 4, 5];
const karisik = [1, 'iki', true, null, { a: 1 }, [6, 7]];

console.log('
Array örnekleri:');
console.log(typeof sayilar);       // "object" (array de object'tir!)
console.log(Array.isArray(sayilar)); // true (doğru kontrol yöntemi)
console.log(sayilar.length);       // 5

// Referans vs Değer kopyalama farkı
console.log('
--- Referans Farkı ---');
let a = 5;
let b = a;    // Değer kopyalandı
b = 10;
console.log(`a: ${a}, b: ${b}`);  // a: 5, b: 10 (bağımsız)

const obj1 = { x: 1, y: 2 };
const obj2 = obj1;  // Referans kopyalandı!
obj2.x = 999;
console.log(`obj1.x: ${obj1.x}`);  // 999 (obj1 de değişti!)

// Gerçek kopyalama yöntemleri
const obj3 = { ...obj1 };              // Shallow copy (spread)
const obj4 = Object.assign({}, obj1);  // Shallow copy (assign)
const obj5 = JSON.parse(JSON.stringify(obj1)); // Deep copy (basit objeler için)
const obj6 = structuredClone(obj1);    // Deep copy (modern yöntem)

obj3.x = 111;
console.log(`obj1.x: ${obj1.x}, obj3.x: ${obj3.x}`); // Artık bağımsız

// Type Coercion (Tip Dönüşümü) - Dikkat!
console.log('
--- Type Coercion Tuzakları ---');
console.log('5' + 3);        // "53" (string birleştirme)
console.log('5' - 3);        // 2 (sayısal çıkarma)
console.log('5' * '3');      // 15
console.log(true + true);    // 2
console.log([] + []);        // "" (boş string)
console.log([] + {});        // "[object Object]"
console.log(null + 1);       // 1
console.log(undefined + 1);  // NaN

Bu tuzakları bilmek gerçekten çok önemli. Ben her zaman strict equality (===) kullanıyorum, loose equality (==) neredeyse hiç kullanmıyorum. Aynı şekilde type coercion'a güvenmek yerine explicit dönüşüm yapıyorum: Number('5'), String(42), Boolean(1) gibi. Bu şekilde kodunuz hem daha okunabilir olur hem de beklenmeyen hatalardan kaçınırsınız.

Ha bir de şunu ekleyeyim: Node.js'te TypeScript kullanımı giderek artıyor. TypeScript ile tip güvenliği sağlayabilirsiniz ama sonuçta alttaki JavaScript'in tip sistemini anlamak şart. TypeScript sizi birçok hatadan korur ama JavaScript'in nasıl çalıştığını bilmelisiniz. Kolay gelsin.

devemoji · Dün 21:53 da

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

[NODE JS] Node.js'te Değişken Tanımlama ve Veri Tipleri

Silverhand