Learn Rust Coding · บทเรียน

คุณลักษณะ Iterator

next และการประเมินแบบขี้เกียจ

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

ตัววนซ้ำคืออะไร

ตัววนซ้ำคือสิ่งใดก็ตามที่สร้างลำดับของค่าทีละค่า ใน Rust ตัววนซ้ำเป็นวิธีมาตรฐานในการประมวลผลคอลเลกชัน เช่น เวกเตอร์ ช่วง และสไลซ์

แนวคิดทั้งหมดสร้างอยู่บนคุณลักษณะเดียวคือ Iterator เมื่อชนิดข้อมูลนำคุณลักษณะนี้ไปใช้ คุณจะได้เมธอดที่มีประโยชน์มากมายโดยไม่ต้องเขียนเพิ่ม

คุณลักษณะ Iterator

คุณลักษณะ Iterator มีเมธอดที่จำเป็นหนึ่งเมธอดคือ next และชนิดข้อมูลที่เกี่ยวข้องหนึ่งชนิดคือ Item:

type Item — ชนิดของค่าที่สร้างขึ้น
fn next(&mut self) -> Option<Self::Item> — คืนค่าถัดไป

เมธอดนี้คืนค่า Some(value) ขณะที่ยังมีค่าเหลือ และคืนค่า None เมื่อทำงานเสร็จ

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

next คืนค่า Option

การเรียก next แต่ละครั้งจะเลื่อนตัววนซ้ำไปข้างหน้าและส่งค่า Option ให้คุณ Some ห่อหุ้มค่าจริง ส่วน None ส่งสัญญาณว่าถึงจุดสิ้นสุด

สังเกตว่า next รับค่า &mut self การเรียกใช้จึงเปลี่ยนสถานะภายใน ทำให้การเรียกครั้งถัดไปคืนค่าแตกต่างออกไป

fn main() {
    let mut it = (1..4).into_iter();
    while let Some(n) = it.next() {
        println!("got {}", n);
    }
    println!("done");
}

ตัววนซ้ำทำงานแบบขี้เกียจ

การสร้างตัววนซ้ำเพียงอย่างเดียวไม่ทำอะไร จะยังไม่มีการคำนวณค่าใดจนกว่าจะมีสิ่งอื่นขอค่า แนวคิดนี้เรียกว่าการประเมินแบบขี้เกียจ

ในตัวอย่างถัดไป คลอสเชอร์ map จะไม่ทำงาน เพราะเราไม่ได้นำตัววนซ้ำไปใช้จนหมด

fn main() {
    let nums = vec![1, 2, 3];
    let _doubled = nums.iter().map(|x| {
        println!("mapping {}", x);
        x * 2
    });
    println!("nothing printed above this line");
}

การใช้ข้อมูลจะเริ่มการทำงาน

หากต้องการให้ตัววนซ้ำแบบขี้เกียจทำงานจริง คุณต้องใช้ข้อมูลจากมัน ลูป for เป็นตัวใช้ข้อมูลที่ง่ายที่สุด โดยเรียก next ซ้ำไปเรื่อย ๆ จนได้ค่า None

ตอนนี้คลอสเชอร์ map เดิมจะทำงานกับทุกองค์ประกอบ

fn main() {
    let nums = vec![1, 2, 3];
    for x in nums.iter().map(|x| x * 2) {
        println!("value {}", x);
    }
}

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

คอลเลกชันมีเมธอดที่สร้างตัววนซ้ำสามแบบ:

iter() — ให้ค่า &T (ยืม)
iter_mut() — ให้ค่า &mut T (ยืมแบบเปลี่ยนแปลงได้)
into_iter() — ให้ค่า T (รับความเป็นเจ้าของ)

fn main() {
    let mut v = vec![1, 2, 3];
    for x in v.iter_mut() {
        *x += 10;
    }
    println!("{:?}", v);
}

ลูป for ใช้ into_iter

เมื่อคุณเขียน for x in collection โดยตรง Rust จะเรียก into_iter() ซึ่งใช้คอลเลกชันจนหมด

หลังจากลูปนี้ คุณจะใช้ v อีกไม่ได้ เพราะค่าถูกย้ายเข้าไปในตัววนซ้ำแล้ว

fn main() {
    let v = vec![String::from("a"), String::from("b")];
    for s in v {
        println!("{}", s);
    }
    // v is no longer usable here
}

ช่วงคือ ตัววนซ้ำ

ช่วงอย่าง 0..5 เป็นตัววนซ้ำในตัว ซึ่งสร้างค่า 0, 1, 2, 3, 4 โดยตำแหน่งสิ้นสุดไม่รวมอยู่ในช่วง ใช้ 0..=5 สำหรับช่วงที่รวมตำแหน่งสิ้นสุด

ช่วงเหมาะอย่างยิ่งสำหรับลูปนับจำนวน โดยไม่ต้องติดตามดัชนีด้วยตนเอง

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

count: ตัวใช้ข้อมูลแบบง่าย

count ใช้ตัววนซ้ำจนหมดและคืนค่าจำนวนรายการที่ตัววนซ้ำสร้างขึ้น เมธอดนี้เป็นหนึ่งในตัวปรับที่ใช้ข้อมูลจนหมดหลายตัว

เนื่องจากเมธอดนี้ใช้ตัววนซ้ำจนหมด คุณจึงนำตัววนซ้ำกลับมาใช้ซ้ำภายหลังไม่ได้

fn main() {
    let total = (1..=100).count();
    println!("there are {} numbers", total);
}

sum: การรวมเป็นค่าเดียว

sum นำทุกองค์ประกอบมารวมกันและคืนค่าเดียว โดยมักระบุชนิดเป้าหมายไว้เพื่อให้ Rust ทราบว่าควรสร้างผลลัพธ์ชนิดใด

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

fn main() {
    let total: i32 = (1..=5).sum();
    println!("sum is {}", total);
}

เหตุใด Iterator จึงสำคัญ

Iterator ช่วยให้เกิด การประกอบการทำงาน: เชื่อมการดำเนินการเล็ก ๆ เข้าด้วยกันเป็นสายการประมวลผลที่ชัดเจน นอกจากนี้ยังมี ต้นทุนเป็นศูนย์ — คอมไพเลอร์ปรับให้ทำงานได้เร็วเท่ากับลูปที่เขียนด้วยตนเอง

การเชี่ยวชาญ next ความประเมินผลแบบขี้เกียจ และการใช้ค่าจนหมด เป็นพื้นฐานของเนื้อหาทั้งหมดต่อจากนี้

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

ทดสอบความเข้าใจเกี่ยวกับคุณลักษณะ Iterator

สรุปทบทวน

คุณได้เรียนรู้แก่นสำคัญของ Iterator ใน Rust:

คุณลักษณะ Iterator ต้องการเพียง next และชนิด Item
next คืนค่า Some(value) แล้วจึงคืนค่า None
Iterator เป็นแบบ ขี้เกียจ — จะไม่ทำงานจนกว่าจะถูกใช้จนหมด
iter, iter_mut และ into_iter ควบคุมการยืมกับการเป็นเจ้าของ
ตัวใช้ผลลัพธ์อย่าง for, count และ sum เป็นผู้ขับเคลื่อนการทำงาน

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

บทเรียน “คุณลักษณะ Iterator” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “คุณลักษณะ Iterator”

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

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

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

บทเรียน “คุณลักษณะ Iterator” ใช้เวลานานแค่ไหน

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

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

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

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

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