Belajar Pengaturcaraan Rust · Pelajaran

map, filter, collect

Mengubah jujukan

Pelajaran 2 daripada 413 langkah

map, filter, collect ialah pelajaran Belajar Pengaturcaraan Rust percuma di CoddyKit. Ini ialah pelajaran 2 daripada 4. Sebanyak 3 pelajaran dalam laluan pembelajaran ini boleh dibaca sepenuhnya secara percuma — selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan praktikal dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Belajar Pengaturcaraan Rust, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Belajar Pengaturcaraan Rust merangkumi sejumlah 4 pelajaran.

Mengubah Jujukan

Tiga kaedah melakukan kebanyakan kerja dalam saluran paip iterator: map mengubah setiap item, filter mengekalkan sesetengah item, dan collect mengumpulkan hasil ke dalam koleksi.

Gabungan ini menggantikan banyak gelung manual dengan rangkaian yang pendek dan mudah dibaca.

map: Satu Masuk, Satu Keluar

map menggunakan closure pada setiap item dan menghasilkan nilai yang telah diubah. Bilangan item kekal sama; hanya nilainya berubah.

Kaedah ini bersifat malas, jadi closure hanya dijalankan apabila iterator digunakan.

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

map Boleh Mengubah Jenis

Jenis output map tidak semestinya sepadan dengan input. Di sini, kita menukar nombor menjadi rentetan.

Ini menjadikan map sesuai untuk menukar data daripada satu bentuk kepada bentuk yang lain.

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

filter: Kekalkan Perkara yang Dikehendaki

filter menerima closure yang mengembalikan bool. Item yang mengembalikan true dikekalkan; selebihnya dibuang.

Closure menerima rujukan, jadi anda biasanya menyahrujuk dengan * atau menggunakan padanan corak.

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

Merangkaikan map dan filter

Anda boleh merangkaikan penyesuai dengan bebas. Susunan penting: setiap item mengalir melalui rangkaian dari atas ke bawah.

Di sini, kita mengekalkan nombor genap, kemudian mengkuasa duakan nombor yang tinggal.

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

collect ke dalam Vec

collect menggunakan iterator dan membina koleksi. Oleh sebab terdapat banyak jenis koleksi yang mungkin, anda biasanya menganotasi jenis sasaran.

Sintaks turbofish collect::<Vec<_>>() ialah alternatif kepada menganotasi pemboleh ubah.

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

collect ke dalam String

collect tidak terhad kepada vektor. Iterator bagi char boleh dikumpulkan menjadi String.

Rust menggunakan jenis sasaran untuk menentukan cara item tersebut dihimpunkan.

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

collect ke dalam HashMap

Iterator bagi tupel kunci-nilai boleh dikumpulkan menjadi HashMap. Padankan item dengan zip atau bina tupel dalam map.

Ini ialah cara yang kemas untuk membina carian daripada dua jujukan selari.

use std::collections::HashMap;

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

Menggabungkan Ketiga-tiganya

Saluran paip biasa dibaca seperti ayat: ambil item, tapis item tersebut, ubah item tersebut, kemudian kumpulkannya.

Di sini, kita mengekalkan perkataan yang lebih panjang daripada tiga huruf dan menjadikannya huruf besar.

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: Tapis dan Ubah Sekaligus

filter_map menggunakan closure yang mengembalikan Option. Some(v) dikekalkan dan nilainya dikeluarkan; None dibuang.

Kaedah ini amat berguna semasa menghuraikan data, apabila sesetengah input mungkin tidak sah.

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 Corak Ini Berkesan

Saluran paip map/filter/collect bersifat deklaratif: ia menyatakan perkara yang anda mahu, bukan cara untuk membuat gelung. Saluran paip ini mengelakkan pepijat terlebih atau terkurang satu serta keadaan boleh ubah perantaraan.

Tambahan pula, berkat sifat malas, tiada vektor sementara dibina antara langkah-langkah tersebut.

Semakan Pantas

Semak pengetahuan anda tentang mengubah jujukan.

Jawab dalam pelajaran interaktif

Imbas Kembali

Kini anda boleh membina saluran paip iterator sebenar:

map mengubah setiap item dan mungkin menukar jenisnya
filter mengekalkan item yang predikatnya true
collect mengumpulkan hasil menjadi Vec, String, HashMap, dan banyak lagi
filter_map menapis dan mengubah dalam satu langkah menggunakan Option

Percuma untuk bermula

Pelajari Rust dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 39
Pelajaran: 144

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “map, filter, collect” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Belajar Pengaturcaraan Rust, termasuk “map, filter, collect”, boleh dibaca sepenuhnya secara percuma di web ini. Selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan interaktif dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Kursus Belajar Pengaturcaraan Rust merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “map, filter, collect”?

Mengubah jujukan Anda berlatih Belajar Pengaturcaraan Rust menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Belajar Pengaturcaraan Rust?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Belajar Pengaturcaraan Rust di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 2 daripada 4.

Berapa lamakah pelajaran “map, filter, collect” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Belajar Pengaturcaraan Rust ini?

Ya. Setiap pelajaran Belajar Pengaturcaraan Rust menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

← Kembali ke Belajar Pengaturcaraan Rust