Learn Rust Coding · Pelajaran

map, filter, collect

Mengubah urutan

Pelajaran 2 dari 413 langkah

map, filter, collect adalah pelajaran Learn Rust Coding gratis di CoddyKit. Ini adalah pelajaran 2 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.

Mentransformasi Urutan

Tiga metode melakukan sebagian besar pekerjaan dalam alur iterator: map mentransformasi setiap item, filter mempertahankan sebagian item, dan collect mengumpulkan hasil ke dalam koleksi.

Ketiganya menggantikan banyak perulangan manual dengan rangkaian singkat yang mudah dibaca.

map: Satu Masuk, Satu Keluar

map menerapkan closure ke setiap item dan menghasilkan nilai yang telah ditransformasi. Jumlah item tetap sama; hanya nilainya yang berubah.

map bersifat malas, sehingga closure hanya dijalankan saat iterator dikonsumsi.

fn main() {
    let nums = vec![1, 2, 3];
    let doubled: Vec<i32> = nums.iter().map(|x| x * 2).collect();
    println!("{:?}", doubled);
}

map Dapat Mengubah Tipe

Tipe keluaran map tidak harus sama dengan masukan. Di sini, kita mengubah angka menjadi string.

Dengan demikian, map sangat cocok untuk mengubah data dari satu bentuk ke bentuk lain.

fn main() {
    let nums = vec![1, 2, 3];
    let labels: Vec<String> = nums.iter().map(|x| format!("n{}", x)).collect();
    println!("{:?}", labels);
}

filter: Pertahankan yang Diinginkan

filter menerima closure yang mengembalikan bool. Item yang menghasilkan true akan dipertahankan; sisanya dibuang.

Closure menerima referensi, jadi Anda sering perlu melakukan dereferensi dengan * atau menggunakan pencocokan pola.

fn main() {
    let nums = vec![1, 2, 3, 4, 5, 6];
    let evens: Vec<i32> = nums.into_iter().filter(|x| x % 2 == 0).collect();
    println!("{:?}", evens);
}

Merangkai map dan filter

Anda dapat merangkai adaptor dengan bebas. Urutannya penting: setiap item mengalir melalui rangkaian dari atas ke bawah.

Di sini, kita mempertahankan angka genap, lalu menguadratkan hasilnya.

fn main() {
    let result: Vec<i32> = (1..=6)
        .filter(|x| x % 2 == 0)
        .map(|x| x * x)
        .collect();
    println!("{:?}", result);
}

collect Menjadi Vec

collect mengonsumsi iterator dan membangun koleksi. Karena ada banyak kemungkinan tipe koleksi, Anda biasanya memberi anotasi pada tipe target.

Sintaks turbofish collect::<Vec<_>>() merupakan alternatif untuk memberi anotasi pada variabel.

fn main() {
    let squares = (1..=4).map(|x| x * x).collect::<Vec<i32>>();
    println!("{:?}", squares);
}

collect Menjadi String

collect tidak terbatas pada vektor. Iterator berisi char dapat dikumpulkan menjadi String.

Rust menggunakan tipe target untuk menentukan cara menyusun item-item tersebut.

fn main() {
    let shouted: String = "hello".chars().map(|c| c.to_ascii_uppercase()).collect();
    println!("{}", shouted);
}

collect Menjadi HashMap

Iterator berisi tuple kunci-nilai dapat dikumpulkan menjadi HashMap. Pasangkan item dengan zip atau buat tuple di dalam map.

Ini merupakan cara yang rapi untuk membuat pencarian dari dua urutan paralel.

use std::collections::HashMap;

fn main() {
    let map: HashMap<i32, i32> = (1..=3).map(|x| (x, x * x)).collect();
    println!("{:?}", map.get(&2));
}

Menggabungkan Ketiganya

Alur yang umum dibaca seperti sebuah kalimat: ambil item, saring, transformasikan, lalu kumpulkan.

Di sini, kita mempertahankan kata yang memiliki lebih dari tiga huruf dan mengubahnya menjadi huruf kapital.

fn main() {
    let words = vec!["hi", "rust", "go", "code"];
    let kept: Vec<String> = words
        .into_iter()
        .filter(|w| w.len() > 3)
        .map(|w| w.to_uppercase())
        .collect();
    println!("{:?}", kept);
}

filter_map: Menyaring dan Mentransformasi Sekaligus

filter_map menerapkan closure yang mengembalikan Option. Some(v) dipertahankan dan dibuka nilainya; None dibuang.

Fitur ini sangat berguna saat melakukan penguraian, ketika sebagian input mungkin tidak valid.

fn main() {
    let inputs = vec!["1", "two", "3"];
    let nums: Vec<i32> = inputs
        .into_iter()
        .filter_map(|s| s.parse::<i32>().ok())
        .collect();
    println!("{:?}", nums);
}

Mengapa Pola Ini Unggul

Alur map/filter/collect bersifat deklaratif: alur ini menyatakan apa yang Anda inginkan, bukan bagaimana cara melakukan perulangan. Alur ini menghindari kesalahan batas indeks dan keadaan yang dapat berubah di tengah proses.

Selain itu, berkat evaluasi malas, tidak ada vektor sementara yang dibuat di antara langkah-langkah tersebut.

Pemeriksaan Singkat

Periksa pemahaman Anda tentang transformasi urutan.

Jawab di pelajaran interaktif

Ringkasan

Sekarang Anda dapat membangun alur iterator yang nyata:

map mentransformasi setiap item dan dapat mengubah tipenya
filter mempertahankan item yang predikatnya bernilai true
collect mengumpulkan hasil menjadi Vec, String, HashMap, dan lainnya
filter_map menyaring dan mentransformasi dalam satu langkah menggunakan Option

Gratis untuk memulai

Belajar Rust dengan tutor AI — gratis

Tulis dan jalankan kode asli di browser kamu, dapatkan bantuan instan dari tutor AI 24/7, dan lanjutkan di mana kamu tinggalkan di web atau aplikasi.

Kursus: 39
Pelajaran: 144

Mulai belajar gratis Lihat kursus lengkapnya

Pertanyaan yang Sering Diajukan

Apakah pelajaran “map, filter, collect” gratis?

Ya — teks lengkap “map, filter, collect” 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 “map, filter, collect”?

Mengubah urutan 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 2 dari 4.

Berapa lama pelajaran “map, filter, collect” 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