TypeScript Mülakat Soruları ve Cevapları (Kodlu 25 Soru)

Bunlar mülakatçıların en çok sorduğu TypeScript soruları; her birinde verebilmeniz gereken kısa cevap ve küçük bir örnek var. Seviyeye göre gruplanmıştır: junior bir pozisyon genellikle ilk grupta durur, senior bir pozisyon ise son gruptaki tipleri ezberden yazmanızı bekler.

Başlangıç Seviyesi Sorular

1. TypeScript nedir?

TypeScript, Microsoft tarafından geliştirilen, statik tiplere sahip JavaScript'tir. Değerleri tiplerle işaretlersiniz, derleyici onları kontrol eder, sonra tipleri silip JavaScript'in çalıştığı her yerde çalışan düz JavaScript üretir.

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

console.log(add(2, 3)); // 5

// @ts-expect-error Argument of type 'string' is not assignable to parameter of type 'number'.
const wrong = add("2", 3);
console.log(wrong); // 23: the call was forced through, and JavaScript concatenated

@ts-expect-error yorumu olmadan ikinci çağrı bir derleme hatasıdır, böylece hata asla yayına çıkmaz.

2. TypeScript tipleri çalışma zamanında kontrol eder mi?

Hayır. Tipler derleme sırasında silinir; çıktıda onlardan hiçbir iz kalmaz. Yukarıdaki çalıştırma 23 yazdırır, çünkü çalışma zamanında hiçbir şey a'nın bir number olması gerektiğini bilmez. Programın dışından gelen veriyi (JSON, kullanıcı girdisi, API yanıtları) kontrol etmek için bir type guard ya da bir şema doğrulayıcısı gibi gerçek kontroller yazarsınız.

3. Temel tipler nelerdir?

string, number (tamsayılar ve ondalıklı sayılar için tek bir tip; int yoktur), boolean, bigint, symbol, null ve undefined, ayrıca diziler (number[]), tuple'lar ([string, number]), nesne tipleri, any, unknown, never ve void. Küçük harfli adları kullanın: String ve Number sarmalayıcı nesne tipleridir.

4. any ile unknown arasındaki fark nedir?

İkisi de her değeri kabul eder. any ayrıca kontrolü kapatır, bu yüzden her işlem derlenir. unknown ise siz onu daraltana kadar hiçbir şeye izin vermez; bu da onu henüz kontrol etmediğiniz değerler için güvenli tip yapar.

let a: any = "hello";
a.toFixed; // allowed: any turns checking off

let u: unknown = "hello";
// @ts-expect-error 'u' is of type 'unknown'.
u.toUpperCase();

if (typeof u === "string") {
  console.log(u.toUpperCase()); // HELLO: narrowed to string
}

5. Tip çıkarımı (type inference) nedir?

Derleyici yazmadığınız tipleri kendisi bulur: let count = 0 bir number'dır, const mode = "dark" "dark" literal tipindedir ve bir fonksiyonun dönüş tipi return ifadelerinden gelir. Olağan kural, fonksiyon parametrelerini ve public dönüş tiplerini işaretlemek, yerel değişkenleri tip çıkarımına bırakmaktır.

6. interface ile type arasındaki fark nedir?

İkisi de nesne şekillerini tanımlar ve bir class ikisini de implements edebilir. Bir interface yeniden açılıp birleştirilebilir (declaration merging) ve başka interface'leri extends edebilir. Bir type alias ise her şeye ad verebilir: union'lar, tuple'lar, primitive'ler, mapped ve conditional type'lar.

interface User { name: string }
interface User { age: number }       // merged: User has name and age

type Id = string | number;           // only a type alias can be a union
type Pair = [string, number];        // or a tuple
type Admin = User & { role: "admin" };

Yaygın bir gelenek, nesne şekilleri için interface, geri kalan her şey için type kullanmaktır. Tam karşılaştırma interface ve type sayfasındadır.

7. Union ve intersection tipleri nedir?

Bir union A | B, tiplerden biri olan bir değerdir; onu daraltana kadar yalnızca hepsinde ortak olan üyeleri kullanabilirsiniz. Bir intersection A & B ise aynı anda ikisi birden olan, her birinin bütün üyelerine sahip bir değerdir.

