Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

ประมวลผลลำดับรายการด้วยอิเทอเรเตอร์

รูปแบบอิเทอเรเตอร์ (iterator pattern) ช่วยให้คุณทำงานกับชุดลำดับของข้อมูลทีละสมาชิกได้อย่างเป็นระเบียบ ตัวอิเทอเรเตอร์ (iterator) จะรับหน้าที่จัดการตรรกะในการวนลูปผ่านสมาชิกแต่ละตัว และคอยตรวจสอบว่าลำดับข้อมูลนั้นสิ้นสุดลงเมื่อใด ทำให้เมื่อคุณใช้งานอิเทอเรเตอร์ คุณจึงไม่จำเป็นต้องเขียนตรรกะการวนลูปเหล่านั้นขึ้นมาใหม่ด้วยตัวเอง

ในภาษา Rust อิเทอเรเตอร์จะทำงานแบบ_ประเมินผลตามความต้องการ_ หรือ เลซี่ (lazy evaluation) ซึ่งหมายความว่ามันจะยังไม่เริ่มประมวลผลข้อมูลใดๆ จนกว่าคุณจะเรียกใช้เมธอดที่ดึงข้อมูลจากอิเทอเรเตอร์ไปใช้งานจริง ตัวอย่างเช่น โค้ดในลิสติ้ง 13-10 เป็นการสร้างอิเทอเรเตอร์เพื่อวนอ่านสมาชิกในเวกเตอร์ v1 โดยเรียกเมธอด iter ที่นิยามไว้บน Vec<T> ซึ่งลำพังโค้ดชุดนี้เพียงอย่างเดียวยังไม่ได้ก่อให้เกิดผลลัพธ์ที่เป็นประโยชน์ใดๆ

fn main() {
    let v1 = vec![1, 2, 3];

    let v1_iter = v1.iter();
}

อิเทอเรเตอร์จะถูกจัดเก็บไว้ในตัวแปร v1_iter และเมื่อเราสร้างอิเทอเรเตอร์ขึ้นมาแล้ว เราก็สามารถนำไปใช้งานต่อได้หลากหลายรูปแบบ ในลิสติ้ง 3-5 เราเคยวนลูปผ่านอาร์เรย์โดยใช้ลูป for เพื่อรันโค้ดกับสมาชิกแต่ละตัว ซึ่งเบื้องหลังการทำงานนั้น ลูป for ได้สร้างอิเทอเรเตอร์ขึ้นมาโดยปริยายแล้วดึงข้อมูลไปใช้จนหมด แต่เราข้ามรายละเอียดการทำงานเบื้องลึกตรงนั้นมาจนถึงบทนี้

ในตัวอย่างลิสติ้ง 13-11 เราได้แยกขั้นตอนการสร้างอิเทอเรเตอร์ ออกจากการนำอิเทอเรเตอร์ไปใช้ในลูป for อย่างชัดเจน เมื่อลูป for เริ่มทำงานกับอิเทอเรเตอร์ใน v1_iter สมาชิกแต่ละตัวจากอิเทอเรเตอร์ก็จะถูกดึงมาประมวลผลในลูปแต่ละรอบเพื่อพิมพ์ค่าออกมา

fn main() {
    let v1 = vec![1, 2, 3];

    let v1_iter = v1.iter();

    for val in v1_iter {
        println!("Got: {val}");
    }
}

ในภาษาโปรแกรมที่ไม่มีอิเทอเรเตอร์เตรียมไว้ให้ในไลบรารีมาตรฐาน คุณมักจะต้องเขียนการทำงานลักษณะนี้ด้วยตนเอง โดยเริ่มประกาศตัวแปรดัชนี (index) ที่ค่า 0 แล้วใช้ดัชนีนั้นเข้าถึงข้อมูลในเวกเตอร์ทีละตำแหน่ง พร้อมกับคอยบวกค่าดัชนีเพิ่มขึ้นทีละ 1 ในลูปไปเรื่อยๆ จนกว่าจะครบตามจำนวนสมาชิกทั้งหมดของเวกเตอร์

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

