---
title: 'Birleşim ve Kesişim Tipleri'
source: 'https://academia.sh/tr/kurslar/typescript/birlesim-ve-kesisim-tipleri'
course: TypeScript
language: tr
updated: '2026-08-17T18:09:55+00:00'
license: 'CC BY-SA 4.0'
---

# Birleşim ve Kesişim Tipleri

Birleşim tipinde ortak üye kuralı, ayırt edici birleşim kalıbı, kesişimle tip birleştirme ve çakışan alanların boş tipe indirgenmesi.

Ölçüm kaydının `birim` alanı `"C" | "Pa" | "%"` biçiminde yazılmıştı: birbirinin
alternatifi olan üç tipin **birleşimi**. Aynı işlemin bir de kesişim yönü vardır — iki
tipin gerekliliklerini aynı anda taşıyan değerler.

Bu iki işleç, tip düzeyinde küme cebrinin karşılığıdır ve ölçüm kaydının bundan sonraki
gelişiminin çatısını kurar. Ders, birleşim üzerinde hangi işlemlerin yapılabildiğini,
ayırt edici alan kalıbını ve kesişimin ne zaman boşa düştüğünü ele alır.

## Birleşim: Değerlerin Toplamı

`A | B` tipi, `A` tipindeki **veya** `B` tipindeki tüm değerleri kapsar. Değer kümeleri
düzeyinde bu bir birleşim işlemidir:

$$
\text{values}(A \mid B) = \text{values}(A) \cup \text{values}(B)
$$

Bir birleşim değeri elde eden kod, o değerin hangi üyeden geldiğini bilmez. Bu nedenle
üzerinde yalnızca **her iki üyede de bulunan** işlemleri yapabilir:

```typescript
type SayisalOlcum = { kimlik: string; deger: number };
type MetinselOlcum = { kimlik: string; metin: string };
type Kayit = SayisalOlcum | MetinselOlcum;

function yaz(kayit: Kayit): void {
  console.log(kayit.kimlik);
  console.log(kayit.deger);
}

yaz({ kimlik: "s-01", deger: 21.4 });
```

```text
e1.ts(7,21): error TS2339: Property 'deger' does not exist on type 'Kayit'.
  Property 'deger' does not exist on type 'MetinselOlcum'.
```

`kimlik` erişimi geçerlidir, çünkü her iki üyede de bulunur. `deger` erişimi reddedilir,
çünkü değer `MetinselOlcum` olabilir. Tanının ikinci satırı hangi üyenin engel olduğunu
söyler.

Buradan bir ters orantı çıkar ve ilk bakışta şaşırtıcıdır: **değer kümesi büyüdükçe
kullanılabilir üye kümesi küçülür.** Birleşime yeni bir üye eklemek, o tiple yapılabilecek
işlemleri azaltır. Küme dilinde: değerlerin birleşimi, güvenceli üyelerin kesişimidir.

## Ayırt Edici Birleşim

Birleşim üyelerinden yalnızca birinde bulunan bir üyeye erişebilmek için, değerin hangi
üyeden geldiğinin **kanıtlanması** gerekir. En kullanışlı kanıt biçimi, her üyeye ortak
adlı ama farklı sabit tipli bir alan koymaktır:

```typescript
type Olcum =
  | { durum: "gecerli"; kimlik: string; deger: number }
  | { durum: "hatali"; kimlik: string; kod: string };

function ozet(olcum: Olcum): string {
  if (olcum.durum === "gecerli") {
    return `${olcum.kimlik}: ${olcum.deger}`;
  }
  return `${olcum.kimlik}: hata ${olcum.kod}`;
}

console.log(ozet({ durum: "gecerli", kimlik: "s-01", deger: 21.4 }));
console.log(ozet({ durum: "hatali", kimlik: "s-02", kod: "E17" }));
```

Bu dosya tip denetiminden geçer ve çıktısı şudur:

```text
s-01: 21.4
s-02: hata E17
```

`durum` alanına **ayırt edici** (discriminant) denir; bu kalıba da **ayırt edici birleşim**
(discriminated union). Çalışması için üç koşul gerekir: alanın adı tüm üyelerde aynı
olmalı, tipi sabit tip olmalı ve sabitler üyeler arasında farklı olmalıdır.

Koşullar sağlandığında derleyici `olcum.durum === "gecerli"` sınamasını bir kanıt olarak
kabul eder ve `if` gövdesinde tipi tek bir üyeye indirir. Bu indirgemeye **daraltma**
(narrowing) denir ve kuralları ayrı bir dersin konusudur. `if` bloğundan sonra kalan tek
üye `"hatali"` olduğu için `olcum.kod` erişimi de geçerlidir.

Ölçüm kaydının modeli bu noktada ilk yapısal kararını almış olur: geçerli ve hatalı kayıt
aynı tipin iki durumu değil, iki ayrı tiptir. Böylece `deger` alanı yalnızca gerçekten
bulunduğu durumda erişilebilir hâle gelir — "değer var mı" sorusu çalışma zamanından
derleme anına taşınmıştır.

## Kesişim: Gerekliliklerin Toplamı

`A & B` tipi, hem `A` hem `B` olan değerleri kapsar. Nesne tiplerinde bu, alanların
birleştirilmesi anlamına gelir:

```typescript
type Olcum = { kimlik: string; deger: number };
type ZamanDamgali = { zaman: number };
type Kayit = Olcum & ZamanDamgali;

const kayit: Kayit = { kimlik: "s-01", deger: 21.4, zaman: 1706000000000 };
console.log(kayit.kimlik, kayit.deger, kayit.zaman);

const eksik: Kayit = { kimlik: "s-02", deger: 22.1 };
```

```text
e2.ts(8,7): error TS2322: Type '{ kimlik: string; deger: number; }' is not assignable to type 'Kayit'.
  Property 'zaman' is missing in type '{ kimlik: string; deger: number; }' but required in type 'ZamanDamgali'.
```

Birleşimdeki ters orantı burada düzelir: kesişimin değer kümesi daha küçük, kullanılabilir
üye kümesi daha büyüktür. Bir `Kayit` değeri hem `Olcum` hem `ZamanDamgali`nin tüm
alanlarını taşır.

Kesişimin tipik kullanımı, bağımsız olarak anlamlı olan nitelikleri ayrı tiplerde tutup
gerektiğinde birleştirmektir. Ölçüm kaydında zaman damgası, kaynak bilgisi ve doğrulama
sonucu ayrı ayrı tanımlanabilir; farklı bağlamlarda farklı bileşimleri kullanılır. Bu,
Veri Yapıları kursunda tanıtılan **soyut veri tipi** düşüncesinin tip düzeyindeki
karşılığıdır: bir tip, taşıdığı alanlardan çok karşıladığı sözleşmelerle tanımlanır.

## Kesişim Boşa Düştüğünde

Kesişim her zaman anlamlı bir tip üretmez. İki ilkel tipin kesişiminde ortak değer
yoktur:

```typescript
type Imkansiz = string & number;

const bos: Imkansiz = "s-01";
console.log(bos);
```

```text
e6.ts(3,7): error TS2322: Type '"s-01"' is not assignable to type 'never'.
```

`string & number` tipi `never`e indirgenmiştir — hiçbir değer hem dizgi hem sayı olamaz.
Tanının doğrudan `never`den söz etmesi bu indirgemenin sonucudur.

Aynı durum nesne tiplerinde, çakışan bir alan üzerinden ortaya çıkar:

```typescript
type CelsiusKayit = { birim: "C"; deger: number };
type PascalKayit = { birim: "Pa"; deger: number };
type Ikisi = CelsiusKayit & PascalKayit;

declare const kayit: Ikisi;
const sinama: null = kayit;
const alan: null = kayit.birim;
```

```text
e4.ts(7,26): error TS2339: Property 'birim' does not exist on type 'never'.
  The intersection 'Ikisi' was reduced to 'never' because property 'birim' has conflicting types in some constituents.
```

Tanı, indirgemenin gerekçesini açıkça yazar: `birim` alanının tipleri bağdaşmadığı için
kesişim tümüyle `never` olmuştur. Altıncı satırın hata vermemesi de bunun sonucudur —
`never` her tipe atanabilir.

Bu davranış bir tasarım uyarısıdır. Çakışan alanlar taşıyan iki tip birleştirilmek
isteniyorsa, doğru araç kesişim değil birleşimdir: değerler ya birinin ya diğerinin
kuralına uyar, ikisinin birden değil.

## İki İşlecin Karşılaştırması

| Ölçüt | Birleşim `A \| B` | Kesişim `A & B` |
|---|---|---|
| Değer kümesi | `A` ve `B` kümelerinin birleşimi | `A` ve `B` kümelerinin kesişimi |
| Erişilebilir üyeler | Yalnızca ortak üyeler | Tüm üyeler |
| Kullanmadan önce | Daraltma gerekir | Gerekmez |
| Çakışan alan | Ayırt edici olarak kullanılır | Boş tipe indirger |
| Tipik kullanım | Bir değerin alabildiği durumlar | Bağımsız niteliklerin bileşimi |

Tablo, iki işlecin birbirinin yerine geçmediğini gösterir. Birleşim bir **seçim**
modellemek içindir: kayıt ya geçerlidir ya hatalıdır. Kesişim bir **toplam** modellemek
içindir: kayıt hem kimlikli hem zaman damgalıdır.

## Özet

- Birleşim tipinin değer kümesi üyelerin birleşimidir; erişilebilir üye kümesi ise
  üyelerin kesişimidir.
- Ayırt edici birleşim, her üyeye aynı adlı ve farklı sabit tipli bir alan koyar; bu alan
  üzerinde yapılan sınama daraltmayı mümkün kılar.
- Kesişim tipi, nesne tiplerinin alanlarını birleştirir ve tüm gereklilikleri aynı anda
  dayatır.
- İki ilkel tipin kesişimi ile çakışan alan taşıyan nesne tiplerinin kesişimi `never`e
  indirgenir; derleyici indirgeme gerekçesini tanıda belirtir.
- Birleşim bir seçimi, kesişim bir toplamı modeller; çakışan alanlar için doğru araç
  birleşimdir.

## Sonraki Adım

Ayırt edici birleşimin çalışması için alanların sabit tipte olması gerekiyordu. Oysa tip
çıkarımı dersinde görüldüğü gibi, bir nesne sabitinin alanları kendiliğinden genişletilir
ve sabit tip kaybolur. Sonraki ders bu genişletmeyi durduran araçları — sabit tipleri,
`as const` yazımını ve tipin sınanmasını sağlayan `satisfies` işlecini — ele alacak.