type Id = string | number;                 // either
type Timestamped = { createdAt: Date };
type Post = { title: string } & Timestamped; // both: title and createdAt

8. void ile never arasındaki fark nedir?

void, faydalı bir değer döndürmeden normal şekilde dönen bir fonksiyonun dönüş tipidir. never ise gerçekleşemeyecek bir şeyin tipidir: her zaman hata fırlatan ya da sonsuza kadar dönen bir fonksiyon veya bütün durumları çıkarılmış bir union. never her tipe atanabilir ve hiçbir değer never'a atanamaz.

function log(msg: string): void { console.log(msg); }
function fail(msg: string): never { throw new Error(msg); }
type Impossible = string & number; // never

Orta Seviye Sorular

9. Type narrowing nedir?

Narrowing, derleyicinin kontrollerinizi izleyip her dalın içinde bir tipi daraltmasıdır. typeof, instanceof, in, eşitlik kontrollerini, truthiness'i ve kullanıcı tanımlı type guard'ları anlar.

class ApiError extends Error {
  constructor(public status: number) {
    super(`HTTP ${status}`);
  }
}

type Input = string | number | { id: number } | ApiError;

function describe(x: Input): string {
  if (typeof x === "string") return `string of length ${x.length}`;
  if (typeof x === "number") return `number ${x.toFixed(1)}`;
  if (x instanceof ApiError) return `error with status ${x.status}`;
  return `object with id ${x.id}`; // only { id: number } is left
}

console.log(describe("hi"));             // string of length 2
console.log(describe(3));                // number 3.0
console.log(describe(new ApiError(404))); // error with status 404
console.log(describe({ id: 7 }));        // object with id 7

10. Kullanıcı tanımlı type guard nedir?

Dönüş tipi value is T olan bir fonksiyondur. true döndürdüğünde çağıranın değişkeni T'ye daraltılır. Derleyici fonksiyona güvenir, bu yüzden gövdesinin değeri gerçekten kontrol etmesi gerekir.

interface Cat { meow(): void }

function isCat(value: unknown): value is Cat {
    return (
        typeof value === "object" &&
        value !== null &&
        "meow" in value &&
        typeof value.meow === "function"
    );
}

Bir assertion fonksiyonu, function assertCat(v: unknown): asserts v is Cat, false döndürmek yerine hata fırlatarak daraltır.

11. Generics nedir?

Tek bir fonksiyonun, class'ın ya da tipin girdi ile çıktı arasındaki bağı koruyarak birçok tiple çalışmasını sağlayan tip parametreleridir. T argümanlardan çıkarılır ve extends onun ne olabileceğini kısıtlar.

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

const n = first([10, 20]);   // T is number, n is number | undefined
const s = first(["a", "b"]); // T is string

function pluck<T, K extends keyof T>(items: T[], key: K): T[K][] {
  return items.map((item) => item[key]);
}

const users = [{ name: "Ada", age: 36 }, { name: "Lin", age: 29 }];
console.log(n, s, pluck(users, "name"), pluck(users, "age")); // 10 a [ 'Ada', 'Lin' ] [ 36, 29 ]

pluck(users, "email") bir derleme hatası olurdu, çünkü "email" kullanıcı tipinin bir keyof değeri değildir.

12. keyof ve typeof bir tipte ne yapar?

keyof T, T'nin özellik adlarının union'ıdır. Tip konumunda typeof x bir değişkenin tipini verir. Birlikte, keyof typeof obj bir nesnenin anahtarlarını bir union'a çevirir.

const colors = { red: "#f00", green: "#0f0" };
type Colors = typeof colors;        // { red: string; green: string }
type ColorName = keyof typeof colors; // "red" | "green"

13. Utility type'lar nedir? Birkaçını sayın.

Başka tipleri dönüştüren yerleşik generic tiplerdir. En çok sorulanlar:

Tam liste utility type'lar sayfasındadır.

14. Discriminated union nedir?

