---
title: "TypeScript'in Amacı"
source: 'https://academia.sh/tr/kurslar/typescript/typescriptin-amaci'
course: TypeScript
language: tr
updated: '2026-08-17T18:09:54+00:00'
license: 'CC BY-SA 4.0'
---

# TypeScript'in Amacı

Statik tip katmanının yakaladığı hata sınıfı, tiplerin derleme anında silinmesi ve tip denetimi ile çalışma zamanı doğrulaması arasındaki ayrım.

Modüller, Araçlar ve Ekosistem kursu, kaynak kodun hedef ortama uyarlanmasını ve statik
çözümleme araçlarının kural kümesiyle nasıl çalıştığını ele aldı. Bu araçların tümü ortak
bir soru sorar: programı çalıştırmadan hakkında ne söylenebilir? TypeScript, bu sorunun
en iddialı yanıtını verir — programın her ifadesinin hangi değer kümesinden değer
üretebileceğini hesaplar ve tutarsızlıkları bildirir.

Bu ders üç şeyi kurar: tip katmanının hangi hata sınıfını yakaladığı, tiplerin çalışma
zamanında ne olduğu ve tip denetiminin **neyi vaat etmediği**. Üçüncüsü, ilk ikisi kadar
önemlidir; kursun ilerleyen bölümlerinde tekrar tekrar bu ayrıma dönülecektir.

Kurs boyunca tek bir somut örnek kullanılacaktır: bir **ölçüm kaydı** modeli. Model,
tipsiz bir JavaScript nesnesinden başlar ve her konuda bir adım daha güvenli hâle gelir.

## Sessiz Hatanın Anatomisi

Ölçüm kayıtlarının ortalamasını hesaplayan bir fonksiyonla başlayalım. JavaScript
Temelleri kursunda kurulan araçlardan fazlasını kullanmıyor:

```javascript
function ortalama(olcumler) {
  let toplam = 0;
  for (const o of olcumler) {
    toplam += o.deger;
  }
  return toplam / olcumler.length;
}

const kayitlar = [{ deger: 21.4 }, { deger: 22.1 }, { deger: "23.0" }];
console.log(ortalama(kayitlar));
```

Çalıştırıldığında çıktı `NaN` olur. Program çökmez, hata iletisi vermez, yanlış bir sayı
üretir. Nedeni Programlama Temelleri kursundaki Tip Dönüşümü dersinde kurulmuştu: üçüncü
kaydın `deger` alanı sayı değil dizgidir; `+` işleci bir tarafı dizgi görünce toplama
değil birleştirme yapar. `43.5 + "23.0"` ifadesi `"43.523.0"` dizgisini verir, bu dizginin
üçe bölümü de `NaN` olur.

Bu, mantık hatası sınıfının tipik bir örneğidir: program çalışır, hata vermez, yanlış
sonuç verir. Hatanın kaynağı ile belirtisi arasında bir mesafe vardır — kayıt belki
saatler önce bir dosyadan okunmuş, `NaN` ise bir raporun sonunda görünmüştür.

## Tip Katmanı Ne Yapar

Aynı programı, değerlerin hangi kümeye ait olduğunu açıkça yazarak kuralım:

```typescript
type Olcum = { deger: number };

function ortalama(olcumler: Olcum[]): number {
  let toplam = 0;
  for (const o of olcumler) {
    toplam += o.deger;
  }
  return toplam / olcumler.length;
}

const kayitlar: Olcum[] = [{ deger: 21.4 }, { deger: 22.1 }, { deger: "23.0" }];
console.log(ortalama(kayitlar));
```

`: Olcum[]` ve `: number` yazımlarına **tip açıklaması** (type annotation) denir. Derleyici
bu dosyayı denetlediğinde şu tanıyı üretir:

```text
a1.ts(11,64): error TS2322: Type 'string' is not assignable to type 'number'.
```

Tanı, hatanın nerede olduğunu değil, **nereden başladığını** gösterir: `NaN`'ın oluştuğu
bölme işlemini değil, dizginin sayı beklenen yere konduğu satır ve sütunu. Hata, belirtiye
dönüşmeden önce yakalanmıştır.

Bu kurstaki tanı iletileri derleyicinin 6.0 sürümüyle üretilmiştir. İleti metni sürümden
sürüme yeniden yazılabilir; `TS2322` gibi **hata kodları** daha kararlıdır. Bir tanıyı
aratırken kod üzerinden aramak, metin üzerinden aramaktan güvenilirdir.

