Learn Rust Coding · Pelajaran

Iterator Kustom

Mengimplementasikan Iterator

Iterator Kustom adalah pelajaran Learn Rust Coding gratis di CoddyKit. Ini adalah pelajaran 4 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.

Buat Iterator Anda Sendiri

Anda tidak terbatas pada iterator bawaan. Dengan mengimplementasikan sifat Iterator pada tipe Anda sendiri, tipe tersebut langsung mendapatkan semua adaptor dan konsumen.

Yang perlu Anda sediakan hanyalah tipe Item dan metode next.

Struct Counter

Mulailah dengan struct yang menyimpan keadaan iterator. Counter sederhana hanya memerlukan nilai saat ini.

struct Counter {
    count: u32,
}

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

Mengimplementasikan next

Implementasikan Iterator untuk struct tersebut. Tetapkan type Item, lalu tulis next untuk memajukan keadaan dan mengembalikan Some sampai kondisi berhenti tercapai, kemudian None.

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

Menggunakannya dalam Perulangan for

Setelah next tersedia, tipe Anda dapat digunakan dalam perulangan for seperti iterator standar lainnya.

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!();
}

Adaptor dan Konsumen Gratis

Karena Anda mengimplementasikan satu metode, seluruh perlengkapan iterator kini dapat digunakan. Di sini, kita menjumlahkan kuadrat dari nilai counter yang dipasangkan.

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

Metode Konstruktor

Tambahkan fungsi new agar pengguna tidak perlu mengakses bidang internal secara langsung. Cara ini lebih rapi dan memungkinkan Anda menjaga bidang tersebut tetap privat.

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

Iterator Fibonacci

Iterator dapat menyimpan keadaan yang lebih kompleks. Generator Fibonacci menyimpan dua nilai terakhir dan memperbaruinya pada setiap pemanggilan next.

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

Iterator Tak Terbatas Tidak Masalah

Iterator Fibonacci tidak pernah mengembalikan None — iterator ini tidak terbatas. Hal itu aman karena evaluasi malas berarti nilai hanya dihasilkan saat diminta. Gunakan take untuk membatasinya.

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

Melakukan Iterasi pada Tipe Pembungkus

Sering kali Anda mengimplementasikan Iterator pada struct helper yang meminjam data Anda. Di sini, stepper menghasilkan setiap angka kedua dari rentang yang tersimpan di dalamnya.

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

Mengapa Membuat Iterator Kustom?

Iterator kustom memungkinkan Anda mengalirkan nilai tanpa mengalokasikan koleksi lengkap, memodelkan urutan tak terbatas atau hasil perhitungan, serta memberikan antarmuka yang familier dan mudah digabungkan kepada pemanggil.

Satu metode next yang kecil membuka seluruh ekosistem.

Kiat Perancangan

Jaga agar keadaan tetap minimal, kembalikan None tepat satu kali di akhir (atau jangan pernah mengembalikannya untuk iterator tak terbatas), dan hindari pekerjaan berat di dalam next agar evaluasi malas tetap ringan.

Pemeriksaan Singkat

Mengimplementasikan sifat Iterator.

Ringkasan

Anda telah membuat iterator kustom:

Simpan keadaan dalam struct, lalu gunakan impl Iterator
Tentukan type Item dan tulis next
Anda langsung mendapatkan adaptor dan konsumen secara gratis
Iterator dapat terbatas atau tak terbatas; gunakan take untuk membatasi iterator tak terbatas

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Iterator Kustom” gratis?

Ya — teks lengkap “Iterator Kustom” 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 “Iterator Kustom”?

Mengimplementasikan Iterator 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 4 dari 4.

Berapa lama pelajaran “Iterator Kustom” 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