Learn Rust Coding · Ders

Özel Yineleyiciler

Iterator'ı uygulayın

Özel Yineleyiciler, CoddyKit'te ücretsiz bir Learn Rust Coding dersidir. Bu, 4 dersinin 4. 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, Learn Rust Coding öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Learn Rust Coding kursu toplamda 4 dersten oluşur.

Kendi Yineleyicinizi Oluşturun

Yerleşik yineleyicilerle sınırlı değilsiniz. Kendi türünüz üzerinde Iterator özelliğini uyguladığınızda, bu tür tüm bağdaştırıcıları ve tüketicileri ek bir işlem yapmadan kazanır.

Sağlamanız gereken tek şey Item türü ve bir next yöntemidir.

Bir Counter Yapısı

Yineleyicinin durumunu tutan bir yapıyla başlayın. Basit bir sayacın yalnızca geçerli bir değere ihtiyacı vardır.

struct Counter {
    count: u32,
}

fn main() {
    let c = Counter { count: 0 };
    println!("start at {}", c.count);
}

next Uygulaması

Yapı için Iterator özelliğini uygulayın. type Item değerini belirleyin; ardından durma koşuluna ulaşılana kadar durumu ilerletip Some, sonrasında ise None döndürecek şekilde next yöntemini yazın.

struct Counter { count: u32 }

impl Iterator for Counter {
    type Item = u32;
    fn next(&mut self) -> Option<u32> {
        if self.count < 5 {
            self.count += 1;
            Some(self.count)
        } else {
            None
        }
    }
}

fn main() {
    let mut c = Counter { count: 0 };
    println!("{:?}", c.next());
    println!("{:?}", c.next());
}

for Döngüsünde Kullanma

next mevcut olduğunda, türünüz diğer tüm standart yineleyiciler gibi bir for döngüsünde çalışır.

struct Counter { count: u32 }

impl Iterator for Counter {
    type Item = u32;
    fn next(&mut self) -> Option<u32> {
        if self.count < 5 { self.count += 1; Some(self.count) } else { None }
    }
}

fn main() {
    for n in (Counter { count: 0 }) {
        print!("{} ", n);
    }
    println!();
}

Ücretsiz Uyarlayıcılar ve Tüketiciler

Bir yöntem uyguladığınız için artık tüm yineleyici araçları kullanılabilir. Burada eşleştirilmiş sayaç değerlerinin karelerini topluyoruz.

struct Counter { count: u32 }

impl Iterator for Counter {
    type Item = u32;
    fn next(&mut self) -> Option<u32> {
        if self.count < 5 { self.count += 1; Some(self.count) } else { None }
    }
}

fn main() {
    let total: u32 = Counter { count: 0 }.map(|x| x * 2).sum();
    println!("{}", total);
}

Yapıcı Yöntemi

Kullanıcıların dahili alanlara doğrudan erişmemesi için bir new işlevi ekleyin. Bu, kodu daha temiz hâle getirir ve alanı gizli tutmanızı sağlar.

struct Counter { count: u32 }

impl Counter {
    fn new() -> Counter { Counter { count: 0 } }
}

impl Iterator for Counter {
    type Item = u32;
    fn next(&mut self) -> Option<u32> {
        if self.count < 3 { self.count += 1; Some(self.count) } else { None }
    }
}

fn main() {
    let v: Vec<u32> = Counter::new().collect();
    println!("{:?}", v);
}

Fibonacci Yineleyicisi

Yineleyiciler daha zengin bir durum taşıyabilir. Bir Fibonacci üreteci son iki değeri tutar ve her next çağrısında bunları günceller.

struct Fib { a: u64, b: u64 }

impl Iterator for Fib {
    type Item = u64;
    fn next(&mut self) -> Option<u64> {
        let current = self.a;
        self.a = self.b;
        self.b = current + self.b;
        Some(current)
    }
}

fn main() {
    let fib = Fib { a: 0, b: 1 };
    let seq: Vec<u64> = fib.take(8).collect();
    println!("{:?}", seq);
}

Sonsuz Yineleyiciler Sorun Değildir

Fibonacci yineleyicisi hiçbir zaman None döndürmez; sonsuzdur. Tembel değerlendirme değerlerin yalnızca gerektiğinde üretilmesini sağladığı için bu güvenlidir. Sınırlandırmak için take kullanın.

struct Fib { a: u64, b: u64 }

impl Iterator for Fib {
    type Item = u64;
    fn next(&mut self) -> Option<u64> {
        let c = self.a;
        self.a = self.b;
        self.b = c + self.b;
        Some(c)
    }
}

fn main() {
    let big = Fib { a: 0, b: 1 }.nth(20);
    println!("{:?}", big);
}

Bir Sarmalayıcı Tür Üzerinde Yineleme

Çoğu zaman Iterator uygulamasını verilerinize ödünç erişen bir yardımcı yapı üzerinde gerçekleştirirsiniz. Burada bir adımlayıcı, içinde saklanan aralıktaki her iki sayıdan birini üretir.

struct EvenUpTo { current: u32, max: u32 }

impl Iterator for EvenUpTo {
    type Item = u32;
    fn next(&mut self) -> Option<u32> {
        if self.current > self.max { return None; }
        let value = self.current;
        self.current += 2;
        Some(value)
    }
}

fn main() {
    let evens: Vec<u32> = (EvenUpTo { current: 0, max: 10 }).collect();
    println!("{:?}", evens);
}

Özel Yineleyiciler Neden Oluşturulur?

Özel yineleyiciler, tam bir koleksiyon ayırmadan değerleri akış hâlinde işlemenizi, sonsuz veya hesaplanan dizileri modellemenizi ve çağıranlara tanıdık, birleştirilebilir bir arayüz sunmanızı sağlar.

Tek bir küçük next yöntemi, tüm ekosistemin kullanılmasını sağlar.

Tasarım İpuçları

Durumunuzu olabildiğince küçük tutun, sonunda tam olarak bir kez None döndürün (sonsuz yineleyicilerde ise hiç döndürmeyin) ve tembelliğin düşük maliyetli kalması için next içinde ağır işlemlerden kaçının.

Hızlı Kontrol

Iterator özelliğini uygulama.

Özet

Özel yineleyiciler oluşturdunuz:

Durumu bir yapıda tutup ardından impl Iterator yazarsınız
type Item tanımlayıp next yazarsınız
Uyarlayıcıları ve tüketicileri hiçbir ek ücret ödemeden hemen elde edersiniz
Yineleyiciler sonlu veya sonsuz olabilir; sonsuz olanları sınırlandırmak için take kullanın

Sıkça Sorulan Sorular

“Özel Yineleyiciler” dersi ücretsiz mi?

Evet — “Özel Yineleyiciler” 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 Learn Rust Coding kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Learn Rust Coding kursu toplamda 4 dersten oluşur.

“Özel Yineleyiciler” dersinde ne öğreneceğim?

Iterator'ı uygulayın Learn Rust Coding 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.

Learn Rust Coding öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te Learn Rust Coding, 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 4. dersidir.

“Özel Yineleyiciler” 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 Learn Rust Coding dersinde kod yazıp çalıştırabilir miyim?

Evet. Her Learn Rust Coding 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

← Learn Rust Coding Sayfasına Dön