Ortak bir literal "etiket" özelliği paylaşan nesne tiplerinden oluşan bir union'dır. Etiketi kontrol etmek değeri tek bir üyeye daraltır ve default dalındaki bir never kontrolü, unuttuğunuz her durumu derleyicinin bildirmesini sağlar.

type Shape =
  | { kind: "circle"; radius: number }
  | { kind: "rect"; width: number; height: number };

function area(shape: Shape): number {
  switch (shape.kind) {
    case "circle":
      return Math.PI * shape.radius ** 2;
    case "rect":
      return shape.width * shape.height;
    default: {
      const unreachable: never = shape;
      return unreachable;
    }
  }
}

console.log(area({ kind: "rect", width: 3, height: 4 }));    // 12
console.log(area({ kind: "circle", radius: 1 }).toFixed(2)); // 3.14

15. as ile satisfies arasındaki fark nedir?

value as T bir type assertion'dır: derleyiciye değeri T olarak görmesini söyler ve kontrolün çoğunu atlar. value satisfies T ise değeri T'ye göre kontrol eder ama değerin kendi, daha kesin tipini korur.

type Theme = { primary: string; secondary: string };

const a = { primary: "#07f" } as Theme;        // compiles: the missing key is not reported
const b = { primary: "#07f" } satisfies Theme; // error TS2741: Property 'secondary' is missing
const c = {} as { name: string };              // compiles; c.name is undefined at run time

Nesne tamamlandığında satisfies kendi çıkarılan tipini de korur: Record<string, string>'e göre kontrol edilse bile değişken hangi anahtarlara sahip olduğunu tam olarak bilir; bir işaretleme ise onu herhangi bir string anahtara genişletirdi.

16. Bir değişkenden sonraki ! operatörü ne yapar?

Bu, non-null assertion'dır: el! tipten null ve undefined'ı çıkarır. Hiçbir kontrol üretmez, bu yüzden değer aslında null ise program onun kullanıldığı yerde çöker. ?., ?? ya da açık bir if tercih edin.

17. private ile #private arasındaki fark nedir?

private yalnızca derleyici tarafından uygulanır; özellik JavaScript çıktısında sıradan bir özelliktir. #field ise çalışma zamanının uyguladığı bir JavaScript private alanıdır.

class Account {
  private pin = "1234"; // TypeScript-only privacy
  #balance = 100;       // JavaScript private field

  get balance() {
    return this.#balance;
  }
}

const acc = new Account();
// acc.pin is error TS2341; bracket access is an allowed escape hatch,
// and at run time pin is an ordinary property:
console.log(acc["pin"]);       // 1234
console.log(Object.keys(acc)); // [ 'pin' ]
console.log(acc.balance);      // 100

protected, private gibi çalışır ama alt class'lardan erişime de izin verir; readonly ise nesne oluşturulduktan sonra yeniden atamayı yasaklar.

18. Abstract class ile interface arasındaki fark nedir?

Bir interface yalnızca bir tiptir: bir şekli tanımlar ve çıktıdan kaybolur. Bir abstract class ise örneği oluşturulamayan gerçek bir class'tır; alt class'ların uygulaması gereken abstract üyelerin yanında uygulanmış metotlar, alanlar ve constructor'lar tutabilir. Bir class birçok interface'i implement edebilir ama yalnızca bir class'ı extend edebilir.

abstract class Repository<T> {
    protected items: T[] = [];
    abstract validate(item: T): boolean; // subclasses must implement
    add(item: T): void {                 // shared implementation
        if (this.validate(item)) this.items.push(item);
    }
}

19. TypeScript'te function overloading nedir?

Birkaç çağrı imzası ve ardından imzası hepsiyle uyumlu olan tek bir uygulamadır. Çağıranlar yalnızca overload'ları görür, böylece her çağrı kesin bir dönüş tipi alır.

function parse(value: string): number;
function parse(value: string[]): number[];
function parse(value: string | string[]): number | number[] {
    return Array.isArray(value) ? value.map(Number) : Number(value);
}

const one = parse("4");          // number
const many = parse(["1", "2"]);  // number[]

Dönüş tipi argüman tipine bağlı değilse, union parametreli tek bir imza daha basittir.

İleri Seviye Sorular

20. Structural typing nedir?

