2026 İçin En İyi 40 TypeScript Mülakat Sorusu ve Cevabı

TypeScript, niş bir JavaScript üst kümesinden modern web geliştirme için temel bir dile dönüştü. 

Web uygulamaları üzerinde çalışırken, güçlü türleme ve sürdürülebilirliğin hataları önemli ölçüde azalttığını ve ekipler arası iş birliğini iyileştirdiğini bizzat gördüm. 

TypeScript bunların hepsini sağlar; bu yüzden modern geliştirmede sektör standardı haline gelmiştir.

Microsoft’tan (yaratıcısı) Google, Airbnb ve Netflix’e kadar pek çok kuruluş, React, Angular ve Node.js gibi çerçevelerle yazılmış ürünlerini TypeScript ile güçlendirir. 

Çalışmalarımda, TypeScript yeterliliğinin temel gereklilik olarak listelendiği, isteğe bağlı bir beceri olmadığı iş ilanlarını sıkça gördüm.

Kendim de TypeScript kullandığım için, türleri, arayüzleri ve gelişmiş özelliklerini anlamanın teknik mülakatlara hazırlanan her geliştirici için kritik önemde olduğunu rahatlıkla söyleyebilirim.

Temel TypeScript Mülakat Soruları

Şimdi bazı yaygın TypeScript mülakat sorularına ve bunların kod güvenliği ve açıklıkla ilişkisine bakalım.

1. Neden JavaScript yerine TypeScript kullanılır?

TypeScript, statik türleme ve derleme zamanı hata denetimi ekleyerek geliştiricilerin hataları erken tespit etmesine ve kod tabanlarını daha öngörülebilir hale getirmesine yardımcı olur.

Bu da daha iyi sürdürülebilirlik ve ölçeklenebilirlik sağlar.

2. TypeScript hangi sorunları çözer?

TypeScript, JavaScript’in tür güvenliği, ölçeklenebilirlik ve okunabilirlik konularındaki zayıflıklarını ele alır.

Açık tür tanımlarını zorunlu kılması, sinsi çalışma zamanı hatalarını engeller ve yeniden düzenlemeyi daha güvenli hale getirir.

3. TypeScript’te statik türlemenin başlıca faydaları nelerdir?

Statik türleme, kod güvenilirliğini, otomatik tamamlamayı ve geliştirici verimliliğini artırır.

Tür hatalarının erken tespitine yardımcı olur ve IDE’lerin daha zengin araç desteği sunmasını sağlar.

4. Tür açıklamaları (type annotations) nedir ve neden faydalıdır?

Tür açıklamaları, geliştiricilerin değişken türlerini açıkça belirtmesine olanak tanır.

Bu, kod okunabilirliğini artırır ve çalışma zamanı hatalarını azaltır.

İşte bir örnek:

let username: string = "DataCamper";
let age: number = 25;
let isAdmin: boolean = true;

Yukarıdaki kodda derleyici, her değişkene yalnızca doğru türün atanmasını sağlar.

Örneğin age değişkenine bir string atamaya çalışırsanız, TypeScript hata verir; bu da hataların erken yakalanmasına yardımcı olur.

Açık türleme özellikle fonksiyon parametreleri, dönüş türleri ve API sözleşmeleri için önemlidir; çünkü beklentileri diğer geliştiricilere net şekilde aktarır.

5. TypeScript’te tür çıkarımı (type inference) nedir?

TypeScript, atanan değerlere göre türleri otomatik olarak çıkarabilir.

Bu, her zaman türü açıkça belirtmeniz gerekmediği anlamına gelir. TypeScript sizin için bunu çözer.

İşte bir örnek:

let count = 10;  // inferred as number
count = "hello"; // Error: Type 'string' is not assignable to type 'number'

Bu örnekte TypeScript, count değişkeninin ilk değerine bakarak sayı olması gerektiğini çıkarır; bu yüzden daha sonra bir string atamak derleme zamanı hatasına neden olur. 

Tür çıkarımı için en iyi uygulamalar şunlardır:

• Net sözleşmeler sağlamak için dışa aktarılan fonksiyon, sınıf ve arayüzler için açık türler kullanın.
• Türün bariz olduğu yerel değişkenlerde çıkarıma izin verin.
• TypeScript’in güvenlik özelliklerini baypas ettiği için, çok zorunlu olmadıkça any kullanmaktan kaçının.

