info@teknoedu.com
Yazılım

TypeScript’e Giriş: Tipler, Arayüzler ve tsconfig ile Daha Güvenli JavaScript

TypeScript nedir, JavaScript'e ne katar ve nasıl başlanır? Temel tipler, interface ve type farkı, birleşim tipleri, generic'ler ve strict modu örneklerle anlatıyor, mevcut bir projeye kademeli geçiş için yol gösteriyoruz.

TypeScript'e Giriş: Tipler, Arayüzler ve tsconfig ile Daha Güvenli JavaScript

JavaScript esnek bir dildir; bir değişkene önce sayı, sonra metin atayabilir, var olmayan bir özelliğe erişip sessizce undefined alabilirsiniz. Küçük betiklerde bu esneklik hız kazandırır, ama proje büyüdükçe “bu fonksiyon tam olarak ne bekliyordu?” sorusu hatalara dönüşür. TypeScript, JavaScript’e statik tip denetimi ekleyerek bu hataları kod çalışmadan, daha yazarken yakalamanızı sağlar.

TypeScript nedir, ne değildir?

TypeScript, Microsoft tarafından geliştirilen açık kaynaklı bir dildir ve JavaScript’in bir üst kümesidir: Geçerli her JavaScript kodu aynı zamanda geçerli TypeScript kodudur. TypeScript kodu doğrudan tarayıcıda çalışmaz; derleyici (tsc) tipleri kontrol eder, ardından tipleri silerek düz JavaScript üretir.

Bu yüzden iki noktayı baştan bilmek önemli:

  • Tipler yalnızca geliştirme anında vardır. Çalışma zamanında, örneğin bir API’den gelen veriyi otomatik doğrulamaz.
  • TypeScript’in asıl faydası editördedir: otomatik tamamlama, güvenli yeniden adlandırma ve anında hata gösterimi.

Kurulum ve ilk derleme

Node.js kurulu bir bilgisayarda yeni bir klasörde şu komutları çalıştırın:

npm init -y
npm install --save-dev typescript
npx tsc --init

tsc --init komutu, açıklamalı bir tsconfig.json dosyası oluşturur. Şimdi merhaba.ts adlı bir dosya yazalım:

function selamla(ad: string): string {
  return `Merhaba, ${ad}!`;
}

console.log(selamla("Teknoedu"));
// console.log(selamla(42));
// Hata: Argument of type 'number' is not assignable to parameter of type 'string'.

npx tsc komutu projeyi derler ve .js dosyalarını üretir; ardından node merhaba.js ile çalıştırabilirsiniz. Son satırdaki yorumu kaldırırsanız derleyici hatayı daha kod çalışmadan bildirir.

Temel tipler ve tip çıkarımı

let ad: string = "Ayşe";
let yas: number = 14;
let aktif: boolean = true;
let notlar: number[] = [80, 95];
let koordinat: [number, number] = [41.01, 28.97]; // tuple

let sehir = "İzmir"; // tip yazmadık ama TypeScript bunu string olarak çıkarır
// sehir = 35;        // Hata

Her değişkene tip yazmak zorunda değilsiniz. TypeScript, atanan değerden tipi çıkarır (type inference). Genel kural: Fonksiyon parametrelerine ve dışarıya açılan fonksiyonların dönüş tiplerine açıkça tip yazın, yerel değişkenleri çıkarıma bırakın.

any tipi tüm denetimi kapatır; mecbur kalmadıkça kullanmayın. Tipini bilmediğiniz bir değer için unknown daha güvenlidir, çünkü kullanmadan önce kontrol etmeye zorlar:

function uzunluk(deger: unknown): number {
  if (typeof deger === "string") return deger.length; // burada string olduğu biliniyor
  if (Array.isArray(deger)) return deger.length;
  return 0;
}

Nesne tipleri: interface ve type

Bir nesnenin şeklini tanımlamanın iki yolu vardır:

interface Ogrenci {
  id: number;
  ad: string;
  sinif: string;
  eposta?: string;          // isteğe bağlı
  readonly kayitYili: number; // sonradan değiştirilemez
}

type Not = {
  ogrenciId: number;
  ders: string;
  puan: number;
};

const o: Ogrenci = { id: 1, ad: "Can", sinif: "9-A", kayitYili: 2025 };
// o.kayitYili = 2026; // Hata: readonly

İkisi çoğu durumda birbirinin yerine kullanılabilir. Pratik bir ayrım: Nesne şekilleri için interface, birleşim tipleri ve daha karmaşık tip ifadeleri için type tercih edilir. Önemli olan proje içinde tutarlı olmaktır.

Birleşim tipleri ve daraltma

TypeScript’in en güçlü yanlarından biri, bir değerin “şunlardan biri” olduğunu ifade edebilmektir:

type Durum = "taslak" | "yayinda" | "arsiv";

function etiket(d: Durum): string {
  switch (d) {
    case "taslak":
      return "Taslak";
    case "yayinda":
      return "Yayında";
    case "arsiv":
      return "Arşivlendi";
  }
}