## Tipler Derleme Anında Silinir

Şimdi kursun en önemli ayrımına gelelim. TypeScript kaynak kodu doğrudan çalışmaz; önce
JavaScript'e çevrilir. Bu çeviride tip açıklamalarına ne olur?

Aşağıdaki dosya `olcum.ts` adıyla kaydedilsin:

```typescript
type Olcum = { kimlik: string; deger: number };

function ortalama(olcumler: Olcum[]): number {
  let toplam: number = 0;
  for (const o of olcumler) {
    toplam += o.deger;
  }
  return toplam / olcumler.length;
}

const kayitlar: Olcum[] = [
  { kimlik: "s-01", deger: 21.4 },
  { kimlik: "s-02", deger: 22.1 },
];
console.log(ortalama(kayitlar));
```

Derleyici `tsc --target es2022 olcum.ts` komutuyla çağrıldığında yanına `olcum.js`
dosyasını yazar:

```javascript
"use strict";
function ortalama(olcumler) {
    let toplam = 0;
    for (const o of olcumler) {
        toplam += o.deger;
    }
    return toplam / olcumler.length;
}
const kayitlar = [
    { kimlik: "s-01", deger: 21.4 },
    { kimlik: "s-02", deger: 22.1 },
];
console.log(ortalama(kayitlar));
```

Çıktı, kaynağın tip açıklamaları silinmiş hâlidir. `type Olcum` bildirimi tamamen yok
olmuştur; `: Olcum[]`, `: number` yazımları kalkmıştır. Derleyicinin eklediği tek satır
`"use strict";`dir ve o da tiplerle ilgili değildir. `node olcum.js` çıktısı `21.75`tir.

Buna **tip silme** (type erasure) denir. Sonucu şudur: **tip katmanı çalışma zamanı
davranışını değiştirmez.** Aynı programın tipli ve tipsiz sürümleri, tip hatası
içermedikleri sürece bit bit aynı işi yapar. Tip sistemi bir kütüphane değil, bir **kanıt
katmanıdır**: kaynak kod üzerinde yürütülen ve çeviri bittiğinde geride kalmayan bir akıl
yürütme.

Bu ayrımın doğrudan bir sonucu, tip hatasının kendiliğinden yayını durdurmamasıdır:

```text
kayit.ts(3,40): error TS2322: Type 'string' is not assignable to type 'number'.
```

Bu tanıyı üreten derleme, yine de `kayit.js` dosyasını yazar ve o dosya çalıştırılabilir.
Derleyici "bu programın tipleri tutarsız" der, "bu program çalışmaz" demez. Hatanın yayını
engellemesi ayrı bir yapılandırma kararıdır ve Derleme ve Çalıştırma Akışı dersinde ele
alınacaktır.

## Tip Denetimi Çalışma Zamanı Doğrulaması Değildir

Tip silme, sık yapılan bir yanlış beklentiyi de açıklar. Bir değerin tipini yazmak, o
değerin çalışma zamanında gerçekten o tipte olacağını **garanti etmez**. Garanti, yalnızca
derleyicinin gördüğü kod parçası için ve yalnızca oradaki bilgi doğruysa geçerlidir.

Ölçüm kaydı bir dosyadan veya ağdan geldiğinde bilgi doğru olmayabilir:

```typescript
type Olcum = { kimlik: string; deger: number };

const ham = '{"kimlik":"s-01","deger":"23.0"}';
const olcum = JSON.parse(ham) as Olcum;

console.log(typeof olcum.deger);
console.log(olcum.deger.toFixed(1));
```

Bu dosya tip denetiminden **hatasız geçer**. Çalıştırıldığında ise:

```text
string
TypeError: olcum.deger.toFixed is not a function
```

`JSON.parse` çağrısının dönüş tipi `any`dir; `as Olcum` yazımı derleyiciye "bu değeri
`Olcum` say" demektir. Derleyici bu bildirimi sorgulamaz, çünkü sorgulayacak bir aracı
yoktur: dizginin içeriği ancak program çalışırken bilinir.

Buradan iki kural çıkar ve kurs boyunca geçerlidir:

1. **Sistem sınırında doğrulama yapılır.** Dosya, ağ, kullanıcı girdisi ve veri
   tabanından gelen veri, tipi bildirilerek değil, alan alan sınanarak kabul edilir.