6. TypeScript, dizileri (arrays), demetleri (tuples) ve enum’ları nasıl ele alır?

TypeScript, açıklığı artırmak ve çalışma zamanı hatalarını önlemek için diziler, demetler ve enum’lar üzerinde sıkı türler uygulanmasına izin verir.

İşte türlenmiş dizi örneği:

let scores: number[] = [95, 80, 85];
scores.push(100); // OK
scores.push("A+"); // Error

Türlenmiş diziler, dizideki tüm öğelerin aynı türü izlemesini sağlar.

İşte bir demet örneği:

let user: [string, number] = ["Don", 25];

Demetler, her konum için belirli türlere sahip, sabit uzunluklu dizileri tanımlar.

Öğe sırası ve türünün önemli olduğu yapılandırılmış veriler için kullanışlıdırlar.

İşte bir enum örneği:

enum Status {
  Active,
  Inactive,
  Pending,
}
let currentStatus: Status = Status.Active;

Enum’lar, okunabilirliği artıran ve geçersiz değerleri azaltan adlandırılmış sabitler sağlar.

Özellikle durum kodları, roller ve yapılandırma seçenekleri için faydalıdırlar.

7. any, unknown ve never türleri arasındaki fark nedir?

Aşağıdaki tablo, TypeScript’teki any, unknown ve never türleri arasındaki temel farkları vurgular.

İşte bir örnek:

function fail(): never {
  throw new Error("Something went wrong");
}

Esneklikten çok şey kaybetmeden tür güvenliğini korumak için any yerine unknown tercih edilmelidir.

8. TypeScript’te null ve undefined arasındaki fark nedir?

null ve undefined arasındaki temel farklar şunlardır:

• undefined, bir değişkenin tanımlandığı ancak bir değer atanmadığı anlamına gelir.

• null, açıkça “değer yok” anlamına gelen özel bir değerdir.

TypeScript’in strictNullChecks modu, bunları ayrı türler olarak ele alır ve kazara null kaynaklı hataları önler.

İşte bir örnek:

let a: string | null = null;
let b: string | undefined = undefined;

9. strict derleyici seçeneği ne yapar?

strict bayrağı, TypeScript’in tüm katı tür denetimi kurallarını etkinleştirir; örneğin:

• strictNullChecks: null ve undefined değerlerinin, açıkça izin verilmedikçe değişkenlere atanmasını engeller; çalışma zamanındaki null başvuru hatalarını önlemeye yardımcı olur.

• noImplicitAny: Tüm değişkenlerin açık veya çıkarılmış türe sahip olmasını gerektirir; TypeScript’in varsayılan olarak any kullanmasını engeller.

• strictFunctionTypes: Fonksiyon türü uyumluluğu için daha sıkı kurallar uygular; fonksiyon parametresi ve dönüş türlerindeki uyumsuzlukları yakalar.

• strictBindCallApply: bind, call ve apply yöntemlerinin fonksiyonlar için doğru argüman türleriyle kullanılmasını sağlar.

Daha güvenli, daha öngörülebilir kod sağlar ve ince hataları erken yakalar.

TypeScript Tür Sistemi Mülakat Soruları

Şimdi teknik mülakatlarda sıkça konuşulan TypeScript tür sistemi kavramlarına bakalım.

10. TypeScript’te interface ve type alias arasındaki fark nedir?

Hem arayüzler (interface) hem de tür takma adları (type alias) nesnelerin şeklini tanımlar; ancak amaçları biraz farklıdır.

Arayüzler extends ile genişletilebilir; bu da onları hiyerarşik nesne modelleri için ideal kılar.

Tür takma adları birlikler (union), kesişimler (intersection), ilkel türler ve daha karmaşık bileşik türleri temsil edebilir.

İşte bir örnek:

interface Person {
  name: string;
  age: number;
}

type Employee = {
  name: string;
  department: string;
};

Nesne şekilleri veya sınıf sözleşmeleri tanımlarken arayüzleri kullanın.

Birlik ya da kesişim gibi esnek, bileşebilir türlere ihtiyaç duyduğunuzda tür takma adlarını kullanın.