TypeScript tipleri adlarına göre değil şekillerine göre karşılaştırır. Gerekli özelliklere sahip her değer, o tiple hiç tanımlanmamış olsa bile kabul edilir.

interface Point {
  x: number;
  y: number;
}

function show(p: Point): string {
  return `(${p.x}, ${p.y})`;
}

const pixel = { x: 3, y: 4, color: "red" }; // never declared as a Point
console.log(show(pixel)); // (3, 4): it has the right shape, so it is a Point

class Vector {
  constructor(public x: number, public y: number) {}
}
console.log(show(new Vector(1, 2))); // (1, 2)

Fazladan color burada sorun değildir, çünkü pixel bir değişkendir. Nesne literal'ini doğrudan vermek, show({ x: 3, y: 4, color: "red" }), bir excess property hatasıdır; bu kontrol yalnızca yeni oluşturulmuş literal'lere uygulanır. Aynı şekle sahip iki tipin karışmaması gerektiğinde (ikisi de string olan bir UserId ve bir OrderId), bir branded type kullanın: type UserId = string & { readonly __brand: "UserId" }.

21. Readonly ve Partial'ı kendiniz nasıl yazardınız?

Mapped type'larla: keyof T üzerinde dönün ve her özelliğe bir belirteç ekleyin.

type MyReadonly<T> = { readonly [K in keyof T]: T[K] };
type MyPartial<T> = { [K in keyof T]?: T[K] };
type Mutable<T> = { -readonly [K in keyof T]: T[K] }; // "-" removes a modifier

type User = { name: string; age: number };
type Draft = MyPartial<User>; // { name?: string; age?: number }

22. Conditional type'lar ve infer nedir?

T extends U ? X : Y bir koşula göre bir tip seçer. Koşulun içinde infer, eşleşen tipin bir parçasını yakalayan bir tip değişkeni tanımlar. Conditional type'lar union'lar üzerine dağılır.

type MyReturnType<F> = F extends (...args: any[]) => infer R ? R : never;
type ElementOf<T> = T extends (infer E)[] ? E : T;

type A = MyReturnType<() => Promise<number>>; // Promise<number>
type B = ElementOf<string[]>;                 // string
type C = ElementOf<number | boolean[]>;       // number | boolean (distributed)

Daha fazla kalıp conditional type'lar sayfasındadır.

23. .d.ts dosyası nedir ve declare ne yapar?

Bir declaration dosyası, bir JavaScript kütüphanesi ya da tarayıcı API'leri gibi başka bir yerde var olan kod için yalnızca tipleri tutar. declare bir değerin var olduğunu, onu oluşturmadan belirtir: declare const VERSION: string; hiçbir şeye derlenmez. Kütüphane tipleri paketle birlikte ya da @types/{name} paketlerinden gelir ve tsc, declaration: true ile kendi kodunuz için .d.ts dosyaları üretir.

24. strict ne yapar ve en önemli tsconfig seçenekleri hangileridir?

"strict": true; noImplicitAny, strictNullChecks, strictFunctionTypes, strictBindCallApply, strictPropertyInitialization, noImplicitThis, useUnknownInCatchVariables ve strictBuiltinIteratorReturn bayraklarını açar. TypeScript 7'de varsayılan olarak açıktır. Mülakatçıların sorduğu diğer seçenekler:

25. TypeScript 7 nedir?

Go ile yerel bir program olarak yeniden yazılmış ve typescript npm paketinin 7. sürümü olarak yayımlanmış TypeScript derleyicisidir. Komut hâlâ tsc'dir ve dil aynıdır, ancak JavaScript tabanlı 6.x derleyicisinden çok daha hızlıdır: TypeScript ekibi, yerel kod ve paylaşılan bellekli çoklu thread sayesinde tipik tam build'lerde 8x ile 12x arası hızlanma bildiriyor. Ayrıca 6.0'ın kullanımdan kaldırdığı seçeneklerin silinmesini uygular; örneğin baseUrl, outFile, moduleResolution: "node10", module: "amd" ve alwaysStrict: false artık onları kaldırmanızı söyleyen hatalardır (TS5102, TS5108).