TypeScript Academy · Ders

Tür Düzeyi Özyineleme

Özyinelemeli koşullu türleri kullanarak türler üzerinde döngü kurun.

Tür Düzeyi Özyineleme, CoddyKit'te ücretsiz bir TypeScript Academy dersidir. Bu, 4 dersinin 3. 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ürlerde Özyineleme

Koşullu bir tür kendisine başvurabilir. Bu, tür diline döngüler kazandırır. Tür düzeyindeki özyinelemelerin çoğu, bir demeti her seferinde bir öğe ilerleyerek işler; başı ayırır ve kuyruk üzerinde özyinelemeye devam eder.

type Length<T extends unknown[]> =
  T extends [unknown, ...infer Rest]
    ? Length<Rest>
    : 0;
// (this counts down to a base case)

Temel Durum

Her özyinelemenin bir durma koşuluna ihtiyacı vardır. Demetlerde bu genellikle boş demettir. [head, ...rest] kalıbı artık eşleşmediğinde sona ulaşmış olursunuz ve sabit bir sonuç döndürürsünüz.

type IsEmpty<T extends unknown[]> =
  T extends [] ? true : false;

type A = IsEmpty<[]>;     // true
type B = IsEmpty<[1, 2]>; // false

Baş ve Kuyruk

Temel işlem, yayma kalıbıyla birlikte infer kullanarak bir demeti ilk öğesine ve kalan demete ayırmaktır.

type Head<T extends unknown[]> = T extends [infer H, ...unknown[]] ? H : never;
type Tail<T extends unknown[]> = T extends [unknown, ...infer R] ? R : [];

type A = Head<[1, 2, 3]>; // 1
type B = Tail<[1, 2, 3]>; // [2, 3]

Öğeleri Tek Tek İşleme

Bir demetin tamamını dönüştürmek için başı, kuyruğu ve özyinelemeyi birleştirin. ToStrings, her öğe türünü string ile değiştirerek demeti yeniden oluşturur.

type ToStrings<T extends unknown[]> =
  T extends [infer H, ...infer R]
    ? [string, ...ToStrings<R>]
    : [];

type A = ToStrings<[1, true, 3]>; // [string, string, string]

Biriktirici Kalıbı

Çoğu zaman biriktirici adı verilen ek bir parametrede sonuç oluşturursunuz. Biriktirici boş başlar ve her adımda büyür. Bu yöntem, yapının üzerinden yeniden geçmeyi önler ve tür düzeyindeki döngüler için standart tekniktir.

type Reverse<T extends unknown[], Acc extends unknown[] = []> =
  T extends [infer H, ...infer R]
    ? Reverse<R, [H, ...Acc]>
    : Acc;

type A = Reverse<[1, 2, 3]>; // [3, 2, 1]

Biriktiricide İlerleme

Reverse<[1,2,3]> ifadesini izleyin:

Adım 1: H=1, Acc [1] olur
Adım 2: H=2, Acc [2,1] olur
Adım 3: H=3, Acc [3,2,1] olur
Demet boşalır, Acc = [3,2,1] döndürülür

Biriktirici, her özyinelemeli çağrıda yanıtı taşır.

type R = Reverse<["a", "b"]>; // ["b", "a"]

Birleşimler Üzerinde Özyineleme

Dizelerden oluşan bir birleşimi birleştirmek için de özyineleme kullanabilirsiniz. Burada demet öğelerini, bir ayraçla ayrılmış tek bir dize değişmez türünde birleştiriyoruz.

Gösterim: Gerçek TypeScript, şablon değişmez türlerini dolar-süslü parantez yer tutucuları içeren ve ters tırnaklarla sınırlandırılmış dizelerle yazar. Bu kod parçalarında bu kalıbı, her bölümü sırasıyla listeleyen Tpl<...> biçiminde gösteriyoruz; örneğin değişmez önekle eşleşen ve ardından Rest gelen bir ters tırnak şablonu Tpl<'prefix', infer Rest> olarak gösterilir.

