Learn Rust Coding · บทเรียน

map, filter, collect

แปลงลำดับข้อมูล

map, filter, collect เป็นบทเรียน Learn Rust Coding ฟรีบน CoddyKit นี่คือบทเรียนที่ 2 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Learn Rust Coding และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Learn Rust Coding มีบทเรียนทั้งหมด 4 บทเรียน

การแปลงลำดับข้อมูล

เมธอดสามรายการทำงานส่วนใหญ่ในสายการประมวลผลของ Iterator: map แปลงแต่ละองค์ประกอบ filter เก็บบางองค์ประกอบไว้ และ collect รวบรวมผลลัพธ์เป็นคอลเลกชัน

เมื่อใช้ร่วมกัน เมธอดเหล่านี้ช่วยแทนที่ลูปที่ต้องเขียนเองจำนวนมากด้วยสายการทำงานสั้น ๆ ที่อ่านง่าย

map: หนึ่งเข้า หนึ่งออก

map ใช้ closure กับทุกองค์ประกอบและให้ค่าที่แปลงแล้วออกมา จำนวนองค์ประกอบยังเท่าเดิม มีเพียงค่าขององค์ประกอบที่เปลี่ยนไป

เมธอดนี้ทำงานแบบขี้เกียจ ดังนั้น closure จะทำงานเมื่อ Iterator ถูกใช้จนหมดเท่านั้น

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

map เปลี่ยนชนิดข้อมูลได้

ชนิดผลลัพธ์ของ map ไม่จำเป็นต้องตรงกับชนิดอินพุต ในตัวอย่างนี้ เราแปลงตัวเลขเป็นสตริง

จึงเหมาะอย่างยิ่งสำหรับการแปลงข้อมูลจากรูปแบบหนึ่งเป็นอีกรูปแบบหนึ่ง

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

filter: เก็บสิ่งที่ต้องการ

filter รับ closure ที่คืนค่าเป็น bool องค์ประกอบที่ closure คืนค่า true จะถูกเก็บไว้ ส่วนที่เหลือจะถูกตัดออก

closure จะได้รับรีเฟอเรนซ์ ดังนั้นบ่อยครั้งคุณจึงต้องใช้ * เพื่อถอดการอ้างอิง หรือใช้การจับคู่รูปแบบ

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

การเชื่อม map และ filter

คุณสามารถเชื่อมอะแดปเตอร์ได้อย่างอิสระ ลำดับมีความสำคัญ: แต่ละองค์ประกอบจะไหลผ่านสายการทำงานจากบนลงล่าง

ในที่นี้ เราเก็บตัวเลขคู่ไว้ แล้วจึงยกกำลังสององค์ประกอบที่เหลือ

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

collect เป็น Vec

collect ใช้ Iterator จนหมดและสร้างคอลเลกชันขึ้นมา เนื่องจากมีชนิดคอลเลกชันที่เป็นไปได้หลายชนิด คุณจึงมักระบุชนิดเป้าหมายไว้

ไวยากรณ์แบบ turbofish collect::<Vec<_>>() เป็นอีกทางเลือกหนึ่งแทนการระบุชนิดของตัวแปร

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

collect เป็น String

collect ไม่ได้จำกัดอยู่แค่เวกเตอร์ Iterator ของ char สามารถรวบรวมเป็น String ได้

Rust ใช้ชนิดเป้าหมายเพื่อตัดสินใจว่าจะประกอบองค์ประกอบเหล่านั้นอย่างไร

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

collect เป็น HashMap

Iterator ของทูเพิลคีย์-ค่าสามารถรวบรวมเป็น HashMap ได้ จับคู่องค์ประกอบด้วย zip หรือสร้างทูเพิลภายใน map

นี่เป็นวิธีที่สะอาดในการสร้างตารางค้นหาจากลำดับข้อมูลสองชุดที่ดำเนินไปคู่ขนานกัน

use std::collections::HashMap;

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

รวมทั้งสามเข้าด้วยกัน

สายการประมวลผลทั่วไปอ่านได้คล้ายประโยค: เลือกองค์ประกอบ กรอง แปลง แล้วรวบรวม

ในที่นี้ เราเก็บคำที่ยาวกว่าสามตัวอักษรไว้และแปลงเป็นตัวพิมพ์ใหญ่

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: กรองและแปลงในครั้งเดียว

filter_map ใช้ closure ที่คืนค่าเป็น Option ค่า Some(v) จะถูกเก็บไว้และแกะค่าออก ส่วน None จะถูกตัดออก

เมธอดนี้โดดเด่นเมื่อใช้แยกวิเคราะห์ข้อมูล ซึ่งอินพุตบางรายการอาจไม่ถูกต้อง

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

เหตุใดรูปแบบนี้จึงได้ผลดี

สายการประมวลผลแบบ map/filter/collect เป็นการประกาศเจตนา: บอกว่าเราต้องการ อะไร ไม่ใช่บอกว่าเราจะวนลูป อย่างไร อีกทั้งยังหลีกเลี่ยงข้อผิดพลาดแบบนับเกินหรือนับขาด และสถานะที่เปลี่ยนแปลงได้ระหว่างทาง

และด้วยการทำงานแบบขี้เกียจ จึงไม่มีการสร้างเวกเตอร์ชั่วคราวระหว่างแต่ละขั้นตอน

ตรวจสอบความเข้าใจอย่างรวดเร็ว

ตรวจสอบความเข้าใจเกี่ยวกับการแปลงลำดับข้อมูล

สรุปทบทวน

ตอนนี้คุณสามารถสร้างสายการประมวลผลของ Iterator ที่ใช้งานได้จริง:

map แปลงแต่ละองค์ประกอบและอาจเปลี่ยนชนิดข้อมูลได้
filter เก็บองค์ประกอบที่เพรดิเคตให้ค่าเป็น true
collect รวบรวมผลลัพธ์เป็น Vec, String, HashMap และชนิดอื่น ๆ
filter_map กรองและแปลงในขั้นตอนเดียวโดยใช้ Option

คำถามที่พบบ่อย

บทเรียน “map, filter, collect” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “map, filter, collect” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Learn Rust Coding ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Learn Rust Coding มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “map, filter, collect”

แปลงลำดับข้อมูล คุณปฏิบัติ Learn Rust Coding ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Learn Rust Coding หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Learn Rust Coding บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 2 จากทั้งหมด 4 บทเรียน

บทเรียน “map, filter, collect” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Learn Rust Coding นี้ได้ไหม

ได้ บทเรียน Learn Rust Coding ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

← กลับไปที่ Learn Rust Coding