11. TypeScript’te union ve intersection türleri nedir?

Union türleri, bir değişkenin birden fazla olası türü taşımasına izin verirken; intersection türleri, birden fazla türü tek bir türde birleştirir.

İşte bir union örneği:

let id: string | number;
id = ‘abc’; // OK
id = 123; // OK

İşte bir intersection örneği:

type Admin = { name: string };
type Permissions = { canEdit: boolean };
type AdminUser = Admin & Permissions;

Union türleri sıklıkla fonksiyon parametrelerinde kullanılır.

Intersection türleri karmaşık nesne bileşimlerinde yaygındır.

12. Tür daraltma (type narrowing) nedir ve type guard’lar nasıl çalışır?

Tür daraltma, TypeScript’in kontrol akışına bağlı olarak daha spesifik bir tür çıkarmasına olanak tanır.

İşte bir örnek:

function printId(id: string | number) {
  if (typeof id === "string") {
    console.log(id.toUpperCase());
  } else {
    console.log(id.toFixed());
  }
}

Type guard’lar, belirli işlemlerden önce türü doğrulayarak çalışma zamanında güvenli işlemleri garanti altına alır.

Şunları kullanabilirsiniz:

• typeof: ilkel türler için

• instanceof: sınıflar için

• Özel type guard’lar: param is Type söz dizimiyle

Type guard’lar tür güvenliğini artırır ve çalışma zamanı hatalarını azaltır.

13. TypeScript’te literal türler ve ayrık birleşimler (discriminated unions) nedir?

Literal türler, bir değişkeni önceden tanımlanmış belirli bir değer kümesiyle sınırlar.

İşte bir örnek:

let direction: "up" | "down" | "left" | "right";

Ayrık birleşimler, desen eşleme için literal türleri nesne varyantlarıyla birleştirir.

İşte bir örnek:

type Shape =
  | { kind: "circle"; radius: number }
  | { kind: "square"; side: number };

function area(shape: Shape): number {
  if (shape.kind === "circle") return Math.PI * shape.radius ** 2;
  return shape.side ** 2;
}

Ayrık birleşimler, nesne türlerinde güvenli dallanmaya imkân verir ve karmaşık uygulamalarda mantığı basitleştirir.

14. TypeScript’te keyof, typeof ve in nedir?

Bu operatörler, güçlü tür düzeyi yansıma (reflection) sağlar.

• Keyof: bir türün özellik adlarını elde eder

• typeof: bir değerin türünü elde eder

• in: eşlenmiş türlerde kullanılır

İşte bir örnek:

type Keys = keyof User; // "name" | "age"
const person = { name: "Alice", age: 25 };
type PersonType = typeof person; // { name: string; age: number }

15. TypeScript’te indeks imzaları (index signatures) nedir?

İndeks imzaları, dinamik anahtarlara sahip nesnelere izin verir.

İşte bir örnek:

interface Errors {
  [key: string]: string;
}

const messages: Errors = {
  email: "Invalid email",
  password: "Required"
};

Bunlar, sözlükler, harita benzeri nesneler veya dinamik yapılandırma desenleri için kullanılır.

16. TypeScript’te yapısal türleme (structural typing) nedir?

Yapısal türleme (ördek türleme), türlerin adlarına göre değil, yapısına göre uyumlu olması demektir.

İşte bir örnek:

interface Point { x: number; y: number; }
let p = { x: 10, y: 20, z: 30 };
let q: Point = p; // OK because structural match

Bu, TypeScript’i esnek kılar ve JavaScript desenleriyle iyi çalışır.

17. TypeScript’te bildirim birleştirme (declaration merging) nedir?

Bildirim birleştirme, TypeScript’in aynı ada sahip birden çok bildirimi birleştirmesidir.

İşte iki arayüzün birleştirilmesine bir örnek:

interface User { name: string; }
interface User { age: number; }
const u: User = { name: "Rob", age: 30 }; // merged

Üçüncü taraf türlerini genişletirken veya kütüphaneleri zenginleştirirken kullanışlıdır.

İleri Düzey TypeScript Mülakat Soruları

İşte ileri seviye TypeScript mülakat soruları ve cevapları.

