Learn Rust Coding · Ders

Iterator Özelliği

next ve tembellik

Iterator Özelliği, CoddyKit'te ücretsiz bir Learn Rust Coding dersidir. Bu, 4 dersinin 1. 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.

Yineleyici Nedir?

Yineleyici, bir değerler dizisini tek seferde bir değer üreterek sağlayan her şeydir. Rust'ta yineleyiciler; vektörler, aralıklar ve dilimler gibi koleksiyonları işlemenin deyimsel yoludur.

Tüm kavram tek bir özellik üzerine kuruludur: Iterator. Bir tür bu özelliği uyguladığında, onlarca kullanışlı yöntemi ek bir işlem yapmadan elde edersiniz.

Iterator Özelliği

Iterator özelliğinde bir zorunlu yöntem olan next ve ilişkili bir tür olan Item bulunur:

type Item — üretilen değerin türü
fn next(&mut self) -> Option<Self::Item> — sonraki değeri döndürür

Değerler kaldığı sürece Some(value), işlem tamamlandığında ise None döndürür.

fn main() {
    let v = vec![10, 20, 30];
    let mut it = v.iter();
    println!("{:?}", it.next());
    println!("{:?}", it.next());
    println!("{:?}", it.next());
    println!("{:?}", it.next());
}

next, Option Döndürür

next çağrılarının her biri yineleyiciyi ilerletir ve size bir Option verir. Some gerçek bir değeri sarar; None ise sona ulaşıldığını belirtir.

next yönteminin &mut self aldığını fark edin: Bu yöntemi çağırmak iç durumu değiştirir; böylece sonraki çağrı farklı bir değer döndürür.

fn main() {
    let mut it = (1..4).into_iter();
    while let Some(n) = it.next() {
        println!("got {}", n);
    }
    println!("done");
}

Yineleyiciler Tembeldir

Bir yineleyici oluşturmak kendi başına hiçbir şey yapmaz. Bir şey onları isteyene kadar hiçbir değer hesaplanmaz. Buna tembellik denir.

Sonraki örnekte map kapanışı hiç çalışmaz; çünkü yineleyiciyi hiç tüketmeyiz.

fn main() {
    let nums = vec![1, 2, 3];
    let _doubled = nums.iter().map(|x| {
        println!("mapping {}", x);
        x * 2
    });
    println!("nothing printed above this line");
}

Tüketim İşlemi Başlatır

Tembel bir yineleyicinin gerçekten çalışmasını sağlamak için onu tüketmeniz gerekir. Bir for döngüsü en basit tüketicidir: None döndürülene kadar next yöntemini tekrar tekrar çağırır.

Artık aynı map kapanışı her öğe için çalışır.

fn main() {
    let nums = vec![1, 2, 3];
    for x in nums.iter().map(|x| x * 2) {
        println!("value {}", x);
    }
}

Yineleme Yapmanın Üç Yolu

Koleksiyonlar, yineleyici üreten üç yöntem sunar:

iter() — &T üretir (ödünç alır)
iter_mut() — &mut T üretir (değiştirilebilir olarak ödünç alır)
into_iter() — T üretir (sahipliği alır)

fn main() {
    let mut v = vec![1, 2, 3];
    for x in v.iter_mut() {
        *x += 10;
    }
    println!("{:?}", v);
}

for Döngüleri into_iter Kullanır

for x in collection ifadesini doğrudan yazdığınızda Rust, koleksiyonu tüketen into_iter() yöntemini çağırır.

Bu döngüden sonra v değişkenini yeniden kullanamazsınız; çünkü v yineleyiciye taşınmıştır.

fn main() {
    let v = vec![String::from("a"), String::from("b")];
    for s in v {
        println!("{}", s);
    }
    // v is no longer usable here
}

Aralıklar Yineleyicidir

0..5 gibi bir aralık, 0, 1, 2, 3, 4 üreten bir yineleyicinin kendisidir. Son değer aralığa dâhil değildir. Her iki sınırın da dâhil olduğu bir aralık için 0..=5 kullanın.

Aralıklar, dizinleri elle izlemeye gerek kalmadan sayma döngüleri oluşturmak için idealdir.

fn main() {
    for i in 0..5 {
        print!("{} ", i);
    }
    println!();
    for i in 1..=3 {
        print!("{} ", i);
    }
    println!();
}

count: Basit Bir Tüketici

count, yineleyicinin tamamını tüketir ve ürettiği öğe sayısını döndürür. Bu, birçok tüketici bağdaştırıcısından biridir.

Yineleyiciyi tükettiği için daha sonra yeniden kullanamazsınız.

fn main() {
    let total = (1..=100).count();
    println!("there are {} numbers", total);
}

sum: Tek Bir Değerde Birleştirme

sum, tüm öğeleri birbirine ekler ve tek bir değer döndürür. Rust'ın ne üreteceğini bilmesi için hedef türü çoğu zaman belirtirsiniz.

Bu yöntem, elle yazılmış bir biriktirici döngüsünden daha kısa ve anlaşılırdır.

fn main() {
    let total: i32 = (1..=5).sum();
    println!("sum is {}", total);
}

Yineleyiciler Neden Önemlidir?

Yineleyiciler size birleştirilebilirlik sağlar: Küçük işlemleri anlaşılır işlem hatları hâlinde zincirleyebilirsiniz. Ayrıca sıfır maliyetlidir; derleyici bunları elle yazılmış döngüler kadar hızlı olacak şekilde eniyiler.

next, tembellik ve tüketim kavramlarında ustalaşmak, bundan sonra öğreneceğiniz her şeyin temelidir.

Hızlı Kontrol

Iterator özelliğini anlayıp anlamadığınızı sınayın.

Özet

Rust yineleyicilerinin temelini öğrendiniz:

Iterator özelliğinin yalnızca next yöntemine ve bir Item türüne ihtiyacı vardır
next, önce Some(value), ardından None döndürür
Yineleyiciler tembeldir — tüketilene kadar hiçbir şey yapmazlar
iter, iter_mut ve into_iter, ödünç alma ile sahiplik arasındaki seçimi belirler
for, count ve sum gibi tüketiciler işi yürütür

Sıkça Sorulan Sorular

“Iterator Özelliği” dersi ücretsiz mi?

Evet — “Iterator Özelliği” 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.

“Iterator Özelliği” dersinde ne öğreneceğim?

next ve tembellik 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 1. dersidir.

“Iterator Özelliği” 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