เทรต Iterator และเมธอด next

อิเทอเรเตอร์ทุกตัวใน Rust จะต้องอิมพลีเมนต์เทรต (trait) ที่ชื่อว่า Iterator ซึ่งถูกนิยามไว้ในไลบรารีมาตรฐาน โดยนิยามของเทรตนี้มีหน้าตาดังนี้:

#![allow(unused)]
fn main() {
pub trait Iterator {
    type Item;

    fn next(&mut self) -> Option<Self::Item>;

    // methods with default implementations elided
}
}

โปรดสังเกตว่านิยามนี้ใช้ไวยากรณ์ใหม่: type Item และ Self::Item ซึ่งเป็นการนิยามชนิดข้อมูลประจำเทรต (associated type) ร่วมกับเทรตนี้ เราจะพูดถึง associated type อย่างละเอียดในบทที่ 20 สำหรับตอนนี้ สิ่งที่คุณต้องทราบคือ โค้ดนี้ระบุว่าการจะอิมพลีเมนต์เทรต Iterator ได้นั้น คุณจะต้องกำหนดชนิดข้อมูล Item ด้วยเสมอ และชนิดข้อมูล Item นี้จะถูกนำไปใช้เป็นชนิดของค่าที่ส่งกลับจากเมธอด next หรือกล่าวอีกนัยหนึ่งคือ ชนิดข้อมูล Item จะเป็นชนิดข้อมูลของสมาชิกที่อิเทอเรเตอร์ตัวนั้นส่งออกมา

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

เราสามารถเรียกใช้เมธอด next บนอิเทอเรเตอร์ได้โดยตรง ลิสติ้ง 13-12 สาธิตให้เห็นว่าค่าใดบ้างที่จะถูกส่งกลับมาจากการเรียกใช้ next ซ้ำๆ บนอิเทอเรเตอร์ที่สร้างขึ้นจากเวกเตอร์

#[cfg(test)]
mod tests {
    #[test]
    fn iterator_demonstration() {
        let v1 = vec![1, 2, 3];

        let mut v1_iter = v1.iter();

        assert_eq!(v1_iter.next(), Some(&1));
        assert_eq!(v1_iter.next(), Some(&2));
        assert_eq!(v1_iter.next(), Some(&3));
        assert_eq!(v1_iter.next(), None);
    }
}

โปรดสังเกตว่าเราจำเป็นต้องประกาศให้ v1_iter เปลี่ยนแปลงค่าได้ (mut): การเรียกเมธอด next บนอิเทอเรเตอร์จะไปเปลี่ยนสถานะภายในที่อิเทอเรเตอร์ใช้คอยติดตามลำดับตำแหน่งของข้อมูล กล่าวคือ โค้ดชุดนี้จะ_ดึงใช้ข้อมูล (consume)_ จากอิเทอเรเตอร์ โดยการเรียก next แต่ละครั้งจะดึงข้อมูลสมาชิกหนึ่งตัวออกจากอิเทอเรเตอร์ไป ทั้งนี้เราไม่จำเป็นต้องทำให้ v1_iter เปลี่ยนแปลงค่าได้เมื่อเราใช้ลูป for เนื่องจากลูป for จะรับสิทธิ์ความเป็นเจ้าของ v1_iter และจัดการให้มันเปลี่ยนแปลงค่าได้อยู่เบื้องหลังโดยอัตโนมัติ

โปรดสังเกตเพิ่มเติมว่า ค่าที่เราได้จากการเรียก next จะเป็นเรเฟอเรนซ์แบบเปลี่ยนแปลงไม่ได้ (immutable reference) ที่ชี้ไปยังค่าในเวกเตอร์ เนื่องจากการเรียกเมธอด iter จะสร้างอิเทอเรเตอร์ที่วนซ้ำบนเรเฟอเรนซ์แบบเปลี่ยนแปลงไม่ได้ แต่หากเราต้องการสร้างอิเทอเรเตอร์ที่รับสิทธิ์ความเป็นเจ้าของ v1 และส่งคืนค่าที่เป็นเจ้าของโดยตรง เราสามารถเรียกใช้เมธอด into_iter แทน iter ได้ ในทำนองเดียวกัน หากเราต้องการวนซ้ำเพื่อแก้ไขข้อมูลผ่านเรเฟอเรนซ์แบบเปลี่ยนแปลงได้ เราก็สามารถเรียกใช้เมธอด iter_mut แทนได้เช่นกัน