18. TypeScript’te generics nedir ve neden kullanışlıdır?

Generics, birden çok veri türüyle çalışan, yeniden kullanılabilir ve tür güvenli fonksiyonlar ve sınıflar yazmanıza olanak tanır.

İşte jenerik bir fonksiyon örneği:

function identity<T>(value: T): T {
  return value;
}

let output = identity<string>("DataCamp");
let outputNumber = identity<number>(42);

İşte jenerik bir sınıf örneği:

class Box<T> {
  content: T;
  constructor(content: T) {
    this.content = content;
  }
  getContent(): T {
    return this.content;
  }
}

let stringBox = new Box("Hello");
let numberBox = new Box(123);

En iyi uygulamalar şunları içerir:

• <T>, <K, V> veya alanınıza özgü açıklayıcı adlar kullanın.

• Gereksiz karmaşıklıktan kaçının.

• Kabul edilebilir türleri kısıtlamak için (extends) kısıtlamalar kullanın.

Generics, tekrarları azaltarak ve tutarlı türlemeyi zorunlu kılarak kodun yeniden kullanılabilirliğini artırır.

19. TypeScript yardımcı türleri (utility types) nelerdir ve nasıl kullanılır?

TypeScript, mevcut türleri verimli bir şekilde dönüştürmek ve değiştirmek için yerleşik yardımcı türler sağlar.

İşte bir örnek:

interface Todo {
  title: string;
  description: string;
  completed: boolean;
}

type PartialTodo = Partial<Todo>; // all properties optional
type RequiredTodo = Required<Todo>; // all properties required
type TodoPreview = Pick<Todo, "title" | "completed">; // select specific properties
type TodoWithoutDescription = Omit<Todo, "description">; // exclude properties

Bunlar özellikle API yanıtları, formlar veya bileşen prop’larıyla çalışırken faydalıdır.

Mümkün olduğunda yardımcı türlerden yararlanarak kodu basitleştirin ve tür tutarlılığını sağlayın.

20. TypeScript’te koşullu (conditional) ve eşlenmiş (mapped) türler nelerdir?

Koşullu türler, türler arasındaki ilişkilere dayalı olarak türlerin içinde mantık tanımlamanıza izin verir.

İşte bir örnek:

type IsString<T> = T extends string ? "yes" : "no";
type Result1 = IsString<string>; // "yes"
type Result2 = IsString<number>; // "no"

Eşlenmiş türler, bir türün tüm özelliklerini bir kerede dönüştürmenize olanak tanır.

İşte bir örnek:

type ReadonlyTodo = {
  readonly [K in keyof Todo]: Todo[K];
};

type OptionalTodo = {
  [K in keyof Todo]?: Todo[K];
};

Temel farklar şunlardır:

• keyof bir türün özellik adlarını çıkarır.
• typeof bir değişkenin veya nesnenin türünü alır. Bunların birleştirilmesi dinamik tür manipülasyonu ve daha güvenli yeniden düzenleme sağlar.

21. infer anahtar sözcüğü TypeScript’te ne için kullanılır?

infer, koşullu bir tür içinde bir türü çıkarmanıza (infer) olanak tanır.

İşte bir örnek:

type ReturnType<T> =
  T extends (...args: any[]) => infer R ? R : never;

type R = ReturnType<() => number>; // number

Genellikle gelişmiş yardımcılar ve jenerik tür dönüşümlerinde kullanılır.

22. Şablon literal türleri (template literal types) nedir?

Şablon literal türleri, aradeğer yerleştirme (interpolation) kullanarak string türleri oluşturur.

İşte bir örnek:

type Event = ${string}Changed;
let e: Event = "nameChanged"; // OK

Şunlar için kullanışlıdır:

• Olay adlandırma
• CSS sınıf desenleri
• API rota desenleri

23. TypeScript’te satisfies ve as const nedir?

satisfies, bir değerin belirli bir türü sağladığını (satisfy) garanti eder; ancak kendi literal türünü korur. 

Örneğin:

const config = {
  mode: "dark",
  version: 1
} satisfies { mode: string; version: number };

as const, tüm özellikleri salt okunur ve literal yapar. 

Örneğin:

const directions = ["up", "down"] as const;
// type is readonly ["up", "down"]

