TypeScript Intersection Tipler: Tipleri & ile Birleştirmek

A & B şeklinde yazılan bir intersection tip, aynı anda hem bir A hem bir B olan bir değeri tanımlar. Nesne tipleri için bu, değerin ikisinin de her özelliğine sahip olması demektir. Mevcut tipleri, özellikleri yeniden yazmadan bu şekilde birleştirirsiniz.

type Person = { name: string; email: string };
type Employee = { employeeId: number; team: string };

type Staff = Person & Employee; // has all four properties

const ada: Staff = { name: "Ada", email: "ada@example.com", employeeId: 7, team: "compilers" };

function badge(s: Staff): string {
  return `${s.name} (#${s.employeeId}, ${s.team})`;
}

console.log(badge(ada)); // Ada (#7, compilers)

// @ts-expect-error: Type '{ name: string; email: string; employeeId: number; }' is not assignable to type 'Staff'.
const partial: Staff = { name: "Alan", email: "alan@example.com", employeeId: 8 };

İkinci nesne team özelliğini atlıyor, bu yüzden TS2322 derleme hatası veriyor; mesajın sonraki satırı da Property 'team' is missing ... but required in type 'Employee' diyor. Bir Staff değeri, bir Person veya bir Employee beklenen her yere verilebilir.

Nesne Tiplerini Birleştirmek

&, type alias'ların, interface'lerin ve satır içi nesne tiplerinin her karışımıyla, ayrıca generic tip parametreleriyle çalışır. Yerini doldurmanın zor olduğu yer bu son durumdur: aldığı her nesneye özellik ekleyen bir fonksiyon bunu kesin olarak ifade edebilir.

function withMeta<T extends object>(obj: T, author: string): T & { author: string; savedAt: string } {
  return { ...obj, author, savedAt: "2024-03-15T10:30:00.000Z" };
}

const note = withMeta({ title: "Draft", words: 120 }, "ada");
// type: { title: string; words: number } & { author: string; savedAt: string }

console.log(note.title, note.words, note.author); // Draft 120 ada
console.log(note.savedAt);                         // 2024-03-15T10:30:00.000Z

Çağıran, verdiği şeyin tam tipini (title, words) ve eklenen iki özelliği korur. Bir interface ... extends "T ne olursa olsun, artı bunlar" diyemez, çünkü bir interface bir tip parametresini genişletemez.

Çakışan Özellikler never Olur

İki taraf da aynı özelliği bildirdiğinde özelliğin tipi ikisinin intersection'ı olur. Bu tiplerin ortak hiçbir değeri yoksa özellik never olur ve derleyici siz bir değer oluşturmaya çalışana kadar hiçbir şey söylemez:

// This does not compile: id cannot be a string and a number at once
type WithStringId = { id: string; name: string };
type WithNumberId = { id: number };

type Account = WithStringId & WithNumberId; // no error on this line

const r: Account = { id: "u1", name: "Ada" };
console.log(r);

index.ts(7,22): error TS2322: Type 'string' is not assignable to type 'never'.

Hata, ona neden olan tipi değil nesneyi gösterir; bu da bu hataların izini sürmeyi yavaşlatır. Editörde r.id üzerine gelmek tipini gösterir: never. Çakışan özellik bir literal etiket olduğunda, örneğin type Shape = { kind: "circle" } & { kind: "square" }, TypeScript daha da ileri gider ve intersection'ın tamamını never tipine indirger. Böyle bir değerin bir özelliğini okumak da nedenini açıklar: Property 'kind' does not exist on type 'never'. The intersection 'Shape' was reduced to 'never' because property 'kind' has conflicting types in some constituents.

interface ... extends ise aynı çakışmayı TS2430 hatasıyla bildirimde yakalar. İkisi arasındaki ana pratik fark budur; interface ile type sayfası onları yan yana karşılaştırıyor.

Uyumlu Örtüşmeler Özelliği Daraltır

İki özellik tipi örtüşüyorsa sonuç örtüşen kısımdır. Bu bir hata değil, işe yarar bir şeydir:

type Editable = { id: string | number; tags: string[] };
type Stored = { id: string; createdAt: string };

type Doc = Editable & Stored; // id: (string | number) & string, which is string

const doc: Doc = { id: "d1", tags: ["draft"], createdAt: "2024-03-15" };
console.log(doc.id.toUpperCase()); // D1: id is a string, so string methods are allowed

type Letters = "a" | "b" | "c";
type Later = "b" | "c" | "d";
type Both = Letters & Later; // "b" | "c": what the two unions have in common

const shared: Both[] = ["b", "c"];
console.log(shared); // [ 'b', 'c' ]

İkinci yarı & işaretinin union'lara ne yaptığını gösteriyor: iki tarafın ortak üyelerini tutar. Tipleri değer kümeleri olarak düşünmek bunu öngörülebilir kılar. A | B iki kümenin birleşimi, A & B kesişimleridir; içinde hiçbir şey olmayan bir kesişim de never olur.

Intersection ile Union

Adlar küme teorisinden gelir ve nesne özelliklerine uygulandığında ters görünür:

Nesne tiplerinin bir intersection'ı, tam da daha az değere izin verdiği için daha fazla özelliğe sahiptir: yalnızca her şeye sahip nesneler.

Intersection ile extends

Birkaç nesne type alias'ını birleştirmek için & alışılmış ve uygundur. Pek çok parçadan oluşturulan bir tip ya da public bir API tipi için extends daha erken hatalar ve daha ucuz tip kontrolleri sağlar.

Primitive'lerle Intersection'lar: Branding

Bir primitive'i bir nesne tipiyle kesiştirmek never üretmez: string & { readonly __brand: "UserId" }, fazladan ve yalnızca derleme zamanına ait bir işaret taşıyan bir string'dir. Hiçbir gerçek string o özelliğe sahip değildir ve asıl amaç da budur: yalnızca brand'i bilerek assert eden kod bir tane oluşturabilir; böylece düz bir string ya da bir OrderId artık UserId beklenen yere verilemez. Bu tekniğin kendi sayfası var: branded tipler.