TypeScript Koşullu Türleri

TypeScript'teki koşullu tipler, bir koşula bağlı tipler oluşturmanın bir yolunu sağlar. Tip tanımlarında daha fazla esneklik ve ifade gücü sağlar ve karmaşık tip ilişkilerini açık ve öz bir şekilde modellemeyi mümkün kılar. Bu makale, koşullu tiplerin TypeScript'te nasıl çalıştığını inceler ve kullanımlarını göstermek için örnekler sunar.

Koşullu Tipler Nelerdir?

Koşullu tipler, bir koşula göre seçilen tiplerin oluşturulmasını sağlar. Programlamadaki koşullu ifadelere benzerler ancak tip düzeyinde çalışırlar. Koşullu bir tipin temel sözdizimi şudur:

type ConditionalType = T extends U ? X : Y;

Bu sözdiziminde:

• T kontrol edilen tiptir.
• Karşılaştırma yapılacak tip U'dir.
• X, T'nin U'yi genişletmesi durumunda döndürülen türdür.
• Y, T'nin U'yi genişletmemesi durumunda döndürülen türdür.

Koşullu Türlerin Temel Örneği

İşte verilen türün bir dize olup olmadığına bağlı olarak farklı türler döndüren koşullu bir türün basit bir örneği:

type IsString = T extends string ? "String" : "Not a string";

type Result1 = IsString;  // Result1 is "String"
type Result2 = IsString;  // Result2 is "Not a string"

Bu örnekte, IsString, T'nin string'yi genişletip genişletmediğini kontrol eder. Genişletiyorsa sonuç "String" olur; aksi takdirde "Not a string" olur.

Koşullu Türleri Genel Türlerle Kullanma

Koşullu tipler, daha esnek ve yeniden kullanılabilir tip tanımları oluşturmak için genel tiplerle de kullanılabilir. Örneğin, bir fonksiyonun dönüş tipini çıkaran bir tip:

type ReturnType = T extends (...args: any[]) => infer R ? R : never;

type FunctionType = (x: number) => string;

type Result = ReturnType;  // Result is string

Bu örnekte, ReturnType, T fonksiyon tipinin R dönüş tipini çıkarmak için infer anahtar sözcüğünü kullanır. T bir fonksiyon tipiyse, ReturnType dönüş tipi olacaktır; aksi takdirde, varsayılan olarak never olur.

Birleşim Türleriyle Koşullu Türler

Koşullu tipler, birden fazla olası tipi ele almak için birleşim tipleriyle de çalışabilir. Örneğin, farklı birleşim üyeleri arasında ayrım yapmak:

type ExtractString = T extends string ? T : never;

type UnionType = string | number | boolean;

type Result = ExtractString;  // Result is string

Bu örnekte, ExtractString komutu, UnionType birleşim türünden string öğesini çıkarır ve string sonucunu verir.

Tür Eşlemeleriyle Koşullu Türler

Koşullu tipler, daha karmaşık tip dönüşümleri oluşturmak için tip eşlemeleriyle birleştirilebilir. Örneğin, koşullu bir tip uygulamak için bir dizi tip üzerinde eşleme:

type MapArray = {
  [K in keyof T]: T[K] extends string ? T[K] : never;
};

type ArrayType = [string, number, boolean];

type MappedArray = MapArray;  // MappedArray is [string, never, never]

Bu örnekte, MapArray, T dizisinin her bir elemanına eşleme yapar ve her bir elemana koşullu bir tür uygular; bu da yalnızca dize elemanlarının korunduğu bir diziyle sonuçlanır.

Çözüm

TypeScript'teki koşullu tipler, esnek ve etkileyici tip tanımları oluşturmak için güçlü bir araçtır. Geliştiriciler, koşullu tiplerden yararlanarak karmaşık tip ilişkilerini modelleyebilir, çeşitli senaryoları ele alabilir ve TypeScript kodlarında tip güvenliğini iyileştirebilir. Koşullu tiplerin etkili bir şekilde nasıl kullanılacağını anlamak, sağlam ve sürdürülebilir TypeScript kodu yazma becerisini önemli ölçüde artırabilir.