การตรวจสอบความถูกต้องของเรเฟอเรนซ์ด้วยไลฟ์ไทม์
ไลฟ์ไทม์ (lifetime) เป็นเจเนอริกอีกรูปแบบหนึ่งที่เราเคยใช้งานกันมาแล้ว แต่แทนที่จะเป็นการรับประกันว่าชนิดข้อมูลจะมีพฤติกรรมตามที่เราต้องการ ไลฟ์ไทม์จะช่วยรับประกันว่าเรเฟอเรนซ์ (reference) จะยังคงถูกต้องและใช้งานได้ตราบเท่าที่เรายังจำเป็นต้องใช้มัน
รายละเอียดอย่างหนึ่งที่เรายังไม่ได้พูดถึงในหัวข้อ“เรเฟอเรนซ์และการยืม” ในบทที่ 4 ก็คือ ทุกเรเฟอเรนซ์ใน Rust ต่างก็มีไลฟ์ไทม์ ซึ่งก็คือขอบเขต (scope) ที่เรเฟอเรนซ์นั้นสามารถใช้งานได้อย่างถูกต้อง โดยส่วนใหญ่แล้ว ไลฟ์ไทม์จะถูกอนุมาน (infer) ขึ้นมาโดยปริยาย เช่นเดียวกับชนิดข้อมูลที่คอมไพเลอร์มักอนุมานให้เอง เราจำเป็นต้องระบุชนิดข้อมูลกำกับไว้เฉพาะเมื่อมีชนิดข้อมูลที่เป็นไปได้หลายแบบเท่านั้น ในทำนองเดียวกัน เราต้องระบุไลฟ์ไทม์เมื่อความสัมพันธ์ระหว่างไลฟ์ไทม์ของเรเฟอเรนซ์ต่างๆ อาจเป็นไปได้หลายรูปแบบ Rust กำหนดให้เราระบุความสัมพันธ์เหล่านั้นด้วยพารามิเตอร์ไลฟ์ไทม์แบบเจเนอริก (generic lifetime parameters) เพื่อให้มั่นใจได้ว่าเรเฟอเรนซ์จริงที่ใช้งานตอนรันไทม์จะยังคงถูกต้องและใช้งานได้อย่างแน่นอน
การระบุไลฟ์ไทม์ (lifetime annotation) เป็นแนวคิดที่ภาษาโปรแกรมส่วนใหญ่ไม่มีด้วยซ้ำ จึงอาจทำให้คุณรู้สึกไม่คุ้นเคยอยู่บ้าง แม้ว่าในบทนี้เราจะไม่ได้ครอบคลุมเรื่องไลฟ์ไทม์อย่างครบถ้วนทุกแง่มุม แต่เราจะอธิบายรูปแบบวากยสัมพันธ์ของไลฟ์ไทม์ที่คุณมักพบเจอบ่อยๆ เพื่อให้คุณเริ่มคุ้นเคยกับแนวคิดนี้
เรเฟอเรนซ์ที่ชี้ไปยังหน่วยความจำที่ถูกคืนแล้ว
เป้าหมายหลักของไลฟ์ไทม์คือการป้องกัน dangling reference (เรเฟอเรนซ์ที่ชี้ไปยังข้อมูลที่ถูกคืนหน่วยความจำไปแล้ว) ซึ่งหากยอมให้เกิดขึ้นได้ ก็จะทำให้โปรแกรมไปอ้างอิงข้อมูลอื่นที่ไม่ใช่ข้อมูลที่ตั้งใจไว้ ลองพิจารณาโปรแกรมในลิสติ้ง 10-16 ซึ่งมีสโคปชั้นนอกและสโคปชั้นใน
fn main() {
let r;
{
let x = 5;
r = &x;
}
println!("r: {r}");
}
หมายเหตุ: ตัวอย่างในลิสติ้ง 10-16, 10-17 และ 10-23 มีการประกาศตัวแปรโดยไม่กำหนดค่าเริ่มต้น ชื่อตัวแปรจึงมีตัวตนอยู่ในสโคปชั้นนอก เมื่อมองแวบแรก อาจดูเหมือนขัดแย้งกับความจริงที่ว่า Rust ไม่มีค่า null ทว่าหากเราพยายามนำตัวแปรไปใช้งานก่อนที่จะกำหนดค่าให้ มันจะเกิดข้อผิดพลาดขึ้นตอนคอมไพล์ ซึ่งแสดงให้เห็นว่า Rust ไม่อนุญาตให้มีค่า null อย่างแท้จริง
สโคปชั้นนอกประกาศตัวแปรชื่อ r โดยไม่มีค่าเริ่มต้น ส่วนสโคปชั้นในประกาศตัวแปรชื่อ x ที่มีค่าเริ่มต้นเป็น 5 ภายในสโคปชั้นใน เราพยายามกำหนดค่าให้ r เป็นเรเฟอเรนซ์ที่ชี้ไปยัง x จากนั้นเมื่อสโคปชั้นในสิ้นสุดลง เราจึงพยายามพิมพ์ค่าของ r ออกมา โค้ดนี้จะไม่สามารถคอมไพล์ได้ เพราะค่าที่ r อ้างอิงอยู่นั้นหลุดออกจากสโคปไปแล้วก่อนที่เราจะนำมันมาใช้งาน นี่คือข้อความแสดงข้อผิดพลาดที่เกิดขึ้น:
$ cargo run
Compiling chapter10 v0.1.0 (file:///projects/chapter10)
error[E0597]: `x` does not live long enough
--> src/main.rs:6:13
|
5 | let x = 5;
| - binding `x` declared here
6 | r = &x;
| ^^ borrowed value does not live long enough
7 | }
| - `x` dropped here while still borrowed
8 |
9 | println!("r: {r}");
| - borrow later used here
For more information about this error, try `rustc --explain E0597`.
error: could not compile `chapter10` (bin "chapter10") due to 1 previous error
ข้อความแสดงข้อผิดพลาดระบุว่าตัวแปร x “does not live long enough” (อยู่ได้ไม่นานพอ) สาเหตุก็คือ x จะหลุดออกจากสโคปเมื่อสโคปชั้นในสิ้นสุดลงที่บรรทัดที่ 7 แต่ r ยังคงใช้งานได้ในสโคปชั้นนอก เนื่องจากสโคปของมันกว้างกว่า เราจึงกล่าวว่ามัน “มีอายุยืนยาวกว่า (lives longer)” หาก Rust ปล่อยให้โค้ดนี้ทำงานได้ r ก็จะไปอ้างถึงตำแหน่งหน่วยความจำที่ถูกคืน (deallocated) ไปแล้วตั้งแต่ตอนที่ x หลุดจากสโคป และไม่ว่าเราจะพยายามทำอะไรกับ r ก็จะไม่สามารถทำงานได้อย่างถูกต้อง แล้ว Rust ตรวจสอบได้อย่างไรว่าโค้ดนี้ไม่ถูกต้อง? คำตอบคือ Rust ใช้ระบบที่เรียกว่าตัวตรวจการยืม (borrow checker)
ตัวตรวจการยืม
คอมไพเลอร์ของ Rust มี ตัวตรวจการยืม (borrow checker) ที่คอยเปรียบเทียบสโคปต่างๆ เพื่อประเมินว่าการยืมทั้งหมดนั้นถูกต้องหรือไม่ ลิสติ้ง 10-17 แสดงโค้ดชุดเดิมจากลิสติ้ง 10-16 แต่เพิ่มคำอธิบายกำกับเพื่อแสดงช่วงอายุ (lifetime) ของตัวแปรแต่ละตัว
fn main() {
let r; // ---------+-- 'a
// |
{ // |
let x = 5; // -+-- 'b |
r = &x; // | |
} // -+ |
// |
println!("r: {r}"); // |
} // ---------+
ในที่นี้ เราได้กำกับไลฟ์ไทม์ของ r ด้วย 'a และไลฟ์ไทม์ของ x ด้วย 'b อย่างที่คุณเห็น บล็อก 'b ชั้นในนั้นมีขนาดเล็กกว่าบล็อกไลฟ์ไทม์ 'a ชั้นนอกมาก ในตอนคอมไพล์ Rust จะเปรียบเทียบขนาดของไลฟ์ไทม์ทั้งสอง และพบว่า r มีไลฟ์ไทม์เป็น 'a แต่มันกลับไปอ้างถึงหน่วยความจำที่มีไลฟ์ไทม์เพียงแค่ 'b โปรแกรมจึงถูกปฏิเสธเนื่องจากช่วงชีวิตของ 'b สั้นกว่า 'a' นั่นคือ ข้อมูลที่ถูกเรเฟอเรนซ์อ้างถึงอยู่ได้ไม่นานเท่ากับตัวเรเฟอเรนซ์เอง
ลิสติ้ง 10-18 แก้ไขโค้ดไม่ให้มี dangling reference อีกต่อไป ทำให้สามารถคอมไพล์ผ่านได้โดยไม่มีข้อผิดพลาดใดๆ
fn main() {
let x = 5; // ----------+-- 'b
// |
let r = &x; // --+-- 'a |
// | |
println!("r: {r}"); // | |
// --+ |
} // ----------+
ในตัวอย่างนี้ x มีไลฟ์ไทม์ 'b ซึ่งกว้างกว่า 'a นั่นหมายความว่า r สามารถอ้างถึง x ได้อย่างปลอดภัย เพราะ Rust ทราบว่าเรเฟอเรนซ์ใน r จะยังคงถูกต้องและใช้งานได้เสมอ ตราบใดที่ x ยังคงมีชีวิตอยู่
เมื่อคุณเข้าใจแล้วว่าไลฟ์ไทม์ของเรเฟอเรนซ์ทำงานอย่างไร และ Rust วิเคราะห์ไลฟ์ไทม์เพื่อรับประกันความถูกต้องของเรเฟอเรนซ์อย่างไร ต่อไปเรามาสำรวจการใช้ไลฟ์ไทม์แบบเจเนอริกในพารามิเตอร์และค่าที่ส่งคืนจากฟังก์ชันกัน
ไลฟ์ไทม์แบบเจเนอริกในฟังก์ชัน
เราจะเขียนฟังก์ชันที่คืนค่าที่ยาวกว่าระหว่างสตริงสไลซ์ (string slice) สองตัว ฟังก์ชันนี้จะรับสตริงสไลซ์สองตัวและคืนสตริงสไลซ์เพียงตัวเดียว หลังจากที่เราอิมพลีเมนต์ฟังก์ชัน longest แล้ว โค้ดในลิสติ้ง 10-19 ควรพิมพ์ The longest string is abcd
fn main() {
let string1 = String::from("abcd");
let string2 = "xyz";
let result = longest(string1.as_str(), string2);
println!("The longest string is {result}");
}
โปรดสังเกตว่าเราต้องการให้ฟังก์ชันรับสตริงสไลซ์ (string slice) ซึ่งเป็นเรเฟอเรนซ์ แทนที่จะเป็นชนิดข้อมูลสตริงที่เป็นเจ้าของค่า เพราะเราไม่ต้องการให้ฟังก์ชัน longest เข้ามาเป็นเจ้าของพารามิเตอร์เหล่านั้น สามารถดูรายละเอียดเพิ่มเติมได้ที่หัวข้อ“สตริงสไลซ์ในฐานะพารามิเตอร์” ในบทที่ 4 ว่าเหตุใดพารามิเตอร์ที่เราใช้ในลิสติ้ง 10-19 จึงเป็นทางเลือกที่เหมาะสมที่สุด
หากเราพยายามอิมพลีเมนต์ฟังก์ชัน longest ตามที่แสดงในลิสติ้ง 10-20 มันจะไม่คอมไพล์
fn main() {
let string1 = String::from("abcd");
let string2 = "xyz";
let result = longest(string1.as_str(), string2);
println!("The longest string is {result}");
}
fn longest(x: &str, y: &str) -> &str {
if x.len() > y.len() { x } else { y }
}
แต่ผลลัพธ์กลับกลายเป็นข้อผิดพลาดต่อไปนี้ที่กล่าวถึงเรื่องไลฟ์ไทม์:
$ cargo run
Compiling chapter10 v0.1.0 (file:///projects/chapter10)
error[E0106]: missing lifetime specifier
--> src/main.rs:9:33
|
9 | fn longest(x: &str, y: &str) -> &str {
| ---- ---- ^ expected named lifetime parameter
|
= help: this function's return type contains a borrowed value, but the signature does not say whether it is borrowed from `x` or `y`
help: consider introducing a named lifetime parameter
|
9 | fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
| ++++ ++ ++ ++
For more information about this error, try `rustc --explain E0106`.
error: could not compile `chapter10` (bin "chapter10") due to 1 previous error
ข้อความช่วยเหลือ (help text) ชี้แจงว่าชนิดข้อมูลที่ส่งคืนจำเป็นต้องมีพารามิเตอร์ไลฟ์ไทม์แบบเจเนอริกกำกับอยู่ด้วย เนื่องจาก Rust ไม่สามารถบอกได้ว่าเรเฟอเรนซ์ที่ส่งคืนนั้นอ้างถึง x หรือ y กันแน่ ซึ่งอันที่จริงแล้ว แม้แต่เราเองก็ไม่ทราบ เพราะบล็อก if ในเนื้อหาของฟังก์ชันจะคืนเรเฟอเรนซ์ของ x ส่วนบล็อก else จะคืนเรเฟอเรนซ์ของ y!
ในตอนที่เรานิยามฟังก์ชันนี้ เราไม่รู้ค่าจริงที่จะถูกส่งเข้ามา เราจึงไม่อาจทราบล่วงหน้าได้ว่าโค้ดจะเข้าไปทำงานในกรณี if หรือ else ยิ่งไปกว่านั้น เรายังไม่รู้ไลฟ์ไทม์ที่แท้จริงของเรเฟอเรนซ์ที่จะถูกส่งเข้ามาด้วย จึงไม่สามารถตรวจสอบสโคปแบบที่เราทำในลิสติ้ง 10-17 และ 10-18 เพื่อชี้ขาดว่าเรเฟอเรนซ์ที่เราส่งคืนจะยังใช้งานได้อย่างถูกต้องเสมอหรือไม่ ตัวตรวจการยืมเองก็ตัดสินไม่ได้เช่นกัน เพราะมันไม่รู้ว่าไลฟ์ไทม์ของ x และ y เชื่อมโยงกับไลฟ์ไทม์ของค่าที่ส่งคืนอย่างไร เพื่อแก้ไขข้อผิดพลาดนี้ เราจำเป็นต้องเพิ่มพารามิเตอร์ไลฟ์ไทม์แบบเจเนอริกเพื่อกำหนดความสัมพันธ์ระหว่างเรเฟอเรนซ์เหล่านั้น ซึ่งจะช่วยให้ตัวตรวจการยืมสามารถวิเคราะห์ความถูกต้องได้อย่างสมบูรณ์
วากยสัมพันธ์ของการระบุไลฟ์ไทม์
การระบุไลฟ์ไทม์ (lifetime annotation) ไม่ได้เป็นการเปลี่ยนแปลงช่วงชีวิตของเรเฟอเรนซ์ใดๆ เลย แต่มีไว้เพื่ออธิบายความสัมพันธ์ระหว่างช่วงชีวิตของเรเฟอเรนซ์หลายๆ ตัวเข้าด้วยกัน โดยไม่ส่งผลกระทบต่อไลฟ์ไทม์เดิมของพวกมัน เช่นเดียวกับที่ฟังก์ชันสามารถรับชนิดข้อมูลใดๆ ก็ได้เมื่อในซิกเนเจอร์มีพารามิเตอร์ชนิดข้อมูลแบบเจเนอริก ฟังก์ชันก็สามารถรับเรเฟอเรนซ์ที่มีไลฟ์ไทม์ใดๆ ก็ได้โดยการระบุพารามิเตอร์ไลฟ์ไทม์แบบเจเนอริกเช่นกัน
การระบุไลฟ์ไทม์มีวากยสัมพันธ์ที่ค่อนข้างแปลกตาเล็กน้อย: ชื่อของพารามิเตอร์ไลฟ์ไทม์จะต้องขึ้นต้นด้วยเครื่องหมายอะพอสทรอฟี (') และมักจะเป็นตัวพิมพ์เล็กทั้งหมดที่มีความยาวสั้นมากๆ เช่นเดียวกับชนิดข้อมูลเจเนอริก โดยธรรมเนียมแล้วคนส่วนใหญ่มักจะตั้งชื่อ 'a เป็นการระบุไลฟ์ไทม์ตัวแรก เราจะวางการระบุพารามิเตอร์ไลฟ์ไทม์ไว้หลังเครื่องหมาย & ของเรเฟอเรนซ์ และคั่นด้วยการเว้นวรรคหนึ่งช่องก่อนจะตามด้วยชนิดข้อมูลของเรเฟอเรนซ์นั้น
นี่คือตัวอย่างบางส่วน—เรเฟอเรนซ์ที่ชี้ไปยัง i32 แบบไม่มีพารามิเตอร์ไลฟ์ไทม์, เรเฟอเรนซ์ที่ชี้ไปยัง i32 ที่มีพารามิเตอร์ไลฟ์ไทม์ชื่อ 'a กำกับอยู่, และเรเฟอเรนซ์แบบแก้ไขได้ (mutable reference) ที่ชี้ไปยัง i32 ซึ่งมีไลฟ์ไทม์ 'a กำกับไว้เช่นกัน:
&i32 // a reference
&'a i32 // a reference with an explicit lifetime
&'a mut i32 // a mutable reference with an explicit lifetime
การระบุไลฟ์ไทม์โดดๆ เพียงตัวเดียวจะไม่มีความหมายอะไรมากนัก เนื่องจากการระบุไลฟ์ไทม์มีจุดประสงค์หลักเพื่อบอก Rust ว่าพารามิเตอร์ไลฟ์ไทม์แบบเจเนอริกของเรเฟอเรนซ์หลายๆ ตัวนั้นสัมพันธ์กันอย่างไร มาดูกันว่าการระบุไลฟ์ไทม์มีความเกี่ยวข้องกันอย่างไรในบริบทของฟังก์ชัน longest
ในซิกเนเจอร์ของฟังก์ชัน
ในการระบุไลฟ์ไทม์ในซิกเนเจอร์ของฟังก์ชัน เราจะต้องประกาศพารามิเตอร์ไลฟ์ไทม์แบบเจเนอริกไว้ภายในวงเล็บสามเหลี่ยมคั่นกลางระหว่างชื่อฟังก์ชันกับรายการพารามิเตอร์ เช่นเดียวกับวิธีที่เราทำกับพารามิเตอร์ชนิดข้อมูลแบบเจเนอริก
เราต้องการให้ซิกเนเจอร์สื่อถึงเงื่อนไขข้อจำกัดว่า: เรเฟอเรนซ์ที่ส่งคืนจะยังคงใช้งานได้ตราบเท่าที่พารามิเตอร์ทั้งสองตัวยังคงใช้งานได้ นี่คือความสัมพันธ์ระหว่างไลฟ์ไทม์ของพารามิเตอร์กับค่าที่ส่งคืน เราจะตั้งชื่อไลฟ์ไทม์นี้ว่า 'a แล้วนำไปใส่กำกับให้กับเรเฟอเรนซ์แต่ละตัว ดังที่แสดงในลิสติ้ง 10-21
fn main() {
let string1 = String::from("abcd");
let string2 = "xyz";
let result = longest(string1.as_str(), string2);
println!("The longest string is {result}");
}
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
if x.len() > y.len() { x } else { y }
}
โค้ดนี้จะสามารถคอมไพล์ผ่านและให้ผลลัพธ์ตามที่เราต้องการเมื่อนำไปใช้งานร่วมกับฟังก์ชัน main ในลิสติ้ง 10-19
ในตอนนี้ ซิกเนเจอร์ของฟังก์ชันได้บอกให้ Rust ทราบว่า สำหรับไลฟ์ไทม์ 'a หนึ่งๆ ฟังก์ชันนี้จะรับพารามิเตอร์สองตัว ซึ่งทั้งคู่เป็นสตริงสไลซ์ที่มีอายุยืนยาวอย่างน้อยเท่ากับไลฟ์ไทม์ 'a นอกจากนี้ ซิกเนเจอร์ยังบอก Rust อีกว่า สตริงสไลซ์ที่ส่งคืนจากฟังก์ชันก็จะมีอายุยืนยาวอย่างน้อยเท่ากับไลฟ์ไทม์ 'a ด้วยเช่นกัน ในทางปฏิบัติ นั่นหมายความว่าไลฟ์ไทม์ของเรเฟอเรนซ์ที่ฟังก์ชัน longest ส่งคืนจะมีขนาดเท่ากับไลฟ์ไทม์ที่สั้นกว่าระหว่างไลฟ์ไทม์ของค่าที่อาร์กิวเมนต์ทั้งสองตัวอ้างถึง ความสัมพันธ์เหล่านี้คือสิ่งที่ Rust จะนำไปใช้ในการวิเคราะห์โค้ด
โปรดจำไว้ว่า การระบุพารามิเตอร์ไลฟ์ไทม์ในซิกเนเจอร์ของฟังก์ชันนี้ เราไม่ได้ไปเปลี่ยนแปลงไลฟ์ไทม์ของค่าใดๆ ที่ส่งเข้ามาหรือส่งคืนกลับไปเลย แต่เป็นการระบุข้อกำหนดเพื่อให้ตัวตรวจการยืมปฏิเสธค่าใดๆ ก็ตามที่ไม่สอดคล้องกับเงื่อนไขเหล่านี้ โปรดสังเกตว่าฟังก์ชัน longest ไม่จำเป็นต้องรู้ว่า x และ y จะมีอายุอยู่ได้นานเท่าใดกันแน่ ขอเพียงแค่มีสโคปบางสโคปที่สามารถนำมาแทนค่า 'a แล้วทำให้ซิกเนเจอร์นี้ถูกต้องสมบูรณ์ได้ก็เพียงพอแล้ว
เมื่อระบุไลฟ์ไทม์ในฟังก์ชัน คำระบุเหล่านั้นจะวางอยู่ในซิกเนเจอร์ของฟังก์ชัน ไม่ใช่ในเนื้อหาของฟังก์ชัน การระบุไลฟ์ไทม์จึงกลายมาเป็นส่วนหนึ่งของสัญญา (contract) ของฟังก์ชัน คล้ายกับการระบุชนิดข้อมูลในซิกเนเจอร์ การมีสัญญาเรื่องไลฟ์ไทม์อยู่ในซิกเนเจอร์ของฟังก์ชันทำให้การวิเคราะห์ของคอมไพเลอร์ Rust ทำได้ง่ายขึ้นและตรงไปตรงมา หากมีจุดผิดพลาดเกี่ยวกับการระบุไลฟ์ไทม์หรือวิธีการเรียกใช้งานฟังก์ชัน ข้อผิดพลาดจากคอมไพเลอร์ก็จะสามารถชี้ไปยังตำแหน่งของโค้ดและข้อจำกัดต่างๆ ได้อย่างแม่นยำ ในทางตรงกันข้าม หากคอมไพเลอร์ Rust พยายามอนุมานเจตนาความสัมพันธ์ของไลฟ์ไทม์เอาเองมากเกินไป คอมไพเลอร์อาจชี้ได้เพียงแค่จุดที่เรียกใช้โค้ด ซึ่งอาจอยู่ห่างจากต้นตอของปัญหาจริงๆ ไปหลายขั้นตอน
เมื่อเราส่งเรเฟอเรนซ์จริงๆ เข้าไปยัง longest ไลฟ์ไทม์ที่แท้จริงซึ่งจะถูกนำมาแทนที่ 'a ก็คือส่วนของสโคปของ x ที่ทับซ้อนกับสโคปของ y กล่าวอีกนัยหนึ่ง ไลฟ์ไทม์แบบเจเนอริก 'a จะได้รับไลฟ์ไทม์จริงที่มีขนาดเท่ากับไลฟ์ไทม์ที่สั้นกว่าระหว่าง x กับ y และเนื่องจากเรากำกับเรเฟอเรนซ์ที่ส่งคืนด้วยพารามิเตอร์ไลฟ์ไทม์ 'a ตัวเดียวกัน เรเฟอเรนซ์ที่ส่งคืนจึงมีอายุใช้งานได้ยาวนานเท่ากับไลฟ์ไทม์ที่สั้นกว่าระหว่าง x กับ y ด้วยเช่นกัน
มาดูกันว่าการระบุไลฟ์ไทม์จำกัดการทำงานของฟังก์ชัน longest อย่างไรเมื่อเราส่งเรเฟอเรนซ์ที่มีไลฟ์ไทม์จริงๆ แตกต่างกัน ลิสติ้ง 10-22 เป็นตัวอย่างที่ชัดเจนและตรงไปตรงมา
fn main() {
let string1 = String::from("long string is long");
{
let string2 = String::from("xyz");
let result = longest(string1.as_str(), string2.as_str());
println!("The longest string is {result}");
}
}
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
if x.len() > y.len() { x } else { y }
}
ในตัวอย่างนี้ string1 สามารถใช้งานได้จนกระทั่งสิ้นสุดสโคปชั้นนอก ส่วน string2 สามารถใช้งานได้จนสิ้นสุดสโคปชั้นใน และ result อ้างถึงข้อมูลที่ใช้งานได้จนสิ้นสุดสโคปชั้นใน เมื่อรันโค้ดนี้จะพบว่าตัวตรวจการยืมอนุญาตให้ผ่านได้ โดยจะคอมไพล์ผ่านและพิมพ์ The longest string is long string is long
ถัดไป มาลองดูตัวอย่างที่แสดงให้เห็นว่าไลฟ์ไทม์ของเรเฟอเรนซ์ใน result จะต้องเป็นไลฟ์ไทม์ที่สั้นกว่าระหว่างอาร์กิวเมนต์ทั้งสองตัว เราจะย้ายการประกาศตัวแปร result ออกไปไว้นอกสโคปชั้นใน แต่ยังคงการกำหนดค่าให้ตัวแปร result ไว้ภายในสโคปที่มี string2 จากนั้นเราจะย้ายคำสั่ง println! ที่เรียกใช้ result ออกไปไว้นอกสโคปชั้นใน หลังจากที่สโคปชั้นในสิ้นสุดลงแล้ว โค้ดในลิสติ้ง 10-23 จะคอมไพล์ไม่ผ่าน
fn main() {
let string1 = String::from("long string is long");
let result;
{
let string2 = String::from("xyz");
result = longest(string1.as_str(), string2.as_str());
}
println!("The longest string is {result}");
}
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
if x.len() > y.len() { x } else { y }
}
เมื่อเราพยายามคอมไพล์โค้ดนี้ เราจะได้ข้อผิดพลาดนี้:
$ cargo run
Compiling chapter10 v0.1.0 (file:///projects/chapter10)
error[E0597]: `string2` does not live long enough
--> src/main.rs:6:44
|
5 | let string2 = String::from("xyz");
| ------- binding `string2` declared here
6 | result = longest(string1.as_str(), string2.as_str());
| ^^^^^^^ borrowed value does not live long enough
7 | }
| - `string2` dropped here while still borrowed
8 | println!("The longest string is {result}");
| ------ borrow later used here
For more information about this error, try `rustc --explain E0597`.
error: could not compile `chapter10` (bin "chapter10") due to 1 previous error
ข้อผิดพลาดแสดงว่า การที่ result จะสามารถใช้งานในคำสั่ง println! ได้นั้น string2 จะต้องมีอายุใช้งานได้จนถึงจุดสิ้นสุดของสโคปชั้นนอกด้วย Rust ทราบเรื่องนี้เพราะเราได้ระบุไลฟ์ไทม์ของพารามิเตอร์และค่าที่ส่งคืนด้วยพารามิเตอร์ไลฟ์ไทม์ 'a ตัวเดียวกัน
ในฐานะมนุษย์ เราอาจมองโค้ดนี้แล้วเห็นว่า string1 ยาวกว่า string2 ดังนั้น result ย่อมต้องเก็บเรเฟอเรนซ์ที่ชี้ไปยัง string1 อย่างแน่นอน และเนื่องจาก string1 ยังไม่ได้หลุดออกจากสโคป เรเฟอเรนซ์ไปยัง string1 ก็น่าจะยังคงใช้งานในคำสั่ง println! ได้ อย่างไรก็ตาม คอมไพเลอร์ไม่สามารถมองเห็นความจริงเฉพาะหน้านี้ได้ เราได้บอกกับ Rust เอาไว้ว่าไลฟ์ไทม์ของเรเฟอเรนซ์ที่ส่งคืนจากฟังก์ชัน longest มีขนาดเท่ากับไลฟ์ไทม์ที่สั้นกว่าระหว่างเรเฟอเรนซ์ที่ส่งเข้ามา ดังนั้น ตัวตรวจการยืมจึงไม่อนุญาตโค้ดในลิสติ้ง 10-23 เนื่องจากมองว่ามีความเสี่ยงที่จะเกิดเรเฟอเรนซ์ที่ไม่ถูกต้องขึ้น
ลองออกแบบการทดลองเพิ่มเติมโดยปรับเปลี่ยนค่าและไลฟ์ไทม์ของเรเฟอเรนซ์ที่ส่งเข้าฟังก์ชัน longest รวมถึงวิธีนำเรเฟอเรนซ์ที่ได้กลับไปใช้งาน แล้วลองตั้งสมมติฐานดูก่อนคอมไพล์ว่าการทดลองของคุณจะผ่านตัวตรวจการยืมหรือไม่ จากนั้นลองคอมไพล์เพื่อดูว่าผลลัพธ์ตรงกับที่คุณคาดไว้หรือไม่!
ความสัมพันธ์
วิธีที่คุณจำเป็นต้องระบุพารามิเตอร์ไลฟ์ไทม์นั้นขึ้นอยู่กับการทำงานของฟังก์ชัน ตัวอย่างเช่น หากเราเปลี่ยนการทำงานของฟังก์ชัน longest ให้ส่งคืนพารามิเตอร์ตัวแรกเสมอแทนที่จะเป็นสตริงสไลซ์ที่ยาวกว่า เราก็ไม่จำเป็นต้องระบุไลฟ์ไทม์ให้กับพารามิเตอร์ y เลย โค้ดต่อไปนี้จะสามารถคอมไพล์ผ่านได้:
fn main() {
let string1 = String::from("abcd");
let string2 = "efghijklmnopqrstuvwxyz";
let result = longest(string1.as_str(), string2);
println!("The longest string is {result}");
}
fn longest<'a>(x: &'a str, y: &str) -> &'a str {
x
}
เราได้ระบุพารามิเตอร์ไลฟ์ไทม์ 'a ให้กับพารามิเตอร์ x และชนิดข้อมูลที่ส่งคืน แต่ไม่ได้ระบุให้กับพารามิเตอร์ y เนื่องจากไลฟ์ไทม์ของ y ไม่ได้มีความสัมพันธ์ใดๆ กับไลฟ์ไทม์ของ x หรือค่าที่ส่งคืน
เมื่อฟังก์ชันมีการส่งคืนเรเฟอเรนซ์ พารามิเตอร์ไลฟ์ไทม์ของชนิดข้อมูลที่ส่งคืนจะต้องตรงกับพารามิเตอร์ไลฟ์ไทม์ของพารามิเตอร์ตัวใดตัวหนึ่งเสมอ หากเรเฟอเรนซ์ที่ส่งคืนไม่ได้อ้างถึงพารามิเตอร์ตัวใดตัวหนึ่ง ก็แสดงว่ามันจะต้องอ้างถึงค่าที่ถูกสร้างขึ้นภายในฟังก์ชันนั้นเอง ซึ่งนั่นจะทำให้กลายเป็น dangling reference ไปทันที เพราะค่านั้นจะหลุดออกจากสโคปและถูกทำลายไปเมื่อสิ้นสุดการทำงานของฟังก์ชัน ลองพิจารณาความพยายามอิมพลีเมนต์ฟังก์ชัน longest ต่อไปนี้ ซึ่งจะคอมไพล์ไม่ผ่าน:
fn main() {
let string1 = String::from("abcd");
let string2 = "xyz";
let result = longest(string1.as_str(), string2);
println!("The longest string is {result}");
}
fn longest<'a>(x: &str, y: &str) -> &'a str {
let result = String::from("really long string");
result.as_str()
}
ในกรณีนี้ แม้ว่าเราจะระบุพารามิเตอร์ไลฟ์ไทม์ 'a ให้กับชนิดข้อมูลที่ส่งคืนแล้วก็ตาม การอิมพลีเมนต์นี้ก็จะยังคอมไพล์ไม่ผ่านอยู่ดี เพราะไลฟ์ไทม์ของค่าที่ส่งคืนไม่ได้มีความสัมพันธ์ใดๆ กับไลฟ์ไทม์ของพารามิเตอร์เลย นี่คือข้อความแสดงข้อผิดพลาดที่เราได้รับ:
$ cargo run
Compiling chapter10 v0.1.0 (file:///projects/chapter10)
error[E0515]: cannot return value referencing local variable `result`
--> src/main.rs:11:5
|
11 | result.as_str()
| ------^^^^^^^^^
| |
| returns a value referencing data owned by the current function
| `result` is borrowed here
For more information about this error, try `rustc --explain E0515`.
error: could not compile `chapter10` (bin "chapter10") due to 1 previous error
ปัญหาคือ result จะหลุดออกจากสโคปและถูกคืนหน่วยความจำเมื่อสิ้นสุดฟังก์ชัน longest แต่เรากลับพยายามส่งคืนเรเฟอเรนซ์ที่ชี้ไปยัง result จากฟังก์ชัน ไม่มีทางที่การระบุพารามิเตอร์ไลฟ์ไทม์ใดๆ จะสามารถแก้ไขเรเฟอเรนซ์ที่ชี้ไปยังหน่วยความจำที่ถูกคืนไปแล้วได้ และ Rust ก็ไม่อนุญาตให้เราสร้าง dangling reference อย่างเด็ดขาด ในกรณีนี้ ทางแก้ที่ดีที่สุดคือการส่งคืนชนิดข้อมูลที่เป็นเจ้าของค่า (owned data type) แทนที่จะเป็นเรเฟอเรนซ์ เพื่อให้ฟังก์ชันผู้เรียกเป็นผู้รับผิดชอบการทำความสะอาดและคืนหน่วยความจำของค่านั้นต่อไป
โดยสรุปแล้ว วากยสัมพันธ์ของไลฟ์ไทม์มีไว้เพื่อเชื่อมโยงความสัมพันธ์ของไลฟ์ไทม์ระหว่างพารามิเตอร์ต่างๆ กับค่าที่ส่งคืนของฟังก์ชันเข้าด้วยกัน เมื่อเชื่อมโยงกันแล้ว Rust ก็จะมีข้อมูลเพียงพอที่จะอนุญาตให้การดำเนินการที่ปลอดภัยต่อหน่วยความจำทำงานได้ และไม่อนุญาตการกระทำที่จะก่อให้เกิด dangling pointer หรือละเมิดความปลอดภัยของหน่วยความจำในรูปแบบอื่นๆ
ในนิยามของ struct
จนถึงตอนนี้ struct ทั้งหมดที่เราเคยนิยามมาล้วนเก็บชนิดข้อมูลที่เป็นเจ้าของค่า (owned types) ทั้งสิ้น เราสามารถนิยาม struct ให้เก็บเรเฟอเรนซ์ได้เช่นกัน แต่ในกรณีนั้น เราจำเป็นต้องระบุไลฟ์ไทม์กำกับไว้บนเรเฟอเรนซ์ทุกตัวในนิยามของ struct ดังตัวอย่างในลิสติ้ง 10-24 ซึ่งมี struct ชื่อ ImportantExcerpt ที่เก็บสตริงสไลซ์
struct ImportantExcerpt<'a> {
part: &'a str,
}
fn main() {
let novel = String::from("Call me Ishmael. Some years ago...");
let first_sentence = novel.split('.').next().unwrap();
let i = ImportantExcerpt {
part: first_sentence,
};
}
struct นี้มีฟิลด์เดียวคือ part ซึ่งเก็บสตริงสไลซ์ที่เป็นเรเฟอเรนซ์ เช่นเดียวกับชนิดข้อมูลเจเนอริก เราจะประกาศชื่อพารามิเตอร์ไลฟ์ไทม์แบบเจเนอริกไว้ภายในวงเล็บสามเหลี่ยมหลังชื่อ struct เพื่อให้สามารถนำพารามิเตอร์ไลฟ์ไทม์นั้นไปใช้งานในเนื้อหาของนิยาม struct ได้ การระบุนี้หมายความว่า อินสแตนซ์ของ ImportantExcerpt จะไม่สามารถมีอายุยืนยาวไปกว่าเรเฟอเรนซ์ที่มันถือครองอยู่ในฟิลด์ part ได้
ฟังก์ชัน main ในตัวอย่างนี้สร้างอินสแตนซ์ของ ImportantExcerpt ที่เก็บเรเฟอเรนซ์ชี้ไปยังประโยคแรกของ String ซึ่งตัวแปร novel เป็นเจ้าของ ข้อมูลใน novel มีตัวตนอยู่ก่อนที่อินสแตนซ์ของ ImportantExcerpt จะถูกสร้างขึ้น นอกจากนี้ novel ก็ยังไม่หลุดออกจากสโคปจนกระทั่งหลังจากที่ ImportantExcerpt หลุดออกจากสโคปไปแล้ว ดังนั้น เรเฟอเรนซ์ที่อยู่ในอินสแตนซ์ของ ImportantExcerpt จึงมีความถูกต้องและใช้งานได้อย่างปลอดภัย
การละไลฟ์ไทม์
คุณได้เรียนรู้แล้วว่าทุกเรเฟอเรนซ์ต่างก็มีไลฟ์ไทม์ และเราจำเป็นต้องระบุพารามิเตอร์ไลฟ์ไทม์ให้กับฟังก์ชันหรือ struct ที่มีการใช้งานเรเฟอเรนซ์ อย่างไรก็ตาม ในลิสติ้ง 4-9 ซึ่งนำมาแสดงอีกครั้งในลิสติ้ง 10-25 ฟังก์ชันกลับสามารถคอมไพล์ผ่านได้โดยไม่ต้องระบุไลฟ์ไทม์ใดๆ เลย
fn first_word(s: &str) -> &str {
let bytes = s.as_bytes();
for (i, &item) in bytes.iter().enumerate() {
if item == b' ' {
return &s[0..i];
}
}
&s[..]
}
fn main() {
let my_string = String::from("hello world");
// first_word works on slices of `String`s
let word = first_word(&my_string[..]);
let my_string_literal = "hello world";
// first_word works on slices of string literals
let word = first_word(&my_string_literal[..]);
// Because string literals *are* string slices already,
// this works too, without the slice syntax!
let word = first_word(my_string_literal);
}
เหตุผลที่ฟังก์ชันนี้สามารถคอมไพล์ผ่านได้โดยไม่ต้องระบุไลฟ์ไทม์นั้นเป็นเรื่องราวทางประวัติศาสตร์: ในยุคแรกเริ่มของ Rust (ก่อนเวอร์ชัน 1.0) โค้ดนี้จะไม่สามารถคอมไพล์ได้เลย เพราะทุกเรเฟอเรนซ์จำเป็นต้องมีการระบุไลฟ์ไทม์อย่างชัดเจน ในยุคนั้น ซิกเนเจอร์ของฟังก์ชันจะต้องถูกเขียนดังนี้:
fn first_word<'a>(s: &'a str) -> &'a str {
หลังจากเขียนโค้ด Rust ไปเป็นจำนวนมาก ทีมพัฒนา Rust ก็พบว่าเหล่านักพัฒนาต่างต้องเขียนระบุไลฟ์ไทม์แบบเดิมซ้ำๆ ในสถานการณ์เดิมๆ อยู่เสมอ ซึ่งรูปแบบเหล่านี้สามารถคาดเดาได้และเป็นไปตามแพตเทิร์นที่แน่นอนไม่กี่แบบ นักพัฒนาคอมไพเลอร์จึงได้บรรจุแพตเทิร์นเหล่านั้นลงในตัวคอมไพเลอร์ เพื่อให้ตัวตรวจการยืมสามารถอนุมานไลฟ์ไทม์ในสถานการณ์ดังกล่าวได้เองโดยไม่จำเป็นต้องระบุอย่างโจ่งแจ้งอีกต่อไป
ประวัติศาสตร์ส่วนนี้ของ Rust มีความสำคัญ เพราะเป็นไปได้ว่าในอนาคตอาจมีแพตเทิร์นที่แน่นอนเพิ่มเติมถูกนำมาใส่ในคอมไพเลอร์อีก ทำให้เราอาจต้องเขียนระบุไลฟ์ไทม์น้อยลงไปกว่าเดิม
แพตเทิร์นที่ถูกกำหนดไว้ในการวิเคราะห์เรเฟอเรนซ์ของ Rust นี้เรียกว่า กฎการละไลฟ์ไทม์ (lifetime elision rules) กฎเหล่านี้ไม่ใช่กฎที่โปรแกรมเมอร์ต้องคอยท่องจำเพื่อปฏิบัติตาม แต่เป็นชุดเงื่อนไขเฉพาะที่คอมไพเลอร์จะนำมาพิจารณา และหากโค้ดของคุณตรงตามเงื่อนไขเหล่านี้ คุณก็ไม่จำเป็นต้องเขียนระบุไลฟ์ไทม์ด้วยตนเอง
กฎการละไลฟ์ไทม์ไม่ได้ครอบคลุมการอนุมานในทุกกรณี หากคอมไพเลอร์ประยุกต์ใช้กฎเหล่านี้แล้วยังคงมีความคลุมเครือว่าเรเฟอเรนซ์ควรมีไลฟ์ไทม์ใด คอมไพเลอร์จะไม่คาดเดาไปเอง แต่จะรายงานเป็นข้อผิดพลาดออกมาเพื่อให้คุณแก้ไขด้วยการระบุไลฟ์ไทม์ด้วยตนเอง
ไลฟ์ไทม์ที่อยู่บนพารามิเตอร์ของฟังก์ชันหรือเมธอดจะเรียกว่า ไลฟ์ไทม์ขาเข้า (input lifetimes) ส่วนไลฟ์ไทม์ที่อยู่บนค่าที่ส่งคืนจะเรียกว่า ไลฟ์ไทม์ขาออก (output lifetimes)
คอมไพเลอร์จะใช้กฎ 3 ข้อในการหาไลฟ์ไทม์ของเรเฟอเรนซ์เมื่อไม่มีการระบุไว้อย่างชัดแจ้ง โดยกฎข้อแรกจะใช้กับไลฟ์ไทม์ขาเข้า ส่วนกฎข้อที่สองและสามจะใช้กับไลฟ์ไทม์ขาออก หากคอมไพเลอร์พิจารณาจนครบทั้งสามข้อแล้วยังมีเรเฟอเรนซ์ที่ระบุไลฟ์ไทม์ไม่ได้ คอมไพเลอร์จะหยุดการทำงานพร้อมแจ้งข้อผิดพลาด กฎเหล่านี้ใช้ได้กับทั้งนิยามของ fn และบล็อก impl
กฎข้อแรกคือ คอมไพเลอร์จะกำหนดพารามิเตอร์ไลฟ์ไทม์ให้แก่พารามิเตอร์ทุกตัวที่เป็นเรเฟอเรนซ์ กล่าวคือ ฟังก์ชันที่มีพารามิเตอร์หนึ่งตัวจะได้พารามิเตอร์ไลฟ์ไทม์หนึ่งตัว: fn foo<'a>(x: &'a i32) ส่วนฟังก์ชันที่มีสองพารามิเตอร์ก็จะได้พารามิเตอร์ไลฟ์ไทม์แยกกันสองตัว: fn foo<'a, 'b>(x: &'a i32, y: &'b i32) และเป็นเช่นนี้เรื่อยไป
กฎข้อที่สองคือ หากมีพารามิเตอร์ไลฟ์ไทม์ขาเข้าเพียงตัวเดียวเท่านั้น ไลฟ์ไทม์นั้นจะถูกกำหนดให้กับพารามิเตอร์ไลฟ์ไทม์ขาออกทั้งหมดโดยอัตโนมัติ: fn foo<'a>(x: &'a i32) -> &'a i32
กฎข้อที่สามคือ หากมีพารามิเตอร์ไลฟ์ไทม์ขาเข้าหลายตัว แต่มีตัวใดตัวหนึ่งเป็น &self หรือ &mut self (เนื่องจากเป็นเมธอด) ไลฟ์ไทม์ของ self จะถูกกำหนดให้กับพารามิเตอร์ไลฟ์ไทม์ขาออกทั้งหมด กฎข้อที่สามนี้ช่วยให้การเขียนและอ่านเมธอดสะดวกสบายขึ้นมาก เพราะไม่ต้องใส่สัญลักษณ์ให้รกตา
ลองสมมติตัวเราเป็นคอมไพเลอร์ แล้วนำกฎเหล่านี้มาใช้หาไลฟ์ไทม์ของเรเฟอเรนซ์ในซิกเนเจอร์ของฟังก์ชัน first_word ในลิสติ้ง 10-25 ซิกเนเจอร์เริ่มต้นจะไม่มีไลฟ์ไทม์ใดๆ ผูกอยู่กับเรเฟอเรนซ์:
fn first_word(s: &str) -> &str {
จากนั้น คอมไพเลอร์จะใช้กฎข้อแรก ซึ่งระบุว่าพารามิเตอร์แต่ละตัวจะได้ไลฟ์ไทม์เป็นของตัวเอง เราจะตั้งชื่อว่า 'a ตามปกติ ซิกเนเจอร์จึงเปลี่ยนเป็นแบบนี้:
fn first_word<'a>(s: &'a str) -> &str {
ต่อมากฎข้อที่สองจะถูกนำมาใช้ เนื่องจากมีไลฟ์ไทม์ขาเข้าเพียงตัวเดียวพอดี กฎข้อที่สองระบุว่าไลฟ์ไทม์ของพารามิเตอร์ขาเข้าจะถูกนำไปกำหนดให้กับไลฟ์ไทม์ขาออก ซิกเนเจอร์จึงกลายเป็นแบบนี้:
fn first_word<'a>(s: &'a str) -> &'a str {
ในตอนนี้ เรเฟอเรนซ์ทั้งหมดในซิกเนเจอร์ของฟังก์ชันต่างก็มีไลฟ์ไทม์ครบถ้วนแล้ว คอมไพเลอร์จึงสามารถวิเคราะห์โค้ดต่อไปได้ โดยที่โปรแกรมเมอร์ไม่ต้องมาคอยระบุไลฟ์ไทม์ในซิกเนเจอร์ของฟังก์ชันนี้เลย
มาดูอีกตัวอย่างหนึ่ง คราวนี้ใช้ฟังก์ชัน longest ที่ยังไม่ได้ระบุพารามิเตอร์ไลฟ์ไทม์ตอนที่เราเริ่มเขียนในลิสติ้ง 10-20:
fn longest(x: &str, y: &str) -> &str {
เมื่อนำกฎข้อแรกมาใช้: พารามิเตอร์แต่ละตัวจะได้ไลฟ์ไทม์ของตัวเอง คราวนี้เรามีพารามิเตอร์สองตัว จึงได้ไลฟ์ไทม์สองตัวแยกกัน:
fn longest<'a, 'b>(x: &'a str, y: &'b str) -> &str {
คุณจะเห็นว่ากฎข้อที่สองไม่สามารถนำมาใช้ได้ เพราะมีไลฟ์ไทม์ขาเข้ามากกว่าหนึ่งตัว และกฎข้อที่สามก็ใช้ไม่ได้เช่นกัน เพราะ longest เป็นฟังก์ชันธรรมดาไม่ใช่เมธอด จึงไม่มีพารามิเตอร์ที่เป็น self เลย หลังจากพิจารณาผ่านกฎทั้งสามข้อแล้ว คอมไพเลอร์ก็ยังคงไม่สามารถระบุได้ว่าไลฟ์ไทม์ของชนิดข้อมูลที่ส่งคืนคืออะไร นี่คือสาเหตุที่เราพบข้อผิดพลาดเมื่อพยายามคอมไพล์โค้ดในลิสติ้ง 10-20: คอมไพเลอร์ไล่ดูกฎการละไลฟ์ไทม์จนครบแล้ว แต่ก็ยังไม่สามารถหาไลฟ์ไทม์ของเรเฟอเรนซ์ทั้งหมดในซิกเนเจอร์ได้
เนื่องจากกฎข้อที่สามนั้นจะใช้กับซิกเนเจอร์ของเมธอดเท่านั้น ต่อไปเราจะมาดูเรื่องไลฟ์ไทม์ในบริบทของเมธอดกัน เพื่อดูว่าทำไมกฎข้อที่สามจึงช่วยให้เราแทบไม่ต้องระบุไลฟ์ไทม์ในซิกเนเจอร์ของเมธอดเลย
ในนิยามของเมธอด
เมื่อเราอิมพลีเมนต์เมธอดให้กับ struct ที่มีไลฟ์ไทม์ เราจะใช้วากยสัมพันธ์แบบเดียวกับพารามิเตอร์ชนิดข้อมูลแบบเจเนอริกดังที่แสดงในลิสติ้ง 10-11 ตำแหน่งที่เราจะประกาศและนำพารามิเตอร์ไลฟ์ไทม์ไปใช้นั้น ขึ้นอยู่กับว่ามันเกี่ยวข้องกับฟิลด์ของ struct หรือเกี่ยวข้องกับพารามิเตอร์และค่าที่ส่งคืนของเมธอด
ชื่อของไลฟ์ไทม์สำหรับฟิลด์ของ struct จำเป็นต้องประกาศไว้หลังคีย์เวิร์ด impl เสมอ และนำไปใช้หลังชื่อของ struct เพราะไลฟ์ไทม์เหล่านั้นถือเป็นส่วนหนึ่งของชนิดข้อมูลของ struct
ในซิกเนเจอร์ของเมธอดภายในบล็อก impl เรเฟอเรนซ์อาจจะผูกติดอยู่กับไลฟ์ไทม์ของเรเฟอเรนซ์ในฟิลด์ของ struct หรืออาจจะเป็นอิสระต่อกันก็ได้ นอกจากนี้ กฎการละไลฟ์ไทม์ยังช่วยให้เราแทบไม่ต้องระบุไลฟ์ไทม์ในซิกเนเจอร์ของเมธอดเลย มาดูตัวอย่างบางส่วนโดยใช้ struct ชื่อ ImportantExcerpt ที่เรานิยามไว้ในลิสติ้ง 10-24
อันดับแรก เราจะใช้เมธอดชื่อ level ที่มีพารามิเตอร์เพียงตัวเดียวคือเรเฟอเรนซ์ไปยัง self และมีค่าที่ส่งคืนเป็น i32 ซึ่งไม่ใช่เรเฟอเรนซ์:
struct ImportantExcerpt<'a> {
part: &'a str,
}
impl<'a> ImportantExcerpt<'a> {
fn level(&self) -> i32 {
3
}
}
impl<'a> ImportantExcerpt<'a> {
fn announce_and_return_part(&self, announcement: &str) -> &str {
println!("Attention please: {announcement}");
self.part
}
}
fn main() {
let novel = String::from("Call me Ishmael. Some years ago...");
let first_sentence = novel.split('.').next().unwrap();
let i = ImportantExcerpt {
part: first_sentence,
};
}
การประกาศพารามิเตอร์ไลฟ์ไทม์หลัง impl และการนำไปใช้หลังชื่อชนิดข้อมูลนั้นเป็นสิ่งจำเป็น แต่ด้วยกฎการละไลฟ์ไทม์ข้อแรก เราจึงไม่จำเป็นต้องระบุไลฟ์ไทม์ให้กับเรเฟอเรนซ์ที่ชี้ไปยัง self เลย
ต่อไปนี้เป็นตัวอย่างที่กฎการละไลฟ์ไทม์ข้อที่สามถูกนำมาใช้งาน:
struct ImportantExcerpt<'a> {
part: &'a str,
}
impl<'a> ImportantExcerpt<'a> {
fn level(&self) -> i32 {
3
}
}
impl<'a> ImportantExcerpt<'a> {
fn announce_and_return_part(&self, announcement: &str) -> &str {
println!("Attention please: {announcement}");
self.part
}
}
fn main() {
let novel = String::from("Call me Ishmael. Some years ago...");
let first_sentence = novel.split('.').next().unwrap();
let i = ImportantExcerpt {
part: first_sentence,
};
}
ในที่นี้มีไลฟ์ไทม์ขาเข้าสองตัว Rust จึงนำกฎการละไลฟ์ไทม์ข้อแรกมาใช้ โดยกำหนดไลฟ์ไทม์เฉพาะตัวให้กับทั้ง &self และ announcement จากนั้น เมื่อพิจารณาว่ามีพารามิเตอร์ตัวหนึ่งเป็น &self ชนิดข้อมูลที่ส่งคืนจึงได้รับไลฟ์ไทม์ของ &self ไปโดยอัตโนมัติ ทำให้เรเฟอเรนซ์ทั้งหมดได้รับการระบุไลฟ์ไทม์อย่างครบถ้วนสมบูรณ์
ไลฟ์ไทม์ 'static
ไลฟ์ไทม์พิเศษตัวหนึ่งที่เราต้องกล่าวถึงคือ 'static ซึ่งระบุว่าเรเฟอเรนซ์ดังกล่าว สามารถ มีอายุอยู่ได้ตลอดระยะเวลาการทำงานทั้งหมดของโปรแกรม โดยสตริงลิเทอรัล (string literal) ทั้งหมดต่างก็มีไลฟ์ไทม์เป็น 'static ซึ่งเราสามารถเขียนกำกับได้ดังนี้:
#![allow(unused)]
fn main() {
let s: &'static str = "I have a static lifetime.";
}
ข้อความของสตริงนี้จะถูกฝังและจัดเก็บไว้ในไฟล์ไบนารีของโปรแกรมโดยตรง ซึ่งพร้อมใช้งานอยู่ตลอดเวลา ดังนั้น ไลฟ์ไทม์ของสตริงลิเทอรัลทุกตัวจึงเป็น 'static เสมอ
คุณอาจเคยเห็นคำแนะนำในข้อความแสดงข้อผิดพลาดที่บอกให้ลองใช้ไลฟ์ไทม์ 'static แต่ก่อนที่คุณจะระบุ 'static ให้กับเรเฟอเรนซ์ใดๆ ควรไตร่ตรองให้รอบคอบก่อนว่าเรเฟอเรนซ์นั้นจำเป็นต้องมีชีวิตอยู่ตลอดอายุการทำงานของโปรแกรมจริงๆ หรือไม่ และคุณต้องการให้เป็นเช่นนั้นจริงหรือ เพราะส่วนใหญ่แล้ว ข้อความแสดงข้อผิดพลาดที่แนะนำให้ใช้ไลฟ์ไทม์ 'static มักเกิดจากความพยายามสร้าง dangling reference หรือเกิดจากไลฟ์ไทม์ที่มีอยู่ไม่สอดคล้องกัน ในกรณีเช่นนั้น วิธีแก้ที่ถูกต้องคือการจัดการกับปัญหาความสัมพันธ์ของไลฟ์ไทม์ ไม่ใช่การแก้ปัญหาเฉพาะหน้าด้วยการยัดเยียดไลฟ์ไทม์ 'static ลงไป
พารามิเตอร์ชนิดข้อมูลแบบเจเนอริก บาวด์ของเทรต และไลฟ์ไทม์
มาดูวากยสัมพันธ์ในการระบุทั้งพารามิเตอร์ชนิดข้อมูลแบบเจเนอริก บาวด์ของเทรต (trait bound) และไลฟ์ไทม์พร้อมกันทั้งหมดในฟังก์ชันเดียวกันอย่างกระชับกัน!
fn main() {
let string1 = String::from("abcd");
let string2 = "xyz";
let result = longest_with_an_announcement(
string1.as_str(),
string2,
"Today is someone's birthday!",
);
println!("The longest string is {result}");
}
use std::fmt::Display;
fn longest_with_an_announcement<'a, T>(
x: &'a str,
y: &'a str,
ann: T,
) -> &'a str
where
T: Display,
{
println!("Announcement! {ann}");
if x.len() > y.len() { x } else { y }
}
นี่คือฟังก์ชัน longest จากลิสติ้ง 10-21 ที่ส่งคืนสตริงสไลซ์ที่ยาวกว่าระหว่างสองตัว แต่คราวนี้มีพารามิเตอร์เพิ่มเติมชื่อ ann ซึ่งมีชนิดข้อมูลเจเนอริก T โดยสามารถเป็นชนิดข้อมูลใดก็ได้ที่อิมพลีเมนต์เทรต Display ตามที่ระบุไว้ในอนุประโยค where พารามิเตอร์เพิ่มเติมนี้จะถูกนำไปพิมพ์ด้วย {} ซึ่งเป็นเหตุผลที่จำเป็นต้องมีบาวด์ของเทรต Display และเนื่องจากไลฟ์ไทม์ก็เป็นเจเนอริกรูปแบบหนึ่ง การประกาศพารามิเตอร์ไลฟ์ไทม์ 'a และพารามิเตอร์ชนิดข้อมูลแบบเจเนอริก T จึงรวมอยู่ในรายการเดียวกันภายในวงเล็บสามเหลี่ยมหลังชื่อฟังก์ชัน
สรุป
เราได้เรียนรู้เนื้อหาไปมากมายในบทนี้! ตอนนี้คุณเข้าใจทั้งเรื่องพารามิเตอร์ชนิดข้อมูลแบบเจเนอริก เทรตและบาวด์ของเทรต ตลอดจนพารามิเตอร์ไลฟ์ไทม์แบบเจเนอริกแล้ว คุณจึงพร้อมที่จะเขียนโค้ดที่ไม่ต้องทำซ้ำซ้อนและสามารถทำงานได้ในสถานการณ์ที่หลากหลาย พารามิเตอร์ชนิดข้อมูลแบบเจเนอริกช่วยให้คุณนำโค้ดเดิมไปประยุกต์ใช้กับชนิดข้อมูลที่แตกต่างกันได้ เทรตและบาวด์ของเทรตช่วยรับประกันว่าแม้จะเป็นชนิดข้อมูลแบบเจเนอริก แต่พวกมันก็จะมีพฤติกรรมตามที่โค้ดต้องการ และคุณยังได้เรียนรู้วิธีการใช้การระบุไลฟ์ไทม์เพื่อรับประกันว่าโค้ดที่มีความยืดหยุ่นนี้จะไม่มี dangling reference อยู่เลยแม้แต่น้อย ที่สำคัญคือการวิเคราะห์ทั้งหมดนี้เกิดขึ้นในตอนคอมไพล์ จึงไม่ส่งผลกระทบต่อประสิทธิภาพการทำงานตอนรันไทม์เลยแม้แต่นิดเดียว!
เชื่อหรือไม่ว่า ยังมีเนื้อหาให้ศึกษาเพิ่มเติมอีกมากเกี่ยวกับหัวข้อที่เราได้พูดคุยกันในบทนี้: ในบทที่ 18 เราจะพูดถึงเทรตออบเจกต์ (trait objects) ซึ่งเป็นอีกหนึ่งวิธีในการใช้งานเทรต นอกจากนี้ยังมีสถานการณ์ที่ซับซ้อนยิ่งขึ้นเกี่ยวกับการระบุไลฟ์ไทม์ ซึ่งคุณจะได้ใช้งานเฉพาะในกรณีขั้นสูงจริงๆ สำหรับหัวข้อเหล่านั้น คุณสามารถศึกษาเพิ่มเติมได้จาก Rust Reference แต่ในบทถัดไป คุณจะได้เรียนรู้วิธีการเขียนชุดทดสอบ (tests) ใน Rust เพื่อให้มั่นใจได้ว่าโค้ดของคุณจะทำงานได้อย่างถูกต้องตามที่คาดหวังเสมอ