Hem satisfies hem de as const, React, yapılandırma nesneleri ve ayrık birleşimlerde kullanışlıdır.

TypeScript Fonksiyonları ve Nesneleri Mülakat Soruları

Bu bölümde, fonksiyonlar ve nesnelerle ilgili TypeScript mülakat sorularını inceleyeceğiz.

24. TypeScript’te fonksiyon aşırı yüklemesi (overloading) nasıl çalışır?

Fonksiyon aşırı yüklemesi, farklı argüman türleri veya desenleri için birden fazla fonksiyon imzası tanımlamanıza olanak tanır.

İşte bir örnek:

function add(a: number, b: number): number;
function add(a: string, b: string): string;
function add(a: any, b: any): any {
  return a + b;
}

let sumNumbers = add(5, 10); // 15
let sumStrings = add("Hello, ", "World"); // "Hello, World"

En iyi uygulamalar şunlardır:

• Tüm olası aşırı yüklemeleri, uygulamadan önce bildirin.
• Birden çok türü güvenle ele almak için type guard’lar kullanın.

25. TypeScript’te isteğe bağlı (optional) ve rest parametreleri nelerdir?

İsteğe bağlı ve rest parametreleri, fonksiyonları daha esnek ve ifade gücü yüksek hale getirir.

İşte bir örnek:

function greet(name: string, age?: number) {
  console.log(Hello ${name}, age: ${age ?? "unknown"});
}

function sum(...numbers: number[]) {
  return numbers.reduce((a, b) => a + b, 0);
}

İsteğe bağlı ve rest parametreleri kullanmanın temel kuralları şunlardır:

• İsteğe bağlı parametreler için ? kullanın.

• Rest parametreler (değişken sayıda argüman) için ... kullanın.

Bunlar, dinamik fonksiyon girdilerini ne kadar iyi yönettiğinizi değerlendirmek için mülakatlarda sıkça test edilir.

26. TypeScript’te readonly ve const arasındaki fark nedir?

const değişkenlere uygulanırken, readonly nesne özelliklerine uygulanır.

İşte bir örnek:

interface User {
  readonly id: number;
  name: string;
}

const user: User = { id: 1, name: "Bob" };
// user.id = 2; // Error: Cannot assign to 'id'

const { id, name } = user;
console.log(User ${name} has ID ${id});

readonly ve const kullanımı için bazı en iyi uygulamalar:

• API’den dönen veriler gibi değişmemesi gereken nesneler için readonly kullanın.
• Yeniden atanmaması gereken değişkenler için const kullanın.
• Daha temiz ve kendini belgelendiren kod için, tür açıklamalarıyla birlikte ayrıştırmayı (destructuring) kullanın.

27. Fonksiyon türü varyansı (kovaryans ve kontravaryans) nedir?

Fonksiyon türü varyansı, TypeScript’in bir fonksiyon türünün, parametre türleri ve dönüş türlerine göre başka bir fonksiyon türünün yerine güvenle geçip geçemeyeceğine nasıl karar verdiğini açıklar.

Dönüş türleri: Kovaryant

Bir fonksiyon, çağıranın beklediğinden daha spesifik bir tür döndürebilir. Örneğin:

type Animal = { name: string };
type Dog = Animal & { bark: () => void };

let f: () => Animal;
let g: () => Dog = () => ({ name: "Rex", bark() {} });

f = g; // OK: Dog is a subtype of Animal

Parametre türleri: Kontravaryant

Bir fonksiyon, beklenenden daha genel parametre türlerini kabul edebilir. Örneğin:

type Dog = { name: string; bark: () => void };
type Animal = { name: string };

type HandleDog = (dog: Dog) => void;
type HandleAnimal = (animal: Animal) => void;

let handleDog: HandleDog = d => console.log(d.bark());
let handleAnimal: HandleAnimal = a => console.log(a.name);

// A function that accepts an Animal is more general,
// so it can stand in for one that accepts a Dog
handleDog = handleAnimal; // OK

28. TypeScript’te this türleri nedir?

this türleri, yöntemlerin sınıfla aynı türü döndürmesine imkân verir; akıcı (fluent) API’ler için kullanışlıdır:

