Learn Rust Coding · Pelajaran

Adaptor dan Konsumen

Merangkai operasi

Adaptor dan Konsumen adalah pelajaran Learn Rust Coding gratis di CoddyKit. Ini adalah pelajaran 3 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.

Dua Jenis Metode

Metode iterator terbagi menjadi dua kelompok:

Adaptor mengembalikan iterator baru dan bersifat malas (map, filter, take)
Konsumen menjalankan iterator dan menghasilkan nilai akhir (sum, collect, for_each)

Setiap alur terdiri dari nol atau lebih adaptor, lalu diakhiri tepat dengan satu konsumen.

take: Membatasi Jumlah

take(n) menghasilkan paling banyak n item, lalu berhenti. Karena merupakan adaptor, fitur ini tetap bersifat malas.

Fitur ini juga dapat digunakan pada iterator tak terbatas, dengan hanya mengambil sebanyak yang Anda minta.

fn main() {
    let first_three: Vec<i32> = (1..).take(3).collect();
    println!("{:?}", first_three);
}

skip: Mengabaikan Item Pertama

skip(n) membuang n item pertama dan menghasilkan sisanya. Gabungkan dengan take untuk mengambil bagian dari tengah urutan.

fn main() {
    let window: Vec<i32> = (1..=10).skip(3).take(4).collect();
    println!("{:?}", window);
}

enumerate: Memasangkan dengan Indeks

enumerate menghasilkan tuple (index, value), dengan penghitungan dimulai dari nol. Ini merupakan cara idiomatis untuk mendapatkan posisi tanpa penghitung manual.

fn main() {
    let letters = vec!['a', 'b', 'c'];
    for (i, c) in letters.iter().enumerate() {
        println!("{} -> {}", i, c);
    }
}

zip: Menelusuri Dua Iterator Bersama-sama

zip memasangkan item dari dua iterator. Proses ini berhenti saat iterator yang lebih pendek kehabisan item.

Fitur ini berguna untuk menggabungkan data paralel seperti nama dan nilai.

fn main() {
    let names = vec!["Ana", "Ben"];
    let ages = vec![30, 25];
    for (name, age) in names.iter().zip(ages.iter()) {
        println!("{} is {}", name, age);
    }
}

rev: Membalik Urutan

rev menghasilkan item dari belakang ke depan. Fitur ini memerlukan iterator dua arah, yang disediakan oleh rentang dan irisan.

fn main() {
    let backwards: Vec<i32> = (1..=5).rev().collect();
    println!("{:?}", backwards);
}

chain: Menggabungkan Dua Iterator

chain menjalankan iterator pertama sampai selesai, lalu melanjutkan dengan iterator kedua, seolah-olah keduanya merupakan satu urutan.

fn main() {
    let joined: Vec<i32> = (1..=3).chain(10..=12).collect();
    println!("{:?}", joined);
}

fold: Membangun Satu Nilai

fold merupakan konsumen umum. Fitur ini dimulai dengan akumulator, lalu memasukkan setiap item ke dalamnya menggunakan closure.

Banyak konsumen seperti sum merupakan kasus khusus dari fold.

fn main() {
    let product = (1..=5).fold(1, |acc, x| acc * x);
    println!("5! = {}", product);
}

any dan all: Konsumen Boolean

any mengembalikan true jika setidaknya satu item memenuhi predikat; all mengembalikan true hanya jika semua item memenuhinya.

Keduanya berhenti lebih awal: proses berhenti segera setelah jawabannya diketahui.

fn main() {
    let nums = vec![2, 4, 6, 7];
    println!("{}", nums.iter().all(|x| x % 2 == 0));
    println!("{}", nums.iter().any(|x| x % 2 != 0));
}

find dan position

find mengembalikan item pertama yang cocok dengan predikat sebagai Option. Sebaliknya, position mengembalikan indeks kecocokan pertama.

Keduanya berhenti lebih awal setelah menemukan kecocokan pertama.

fn main() {
    let nums = vec![1, 3, 5, 8, 9];
    println!("{:?}", nums.iter().find(|&&x| x % 2 == 0));
    println!("{:?}", nums.iter().position(|&x| x % 2 == 0));
}

Merancang Alur

Bangun alur dengan menumpuk adaptor, lalu mengakhirinya dengan satu konsumen. Jaga agar tetap mudah dibaca: satu operasi per baris.

Karena adaptor bersifat malas, rantai yang panjang sekalipun hanya melakukan satu kali penelusuran data.

Pemeriksaan Singkat

Adaptor dan konsumen.

Ringkasan

Anda telah mempelajari cara merangkai operasi:

Adaptor (take, skip, enumerate, zip, rev, chain) tetap bersifat malas
Konsumen (fold, any, all, find, position) menyelesaikan proses
Konsumen Boolean dan pencarian berhenti lebih awal
Setiap alur terdiri dari adaptor, lalu satu konsumen

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Adaptor dan Konsumen” gratis?

Ya — teks lengkap “Adaptor dan Konsumen” 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 “Adaptor dan Konsumen”?

Merangkai operasi 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 3 dari 4.

Berapa lama pelajaran “Adaptor dan Konsumen” 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