เก็บรายการค่าด้วยเวกเตอร์
คอลเลกชันชนิดแรกที่เราจะมาศึกษากันคือ Vec<T> หรือที่รู้จักกันทั่วไปในชื่อ เวกเตอร์ (vector) เวกเตอร์ช่วยให้คุณสามารถจัดเก็บข้อมูลมากกว่าหนึ่งค่าไว้ในโครงสร้างข้อมูลเดี่ยวชิ้นเดียว โดยวางค่าทั้งหมดเรียงต่อกันเป็นแถวยาวในหน่วยความจำ และเวกเตอร์จะสามารถจัดเก็บได้เฉพาะค่าที่มีชนิดข้อมูลเดียวกันทั้งหมดเท่านั้น เวกเตอร์จึงมีประโยชน์อย่างยิ่งเมื่อคุณต้องการจัดเก็บรายการของข้อมูล เช่น แต่ละบรรทัดของข้อความในไฟล์ หรือราคาสินค้าแต่ละชิ้นในตะกร้าสินค้า
การสร้างเวกเตอร์ใหม่
ในการสร้างเวกเตอร์ใหม่ที่ว่างเปล่า เราสามารถเรียกใช้ฟังก์ชัน Vec::new ได้ดังที่แสดงในลิสติ้ง 8-1
fn main() {
let v: Vec<i32> = Vec::new();
}
โปรดสังเกตว่าเราได้ระบุชนิดข้อมูล (type annotation) กำกับไว้ตรงนี้ด้วย เนื่องจากเรายังไม่ได้ใส่ค่าใดๆ ลงไปในเวกเตอร์ Rust จึงไม่สามารถรู้ได้เองว่าเราตั้งใจจะจัดเก็บข้อมูลชนิดใด ซึ่งนี่เป็นประเด็นที่สำคัญมาก เพราะเวกเตอร์ถูกอิมพลีเมนต์ขึ้นมาโดยใช้เจเนอริก (generics - เราจะได้เรียนรู้วิธีการสร้างเจเนอริกสำหรับชนิดข้อมูลของเราเองในบทที่ 10) แต่สำหรับตอนนี้ ขอให้ทราบไว้ว่าชนิดข้อมูล Vec<T> ในไลบรารีมาตรฐานนั้นสามารถบรรจุข้อมูลชนิดใดก็ได้ และเมื่อเราต้องการสร้างเวกเตอร์ขึ้นมาเพื่อเก็บข้อมูลชนิดใดชนิดหนึ่งเป็นการเฉพาะ เราก็สามารถระบุชนิดข้อมูลนั้นไว้ภายในวงเล็บสามเหลี่ยมมุมแหลม (<...>) ได้ ในลิสติ้ง 8-1 นี้ เราจึงบอกกับ Rust ว่าตัวแปร v ของเราคือ Vec<T> ที่จะใช้เก็บข้อมูลชนิด i32
แต่ในทางปฏิบัติแล้ว บ่อยครั้งคุณมักจะสร้าง Vec<T> ขึ้นมาพร้อมกับกำหนดค่าเริ่มต้นให้กับมันไปเลย ซึ่งจะช่วยให้ Rust สามารถอนุมาน (infer) ชนิดของข้อมูลที่คุณต้องการจัดเก็บได้เองโดยอัตโนมัติ ทำให้แทบไม่จำเป็นต้องเขียนระบุชนิดข้อมูลด้วยตนเอง นอกจากนี้ Rust ยังเตรียมมาโครอำนวยความสะดวกอย่าง vec! เอาไว้ให้ ซึ่งจะช่วยสร้างเวกเตอร์ใหม่ที่บรรจุค่าเริ่มต้นตามที่คุณกำหนดไว้อย่างง่ายดาย ในลิสติ้ง 8-2 จะเป็นการสร้าง Vec<i32> ตัวใหม่ที่บรรจุค่า 1, 2 และ 3 เอาไว้ โดยค่าเหล่านี้จะเป็นชนิด i32 เพราะเป็นชนิดจำนวนเต็มปริยายของภาษา ตามที่เราได้อธิบายไว้ในหัวข้อ “ชนิดข้อมูล” ในบทที่ 3
fn main() {
let v = vec![1, 2, 3];
}
เนื่องจากเราได้กำหนดค่าเริ่มต้นเป็นเลขจำนวนเต็มชนิด i32 ไปแล้ว Rust จึงอนุมานได้ทันทีว่าตัวแปร v มีชนิดข้อมูลเป็น Vec<i32> จึงไม่จำเป็นต้องเขียนระบุชนิดข้อมูลอีกต่อไป ลำดับถัดไป เราจะมาดูวิธีการแก้ไขข้อมูลในเวกเตอร์กัน
การอัปเดตเวกเตอร์
ในการสร้างเวกเตอร์ขึ้นมาแล้วค่อยๆ เพิ่มข้อมูลเข้าไปในภายหลัง เราสามารถเรียกใช้เมธอด push ได้ดังที่แสดงในลิสติ้ง 8-3
fn main() {
let mut v = Vec::new();
v.push(5);
v.push(6);
v.push(7);
v.push(8);
}
และเช่นเดียวกับตัวแปรทั่วไปใน Rust หากเราต้องการแก้ไขเปลี่ยนแปลงค่าในตัวแปรได้ เราจะต้องประกาศให้ตัวแปรนั้นเปลี่ยนแปลงค่าได้ (mutable) ด้วยคีย์เวิร์ด mut ดังที่ได้กล่าวถึงในบทที่ 3 สำหรับตัวเลขที่เราเพิ่มเข้าไปนั้นล้วนเป็นชนิด i32 ซึ่ง Rust สามารถอนุมานได้จากข้อมูลโดยตรง เราจึงไม่จำเป็นต้องเขียนระบุ Vec<i32> แต่อย่างใด
การอ่านองค์ประกอบของเวกเตอร์
การอ้างอิงถึงค่าที่จัดเก็บอยู่ในเวกเตอร์สามารถทำได้ 2 วิธี ได้แก่: การเข้าถึงผ่านดัชนี (indexing) หรือการเรียกใช้เมธอด get ในตัวอย่างถัดไปนี้ เราได้เขียนระบุชนิดข้อมูลของค่าที่ส่งกลับมาจากฟังก์ชันเหล่านี้ไว้ด้วยเพื่อความชัดเจนเป็นพิเศษ
ลิสติ้ง 8-4 แสดงทั้งสองวิธีในการเข้าถึงค่าในเวกเตอร์ ทั้งการใช้วากยสัมพันธ์ดัชนีและการใช้เมธอด get
fn main() {
let v = vec![1, 2, 3, 4, 5];
let third: &i32 = &v[2];
println!("The third element is {third}");
let third: Option<&i32> = v.get(2);
match third {
Some(third) => println!("The third element is {third}"),
None => println!("There is no third element."),
}
}
โปรดสังเกตรายละเอียดที่น่าสนใจตรงนี้ เราใช้ค่าดัชนี 2 เพื่อดึงข้อมูลตัวที่ 3 ออกมา เนื่องจากเวกเตอร์จะเริ่มต้นนับดัชนีจากเลขศูนย์ (0) เสมอ การใช้เครื่องหมาย & ร่วมกับวงเล็บก้ามปู [] จะให้ผลลัพธ์เป็นเรเฟอเรนซ์ (reference) ที่ชี้ไปยังข้อมูล ณ ตำแหน่งดัชนีนั้น ส่วนการเรียกใช้เมธอด get โดยส่งค่าดัชนีเข้าไปเป็นอาร์กิวเมนต์ จะให้ผลลัพธ์กลับมาเป็น Option<&T> ซึ่งเราสามารถนำไปใช้งานต่อร่วมกับคำสั่ง match ได้อย่างสะดวก
Rust จัดเตรียมสองวิธีนี้ไว้ให้ เพื่อให้คุณสามารถเลือกได้ว่าต้องการให้โปรแกรมทำงานอย่างไร เมื่อมีการพยายามเข้าถึงค่าดัชนีที่อยู่นอกช่วงข้อมูลที่มีอยู่จริง ลองมาดูตัวอย่างสิ่งที่จะเกิดขึ้นเมื่อเรามีเวกเตอร์ที่บรรจุข้อมูลอยู่ 5 ตัว แล้วเราพยายามเข้าถึงข้อมูลที่ตำแหน่งดัชนี 100 ด้วยแต่ละเทคนิคกัน ดังแสดงในลิสติ้ง 8-5
fn main() {
let v = vec![1, 2, 3, 4, 5];
let does_not_exist = &v[100];
let does_not_exist = v.get(100);
}
เมื่อเราสั่งรันโค้ดชุดนี้ วิธีการแรกที่ใช้เครื่องหมายก้ามปู [] จะส่งผลให้โปรแกรมเกิดการแพนิก (panic) ทันที เนื่องจากเป็นการพยายามเข้าถึงตำแหน่งข้อมูลที่ไม่มีอยู่จริง วิธีนี้จึงเหมาะสมที่สุดเมื่อคุณต้องการให้โปรแกรมหยุดทำงานและแครชไปเลย หากมีโค้ดส่วนใดพยายามเข้าถึงข้อมูลเกินขอบเขตของเวกเตอร์
ในทางตรงกันข้าม เมื่อเราส่งค่าดัชนีที่อยู่นอกขอบเขตของเวกเตอร์เข้าไปยังเมธอด get มันจะส่งค่า None กลับมาอย่างนุ่มนวลโดยไม่ทำให้โปรแกรมแพนิก ซึ่งคุณควรเลือกใช้วิธีนี้เมื่อการเข้าถึงข้อมูลนอกช่วงมีโอกาสเกิดขึ้นได้เป็นปกติในสถานการณ์ทั่วไป จากนั้นโค้ดของคุณก็จะมีตรรกะคอยดักจับจัดการกับทั้งกรณี Some(&element) หรือกรณี None ดังที่เราได้เรียนรู้กันไปแล้วในบทที่ 6 ตัวอย่างเช่น หากค่าดัชนีนั้นได้รับมาจากการที่ผู้ใช้กรอกตัวเลขเข้ามา แล้วผู้ใช้เผลอพิมพ์ตัวเลขที่มากเกินไปจนได้ค่า None โปรแกรมของคุณก็สามารถแจ้งเตือนผู้ใช้ได้อย่างสุภาพว่าในเวกเตอร์มีข้อมูลอยู่กี่ตัว พร้อมทั้งเปิดโอกาสให้พวกเขากรอกค่าใหม่อีกครั้ง ซึ่งย่อมเป็นมิตรต่อผู้ใช้งานมากกว่าการปล่อยให้โปรแกรมแครชดับไปต่อหน้าต่อตาเพียงเพราะพิมพ์ผิด!
เมื่อโปรแกรมถือเรเฟอเรนซ์ที่ถูกต้องเอาไว้ ตัวตรวจการยืม (borrow checker) จะคอยบังคับใช้กฎความเป็นเจ้าของและการยืม (ownership and borrowing rules - จากบทที่ 4) อย่างเคร่งครัด เพื่อให้มั่นใจได้ว่าเรเฟอเรนซ์นี้ รวมถึงเรเฟอเรนซ์อื่นๆ ทั้งหมดที่ชี้ไปยังข้อมูลภายในเวกเตอร์จะยังคงถูกต้องและปลอดภัยตลอดเวลา ย้อนกลับไปดูกฎสำคัญที่ระบุว่า คุณไม่สามารถถือเรเฟอเรนซ์แบบเปลี่ยนแปลงได้ (mutable reference) และเรเฟอเรนซ์แบบเปลี่ยนแปลงไม่ได้ (immutable reference) ร่วมกันภายในสโคปเดียวกันได้ กฎข้อนี้จะแสดงให้เห็นชัดเจนในลิสติ้ง 8-6 เมื่อเราถือเรเฟอเรนซ์แบบเปลี่ยนแปลงไม่ได้ของข้อมูลตัวแรกในเวกเตอร์เอาไว้ แล้วพยายามจะเพิ่มข้อมูลตัวใหม่ต่อท้ายเวกเตอร์ ซึ่งโปรแกรมนี้จะคอมไพล์ไม่ผ่านอย่างแน่นอน หากเราพยายามนำเรเฟอเรนซ์ของตัวแรกนั้นมาเรียกใช้งานต่อในภายหลัง
fn main() {
let mut v = vec![1, 2, 3, 4, 5];
let first = &v[0];
v.push(6);
println!("The first element is: {first}");
}
เมื่อพยายามคอมไพล์โค้ดดังกล่าว จะได้รับข้อผิดพลาดดังนี้:
$ cargo run
Compiling collections v0.1.0 (file:///projects/collections)
error[E0502]: cannot borrow `v` as mutable because it is also borrowed as immutable
--> src/main.rs:6:5
|
4 | let first = &v[0];
| - immutable borrow occurs here
5 |
6 | v.push(6);
| ^^^^^^^^^ mutable borrow occurs here
7 |
8 | println!("The first element is: {first}");
| ----- immutable borrow later used here
For more information about this error, try `rustc --explain E0502`.
error: could not compile `collections` (bin "collections") due to 1 previous error
เมื่อมองดูผิวเผิน โค้ดในลิสติ้ง 8-6 อาจดูเหมือนไม่น่าจะมีปัญหาอะไร: ทำไมการถือเรเฟอเรนซ์ชี้ไปยังสมาชิกตัวแรก ถึงต้องไปแคร์การเปลี่ยนแปลงที่เกิดขึ้นตรงส่วนท้ายของเวกเตอร์ด้วยล่ะ? สาเหตุของข้อผิดพลาดนี้มาจากกลไกการทำงานของเวกเตอร์ในระดับล่าง: เนื่องจากเวกเตอร์จะจัดเก็บข้อมูลเรียงติดต่อกันเป็นผืนเดียวในหน่วยความจำ ดังนั้นการเพิ่มสมาชิกตัวใหม่เข้าไปต่อท้ายเวกเตอร์ อาจบีบให้ต้องมีการจัดสรรหน่วยความจำก้อนใหม่ที่มีขนาดใหญ่ขึ้นบนฮีป แล้วคัดลอกข้อมูลเดิมทั้งหมดไปยังพื้นที่ใหม่ หากพื้นที่เดิมที่เวกเตอร์อาศัยอยู่มีที่ว่างไม่เพียงพอที่จะวางข้อมูลใหม่ต่อท้าย และในกรณีเช่นนั้น เรเฟอเรนซ์เดิมที่ชี้ไปยังสมาชิกตัวแรกก็จะกลายสภาพเป็นพอยน์เตอร์ที่ชี้ไปยังหน่วยความจำที่ถูกปลดปล่อยคืนไปแล้ว (deallocated memory / dangling reference)! กฎการยืมของ Rust จึงเข้ามาทำหน้าที่ป้องกันไม่ให้โปรแกรมของคุณตกอยู่ในสถานการณ์ที่อันตรายเช่นนี้ตั้งแต่ตอนคอมไพล์
หมายเหตุ: หากต้องการศึกษาลึกซึ้งถึงรายละเอียดการอิมพลีเมนต์ภายในของชนิดข้อมูล
Vec<T>เพิ่มเติม สามารถอ่านต่อได้ใน “The Rustonomicon”
การวนซ้ำค่าต่างๆ ในเวกเตอร์
หากเราต้องการเข้าถึงสมาชิกแต่ละตัวในเวกเตอร์เรียงตามลำดับ เรามักจะเลือกใช้วิธีการวนลูป (iterate) ผ่านสมาชิกทั้งหมด มากกว่าการใช้ดัชนีเข้าถึงทีละตำแหน่ง ลิสติ้ง 8-7 แสดงวิธีการใช้ลูป for เพื่อรับเรเฟอเรนซ์แบบเปลี่ยนแปลงไม่ได้ (immutable references) ของสมาชิกแต่ละตัวในเวกเตอร์ชนิด i32 แล้วพิมพ์ค่านั้นออกมา
fn main() {
let v = vec![100, 32, 57];
for i in &v {
println!("{i}");
}
}
นอกจากนี้ เรายังสามารถวนลูปผ่านเรเฟอเรนซ์แบบเปลี่ยนแปลงได้ (mutable references) ของสมาชิกแต่ละตัวในเวกเตอร์ที่ mutable ได้ เพื่อปรับแก้ค่าของสมาชิกทุกตัวพร้อมกัน ลูป for ในลิสติ้ง 8-8 จะบวกค่า 50 เพิ่มเข้าไปในสมาชิกแต่ละตัว
fn main() {
let mut v = vec![100, 32, 57];
for i in &mut v {
*i += 50;
}
}
ในการปรับเปลี่ยนค่าที่ตัวเรเฟอเรนซ์แบบเปลี่ยนแปลงได้ชี้ไป เราจำเป็นต้องใช้ตัวดำเนินการดีเรเฟอเรนซ์ (dereference operator) คือเครื่องหมายดอกจัน * เพื่อเข้าถึงตัวข้อมูลจริงที่อยู่ใน i เสียก่อน จึงจะสามารถใช้ตัวดำเนินการ += ได้ ซึ่งเราจะได้พูดคุยเกี่ยวกับตัวดำเนินการดีเรเฟอเรนซ์อย่างละเอียดในหัวข้อ “การตามเรเฟอเรนซ์ไปยังค่า” ในบทที่ 15
การวนลูปผ่านเวกเตอร์ ไม่ว่าจะเป็นแบบอ่านอย่างเดียวหรือแบบแก้ไขข้อมูล ล้วนมีความปลอดภัยอย่างยิ่งด้วยกฎเกณฑ์ของ borrow checker หากเราพยายามแทรกหรือลบสมาชิกภายในตัวลูป for ในลิสติ้ง 8-7 หรือลิสติ้ง 8-8 คอมไพเลอร์จะปฏิเสธและแจ้งข้อผิดพลาดออกมาคล้ายกับในลิสติ้ง 8-6 ทันที เพราะเรเฟอเรนซ์ของเวกเตอร์ที่ลูป for ถือครองอยู่นั้น จะช่วยป้องกันไม่ให้เกิดการแก้ไขโครงสร้างของเวกเตอร์ทั้งหมดไปพร้อมๆ กัน
การใช้ enum เพื่อจัดเก็บหลายชนิดข้อมูล
เวกเตอร์สามารถจัดเก็บได้เฉพาะข้อมูลที่เป็นชนิดเดียวกันเท่านั้น ซึ่งในบางกรณีอาจทำให้รู้สึกไม่สะดวกเท่าใดนัก เพราะแน่นอนว่าย่อมมีหลายสถานการณ์ที่เราจำเป็นต้องจัดเก็บรายการข้อมูลที่มีชนิดแตกต่างกันคละกันไป แต่โชคดีที่วาเรียนต์ต่างๆ ของ enum ล้วนถูกนิยามอยู่ภายใต้ชนิดข้อมูล enum เดียวกัน ดังนั้นเมื่อเราต้องการชนิดข้อมูลเดี่ยวชนิดเดียวที่สามารถเป็นตัวแทนของข้อมูลต่างชนิดกันได้ เราจึงสามารถนิยามและใช้งาน enum เข้ามาช่วยได้!
ตัวอย่างเช่น สมมติว่าเราต้องการอ่านค่าจากแถวหนึ่งในโปรแกรมสเปรดชีต ซึ่งข้อมูลในแต่ละคอลัมน์ของแถวนั้นมีทั้งตัวเลขจำนวนเต็ม, ตัวเลขทศนิยม และข้อความสตริง เราสามารถนิยาม enum ที่แต่ละวาเรียนต์ทำหน้าที่เก็บชนิดข้อมูลที่แตกต่างกันเหล่านั้น และวาเรียนต์ทั้งหมดก็จะถือว่าเป็นชนิดข้อมูลเดียวกัน นั่นคือชนิดของ enum ตัวนั้น จากนั้นเราก็สร้างเวกเตอร์ขึ้นมาเพื่อจัดเก็บ enum ดังกล่าว ซึ่งในทางปฏิบัติแล้ว ก็คือการทำให้เวกเตอร์สามารถจัดเก็บข้อมูลต่างชนิดกันได้นั่นเอง ดังที่แสดงไว้ในลิสติ้ง 8-9
fn main() {
enum SpreadsheetCell {
Int(i32),
Float(f64),
Text(String),
}
let row = vec![
SpreadsheetCell::Int(3),
SpreadsheetCell::Text(String::from("blue")),
SpreadsheetCell::Float(10.12),
];
}
Rust จำเป็นต้องรู้ชนิดข้อมูลที่จะบรรจุอยู่ในเวกเตอร์ให้ได้อย่างแน่ชัดตั้งแต่ตอนคอมไพล์ เพื่อที่คอมไพเลอร์จะได้คำนวณขนาดหน่วยความจำบนฮีปที่จะต้องใช้สำหรับจัดเก็บสมาชิกแต่ละตัวได้อย่างถูกต้องแม่นยำ นอกจากนี้ เรายังต้องระบุให้ชัดเจนด้วยว่าอนุญาตให้มีชนิดข้อมูลใดบ้างในเวกเตอร์นี้ หาก Rust ยอมให้เวกเตอร์เก็บชนิดข้อมูลใดๆ ก็ได้อย่างอิสระ ก็อาจมีความเสี่ยงที่ชนิดข้อมูลบางชนิดจะทำให้เกิดข้อผิดพลาดขึ้นเมื่อมีคำสั่งมาดำเนินการกับสมาชิกในเวกเตอร์ การนำ enum มาใช้ควบคู่กับคำสั่ง match จะช่วยให้ Rust มั่นใจได้ตั้งแต่ตอนคอมไพล์ว่า ทุกกรณีที่เป็นไปได้จะได้รับการจัดการอย่างครบถ้วนแน่นอน ดังที่เราได้พูดคุยกันในบทที่ 6
แต่ถ้าหากคุณไม่สามารถล่วงรู้ชนิดข้อมูลทั้งหมดที่โปรแกรมจะต้องรับเข้ามาในเวกเตอร์ในตอนรันไทม์ได้อย่างครบถ้วน เทคนิคการใช้ enum นี้ก็อาจจะไม่ตอบโจทย์ ในกรณีเช่นนั้น คุณสามารถเปลี่ยนไปใช้เทคนิคที่เรียกว่า เทรตออบเจกต์ (trait object) แทนได้ ซึ่งเราจะได้เรียนรู้กันในบทที่ 18
หลังจากที่เราได้เรียนรู้วิธีการใช้งานเวกเตอร์ที่พบบ่อยกันไปแล้ว อย่าลืมเข้าไปอ่าน เอกสารประกอบ API ของ Vec<T> เพื่อศึกษาเมธอดที่มีประโยชน์อื่นๆ อีกมากมายที่ไลบรารีมาตรฐานเตรียมไว้ให้ เช่น นอกเหนือจากเมธอด push แล้ว ยังมีเมธอด pop ที่ใช้สำหรับลบและส่งค่าสมาชิกตัวสุดท้ายกลับออกมา เป็นต้น
การทิ้งเวกเตอร์จะปลดปล่อยองค์ประกอบทั้งหมดไปพร้อมกัน
และเช่นเดียวกับโครงสร้าง struct ทั่วไป เวกเตอร์จะถูกปลดปล่อยหน่วยความจำ (dropped) ทันทีเมื่อมันหลุดออกจากสโคป ดังที่กำกับไว้ในลิสติ้ง 8-10
fn main() {
{
let v = vec![1, 2, 3, 4];
// do stuff with v
} // <- v goes out of scope and is freed here
}
เมื่อเวกเตอร์ถูก drop ข้อมูลทั้งหมดที่บรรจุอยู่ภายในก็จะถูก drop ตามไปด้วย ซึ่งหมายความว่าตัวเลขจำนวนเต็มทั้งหมดที่มันถือครองอยู่จะถูกล้างเคลียร์ออกจากหน่วยความจำอย่างหมดจด โดยที่ borrow checker จะคอยดูแลให้มั่นใจเสมอว่า เรเฟอเรนซ์ใดๆ ที่ชี้ไปยังข้อมูลในเวกเตอร์ จะถูกเรียกใช้งานเฉพาะในช่วงเวลาที่ตัวเวกเตอร์นั้นยังคงมีชีวิตอยู่และถูกต้องเท่านั้น
คราวนี้ เรามาดูคอลเลกชันตัวถัดไปกัน: String!