TypeScript Mülakat Soruları ve Cevapları

TypeScript, Microsoft tarafından geliştirilen, JavaScript'e statik tip sistemi ekleyen bir üst kümedir (superset). Bir TypeScript mülakatında tip sistemi, generic'ler, interface/type farkı ve derleme (transpile) süreciyle ilgili hem tanım hem de uygulamalı sorularla karşılaşırsınız.

Hangi Seviyede Hangi Konular Sorulur?

Temel Seviye Sorular

TypeScript ile JavaScript Arasındaki Fark

TypeScript, JavaScript'in üzerine statik tip kontrolü, arayüzler (interface) ve derleme zamanı hata denetimi ekler; tarayıcıda doğrudan çalışmaz, tsc derleyicisi ile düz JavaScript'e dönüştürülür (transpile edilir). Bu sayede hatalar, kod çalıştırılmadan önce, geliştirme sırasında yakalanır.

Temel Tipler ve Tip Çıkarımı

TypeScript her değişkenin tipini açıkça yazmanızı zorunlu kılmaz; let sayi = 5 yazdığınızda derleyici sayi'nin tipini otomatik olarak number çıkarır. Mülakatlarda any ile unknown arasındaki fark sık sorulur: any tip denetimini tamamen kapatırken, unknown bir değeri kullanmadan önce tip kontrolü yapmaya zorlar, bu yüzden daha güvenlidir.

function alanHesapla(deger: unknown): number {
  if (typeof deger === "number") {
    return deger * deger;
  }
  throw new Error("Sayisal bir deger bekleniyor");
}

typeof ve keyof Operatörleri

TypeScript'te typeof yalnızca çalışma zamanı tip kontrolü için değil, var olan bir değişkenin tipini başka bir yerde yeniden kullanmak için de kullanılır. keyof ise bir nesne tipinin anahtarlarını birleşim (union) tipi olarak çıkarır; bu ikisi birlikte kullanıldığında, bir nesnenin yapısından türeyen güvenli tipler yazılabilir.

const ayarlar = { tema: "koyu", dil: "tr" };
type Ayarlar = typeof ayarlar;         // { tema: string; dil: string }
type AyarAnahtari = keyof Ayarlar;     // "tema" | "dil"

function ayarGetir(anahtar: AyarAnahtari) {
  return ayarlar[anahtar];
}

Tuple Tipleri

Bir tuple, sabit sayıda elemanı ve her elemanın tipini konumuna göre belirleyen bir dizi türüdür; normal bir Array<T>'den farkı, her indeksin farklı bir tip taşıyabilmesi ve dizi uzunluğunun derleme zamanında sabitlenmesidir.

type Koordinat = [number, number];
const nokta: Koordinat = [41.015, 28.979]; // [enlem, boylam]

// nokta[0] her zaman number olarak denetlenir, nokta.length her zaman 2'dir

Orta Seviye Sorular

Interface ile Type Alias Arasındaki Fark

İkisi de bir nesnenin şeklini tanımlamak için kullanılabilir, ama farklıdırlar: interface aynı isimle tekrar tanımlandığında otomatik olarak birleşir (declaration merging) ve extends ile genişletilir; type ise union, intersection ve primitive tipleri de tanımlayabilir ama aynı isimle iki kez tanımlanamaz. Genel kural: nesne şekli tanımlıyorsanız ve genişletilebilir olmasını istiyorsanız interface, union veya karmaşık bir tip kombinasyonu gerekiyorsa type tercih edilir.

Generic Tipler

Generic'ler, bir fonksiyon veya sınıfın tipini çağrıldığı ana kadar esnek bırakmanızı sağlar; böylece tip güvenliğini kaybetmeden yeniden kullanılabilir kod yazılır. Mülakatta "neden generic kullandınız" sorusuna "aynı fonksiyonu her tip için ayrı ayrı yazmamak için" gibi net bir cevap verebilmek beklenir.

function ilkEleman<T>(liste: T[]): T | undefined {
  return liste[0];
}

const sayi = ilkEleman<number>([1, 2, 3]); // number
const isim = ilkEleman(["Ali", "Veli"]);   // string (tip cikarimi ile)

Union, Intersection ve Type Guard'lar

Bir union (string | number) değişkenin birden fazla tipten birini alabileceğini, bir intersection (A & B) ise iki tipin tüm özelliklerini birleştirdiğini ifade eder. Bir union tipin içindeki gerçek tipi ayırt etmek için typeof, instanceof veya özel bir type guard fonksiyonu kullanılır.

Optional Chaining ve Nullish Coalescing

?. (optional chaining), bir nesnenin iç içe geçmiş bir alanına erişirken ara adımlardan biri null veya undefined ise hata fırlatmak yerine undefined döndürür. ?? (nullish coalescing) ise sol taraftaki değer yalnızca null veya undefined olduğunda sağdaki varsayılan değeri kullanır — ||'dan farkı, 0 veya boş string gibi "falsy" ama geçerli değerleri varsayılanla değiştirmemesidir.

const sehir = kullanici?.adres?.sehir ?? "Bilinmiyor";
const adet = urun?.stokAdedi ?? 0; // stokAdedi 0 ise "0" korunur, || kullansaydik degismezdi

Type Assertion (as) Ne Zaman Kullanılır?