// etiket("silindi"); // Hata: '"silindi"' tipi Durum'a atanamaz

Aynı fikir, farklı şekillere sahip nesnelerde de çalışır. Ortak bir alan (burada tur) üzerinden ayrım yapılan bu yapıya ayırt edici birleşim (discriminated union) denir:

type Sonuc =
  | { tur: "basarili"; veri: string[] }
  | { tur: "hata"; mesaj: string };

function yazdir(s: Sonuc): void {
  if (s.tur === "basarili") {
    console.log(`${s.veri.length} kayıt geldi`);
  } else {
    console.error(s.mesaj); // burada s.veri'ye erişmeye çalışmak hata verir
  }
}

Generic’ler: Tipi parametre olarak almak

Farklı tiplerle çalışan ama tip bilgisini kaybetmeyen fonksiyonlar yazmak için generic’ler kullanılır:

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

const sayi = ilk([3, 5, 7]);       // tipi: number | undefined
const isim = ilk(["Ali", "Veli"]); // tipi: string | undefined

Fetch ile veri çekerken de sık kullanılır:

async function getJson<T>(url: string): Promise<T> {
  const yanit = await fetch(url);
  if (!yanit.ok) throw new Error(`HTTP ${yanit.status}`);
  return (await yanit.json()) as T;
}

interface Kullanici { id: number; name: string; }

async function goster() {
  const k = await getJson<Kullanici>("https://jsonplaceholder.typicode.com/users/1");
  console.log(k.name);
}

Buradaki as T, derleyiciye “bana güven” demektir. Sunucu farklı bir şekil döndürürse TypeScript bunu fark etmez. Dış kaynaklı verileri gerçekten doğrulamak için Zod gibi çalışma zamanı doğrulama kütüphaneleri kullanılır.

Yardımcı tipler

TypeScript, mevcut tiplerden yenilerini türetmek için hazır yardımcılar sunar:

Yardımcı tip Ne yapar? Örnek kullanım
Partial<T> Tüm alanları isteğe bağlı yapar Güncelleme formları
Required<T> Tüm alanları zorunlu yapar Doğrulanmış veri
Pick<T, K> Yalnızca seçilen alanları alır Liste görünümü
Omit<T, K> Seçilen alanları çıkarır id olmadan yeni kayıt
Record<K, V> Anahtar-değer sözlüğü Record<string, number>
type YeniOgrenci = Omit<Ogrenci, "id">;
type OgrenciGuncelle = Partial<Omit<Ogrenci, "id" | "kayitYili">>;

tsconfig.json’da önemli ayarlar

tsc --init ile oluşan dosyada pek çok seçenek vardır. Başlangıçta bilmeniz gerekenler:

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "NodeNext",
    "strict": true,
    "outDir": "dist",
    "rootDir": "src",
    "sourceMap": true
  }
}
  • strict: Tüm katı denetimleri açar. Yeni projelerde mutlaka true olsun; özellikle strictNullChecks, null/undefined kaynaklı hataların büyük bölümünü yakalar.
  • target: Üretilecek JavaScript’in hangi sürümü hedefleyeceği.
  • outDir / rootDir: Kaynak ve çıktı klasörleri.
  • sourceMap: Hata ayıklarken derlenmiş koddan özgün .ts satırına dönebilmeyi sağlar.

Mevcut bir JavaScript projesini kademeli taşımak

Büyük bir projeyi tek seferde dönüştürmek gerekmez:

  1. tsconfig.json içinde "allowJs": true ve "checkJs": false ile başlayın.
  2. Dosyaları birer birer .js uzantısından .ts uzantısına çevirin; önce en az bağımlılığı olan yardımcı dosyalardan başlayın.
  3. Tipi belirsiz yerlerde geçici olarak unknown kullanın, any sayısını izleyin.
  4. Proje oturdukça strict seçeneğini açın ve çıkan hataları modül modül düzeltin.

Sık yapılan hatalar

  • Her yere any yazmak: TypeScript kullanıyormuş gibi görünür ama hiçbir koruma sağlamaz.
  • Tiplerin çalışma zamanında doğrulama yaptığını sanmak: API verisi, form girdisi ve dosya içeriği için ayrıca doğrulama gerekir.
  • ! (non-null assertion) operatörünü gelişigüzel kullanmak: eleman!.value derleyiciyi susturur ama null hatasını önlemez.
  • strict modu kapalı başlamak: Sonradan açmak çok daha zahmetlidir.

Sonuç

TypeScript, JavaScript bilgilerinizi çöpe atmadan üzerine güvenlik katmanı ekler. Küçük adımlarla başlayın: fonksiyon parametrelerine tip yazın, nesne şekillerini interface ile tanımlayın ve strict modunu açık tutun. Birkaç hafta sonra editörün size “burada undefined gelebilir” diye uyarıda bulunduğu her an, üretimde yaşanmamış bir hata olarak kazanca dönüşecek.