class Builder {
  setName(name: string): this {
    // ...
    return this;
  }
}
new Builder().setName("Test"); // chaining works

TypeScript OOP Mülakat Soruları

Aşağıdaki sorular, teknik mülakatlarda sıkça konuşulan temel TypeScript OOP kavramlarını kapsar.

29. TypeScript nesne yönelimli programlamayı (OOP) nasıl destekler?

TypeScript, sınıflar, kalıtım ve erişim belirleyicileri gibi OOP ilkelerini destekler.

Sınıflar, nesneler için yeniden kullanılabilir şablonlar tanımlar; kalıtım ise bir sınıfın başka bir sınıfı genişleterek özellik ve davranışları paylaşmasını sağlar.

İşte bir örnek:

class Animal {
  constructor(public name: string) {}

  move(distance: number) {
    console.log(${this.name} moved ${distance}m.);
  }
}

class Dog extends Animal {
  bark() {
    console.log("Woof!");
  }
}

const dog = new Dog("Buddy");
dog.bark();       // Woof!
dog.move(10);     // Buddy moved 10m.

Erişim belirleyicileri şunlardır:

• public: her yerden erişilebilir
• protected: sınıf içinde ve alt sınıflarında erişilebilir
• private: yalnızca bildirildiği sınıf içinde erişilebilir

Kapsüllemeyi sağlamak için erişim belirleyicilerini kullanın; bu, dahili sınıf mantığının veya durumunun istenmeden değiştirilmesini önler.

30. TypeScript’te soyut sınıflar (abstract classes) ve arayüzler (interfaces) arasındaki fark nedir?

Soyut sınıflar da arayüzler de nesneler veya sınıflar için sözleşmeler tanımlar; ancak farklı amaçlara hizmet ederler.

Soyut sınıflar, paylaşılan uygulama ve soyut yöntemler içerebilir.

Arayüzler yalnızca yapıyı tanımlar; uygulama içermez.

İşte bir örnek:

abstract class Shape {
  abstract getArea(): number; // must be implemented
}

class Circle extends Shape {
  constructor(public radius: number) {
    super();
  }

  getArea(): number {
    return Math.PI * this.radius ** 2;
  }
}

En iyi uygulamalar şunlardır:

• İlgili sınıflar arasında paylaşılan mantığa ihtiyaç duyduğunuzda soyut sınıflar kullanın.
• Esnek tür sözleşmeleri ve gevşek bağlı tasarım için arayüzleri kullanın.

31. private, protected ve public belirleyicileri arasındaki fark nedir?

İşte TypeScript’in erişim belirleyicileri ve kontrol ettikleri şeylerin bir karşılaştırması:

Doğru erişim belirleyicisini kullanmak, kapsüllemeyi teşvik eder; böylece dahili durum ve mantık beklenmedik şekilde erişilmez veya değiştirilmez.

32. implements ve extends arasındaki fark nedir?

extends, davranış ve özellikleri devralırken; implements bir sözleşmeyi zorunlu kılar ancak uygulama sağlamaz

İşte bir örnek:

interface Logger { log(msg: string): void; }

class Base { foo() {} }

class MyClass extends Base implements Logger {
  log(msg: string) {}
}

33. TypeScript’te mixin’ler nasıl çalışır?

Mixin’ler, birden fazla yeniden kullanılabilir sınıf bileşenine izin verir.

İşte bir örnek:

type Constructor<T = {}> = new (...args: any[]) => T;

function Timestamped<TBase extends Constructor>(Base: TBase) {
  return class extends Base {
    timestamp = Date.now();
  };
}

class User {}
const TimestampedUser = Timestamped(User);

Birden fazla kalıtım desenine ihtiyaç duyduğunuzda faydalıdır.

Pratik TypeScript Mülakat Soruları

Bu sorular, mülakatlarda sıkça gündeme gelen TypeScript’in gerçek dünya uygulamalarına odaklanır.

34. Bir JavaScript projesini TypeScript’e nasıl taşırsınız?

Eski bir JavaScript kod tabanını TypeScript’e taşımak, riski ve aksaklıkları en aza indirmek için aşamalı olmalıdır.

Önerilen yaklaşım şudur:

1. .js dosyalarını .ts olarak yeniden adlandırın.