2. **Tip iddiası** (type assertion) **bir kanıt değil, bir borçtur.** `as` yazımı denetimi
   susturur; susturulan yerin doğruluğundan programcı sorumludur.

Sınır doğrulaması yazmanın araçları bu kursun ilerleyen derslerinde kurulacaktır:
`unknown` tipi doğru başlangıç noktasını verir, tip yüklemleri doğrulamanın sonucunu tip
sistemine geri bildirir.

## Tip Sistemi Neyi Kanıtlar

Bir tip sistemi, programın **çalıştırılmadan** doğrulanabilen özelliklerini kanıtlar.
TypeScript'in kanıtladığı özellik kabaca şudur: her ifadenin değeri, kendisinden beklenen
kümenin içindedir. Bu kanıt, tüm bir hata sınıfını ortadan kaldırır — var olmayan bir
alana erişim, eksik argümanla çağrı, yanlış tipte atama, birleşim tiplerinde ele alınmamış
durum.

Kanıtlamadığı şeyler de aynı ölçüde nettir:

- **Değer aralığı.** `deger: number` bildirimi, sıcaklığın fizik olarak olanaklı bir
  aralıkta olduğunu söylemez.
- **Sonlanma ve doğruluk.** Bir fonksiyonun ortalamayı doğru hesapladığı tip düzeyinde
  ifade edilemez; bu, Algoritmalar kursundaki kısmi doğruluk ve sonlanma kavramlarının
  alanıdır.
- **Dış dünyanın biçimi.** Yukarıdaki örnekte görüldüğü gibi, sınırın ötesi denetlenmez.

Ayrıca TypeScript'in tip sistemi bilinçli olarak **tam güvenilir** değildir: `any`, tip
iddiaları ve birkaç dil özelliği, sistemin verdiği güvenceyi delen kaçış kapıları bırakır.
Bunun nedeni tasarım hedefidir — dil, var olan JavaScript kodunun üzerine kademeli olarak
eklenebilmelidir. Kaçış kapıları `any`, `unknown` ve `never` dersinde tek tek ele
alınacaktır.

## Kursun Ortak Örneği

Kurs boyunca aynı model üzerinde çalışılacaktır. Başlangıç noktası, hiçbir güvence
taşımayan bu nesnedir:

```javascript
const olcum = {
  kimlik: "s-01",
  sensor: "sicaklik",
  deger: 21.4,
  birim: "C",
  zaman: 1706000000000,
};
```

Bu nesne hakkında şu an hiçbir şey bilinmiyor: `birim` alanına herhangi bir dizgi
yazılabilir, `deger` alanı dizgi olabilir, `sensor` alanı silinebilir. Her konu bu
belirsizliklerden birini kapatacaktır — önce alanların tipleri, sonra alanlar arasındaki
bağıntılar, sonra kaydın geçtiği durumlar ve en sonunda modelin proje sınırında nasıl
yayımlanacağı.

## Özet

- Statik tip katmanı, programı çalıştırmadan her ifadenin değer kümesini hesaplar ve
  tutarsızlıkları derleme anında bildirir.
- Tanı iletileri sürümle değişebilir; `TS2322` gibi hata kodları daha kararlı bir
  başvurudur.
- Tipler derleme anında silinir: derlenmiş JavaScript çıktısı, kaynağın tip açıklamaları
  çıkarılmış hâlidir ve çalışma zamanı davranışı değişmez.
- Tip hatası, yayını kendiliğinden durdurmaz; derleyici tanı üretse de JavaScript
  dosyasını yazar.
- Tip bildirmek çalışma zamanı doğrulaması değildir; sistem sınırından gelen veri alan
  alan sınanmalıdır.
- Tip sistemi değer aralığını, algoritmanın doğruluğunu ve dış dünyanın biçimini
  kanıtlamaz.

## Sonraki Adım

Tip katmanının ne yaptığı belli oldu; sırada bu katmanın söz dağarcığı var. Ölçüm kaydının
alanlarını yazabilmek için önce hangi temel tiplerin bulunduğunu bilmek gerekir: ilkel
tipler, dizi ve demet gösterimleri ile sabit bir değer kümesini adlandıran `enum` yapısı.
Sonraki ders bunları kurar ve modelin ilk tipli sürümünü yazar.