เมธอดที่บริโภคอิเทอเรเตอร์

เทรต Iterator มีเมธอดต่างๆ มากมายที่มีการอิมพลีเมนต์ค่าเริ่มต้นจากไลบรารีมาตรฐาน คุณสามารถเรียนรู้เกี่ยวกับเมธอดเหล่านี้ได้โดยดูในเอกสาร API ของไลบรารีมาตรฐานสำหรับเทรต Iterator เมธอดเหล่านี้บางตัวเรียกเมธอด next ในนิยามของมัน ซึ่งเป็นเหตุผลว่าทำไมคุณจึงต้องอิมพลีเมนต์เมธอด next เมื่ออิมพลีเมนต์เทรต Iterator

เมธอดที่เรียกใช้ next ภายในตัวเองจะเรียกว่า ตัวปรับที่ดึงใช้ข้อมูลจนหมด (consuming adaptors) เนื่องจากการเรียกเมธอดเหล่านี้จะดึงข้อมูลจากอิเทอเรเตอร์ไปจนหมด ตัวอย่างหนึ่งคือเมธอด sum ซึ่งจะรับสิทธิ์ความเป็นเจ้าของของอิเทอเรเตอร์ และวนซ้ำผ่านสมาชิกแต่ละตัวโดยเรียก next ซ้ำๆ จึงถือเป็นการดึงใช้ข้อมูลจากอิเทอเรเตอร์จนหมด ในระหว่างที่วนซ้ำ มันจะนำสมาชิกแต่ละตัวมาบวกสะสมเข้าด้วยกัน แล้วส่งคืนผลรวมออกมาเมื่อวนซ้ำจนเสร็จสมบูรณ์ ลิสติ้ง 13-13 แสดงตัวอย่างการทดสอบการใช้งานเมธอด sum

#[cfg(test)]
mod tests {
    #[test]
    fn iterator_sum() {
        let v1 = vec![1, 2, 3];

        let v1_iter = v1.iter();

        let total: i32 = v1_iter.sum();

        assert_eq!(total, 6);
    }
}

เราจะไม่สามารถใช้งาน v1_iter ต่อหลังจากการเรียก sum ได้อีก เนื่องจาก sum ได้รับสิทธิ์ความเป็นเจ้าของของอิเทอเรเตอร์ตัวนั้นไปแล้ว

เมธอดที่สร้างอิเทอเรเตอร์อื่น

ตัวปรับอิเทอเรเตอร์ (iterator adaptors) คือเมธอดที่นิยามไว้บนเทรต Iterator ซึ่งไม่ได้ดึงใช้ข้อมูลจากอิเทอเรเตอร์เดิมจนหมด แต่จะสร้างอิเทอเรเตอร์ตัวใหม่ขึ้นมาแทน โดยปรับเปลี่ยนพฤติกรรมบางประการไปจากอิเทอเรเตอร์ต้นฉบับ

ลิสติ้ง 13-14 แสดงตัวอย่างการเรียกเมธอดตัวปรับอิเทอเรเตอร์ map ซึ่งรับโคลเชอร์ (closure) เข้าไปเรียกทำงานกับสมาชิกแต่ละตัวในระหว่างวนซ้ำ เมธอด map จะส่งคืนอิเทอเรเตอร์ตัวใหม่ที่ผลิตสมาชิกที่ผ่านการปรับแก้แล้วออกมา โคลเชอร์ในตัวอย่างนี้จะสร้างอิเทอเรเตอร์ตัวใหม่ที่สมาชิกแต่ละตัวจากเวกเตอร์เดิมจะถูกบวกเพิ่มค่าทีละ 1