2. allowJs ve checkJs seçeneklerini tsconfig.json’da etkinleştirin.

3. Çekirdek fonksiyon veya modüllerden başlayarak kademeli olarak türler ekleyin.

4. Geçici olarak any kullanın; ardından kod tabanını iyileştirirken bunu uygun türlerle değiştirin.

Aşamalı geçiş için örnek tsconfig.json:

{
  "compilerOptions": {
    "allowJs": true,
    "checkJs": true,
    "strict": true
  }
}

Aşamalı geçiş, istikrar sağlar ve büyük çaplı yeniden yazımlar olmadan ekibin erken aşamada tür denetiminden faydalanmasına olanak tanır.

35. TypeScript’i React ile nasıl kullanırsınız?

React’te TypeScript kullanmak, prop’lar ve durum (state) için tür güvenliği sağlar; bu da çalışma zamanı hatalarını önlemeye yardımcı olur.

İşte bir örnek:

interface Props {
  title: string;
}

const Header: React.FC<Props> = ({ title }) => <h1>{title}</h1>;

Prop türlerini tanımlamak, TypeScript’in eksik veya hatalı türlenmiş prop’ları derleme aşamasında yakalamasını sağlar; bu da güvenilirliği ve geliştirici verimliliğini artırır.

36. TypeScript’i Node.js ile nasıl kullanırsınız?

TypeScript, API rotaları, yapılandırmalar ve ara katman yazılımları (middleware) için tür güvenliği ekleyerek Node.js uygulamalarını geliştirir.

İşte bir örnek:

import express, { Request, Response } from "express";
const app = express();

app.get("/", (req: Request, res: Response) => res.send("Hello TypeScript"));

Request ve Response’ı türlemek, doğru parametre kullanımını sağlar ve yaygın çalışma zamanı hatalarını önler.

TypeScript, Node.js API’lerinin bakımını ve güvenli şekilde yeniden düzenlenmesini kolaylaştırır.

37. TypeScript tanımları bulunmayan üçüncü taraf JavaScript kütüphanelerini nasıl ele alırsınız?

Bazı kütüphaneler yerleşik türler içermez. Bu durumlarda iki ana seçeneğiniz vardır:

Seçenek 1: Topluluk tarafından bakımı yapılan türleri yükleyin

npm install --save-dev @types/library-name

Seçenek 2: Özel bir bildirim dosyası oluşturun

// custom.d.ts
declare module "legacy-library" {
  export function init(): void;
}

İpuçları şunları içerir:

• Özel bildirim yazmadan önce her zaman @types’ı kontrol edin.

• Uyumluluğu sağlamak için karmaşık kütüphanelerde türleri kademeli olarak ekleyin.

Üçüncü taraf kütüphanelerin doğru türlenmesi, güveni artırır ve çalışma zamanı hatalarını azaltır.

TypeScript Yapılandırma ve Araçlar Mülakat Soruları

Bu bölüm, teknik mülakatlarda sıkça konuşulan temel TypeScript yapılandırma ve araç konularını kapsar.

38. tsconfig.json nedir ve neden önemlidir?

tsconfig.json dosyası, herhangi bir TypeScript projesinin merkezi yapılandırmasıdır. 

Derleyici davranışını tanımlar, dosyaları dahil eder ve özellikleri etkinleştirir.

İşte bir örnek:

{
  "compilerOptions": {
    "target": "ES2020",
    "module": "commonjs",
    "strict": true,
    "outDir": "./dist",
    "esModuleInterop": true,
    "forceConsistentCasingInFileNames": true,
    "noImplicitReturns": true,
    "noFallthroughCasesInSwitch": true
  },
  "include": ["src"],
  "exclude": ["node_modules", "dist"]
}

Temel ayarlar şunlardır:

• target: çıktı için JavaScript sürümü

• module: modül sistemi (CommonJS, ESNext, vb.)

• strict: tüm katı tür denetimi seçeneklerini etkinleştirir

• outDir: derlenen kodun çıkış klasörü

• esModuleInterop: CommonJS modül içe aktarımlarına izin verir

Olası hataları erken yakalamak ve sürdürülebilirliği artırmak için strict modu etkinleştirdiğinizden emin olun.

