ประมวลผลลำดับรายการด้วยอิเทอเรเตอร์
รูปแบบอิเทอเรเตอร์ (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 เราจะได้เฉพาะรองเท้าที่มีขนาดตรงตามที่เราระบุไว้กลับคืนมาอย่างถูกต้อง