TypeScript Academy · Ders

Tür Düzeyi Koşulluları

Koşullu tür ifadeleriyle türlere göre dallanın.

Tür Düzeyi Koşulluları, CoddyKit'te ücretsiz bir TypeScript Academy dersidir. Bu, 4 dersinin 2. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, TypeScript Academy öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. TypeScript Academy kursu toplamda 4 dersten oluşur.

Tür Düzeyindeki Koşul

Tür dili, koşullu türlerle dallanma kazanır. T extends U ? X : Y söz dizimi şöyle okunur: T, U'ya atanabiliyorsa sonuç X, aksi takdirde Y olur.

Bu, if / else ifadesinin tür düzeyindeki karşılığıdır.

type IsString<T> = T extends string ? "yes" : "no";

type A = IsString<string>; // "yes"
type B = IsString<number>; // "no"

extends Atanabilirlik Anlamına Gelir

Bu sınama eşitlik sınaması değildir. T extends U, T türündeki bir değer U beklenen bir yerde kullanılabiliyorsa doğrudur. Değişmez türler, temel türlerine atanabilir.

type T1 = "hello" extends string ? true : false; // true
type T2 = string extends "hello" ? true : false; // false
type T3 = 42 extends number ? true : false;       // true

Sonuç Türünü Seçme

Koşullar, tek bir jeneriğin girdiye bağlı olarak farklı yapılar döndürmesini sağlar. Burada Wrap, dizileri skaler değerlerden farklı biçimde sarmalar.

type Wrap<T> = T extends unknown[]
  ? { list: T }
  : { value: T };

type A = Wrap<number>;   // { value: number }
type B = Wrap<string[]>; // { list: string[] }

Değer Yok Türüne Filtreleme

Yaygın bir yöntem, dallardan birinde never döndürmektir. never, "hiçbir değer" anlamına gelir ve daha sonra birleşimlerden üyeleri kaldırmak için kullanışlıdır.

type OnlyStrings<T> = T extends string ? T : never;

type A = OnlyStrings<string>; // string
type B = OnlyStrings<number>; // never

infer ile Çıkarım

Asıl güç, infer anahtar sözcüğüyle ortaya çıkar. Koşullu bir ifade içinde infer, eşleşen türün bir bölümünü yakalayan yeni bir tür değişkeni tanımlar.

Burada bir dizinin öğe türünü yakalıyoruz.

type ElementType<T> = T extends (infer U)[] ? U : never;

type A = ElementType<number[]>; // number
type B = ElementType<string[]>; // string

İşlev Sonuçlarını Çıkarma

infer ifadesini kalıbın herhangi bir yerine yerleştirebilirsiniz. Bir işlevin dönüş türünü çıkarmak için okun sonrasındaki bölümü çıkarın. Yerleşik ReturnType bu şekilde çalışır.

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

type A = MyReturn<() => number>;      // number
type B = MyReturn<(x: string) => boolean>; // boolean

Birden Çok Parçayı Çıkarma

Tek bir koşullu ifade, aynı anda birkaç infer değişkeni tanımlayabilir. Burada bir demetin hem ilk öğesini hem de geri kalanını alıyoruz.

type FirstRest<T> = T extends [infer H, ...infer R]
  ? { head: H; rest: R }
  : never;

type A = FirstRest<[1, 2, 3]>;
// { head: 1; rest: [2, 3] }

İç İçe Koşullar

Koşullar, tıpkı birbirine zincirlenmiş else if ifadeleri gibi iç içe yerleştirilebilir. Bir koşullu ifadenin else dalı, kendisi de başka bir koşullu ifade olabilir ve bir karar merdiveni oluşturabilir.

type Describe<T> =
  T extends string ? "text" :
  T extends number ? "num" :
  T extends boolean ? "flag" :
  "other";

type A = Describe<number>; // "num"
type B = Describe<null>;   // "other"

Koşulları Koruyucu Olarak Kullanma

Bir yapıdan bilgi çıkarmadan önce yapıyı doğrulamak için koşullu ifade kullanın. Girdi eşleşmiyorsa, yanlış kullanımın görünür olması için never değerine geri dönün.

type GetName<T> = T extends { name: infer N } ? N : never;

type A = GetName<{ name: string }>; // string
type B = GetName<{ age: number }>;  // never

Koşulları Birleştirme

Koşulları iç içe yerleştirerek birden çok koşul gerektirebilirsiniz. Burada bir türün geçebilmesi için hem nesne olması hem de id özelliğine sahip olması gerekir.

type RequireId<T> =
  T extends object
    ? T extends { id: unknown } ? T : never
    : never;

type A = RequireId<{ id: 1; x: 2 }>; // { id: 1; x: 2 }
type B = RequireId<{ x: 2 }>;        // never

Koşullu Türler Her Yerde

Yerleşik yardımcı türlerin çoğu, temelinde koşullu türlerden oluşur: NonNullable, Extract, Exclude, Parameters ve ReturnType. extends ? : yapısını anlamak, bunların tümünü kullanmanın kapısını açar.

type MyNonNullable<T> = T extends null | undefined ? never : T;

type A = MyNonNullable<string | null>; // string

Kısa Değerlendirme

Koşullu türleri ve infer ifadesini ne kadar anladığınızı sınayın.

Özet

Koşullu türler, tür diline bir if/else yapısı ve kalıp eşleştirme özelliği kazandırır.

T extends U ? X : Y, atanabilirliğe göre dallanır.
infer, eşleşen bölümleri yeni değişkenlerde yakalar.
Koşullar, karar merdivenleri oluşturacak şekilde iç içe yerleştirilebilir.
never döndürmek üyeleri filtreler.

Sırada koşullu ifadeyi kendi içine besleyerek özyineleme oluşturmak var.

Sıkça Sorulan Sorular

“Tür Düzeyi Koşulluları” dersi ücretsiz mi?

Evet — “Tür Düzeyi Koşulluları” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve TypeScript Academy kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. TypeScript Academy kursu toplamda 4 dersten oluşur.

“Tür Düzeyi Koşulluları” dersinde ne öğreneceğim?

Koşullu tür ifadeleriyle türlere göre dallanın. TypeScript Academy ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

TypeScript Academy öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te TypeScript Academy, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 2. dersidir.

“Tür Düzeyi Koşulluları” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu TypeScript Academy dersinde kod yazıp çalıştırabilir miyim?

Evet. Her TypeScript Academy dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

← TypeScript Academy Sayfasına Dön