39. TypeScript’i Webpack, Vite veya Babel gibi derleme araçlarıyla nasıl yapılandırırsınız?

TypeScript, modern derleme sistemleriyle sorunsuz entegre olur.

Yaygın kurulumlar şunları içerir:

• Webpack: anlık derleme için ts-loader

• Vite: hızlı derlemeler için vite-plugin-ts

• Babel: JS ağırlıklı ortamlar için @babel/preset-typescript

Örnek Vite yapılandırması:

import { defineConfig } from "vite";
import react from "@vitejs/plugin-react";
import tsconfigPaths from "vite-tsconfig-paths";

export default defineConfig({
  plugins: [react(), tsconfigPaths()],
  build: {
    target: "es2020"
  }
});

Derleyici ve paketleyici ayarlarını hizalayın, artımlı derlemeleri etkinleştirin ve daha kolay hata ayıklama için kaynak haritaları (source map) kullanın.

40. Daha iyi kod kalitesi için TypeScript ile ESLint’i nasıl yapılandırırsınız?

ESLint, tutarlı kodlama standartlarını korumaya ve hataları erken yakalamaya yardımcı olur.

Gerekli paketleri yükleyin:

npm install eslint @typescript-eslint/parser @typescript-eslint/eslint-plugin --save-dev

Örnek ESLint yapılandırması:

{
  "parser": "@typescript-eslint/parser",
  "plugins": ["@typescript-eslint"],
  "extends": [
    "eslint:recommended",
    "plugin:@typescript-eslint/recommended"
  ],
  "rules": {
    "@typescript-eslint/no-explicit-any": "warn",
    "@typescript-eslint/explicit-function-return-type": "off"
  }
}

İpuçları şunları içerir:

• Kuralları küresel olarak devre dışı bırakmaktan kaçının.
• Tür güvenliği ve esneklik arasında denge kurmak için kuralları projeye göre ince ayarlayın.
• Tutarlı ve temiz bir kod tabanı için ESLint’i Prettier ile birlikte kullanın.

TypeScript Mülakatında Başarılı Olmak İçin İpuçları

Mülakatınızdan önce, hem teknik hem de iletişim becerilerinizi geliştirmeye odaklanmalısınız.

Bunu yapmanın bazı yolları şunlardır:

Çalışma yaklaşımı:

• Gelişmiş türler, generics ve yardımcı türler için resmi dokümantasyonu gözden geçirin.
• Ezberlemek yerine gerçek dünya kullanım senaryolarına odaklanın.
• TypeScript derleyici mesajları teknik değerlendirmelerin bir parçası olduğundan, özellikle tür hatalarını okuma ve anlama pratiği yapın.

Uygulama projeleri:

• Pratik becerileri göstermek için küçük ama eksiksiz uygulamalar geliştirin:
• Türlenmiş prop ve state ile React To-Do List.
• Türlenmiş istek ve yanıt nesneleriyle Express REST API.
• Generics ve eşlenmiş türler kullanan yardımcı kütüphaneler.

Yaygın tuzaklar:

• TypeScript’in tür güvenliğini baltalayan any’nin aşırı kullanımı.
• Çalışma zamanı hatalarına yol açan strict modunun göz ardı edilmesi.
• Tür tanımlarında null ile undefined’ın karıştırılması.
• Üçüncü taraf kütüphaneler için tür tanımlarını kurmayı veya yapılandırmayı unutmak.

İletişim ipuçları:

• Mülakatlarda, tür kararlarınızın gerekçesini açıkça anlatın.
• Yaklaşımlar arasındaki ödünleşimleri açıklayın (örneğin: interface vs type alias veya abstract class vs interface).
• TypeScript’in projelerde sürdürülebilirlik ve ölçeklenebilirliği nasıl geliştirdiğini gösterin.

Sonuç

TypeScript, açık ve tutarlı veri türlerini zorunlu kıldığı için modern web geliştirmeye hâkim olmaya devam ediyor; bu da hataları önlemeye ve büyük projeler için ölçeklenebilirliği artırmaya yardımcı oluyor.

Öğrenmeye devam etmek için, farklı teknolojilerde bilginizi genişletmeyi sürdürmek üzere kurs kataloğumuzun tamamını keşfedin.