[NODE JS] typeof ve instanceof Kullanımı
Merhaba arkadaşlar. Bugün JavaScript'te tip kontrolü yapmanın iki temel yolunu konuşacağız: typeof ve instanceof. İkisi farklı amaçlarla kullanılır ve ikisinin de tuzakları var. Ben production kodunda tip kontrolü yapmadan fonksiyon yazmam, özellikle dışarıdan veri alan fonksiyonlarda tip kontrolü hayat kurtarıcı.
typeof Operatörü
typeof bir değerin ilkel tipini string olarak döndürür. Kullanımı basit ama bazı garip davranışları var. Mesela typeof null "object" döndürür ki bu JavaScript'in en eski ve en meşhur bug'ıdır, artık düzeltilemez çünkü milyonlarca site buna güveniyor. Bunun gibi birkaç tuzak daha var ve bunları bilmek gerekiyor.
Tecrübeme göre typeof en çok şu durumlarda kullanılır: fonksiyon parametrelerini doğrulama, undefined kontrolü, tip bazlı farklı işlemler yapma. Ama karmaşık obje tipleri için typeof yetersiz, instanceof veya diğer yöntemler gerekiyor.
JavaScript:
// === TYPEOF OPERATÖRÜ ===
// Temel kullanım ve tüm dönüş değerleri
console.log('--- typeof Sonuçları ---');
console.log(typeof 'merhaba'); // "string"
console.log(typeof 42); // "number"
console.log(typeof 3.14); // "number"
console.log(typeof NaN); // "number" (evet, NaN da number!)
console.log(typeof Infinity); // "number"
console.log(typeof true); // "boolean"
console.log(typeof undefined); // "undefined"
console.log(typeof null); // "object" (JavaScript bug'ı!)
console.log(typeof Symbol('id')); // "symbol"
console.log(typeof 42n); // "bigint"
console.log(typeof {}); // "object"
console.log(typeof []); // "object" (array de object!)
console.log(typeof function(){}); // "function"
console.log(typeof new Date()); // "object"
console.log(typeof /regex/); // "object"
console.log(typeof new Map()); // "object"
console.log(typeof new Set()); // "object"
// Güvenli undefined kontrolü
let tanimsiz;
console.log('
--- Undefined Kontrol ---');
console.log(typeof tanimsiz === 'undefined'); // true
console.log(typeof buHicTanimlanmadi === 'undefined'); // true (hata vermez!)
// buHicTanimlanmadi === undefined; // ReferenceError fırlatır!
// typeof ile tip kontrolü fonksiyonu
function tipKontrol(deger) {
const tip = typeof deger;
switch (tip) {
case 'string':
return `String (${deger.length} karakter): "${deger}"`;
case 'number':
if (Number.isNaN(deger)) return 'NaN (Not a Number)';
if (!Number.isFinite(deger)) return `Infinite: ${deger}`;
return `Number: ${deger}`;
case 'boolean':
return `Boolean: ${deger}`;
case 'undefined':
return 'Undefined';
case 'object':
if (deger === null) return 'Null';
if (Array.isArray(deger)) return `Array (${deger.length} eleman)`;
if (deger instanceof Date) return `Date: ${deger.toISOString()}`;
if (deger instanceof RegExp) return `RegExp: ${deger}`;
if (deger instanceof Map) return `Map (${deger.size} kayıt)`;
if (deger instanceof Set) return `Set (${deger.size} eleman)`;
return `Object (${Object.keys(deger).length} key)`;
case 'function':
return `Function: ${deger.name || 'anonim'}`;
case 'symbol':
return `Symbol: ${deger.toString()}`;
case 'bigint':
return `BigInt: ${deger}`;
default:
return `Bilinmeyen: ${tip}`;
}
}
const testDegerler = [
'merhaba', 42, 3.14, NaN, Infinity, true, undefined, null,
[1, 2, 3], { a: 1 }, new Date(), /test/gi, new Map(), new Set(),
function test() {}, Symbol('id'), 123n
];
console.log('
--- Tip Kontrol Fonksiyonu ---');
testDegerler.forEach(d => console.log(tipKontrol(d)));instanceof Operatörü
instanceof bir nesnenin belirli bir constructor'ın instance'ı olup olmadığını kontrol eder. typeof'un aksine class bazlı kontrol yapar ve prototype chain'i takip eder. Özellikle özel hata sınıfları, class inheritance ve obje tipi belirleme için kullanılır.
Ha bu arada, instanceof farklı realm'ler (iframe, farklı Node.js modülleri) arasında çalışmaz. Farklı bir realm'den gelen Array, instanceof Array kontrolünde false dönebilir. Bu yüzden Array kontrolü için Array.isArray() kullanın, instanceof değil. Bu tuzağa düşen çok kişi gördüm.
JavaScript:
// === INSTANCEOF OPERATÖRÜ ===
// Temel kullanım
class Hayvan {
constructor(isim) {
this.isim = isim;
}
}
class Kedi extends Hayvan {
miyavla() {
return `${this.isim}: Miyav!`;
}
}
class Kopek extends Hayvan {
havla() {
return `${this.isim}: Hav hav!`;
}
}
const kedi = new Kedi('Pamuk');
const kopek = new Kopek('Karabaş');
console.log('--- instanceof Sonuçları ---');
console.log(kedi instanceof Kedi); // true
console.log(kedi instanceof Hayvan); // true (prototype chain)
console.log(kedi instanceof Kopek); // false
console.log(kopek instanceof Kopek); // true
console.log(kopek instanceof Hayvan); // true
// Yerleşik tipler
console.log('
--- Yerleşik Tipler ---');
console.log([] instanceof Array); // true
console.log({} instanceof Object); // true
console.log(new Date() instanceof Date); // true
console.log(/regex/ instanceof RegExp); // true
console.log(new Map() instanceof Map); // true
console.log(new Error() instanceof Error); // true
// Primitive'ler instanceof ile çalışmaz!
console.log('
--- Primitive Tuzağı ---');
console.log('merhaba' instanceof String); // false!
console.log(42 instanceof Number); // false!
console.log(true instanceof Boolean); // false!
// Ama wrapper objeleri çalışır
console.log(new String('merhaba') instanceof String); // true
// Pratik kullanım: Polimorfizm
function hayvanSesVer(hayvan) {
if (hayvan instanceof Kedi) {
console.log(hayvan.miyavla());
} else if (hayvan instanceof Kopek) {
console.log(hayvan.havla());
} else if (hayvan instanceof Hayvan) {
console.log(`${hayvan.isim} ses çıkardı`);
} else {
throw new TypeError('Geçerli bir hayvan nesnesi değil');
}
}
hayvanSesVer(kedi);
hayvanSesVer(kopek);
// Hata yakalama ile instanceof kullanımı
class DogrulamaHatasi extends Error {
constructor(alan, mesaj) {
super(mesaj);
this.name = 'DogrulamaHatasi';
this.alan = alan;
}
}
class VeritabaniHatasi extends Error {
constructor(sorgu, mesaj) {
super(mesaj);
this.name = 'VeritabaniHatasi';
this.sorgu = sorgu;
}
}
function hataIsle(hata) {
if (hata instanceof DogrulamaHatasi) {
console.log(`Doğrulama hatası [${hata.alan}]: ${hata.message}`);
} else if (hata instanceof VeritabaniHatasi) {
console.log(`DB hatası [${hata.sorgu}]: ${hata.message}`);
// Tekrar deneme mantığı eklenebilir
} else if (hata instanceof Error) {
console.log(`Genel hata: ${hata.message}`);
} else {
console.log('Bilinmeyen hata:', hata);
}
}
hataIsle(new DogrulamaHatasi('email', 'Geçersiz email'));
hataIsle(new VeritabaniHatasi('SELECT *', 'Bağlantı zaman aşımı'));
hataIsle(new Error('Genel bir sorun'));
// Daha güvenli tip kontrolü: Object.prototype.toString
function gercekTip(deger) {
return Object.prototype.toString.call(deger).slice(8, -1);
}
console.log('
--- Object.prototype.toString ---');
console.log(gercekTip('merhaba')); // String
console.log(gercekTip(42)); // Number
console.log(gercekTip(null)); // Null (typeof'un aksine!)
console.log(gercekTip([])); // Array
console.log(gercekTip({})); // Object
console.log(gercekTip(new Date())); // Date
console.log(gercekTip(/regex/)); // RegExptypeof ve instanceof'u doğru yerde kullanmak önemli: primitive tipler için typeof, class instance'ları için instanceof, ve her iki durumda da Object.prototype.toString en güvenilir yöntem. Bu üçlüyü birlikte kullanarak sağlam tip kontrolü yapabilirsiniz. Kolay gelsin.