fn main() {
    let v1: Vec<i32> = vec![1, 2, 3];

    v1.iter().map(|x| x + 1);
}

อย่างไรก็ตาม โค้ดนี้สร้างคำเตือน:

$ cargo run
   Compiling iterators v0.1.0 (file:///projects/iterators)
warning: unused `Map` that must be used
 --> src/main.rs:4:5
  |
4 |     v1.iter().map(|x| x + 1);
  |     ^^^^^^^^^^^^^^^^^^^^^^^^
  |
  = note: iterators are lazy and do nothing unless consumed
  = note: `#[warn(unused_must_use)]` (part of `#[warn(unused)]`) on by default
help: use `let _ = ...` to ignore the resulting value
  |
4 |     let _ = v1.iter().map(|x| x + 1);
  |     +++++++

warning: `iterators` (bin "iterators") generated 1 warning
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.47s
     Running `target/debug/iterators`

โค้ดในลิสติ้ง 13-14 ไม่ได้ทำอะไรเป็นชิ้นเป็นอันเลย โคลเชอร์ที่เราระบุไว้ไม่เคยถูกเรียกให้ทำงานด้วยซ้ำ ข้อความเตือนช่วยย้ำเตือนให้เราเห็นเหตุผล: นั่นคือตัวปรับอิเทอเรเตอร์ทำงานแบบเลซี่ (lazy) และเราจำเป็นต้องเรียกใช้เมธอดที่ดึงข้อมูลไปใช้งานจริงในจุดนี้

เพื่อแก้ไขข้อความเตือนนี้และดึงข้อมูลจากอิเทอเรเตอร์ไปใช้งาน เราจะเรียกใช้เมธอด collect ซึ่งเราเคยใช้ร่วมกับ env::args ในลิสติ้ง 12-1 โดยเมธอดนี้จะดึงข้อมูลจากอิเทอเรเตอร์จนหมด แล้วรวบรวมค่าผลลัพธ์เหล่านั้นจัดเก็บไว้ในโครงสร้างข้อมูลแบบคอลเลกชัน (collection)

ในลิสติ้ง 13-15 เราเก็บผลลัพธ์ของการวนซ้ำผ่านอิเทอเรเตอร์ที่ถูกคืนกลับจากการเรียก map ไว้ในเวกเตอร์ เวกเตอร์นี้จะบรรจุสมาชิกแต่ละตัวจากเวกเตอร์ต้นฉบับที่ถูกเพิ่มค่า 1 ในที่สุด

fn main() {
    let v1: Vec<i32> = vec![1, 2, 3];

    let v2: Vec<_> = v1.iter().map(|x| x + 1).collect();

    assert_eq!(v2, vec![2, 3, 4]);
}

เนื่องจาก map รับโคลเชอร์ เราจึงสามารถระบุตรรกะการประมวลผลใดๆ ที่ต้องการกระทำกับสมาชิกแต่ละตัวได้อย่างอิสระ นี่เป็นตัวอย่างอันยอดเยี่ยมที่แสดงให้เห็นว่าโคลเชอร์ช่วยให้เราปรับแต่งพฤติกรรมการทำงานเฉพาะจุดได้อย่างไร ในขณะที่ยังคงนำตรรกะการวนซ้ำที่เทรต Iterator เตรียมไว้มาใช้ซ้ำได้อย่างเต็มที่

คุณสามารถเชื่อมโยง (chain) การเรียกตัวปรับอิเทอเรเตอร์หลายตัวต่อกันเป็นทอดๆ เพื่อทำงานที่ซับซ้อนได้อย่างเป็นระเบียบและอ่านเข้าใจง่าย แต่เนื่องจากอิเทอเรเตอร์ทั้งหมดทำงานแบบเลซี่ คุณจึงต้องเรียกเมธอดตัวปรับที่ดึงใช้ข้อมูล (consuming adaptor) ตัวใดตัวหนึ่งปิดท้ายเสมอ เพื่อให้เกิดการประมวลผลและได้ผลลัพธ์จากการเชื่อมโยงตัวปรับอิเทอเรเตอร์เหล่านั้นออกมา

โคลเชอร์ที่จับสภาพแวดล้อมของมัน

ตัวปรับอิเทอเรเตอร์หลายตัวรับโคลเชอร์เป็นอาร์กิวเมนต์ และโดยทั่วไปโคลเชอร์ที่เราส่งเข้าไปก็มักจะเป็นโคลเชอร์ที่จับค่าจากสภาพแวดล้อมของมัน

สำหรับตัวอย่างนี้ เราจะใช้เมธอด filter ซึ่งรับโคลเชอร์เข้ามา โดยโคลเชอร์จะได้รับสมาชิกหนึ่งตัวจากอิเทอเรเตอร์และส่งคืนค่าเป็นบูลีน (bool) หากโคลเชอร์ส่งคืนค่า true สมาชิกนั้นจะถูกเก็บไว้ในอิเทอเรเตอร์ตัวใหม่ที่ filter สร้างขึ้น แต่หากโคลเชอร์ส่งคืนค่า false สมาชิกนั้นจะถูกคัดทิ้งไป

ในลิสติ้ง 13-16 เราใช้ filter ร่วมกับโคลเชอร์ที่จับค่าตัวแปร shoe_size จากสภาพแวดล้อม เพื่อวนซ้ำผ่านคอลเลกชันของอินสแตนซ์ struct Shoe ซึ่งจะคัดกรองและส่งคืนเฉพาะรองเท้าที่มีขนาดตามที่ระบุเท่านั้น

#[derive(PartialEq, Debug)]
struct Shoe {
    size: u32,
    style: String,
}

fn shoes_in_size(shoes: Vec<Shoe>, shoe_size: u32) -> Vec<Shoe> {
    shoes.into_iter().filter(|s| s.size == shoe_size).collect()
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn filters_by_size() {
        let shoes = vec![
            Shoe {
                size: 10,
                style: String::from("sneaker"),
            },
            Shoe {
                size: 13,
                style: String::from("sandal"),
            },
            Shoe {
                size: 10,
                style: String::from("boot"),
            },
        ];

        let in_my_size = shoes_in_size(shoes, 10);

        assert_eq!(
            in_my_size,
            vec![
                Shoe {
                    size: 10,
                    style: String::from("sneaker")
                },
                Shoe {
                    size: 10,
                    style: String::from("boot")
                },
            ]
        );
    }
}

ฟังก์ชัน shoes_in_size รับสิทธิ์ความเป็นเจ้าของเวกเตอร์ของรองเท้าและขนาดรองเท้าเป็นพารามิเตอร์ และจะส่งคืนเวกเตอร์ที่มีเฉพาะรองเท้าขนาดที่ต้องการกลับออกมา

ในบอดี้ของ shoes_in_size เราเรียก into_iter เพื่อสร้างอิเทอเรเตอร์ที่รับสิทธิ์ความเป็นเจ้าของเวกเตอร์ จากนั้นเรียก filter เพื่อปรับเปลี่ยนให้อิเทอเรเตอร์นั้นส่งคืนเฉพาะสมาชิกที่โคลเชอร์ประเมินค่าได้เป็น true

ตัวโคลเชอร์จะจับค่าพารามิเตอร์ shoe_size จากสภาพแวดล้อมเข้ามาเปรียบเทียบกับขนาดของรองเท้าแต่ละคู่ โดยเลือกเก็บเฉพาะคู่ที่มีขนาดตรงกัน สุดท้าย การเรียกเมธอด collect จะรวบรวมค่าที่อิเทอเรเตอร์คัดกรองได้ทั้งหมดเก็บลงในเวกเตอร์ แล้วส่งคืนออกจากฟังก์ชัน

ผลการทดสอบแสดงให้เห็นว่า เมื่อเราเรียกใช้ shoes_in_size เราจะได้เฉพาะรองเท้าที่มีขนาดตรงตามที่เราระบุไว้กลับคืนมาอย่างถูกต้อง