Learn Rust Coding · Pelajaran

Trait Iterator

next dan evaluasi malas

Trait Iterator adalah pelajaran Learn Rust Coding gratis di CoddyKit. Ini adalah pelajaran 1 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Learn Rust Coding, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Learn Rust Coding mencakup 4 pelajaran total.

Apa Itu Iterator?

Iterator adalah apa pun yang menghasilkan urutan nilai, satu per satu. Di Rust, iterator adalah cara idiomatis untuk memproses koleksi seperti vektor, rentang, dan irisan.

Seluruh konsep ini dibangun di atas satu sifat: Iterator. Setelah suatu tipe mengimplementasikannya, Anda mendapatkan puluhan metode yang berguna secara otomatis.

Sifat Iterator

Sifat Iterator memiliki satu metode wajib, next, dan satu tipe terkait, Item:

type Item — jenis nilai yang dihasilkan
fn next(&mut self) -> Option<Self::Item> — mengembalikan nilai berikutnya

Metode ini mengembalikan Some(value) selama masih ada nilai, lalu None saat selesai.

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 Mengembalikan Option

Setiap pemanggilan next memajukan iterator dan memberikan Option. Some membungkus nilai nyata; None menandakan akhir.

Perhatikan bahwa next menerima &mut self — pemanggilannya mengubah keadaan internal sehingga pemanggilan berikutnya mengembalikan nilai yang berbeda.

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

Iterator Bersifat Malas

Membuat iterator dengan sendirinya tidak melakukan apa-apa. Tidak ada nilai yang dihitung sampai ada sesuatu yang memintanya. Hal ini disebut kemalasan.

Pada contoh berikutnya, closure map tidak pernah dijalankan karena iterator tidak pernah dikonsumsi.

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");
}

Konsumsi Memicu Pekerjaan

Untuk benar-benar menjalankan iterator malas, Anda harus mengonsumsinya. Perulangan for adalah konsumen paling sederhana: perulangan ini memanggil next berulang kali hingga mendapatkan None.

Sekarang closure map yang sama dijalankan untuk setiap elemen.

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

Tiga Cara Melakukan Iterasi

Koleksi menyediakan tiga metode yang menghasilkan iterator:

iter() — menghasilkan &T (meminjam)
iter_mut() — menghasilkan &mut T (meminjam secara mutable)
into_iter() — menghasilkan T (mengambil kepemilikan)

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

Perulangan for Menggunakan into_iter

Saat Anda langsung menulis for x in collection, Rust memanggil into_iter(), yang mengonsumsi koleksi.

Setelah perulangan ini, Anda tidak dapat menggunakan v lagi karena nilainya telah dipindahkan ke iterator.

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

Rentang adalah Iterator

Rentang seperti 0..5 sendiri merupakan iterator yang menghasilkan 0, 1, 2, 3, 4. Nilai akhirnya bersifat eksklusif. Gunakan 0..=5 untuk rentang inklusif.

Rentang sangat cocok untuk perulangan penghitungan tanpa perlu melacak indeks secara manual.

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

count: Konsumen Sederhana

count mengonsumsi seluruh iterator dan mengembalikan jumlah item yang dihasilkannya. Ini adalah salah satu dari banyak adaptor pengonsumsi.

Karena iterator dikonsumsi, Anda tidak dapat menggunakannya kembali setelahnya.

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

sum: Menggabungkan Menjadi Satu Nilai

sum menjumlahkan semua item dan mengembalikan satu nilai. Anda biasanya memberi anotasi pada tipe target agar Rust mengetahui hasil yang harus dibuat.

Ini lebih ringkas dan lebih jelas daripada perulangan akumulator manual.

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

Mengapa Iterator Penting

Iterator memberi Anda kemudahan untuk digabungkan: rangkai operasi-operasi kecil menjadi alur yang jelas. Iterator juga tanpa biaya tambahan — kompilator mengoptimalkannya agar secepat perulangan yang ditulis secara manual.

Menguasai next, evaluasi malas, dan konsumsi merupakan dasar untuk semua materi berikutnya.

Pemeriksaan Singkat

Uji pemahaman Anda tentang sifat Iterator.

Ringkasan

Anda telah mempelajari dasar-dasar iterator Rust:

Sifat Iterator hanya memerlukan next dan tipe Item
next mengembalikan Some(value), lalu None
Iterator bersifat malas — iterator tidak melakukan apa pun sampai dikonsumsi
iter, iter_mut, dan into_iter mengatur peminjaman dan kepemilikan
Konsumen seperti for, count, dan sum menjalankan prosesnya

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Trait Iterator” gratis?

Ya — teks lengkap “Trait Iterator” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Learn Rust Coding, upgrade ke CoddyKit PRO. Kursus Learn Rust Coding mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Trait Iterator”?

next dan evaluasi malas Kamu berlatih Learn Rust Coding dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Learn Rust Coding?

Tidak diperlukan pengalaman sebelumnya. Learn Rust Coding di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 1 dari 4.

Berapa lama pelajaran “Trait Iterator” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Learn Rust Coding ini?

Ya. Setiap pelajaran Learn Rust Coding menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke Learn Rust Coding