เมธอด
เมธอด (method) มีความคล้ายคลึงกับฟังก์ชันอย่างมาก: เราประกาศด้วยคีย์เวิร์ด fn ตามด้วยชื่อ สามารถรับพารามิเตอร์ (parameter) และคืนค่า (return value) ได้ รวมถึงมีบล็อกคำสั่งที่ทำงานเมื่อถูกเรียกใช้จากที่อื่น แต่สิ่งที่ต่างจากฟังก์ชันทั่วไปคือ เมธอดจะถูกนิยามขึ้นภายในบริบทของ struct (หรือ enum หรือเทรตออบเจกต์ ซึ่งเราจะกล่าวถึงใน บทที่ 6 และ บทที่ 18 ตามลำดับ) และพารามิเตอร์ตัวแรกของเมธอดจะต้องเป็น self เสมอ ซึ่งทำหน้าที่แทนอินสแตนซ์ของ struct ที่เมธอดนั้นกำลังถูกเรียกใช้งาน
วากยสัมพันธ์ของเมธอด
เรามาลองเปลี่ยนฟังก์ชัน area ที่เดิมรับอินสแตนซ์ Rectangle เป็นพารามิเตอร์ ให้กลายเป็นเมธอด area ที่นิยามอยู่บน struct Rectangle โดยตรง ดังแสดงในลิสติ้ง 5-13
#[derive(Debug)]
struct Rectangle {
width: u32,
height: u32,
}
impl Rectangle {
fn area(&self) -> u32 {
self.width * self.height
}
}
fn main() {
let rect1 = Rectangle {
width: 30,
height: 50,
};
println!(
"The area of the rectangle is {} square pixels.",
rect1.area()
);
}
ในการนิยามฟังก์ชันให้อยู่ภายในบริบทของ Rectangle เราจะเริ่มต้นด้วยการสร้างบล็อก impl (ย่อมาจาก implementation) สำหรับ Rectangle โดยทุกสิ่งทุกอย่างที่เขียนอยู่ภายในบล็อก impl นี้จะถูกผูกเข้ากับชนิดข้อมูล Rectangle จากนั้นเราย้ายฟังก์ชัน area เข้าไปไว้ในวงเล็บปีกกาของ impl แล้วเปลี่ยนพารามิเตอร์ตัวแรก (และในกรณีนี้เป็นพารามิเตอร์เพียงตัวเดียว) ให้เป็น self ทั้งในส่วนของลายเซ็นและในเนื้อหาของฟังก์ชัน และในฟังก์ชัน main ที่เดิมเคยเรียกฟังก์ชัน area โดยส่ง rect1 เข้าไปเป็นอาร์กิวเมนต์ เราจะเปลี่ยนมาใช้ ไวยากรณ์การเรียกเมธอด (method syntax) บนอินสแตนซ์ rect1 แทน โดยไวยากรณ์นี้จะเขียนต่อท้ายอินสแตนซ์ คือใส่เครื่องหมายจุด ตามด้วยชื่อเมธอด วงเล็บกลม และอาร์กิวเมนต์ต่างๆ (ถ้ามี)
ในลายเซ็นของเมธอด area เราใช้ &self แทน rectangle: &Rectangle ซึ่งแท้จริงแล้ว &self เป็นรูปย่อของ self: &Self โดยภายในบล็อก impl ชนิดข้อมูล Self จะเป็นชื่อเสมือน (alias) ที่แทนชนิดข้อมูลที่บล็อก impl นั้นสังกัดอยู่ เมธอดจะต้องมีพารามิเตอร์ตัวแรกชื่อ self และเป็นชนิดข้อมูล Self เสมอ Rust จึงอนุญาตให้เราเขียนย่อเหลือเพียงชื่อ self สั้นๆ ในตำแหน่งพารามิเตอร์แรกได้ โปรดสังเกตว่าเรายังคงต้องใส่เครื่องหมาย & ไว้ข้างหน้า self เพื่อระบุว่าเมธอดนี้เป็นการยืมอินสแตนซ์ Self มาใช้งาน เช่นเดียวกับที่เราเคยเขียน rectangle: &Rectangle ทั้งนี้ เมธอดสามารถเลือกที่จะรับความเป็นเจ้าของของ self, ยืม self แบบแก้ไขไม่ได้ (immutable borrow) ดังเช่นในตัวอย่างนี้, หรือยืม self แบบแก้ไขได้ (mutable borrow) ก็ได้เช่นเดียวกับพารามิเตอร์ตัวอื่นๆ
เราเลือกใช้ &self ในตัวอย่างนี้ด้วยเหตุผลเดียวกับตอนที่ใช้ &Rectangle ในแบบฟังก์ชัน นั่นคือเราไม่ต้องการรับความเป็นเจ้าของ และต้องการเพียงแค่อ่านข้อมูลใน struct โดยไม่ได้แก้ไขเปลี่ยนแปลงข้อมูลแต่อย่างใด หากเราต้องการให้เมธอดสามารถแก้ไขข้อมูลในอินสแตนซ์ที่เรียกใช้ได้ เราจะเปลี่ยนพารามิเตอร์แรกเป็น &mut self แทน ส่วนการสร้างเมธอดที่ยึดความเป็นเจ้าของของอินสแตนซ์ไปเลยด้วยการใช้เพียง self โดดๆ นั้นเป็นรูปแบบที่ไม่ค่อยพบบ่อยนัก โดยมักจะใช้เมื่อเมธอดนั้นทำหน้าที่แปลง self ให้กลายเป็นข้อมูลชนิดอื่น และคุณต้องการป้องกันไม่ให้ผู้เรียกสามารถนำอินสแตนซ์เดิมกลับมาใช้งานได้อีกหลังจากการแปลง
ประโยชน์หลักของการใช้เมธอดแทนฟังก์ชัน นอกเหนือจากความสะดวกของไวยากรณ์การเรียกใช้และไม่ต้องระบุชนิดข้อมูลของ self ซ้ำในทุกๆ เมธอดแล้ว ยังเป็นเรื่องของการจัดระเบียบโค้ดที่ดีเยี่ยม เพราะเราได้รวบรวมการกระทำทั้งหมดที่สามารถทำได้กับอินสแตนซ์ของชนิดข้อมูลนั้นๆ มาไว้ในบล็อก impl เดียวกัน ช่วยให้ผู้ที่นำโค้ดของเราไปใช้งานสามารถค้นหาความสามารถทั้งหมดของ Rectangle ได้จากที่เดียวอย่างเป็นระบบ
โปรดสังเกตว่าเราสามารถตั้งชื่อเมธอดให้ซ้ำกับชื่อฟิลด์ของ struct ได้ ตัวอย่างเช่น เราสามารถนิยามเมธอดบน Rectangle ที่ชื่อ width ได้เช่นกัน:
#[derive(Debug)]
struct Rectangle {
width: u32,
height: u32,
}
impl Rectangle {
fn width(&self) -> bool {
self.width > 0
}
}
fn main() {
let rect1 = Rectangle {
width: 30,
height: 50,
};
if rect1.width() {
println!("The rectangle has a nonzero width; it is {}", rect1.width);
}
}
ในตัวอย่างนี้ เรากำหนดให้เมธอด width คืนค่า true หากค่าในฟิลด์ width ของอินสแตนซ์มากกว่า 0 และคืนค่า false หากเป็น 0 ซึ่งเราสามารถนำฟิลด์มาใช้งานภายในเมธอดที่มีชื่อเดียวกันเพื่อจุดประสงค์ใดก็ได้ ในฟังก์ชัน main เมื่อเราใส่วงเล็บต่อท้าย rect1.width() Rust จะทราบทันทีว่าเราหมายถึงเมธอด width แต่หากเราไม่ใส่วงเล็บ rect1.width Rust ก็จะทราบว่าเราหมายถึงฟิลด์ข้อมูล width
บ่อยครั้ง (แม้จะไม่เสมอไป) เมื่อเราตั้งชื่อเมธอดให้ตรงกับชื่อฟิลด์ เรามักต้องการให้เมธอดนั้นทำหน้าที่ส่งคืนค่าของฟิลด์นั้นออกมาเพียงอย่างเดียว ซึ่งเมธอดในลักษณะนี้จะเรียกว่า เก็ตเตอร์ (getter) โดย Rust ไม่ได้สร้างเมธอดเก็ตเตอร์ให้อัตโนมัติเหมือนบางภาษา การใช้เก็ตเตอร์มีประโยชน์ตรงที่คุณสามารถกำหนดให้ฟิลด์ข้อมูลเป็นแบบส่วนตัว (private) แต่เปิดเมธอดให้เป็นแบบสาธารณะ (public) เพื่อให้ภายนอกสามารถอ่านข้อมูลของฟิลด์นั้นได้อย่างเดียว (read-only) ผ่านทาง API สาธารณะของชนิดข้อมูล ซึ่งเราจะไปเรียนรู้เรื่อง public และ private รวมถึงการกำหนดการเข้าถึงฟิลด์และเมธอดใน บทที่ 7
ตัวดำเนินการ
->อยู่ที่ไหน?ในภาษา C และ C++ มีการใช้ตัวดำเนินการ (operator) สองตัวที่แตกต่างกันในการเรียกใช้เมธอด กล่าวคือ คุณจะใช้เครื่องหมายจุด
.หากคุณเรียกเมธอดบนออบเจกต์โดยตรง และจะใช้ลูกศร->หากคุณเรียกเมธอดผ่านพอยน์เตอร์ (pointer) ที่ชี้ไปยังออบเจกต์ ซึ่งจำเป็นต้องดีเรเฟอเรนซ์ (dereference) พอยน์เตอร์นั้นก่อน กล่าวอีกนัยหนึ่ง หากobjectเป็นพอยน์เตอร์ คำสั่งobject->something()จะเทียบเท่ากับ(*object).something()แต่ใน Rust ไม่มีตัวดำเนินการอย่าง
->เพราะ Rust มีฟีเจอร์ที่เรียกว่า การสร้างเรเฟอเรนซ์และดีเรเฟอเรนซ์อัตโนมัติ (automatic referencing and dereferencing) ซึ่งการเรียกใช้เมธอดถือเป็นหนึ่งในไม่กี่จุดใน Rust ที่มีพฤติกรรมอำนวยความสะดวกเช่นนี้กลไกการทำงานคือ: เมื่อคุณเรียกเมธอดด้วยคำสั่ง
object.something()Rust จะเติมเครื่องหมาย&,&mut, หรือ*ให้โดยอัตโนมัติเพื่อให้objectมีชนิดข้อมูลตรงกับลายเซ็นของเมธอดนั้นๆ กล่าวอีกนัยหนึ่ง โค้ดสองบรรทัดต่อไปนี้ทำงานเทียบเท่ากันทุกประการ:#![allow(unused)] fn main() { #[derive(Debug,Copy,Clone)] struct Point { x: f64, y: f64, } impl Point { fn distance(&self, other: &Point) -> f64 { let x_squared = f64::powi(other.x - self.x, 2); let y_squared = f64::powi(other.y - self.y, 2); f64::sqrt(x_squared + y_squared) } } let p1 = Point { x: 0.0, y: 0.0 }; let p2 = Point { x: 5.0, y: 6.5 }; p1.distance(&p2); (&p1).distance(&p2); }จะเห็นได้ว่าแบบแรกอ่านง่ายและสะอาดตากว่ามาก พฤติกรรมการจัดการเรเฟอเรนซ์อัตโนมัตินี้ทำงานได้อย่างราบรื่นเพราะเมธอดมีผู้รับการเรียก (receiver) ที่ชัดเจนเสมอ นั่นคือชนิดข้อมูลของ
selfเมื่อทราบทั้งผู้รับและชื่อของเมธอดแล้ว Rust จึงสามารถระบุได้อย่างแม่นยำว่าเมธอดนั้นต้องการแค่อ่านค่า (&self), ต้องการแก้ไขค่า (&mut self), หรือต้องการรับความเป็นเจ้าของไปเลย (self) การที่ Rust ช่วยจัดการเรื่องการยืมให้อัตโนมัติสำหรับตัวรับของเมธอดเช่นนี้ ถือเป็นหัวใจสำคัญที่ช่วยให้ระบบความเป็นเจ้าของมีความสะดวกสบายในการเขียนโค้ดจริงอย่างมาก
เมธอดที่มีพารามิเตอร์เพิ่มเติม
เรามาฝึกฝนการใช้งานเมธอดเพิ่มเติมด้วยการสร้างเมธอดตัวที่สองบน struct Rectangle กัน คราวนี้เราต้องการให้อินสแตนซ์ของ Rectangle สามารถรับอินสแตนซ์ของ Rectangle อีกตัวเข้ามา และส่งคืนค่า true หาก Rectangle ตัวที่สองนั้นสามารถบรรจุอยู่ภายใน self (ซึ่งเป็น Rectangle ตัวแรก) ได้อย่างสมบูรณ์ และส่งคืนค่า false ในกรณีอื่นๆ นั่นคือ เมื่อเรานิยามเมธอด can_hold แล้ว เราต้องการให้สามารถเขียนโปรแกรมได้ดังที่แสดงในลิสติ้ง 5-14
fn main() {
let rect1 = Rectangle {
width: 30,
height: 50,
};
let rect2 = Rectangle {
width: 10,
height: 40,
};
let rect3 = Rectangle {
width: 60,
height: 45,
};
println!("Can rect1 hold rect2? {}", rect1.can_hold(&rect2));
println!("Can rect1 hold rect3? {}", rect1.can_hold(&rect3));
}
ผลลัพธ์ที่คาดหวังควรจะเป็นดังนี้ เพราะขนาดทั้งสองด้านของ rect2 มีขนาดเล็กกว่า rect1 แต่ rect3 มีความกว้างมากกว่า rect1:
Can rect1 hold rect2? true
Can rect1 hold rect3? false
เรารู้แล้วว่าเราต้องการนิยามเมธอด ดังนั้นโค้ดนี้จะต้องอยู่ภายในบล็อก impl Rectangle โดยตั้งชื่อเมธอดว่า can_hold และรับการยืมแบบแก้ไขไม่ได้ของ Rectangle อีกตัวเป็นพารามิเตอร์ เราสามารถทราบชนิดข้อมูลของพารามิเตอร์ได้จากการสังเกตโค้ดที่เรียกใช้: คำสั่ง rect1.can_hold(&rect2) ได้ส่ง &rect2 เข้ามา ซึ่งเป็นการยืมแบบแก้ไขไม่ได้ไปยัง rect2 ที่เป็นอินสแตนซ์ของ Rectangle ซึ่งสมเหตุสมผลอย่างยิ่งเพราะเราต้องการเพียงแค่อ่านค่าใน rect2 เท่านั้น (ไม่ได้ต้องการแก้ไขค่า ซึ่งจะต้องใช้การยืมแบบแก้ไขได้) และเรายังต้องการให้ฟังก์ชัน main คงความเป็นเจ้าของใน rect2 ต่อไป เพื่อให้นำไปใช้งานอื่นต่อได้หลังจากเรียก can_hold แล้ว ค่าที่คืนกลับจาก can_hold จะเป็นชนิดข้อมูลบูลีน และการคำนวณภายในจะตรวจสอบว่าความกว้างและความสูงของ self มีค่ามากกว่าความกว้างและความสูงของ Rectangle อีกตัวตามลำดับหรือไม่ เรามาเพิ่มเมธอด can_hold ลงในบล็อก impl ต่อจากลิสติ้ง 5-13 ดังแสดงในลิสติ้ง 5-15
#[derive(Debug)]
struct Rectangle {
width: u32,
height: u32,
}
impl Rectangle {
fn area(&self) -> u32 {
self.width * self.height
}
fn can_hold(&self, other: &Rectangle) -> bool {
self.width > other.width && self.height > other.height
}
}
fn main() {
let rect1 = Rectangle {
width: 30,
height: 50,
};
let rect2 = Rectangle {
width: 10,
height: 40,
};
let rect3 = Rectangle {
width: 60,
height: 45,
};
println!("Can rect1 hold rect2? {}", rect1.can_hold(&rect2));
println!("Can rect1 hold rect3? {}", rect1.can_hold(&rect3));
}
เมื่อเราสั่งรันโค้ดนี้ร่วมกับฟังก์ชัน main ในลิสติ้ง 5-14 เราจะได้ผลลัพธ์ตามที่ต้องการอย่างถูกต้อง เมธอดสามารถรับพารามิเตอร์ได้หลายตัว โดยระบุต่อท้ายพารามิเตอร์ self ในลายเซ็นของเมธอด และพารามิเตอร์เหล่านั้นจะทำงานเหมือนกับพารามิเตอร์ของฟังก์ชันทั่วไปทุกประการ
ฟังก์ชันที่เชื่อมโยงกับชนิดข้อมูล
ฟังก์ชันทั้งหมดที่นิยามอยู่ภายในบล็อก impl จะเรียกว่า ฟังก์ชันประจำชนิดข้อมูล หรือ ฟังก์ชันที่เชื่อมโยงกับชนิดข้อมูล (associated function) เนื่องจากพวกมันมีความผูกพันอยู่กับชนิดข้อมูลที่ระบุชื่อไว้หลังคำสั่ง impl เราสามารถนิยามฟังก์ชันประจำชนิดข้อมูลโดยไม่ต้องมี self เป็นพารามิเตอร์แรกได้ (ซึ่งจะไม่ถือว่าเป็นเมธอด) เนื่องจากฟังก์ชันประเภทนี้ไม่จำเป็นต้องอาศัยอินสแตนซ์ของชนิดข้อมูลนั้นในการทำงาน ซึ่งเราเคยใช้งานฟังก์ชันในลักษณะนี้มาแล้ว เช่น ฟังก์ชัน String::from ที่นิยามอยู่บนชนิดข้อมูล String
ฟังก์ชันประจำชนิดข้อมูลที่ไม่ใช่เมธอดมักจะนิยมใช้เป็นคอนสตรัคเตอร์ (constructor) ที่ทำหน้าที่สร้างและส่งคืนอินสแตนซ์ใหม่ของ struct ออกมา โดยส่วนใหญ่มักจะตั้งชื่อฟังก์ชันว่า new แต่คำว่า new ไม่ใช่ชื่อพิเศษหรือคำสงวนของภาษาแต่อย่างใด ตัวอย่างเช่น เราสามารถสร้างฟังก์ชันประจำชนิดข้อมูลชื่อ square ที่รับพารามิเตอร์ขนาดเพียงค่าเดียว แล้วนำค่านั้นไปใช้เป็นทั้งความกว้างและความสูง เพื่อช่วยให้สร้างอินสแตนซ์ของ Rectangle ที่เป็นรูปสี่เหลี่ยมจัตุรัสได้อย่างสะดวก โดยไม่ต้องระบุค่าเดิมซ้ำสองครั้ง:
ชื่อไฟล์: src/main.rs
#[derive(Debug)]
struct Rectangle {
width: u32,
height: u32,
}
impl Rectangle {
fn square(size: u32) -> Self {
Self {
width: size,
height: size,
}
}
}
fn main() {
let sq = Rectangle::square(3);
}
คำว่า Self ที่ใช้ระบุชนิดข้อมูลที่คืนกลับและในเนื้อหาของฟังก์ชัน เป็นชื่อเสมือนที่แทนชนิดข้อมูลที่ปรากฏหลังคีย์เวิร์ด impl ซึ่งในที่นี้ก็คือ Rectangle
ในการเรียกใช้ฟังก์ชันประจำชนิดข้อมูลนี้ เราจะใช้ไวยากรณ์ :: ร่วมกับชื่อของ struct เช่น let sq = Rectangle::square(3); ฟังก์ชันนี้ถูกจัดไว้ภายใต้เนมสเปซของ struct นั้นๆ โดยไวยากรณ์ :: นี้ใช้ทั้งสำหรับการเรียกฟังก์ชันประจำชนิดข้อมูลและสำหรับการเข้าถึงเนมสเปซที่สร้างขึ้นโดยมอดูล (module) ซึ่งเราจะได้เรียนรู้เรื่องมอดูลใน บทที่ 7
บล็อก impl หลายบล็อก
struct แต่ละตัวสามารถมีบล็อก impl ได้หลายบล็อก ตัวอย่างเช่น ลิสติ้ง 5-15 สามารถเขียนแยกเมธอดออกเป็นคนละบล็อก impl ได้ดังแสดงในลิสติ้ง 5-16 ซึ่งให้ผลลัพธ์เหมือนกันทุกประการ
#[derive(Debug)]
struct Rectangle {
width: u32,
height: u32,
}
impl Rectangle {
fn area(&self) -> u32 {
self.width * self.height
}
}
impl Rectangle {
fn can_hold(&self, other: &Rectangle) -> bool {
self.width > other.width && self.height > other.height
}
}
fn main() {
let rect1 = Rectangle {
width: 30,
height: 50,
};
let rect2 = Rectangle {
width: 10,
height: 40,
};
let rect3 = Rectangle {
width: 60,
height: 45,
};
println!("Can rect1 hold rect2? {}", rect1.can_hold(&rect2));
println!("Can rect1 hold rect3? {}", rect1.can_hold(&rect3));
}
ในตัวอย่างนี้ไม่มีความจำเป็นใดๆ ที่ต้องแยกเมธอดเหล่านี้ออกเป็นหลายบล็อก แต่ไวยากรณ์นี้ถือว่าถูกต้องสมบูรณ์ และเราจะได้เห็นสถานการณ์ที่การแยกบล็อก impl มีประโยชน์อย่างยิ่งในบทที่ 10 เมื่อเราศึกษาเรื่องชนิดข้อมูลเจเนอริก (generics) และเทรต (traits)
สรุป
struct ช่วยให้คุณสามารถสร้างชนิดข้อมูลกำหนดเองที่มีความหมายเฉพาะเจาะจงสำหรับโดเมนของงานคุณได้ โดยการใช้ struct คุณจะสามารถจัดกลุ่มข้อมูลที่เกี่ยวข้องกันเข้าไว้ด้วยกัน พร้อมทั้งตั้งชื่อให้กับข้อมูลแต่ละส่วนเพื่อช่วยให้โค้ดมีความชัดเจนและสื่อความหมายได้เป็นอย่างดี และในบล็อก impl คุณสามารถนิยามฟังก์ชันประจำชนิดข้อมูลขึ้นมาได้ โดยเมธอดก็คือฟังก์ชันประจำชนิดข้อมูลประเภทหนึ่งที่ช่วยให้คุณสามารถกำหนดพฤติกรรมการทำงานให้กับอินสแตนซ์ของ struct ได้โดยตรง
อย่างไรก็ตาม struct ไม่ใช่วิธีเดียวในการสร้างชนิดข้อมูลกำหนดเอง ในบทถัดไปเราจะไปศึกษาฟีเจอร์ enum ของ Rust เพื่อเพิ่มเครื่องมืออันทรงพลังอีกชิ้นหนึ่งให้กับคลังเครื่องมือของคุณ