type Join<T extends string[], Sep extends string = ','> =
  T extends [infer H extends string, ...infer R extends string[]]
    ? R extends []
      ? H
      : Tpl<H, Sep, Join<R, Sep>>
    : '';
// Tpl<H, Sep, ...> builds a template literal type joining the parts

type A = Join<['a', 'b', 'c']>; // 'a,b,c'

Özyinelemeyle Sayma

Özyineleme ile biriktirici birlikte sayma işlemi yapabilir. Girdiyle aynı uzunlukta bir unknown demeti oluşturun, ardından bu demetin length değerini okuyun. Aritmetik kursunda bunu sıkça kullanacaksınız.

type Count<T extends unknown[], Acc extends unknown[] = []> =
  T extends [unknown, ...infer R]
    ? Count<R, [unknown, ...Acc]>
    : Acc["length"];

type A = Count<["x", "y", "z"]>; // 3

Özyinelemeyle Filtreleme

Bir demeti dolaşın ve yalnızca koşulla eşleşen öğeleri tutarak diğerlerini atın. Bir öğeyi biriktiriciye eklemeyerek onu atlayın.

type KeepStrings<T extends unknown[], Acc extends unknown[] = []> =
  T extends [infer H, ...infer R]
    ? H extends string
      ? KeepStrings<R, [...Acc, H]>
      : KeepStrings<R, Acc>
    : Acc;

type A = KeepStrings<[1, "a", 2, "b"]>; // ["a", "b"]

Özyineleme Derinliği Sınırları

Derleyici özyineleme derinliğini sınırlar (geçmişte bu sınır yaklaşık 50 idi; kuyruk özyineleme iyileştirmeleri bazı kalıplarda daha derine izin verir). Çok büyük demetlerde Tür örneği oluşturma aşırı derecede derin hatasıyla karşılaşabilirsiniz. Sınırı yükseltmek için biriktirici (kuyruk) tarzını kullanın.

type Repeat<T, N extends number, Acc extends T[] = []> =
  Acc["length"] extends N ? Acc : Repeat<T, N, [...Acc, T]>;

type A = Repeat<0, 3>; // [0, 0, 0]

Hepsini Bir Araya Getirme

Baş/kuyruk ayırma, temel durum ve biriktirici, neredeyse her tür düzeyi döngüsünün üç bileşenidir. Bunlarla demetleri tamamen tür sistemi içinde eşleyebilir, filtreleyebilir, ters çevirebilir, sayabilir ve birleştirebilirsiniz.

type MapToPairs<T extends unknown[], Acc extends unknown[] = []> =
  T extends [infer H, ...infer R]
    ? MapToPairs<R, [...Acc, [H, H]]>
    : Acc;

type A = MapToPairs<[1, 2]>; // [[1, 1], [2, 2]]

Kısa Değerlendirme

Biriktirici kalıbını ne kadar anladığınızı sınayın.

Özet

Artık tür düzeyinde döngüler yazabilirsiniz.

Kendisine başvuran koşullu ifadeler özyineleme oluşturur.
Demetleri [H, ...R] biçiminde ayırın ve kuyruk üzerinde özyinelemeye devam edin.
Temel durum (boş demet) döngüyü durdurur.
Bir biriktirici sonucu oluşturur ve derin özyinelemeyi mümkün kılar.

Sırada koşullu ifadelerin birleşimler üzerinde nasıl özel davrandığı var.

Sıkça Sorulan Sorular

“Tür Düzeyi Özyineleme” dersi ücretsiz mi?

Evet — “Tür Düzeyi Özyineleme” 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 Özyineleme” dersinde ne öğreneceğim?

Özyinelemeli koşullu türleri kullanarak türler üzerinde döngü kurun. 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 3. dersidir.

“Tür Düzeyi Özyineleme” 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