0Pricing
Learn Rust Coding · บทเรียน

การวนซ้ำผ่านคอลเลกชัน

for และตัววนซ้ำ

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

การวนซ้ำด้วย for

ลูป for เป็นวิธีที่ง่ายที่สุดในการเข้าถึงสมาชิกแต่ละตัวในคอลเลกชัน

fn main() {
    let nums = vec![1, 2, 3];
    for n in &nums {
        println!("{}", n);
    }
}

การวนซ้ำผ่านช่วงค่า

ช่วงค่าจะสร้างลำดับที่คุณสามารถวนซ้ำได้ 1..5 ไม่รวมค่าสุดท้าย ส่วน 1..=5 รวมค่าสุดท้าย

fn main() {
    for i in 1..=3 {
        println!("i = {}", i);
    }
}

เมธอด iter

การเรียก .iter() จะสร้าง ตัววนซ้ำ ที่ส่งข้อมูลอ้างอิงของสมาชิกแต่ละตัว ตัววนซ้ำจะยังไม่ทำงานจนกว่าจะถูกใช้จนหมด

fn main() {
    let v = vec![10, 20, 30];
    let mut it = v.iter();
    println!("{:?}", it.next());
    println!("{:?}", it.next());
}

สามวิธีในการวนซ้ำ

เวกเตอร์มีรูปแบบการวนซ้ำสามแบบ:

  • iter() — ส่งค่า &T (การยืม)
  • iter_mut() — ส่งค่า &mut T (การยืมแบบเปลี่ยนแปลงได้)
  • into_iter() — ส่งค่า T (รับความเป็นเจ้าของ)
fn main() {
    let v = vec![1, 2, 3];
    for x in v.into_iter() {
        println!("owned {}", x);
    }
}

การแปลงด้วย map

map ใช้ closure กับสมาชิกแต่ละตัวและสร้างตัววนซ้ำใหม่ ใช้ collect เพื่อรวบรวมผลลัพธ์

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

การเลือกด้วย filter

filter จะเก็บไว้เฉพาะสมาชิกที่ closure ส่งค่า true กลับมา

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

การรวมค่าด้วย sum และ count

เมธอดที่ใช้จนหมดจะลดตัววนซ้ำให้เหลือค่าเดียว เช่น sum, count, max และ min

fn main() {
    let v = vec![4, 8, 15, 16];
    let total: i32 = v.iter().sum();
    let how_many = v.iter().count();
    println!("sum {} count {}", total, how_many);
}

การต่ออะแดปเตอร์

เมธอดของตัววนซ้ำสามารถต่อกันเป็นกระบวนการแบบต่อเนื่องที่ชัดเจนได้ แต่ละขั้นตอนจะแปลงกระแสข้อมูลก่อนถึงขั้นตอนสุดท้ายที่ใช้ผลลัพธ์

fn main() {
    let v = vec![1, 2, 3, 4, 5, 6];
    let result: i32 = v.iter()
        .filter(|x| *x % 2 == 0)
        .map(|x| x * 10)
        .sum();
    println!("{}", result);
}

enumerate สำหรับดัชนี

enumerate จะจับคู่สมาชิกแต่ละตัวกับดัชนีของมัน และส่งผลเป็นทูเพิล (index, value)

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

การวนซ้ำใน HashMap

ตัววนซ้ำทำงานกับแผนที่ได้เช่นกัน การวนซ้ำจะให้ทูเพิลคีย์-ค่า

use std::collections::HashMap;

fn main() {
    let mut m = HashMap::new();
    m.insert("a", 1);
    m.insert("b", 2);
    for (k, v) in &m {
        println!("{} -> {}", k, v);
    }
}

for เทียบกับเมธอดของ Iterator

ลูป for แบบธรรมดาเหมาะมากสำหรับผลข้างเคียง เช่น การพิมพ์ค่า ส่วนตัวปรับตัววนซ้ำ (map, filter, sum) เหมาะอย่างยิ่งเมื่อแปลงข้อมูลให้เป็นค่าใหม่

fn main() {
    let v = vec![2, 4, 6];
    let doubled: Vec<i32> = v.iter().map(|x| x * 2).collect();
    for x in &doubled {
        println!("{}", x);
    }
}

ตรวจสอบอย่างรวดเร็ว

ทบทวนบทบาทของตัวปรับตัววนซ้ำ

สรุปทบทวน

การวนซ้ำคอลเลกชันใน Rust:

  • for x in &collection สำหรับลูปแบบง่าย
  • iter, iter_mut, into_iter ควบคุมการยืม
  • ตัวปรับ: map, filter, enumerate
  • ตัวใช้ข้อมูล: collect, sum, count, max
fn main() {
    let prices = vec![10, 25, 40];
    let with_tax: Vec<i32> = prices.iter().map(|p| p + p / 5).collect();
    let total: i32 = with_tax.iter().sum();
    println!("{:?} total {}", with_tax, total);
}

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

บทเรียน “การวนซ้ำผ่านคอลเลกชัน” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “การวนซ้ำผ่านคอลเลกชัน”

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

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

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

บทเรียน “การวนซ้ำผ่านคอลเลกชัน” ใช้เวลานานแค่ไหน

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

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

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

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

  1. เวกเตอร์
  2. สตริงและ &str
  3. HashMaps
  4. การวนซ้ำผ่านคอลเลกชัน
← กลับไปที่ Learn Rust Coding