as ile bir değerin tipini derleyiciye "ben biliyorum" diyerek belirtebilirsiniz; bu bir dönüşüm (cast) değil, sadece derleyiciye verilen bir güvencedir ve çalışma zamanında hiçbir kontrol yapmaz. DOM elemanlarıyla çalışırken (document.getElementById(...) as HTMLInputElement) yaygın kullanılır, ama tip güvenliğini bypass ettiği için aşırı kullanımı TypeScript'in asıl sağladığı güvenceyi ortadan kaldırır. Mülakatlarda bu ayrımı — assertion'ın gerçek bir tip dönüşümü olmadığını — bilmek genelde artı puan getirir.

İleri Seviye Sorular

Utility Type'lar: Partial, Pick, Omit, Record

TypeScript'in yerleşik utility type'ları, var olan bir tipten yeni tipler türetmenizi sağlar: Partial<T> tüm alanları opsiyonel yapar, Pick<T, K> sadece belirtilen alanları seçer, Omit<T, K> belirtilen alanları çıkarır, Record<K, V> ise belirli anahtar ve değer tipleriyle bir nesne tipi oluşturur.

interface Kullanici {
  id: number;
  ad: string;
  email: string;
}

type KullaniciGuncelleme = Partial<Omit<Kullanici, "id">>;
// { ad?: string; email?: string }

Mapped ve Conditional Type'lar

Mapped type'lar, bir tipin her alanı üzerinde gezinerek yeni bir tip üretir (utility type'ların çoğu aslında birer mapped type'tır). Conditional type'lar ise T extends U ? X : Y söz dizimiyle, bir tipin başka bir tiple ilişkisine göre farklı bir tip üretmenizi sağlar; kütüphane geliştirme seviyesinde ileri sorularda karşınıza çıkabilir.

tsconfig ve strict Modu

tsconfig.json içindeki strict: true ayarı; strictNullChecks, noImplicitAny gibi birçok kontrolü birden açar ve null/undefined ile ilgili hataların derleme zamanında yakalanmasını sağlar. Bir projeye strict modu sonradan nasıl kademeli olarak entegre edeceğinizi anlatabilmek, ileri seviye mülakatlarda değer görür.

Sık Yapılan TypeScript Hataları

• any ile sorunu geçiştirmek: Derleyici hata verince tipi any yapmak, TypeScript kullanmanın asıl amacını — tip güvenliğini — ortadan kaldırır.
• strict modu kapalı bırakmak: strict: false ile başlanan bir proje, ilerledikçe null/undefined hatalarını çalışma zamanına kadar saklar.
• interface'i gereksiz yere type ile karıştırmak: İkisi de çalışsa da, tutarsız kullanım kod tabanını okunması zor hale getirir.
• @ts-ignore ile hatayı susturmak: Sorunu çözmeden gizler; ileride aynı satırda farklı bir hata oluşsa bile fark edilmez.
• Generic'i gereksiz yere karmaşıklaştırmak: Tek bir tip için bile çalışacak bir fonksiyona generic eklemek, okunabilirliği düşürür; generic yalnızca birden fazla tip için gerçekten aynı mantık işleyecekse anlamlıdır.

Örnek Mülakat Senaryosu: Kod İnceleme Sorusu

Mülakatlarda sık karşılaşılan bir format, size hazır bir kod parçası verip "buradaki tip hatasını bulun ve düzeltin" demektir. Örneğin aşağıdaki fonksiyon derleyici tarafından reddedilir, çünkü id parametresinin undefined olabileceği durumu ele almaz:

// Hatali:
function kullaniciBul(liste: Kullanici[], id: string | undefined) {
  return liste.find(k => k.id === id).ad; // find() undefined donebilir
}

// Duzeltilmis:
function kullaniciBul(liste: Kullanici[], id: string | undefined): string | undefined {
  const kullanici = liste.find(k => k.id === id);
  return kullanici?.ad;
}

Bu tür sorularda beklenen, sadece hatayı susturmak değil — as ile zorla geçiştirmek yerine — asıl senaryoyu (kullanıcı bulunamayabilir) tipin içine doğru şekilde yansıtmaktır. Mülakatı yapan kişi genelde bu ayrımı, yani "derleyiciyi susturma" ile "gerçek sorunu çözme" arasındaki farkı gözlemler. Kod yazarken sesli düşünmek — neden bu tipi seçtiğinizi, hangi durumu göz ardı etmemek gerektiğini anlatmak — genelde kodun kendisi kadar önemlidir.

Mülakata Hazırlık İçin Pratik İpuçları

• JavaScript temellerinizi (closure, prototip zinciri, asenkron kod) sağlamlaştırın; TypeScript soruları genellikle bunların üzerine inşa edilir.
• Var olan bir JavaScript projesini TypeScript'e taşıma (migration) deneyimi edinin; bu, mülakatlarda somut bir örnek olarak çok işe yarar.
• tsc --noEmit komutunu bir CI adımı olarak kullanmayı bilin; tip kontrolünü geliştirme sürecine nasıl entegre ettiğinizi gösterir.
• Kullandığınız framework'e özgü tipleri (React için @types/react, Node için @types/node) okuyup yorumlayabildiğinizden emin olun.

TypeScript'in temelini oluşturan JavaScript mülakat soruları'na veya TypeScript'in sıkça birlikte kullanıldığı React mülakat soruları ve React Native mülakat soruları yazılarımıza göz atabilirsiniz. AppFellas'ın işlerine göz atabilir, projeniz için bizimle iletişime geçebilirsiniz.

Sıkça Sorulan Sorular