ฟังก์ชัน
ฟังก์ชัน (function) เป็นส่วนประกอบพื้นฐานที่พบได้ทั่วไปในโค้ด Rust คุณได้เห็นหนึ่งในฟังก์ชันที่สำคัญที่สุดของภาษาไปแล้ว นั่นคือฟังก์ชัน main ซึ่งเป็นจุดเริ่มต้นการทำงานของโปรแกรมจำนวนมาก และคุณยังได้เห็นคีย์เวิร์ด fn ที่ใช้สำหรับประกาศฟังก์ชันใหม่ด้วย
โค้ด Rust ใช้สไตล์แบบ snake case เป็นธรรมเนียมปฏิบัติในการตั้งชื่อฟังก์ชันและตัวแปร โดยตัวอักษรทั้งหมดจะเป็นตัวพิมพ์เล็กและคั่นคำด้วยขีดล่าง (underscore) ตัวอย่างโปรแกรมที่มีการนิยามฟังก์ชันมีดังนี้:
ชื่อไฟล์: src/main.rs
fn main() {
println!("Hello, world!");
another_function();
}
fn another_function() {
println!("Another function.");
}
เรานิยามฟังก์ชันใน Rust โดยขึ้นต้นด้วย fn ตามด้วยชื่อฟังก์ชันและคู่วงเล็บเปิดปิด ส่วนวงเล็บปีกกาจะบอกให้คอมไพเลอร์ทราบถึงขอบเขตเริ่มต้นและสิ้นสุดของเนื้อหาฟังก์ชัน (body)
เราสามารถเรียกใช้ฟังก์ชันใดก็ได้ที่นิยามไว้ โดยระบุชื่อฟังก์ชันตามด้วยคู่วงเล็บเปิดปิด เนื่องจาก another_function ถูกนิยามไว้ในโปรแกรม เราจึงสามารถเรียกใช้มันจากภายในฟังก์ชัน main ได้ โปรดสังเกตว่าเรานิยาม another_function ไว้ ต่อจาก ฟังก์ชัน main ในซอร์สโค้ด แต่จริงๆ แล้วเราจะนิยามไว้ก่อนหน้าฟังก์ชัน main ก็ได้เช่นกัน Rust ไม่สนใจว่าคุณจะเขียนนิยามฟังก์ชันไว้ที่ใด ขอเพียงแค่นิยามไว้ภายในขอบเขต (scope) ที่โค้ดผู้เรียกสามารถมองเห็นได้ก็พอ
ลองสร้างโปรเจกต์แบบไบนารีใหม่ขึ้นมาชื่อ functions เพื่อทดลองใช้งานฟังก์ชันเพิ่มเติม นำโค้ดตัวอย่างของ another_function ใส่ลงใน src/main.rs แล้วลองรันดู จะได้ผลลัพธ์ดังนี้:
$ cargo run
Compiling functions v0.1.0 (file:///projects/functions)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.28s
Running `target/debug/functions`
Hello, world!
Another function.
คำสั่งต่างๆ จะทำงานตามลำดับที่ปรากฏในฟังก์ชัน main เริ่มจากพิมพ์ข้อความ “Hello, world!” ก่อน จากนั้นจึงเรียกใช้ another_function แล้วพิมพ์ข้อความของฟังก์ชันนั้นตามมา
พารามิเตอร์
เราสามารถนิยามฟังก์ชันให้รับ พารามิเตอร์ (parameter) ได้ ซึ่งพารามิเตอร์ก็คือตัวแปรพิเศษที่เป็นส่วนหนึ่งของลายเซ็นฟังก์ชัน (function signature) เมื่อฟังก์ชันมีพารามิเตอร์ คุณจะสามารถส่งค่าจริงไปให้พารามิเตอร์เหล่านั้นได้ ซึ่งในทางเทคนิค ค่าจริงที่ส่งเข้าไปจะเรียกว่า อาร์กิวเมนต์ (argument) อย่างไรก็ดี ในการสื่อสารทั่วไป ผู้คนมักใช้คำว่า พารามิเตอร์ และ อาร์กิวเมนต์ สลับกัน ไม่ว่าจะหมายถึงตัวแปรที่ระบุในการนิยามฟังก์ชัน หรือค่าจริงที่ส่งเข้าไปตอนเรียกใช้ฟังก์ชันก็ตาม
ใน another_function เวอร์ชันนี้ เราได้เพิ่มพารามิเตอร์เข้าไปหนึ่งตัว:
ชื่อไฟล์: src/main.rs
fn main() {
another_function(5);
}
fn another_function(x: i32) {
println!("The value of x is: {x}");
}
ลองรันโปรแกรมนี้ดู คุณจะได้ผลลัพธ์ดังต่อไปนี้:
$ cargo run
Compiling functions v0.1.0 (file:///projects/functions)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 1.21s
Running `target/debug/functions`
The value of x is: 5
ในการประกาศ another_function มีพารามิเตอร์หนึ่งตัวชื่อ x โดยระบุชนิดข้อมูลเป็น i32 เมื่อเราส่งค่า 5 เข้าไปใน another_function มาโคร println! จะนำเลข 5 ไปแทนที่ตรงตำแหน่งของวงเล็บปีกกาที่มี x อยู่ในสตริงจัดรูปแบบ
ในลายเซ็นของฟังก์ชัน คุณ จำเป็นต้อง ประกาศชนิดข้อมูลของพารามิเตอร์แต่ละตัวเสมอ นี่เป็นการตัดสินใจออกแบบโดยตั้งใจของ Rust การบังคับให้ระบุชนิดข้อมูลในนิยามฟังก์ชัน ส่งผลให้คอมไพเลอร์แทบไม่จำเป็นต้องให้คุณไประบุชนิดข้อมูลซ้ำในส่วนอื่นๆ ของโค้ดเพื่ออนุมานว่าคุณหมายถึงชนิดข้อมูลใด นอกจากนี้ คอมไพเลอร์ยังสามารถแสดงข้อความแจ้งเตือนข้อผิดพลาดที่เป็นประโยชน์ยิ่งขึ้นได้ หากทราบล่วงหน้าว่าฟังก์ชันนั้นคาดหวังชนิดข้อมูลใด
หากต้องการกำหนดพารามิเตอร์หลายตัว ให้คั่นการประกาศพารามิเตอร์แต่ละตัวด้วยเครื่องหมายจุลภาค ดังนี้:
ชื่อไฟล์: src/main.rs
fn main() {
print_labeled_measurement(5, 'h');
}
fn print_labeled_measurement(value: i32, unit_label: char) {
println!("The measurement is: {value}{unit_label}");
}
ตัวอย่างนี้สร้างฟังก์ชันชื่อ print_labeled_measurement ที่มีพารามิเตอร์สองตัว ตัวแรกชื่อ value เป็นชนิด i32 ส่วนตัวที่สองชื่อ unit_label เป็นชนิด char จากนั้นตัวฟังก์ชันจะพิมพ์ข้อความที่มีทั้งค่าของ value และ unit_label ออกมา
ลองรันโค้ดนี้กัน โดยนำโค้ดตัวอย่างข้างต้นไปแทนที่ในไฟล์ src/main.rs ของโปรเจกต์ functions แล้วสั่งรันด้วย cargo run:
$ cargo run
Compiling functions v0.1.0 (file:///projects/functions)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.31s
Running `target/debug/functions`
The measurement is: 5h
เนื่องจากเราเรียกฟังก์ชันโดยส่ง 5 ไปเป็นค่าของ value และ 'h' ไปเป็นค่าของ unit_label ผลลัพธ์ของโปรแกรมจึงแสดงค่าเหล่านั้นออกมา
สเตตเมนต์และนิพจน์
เนื้อหาของฟังก์ชันประกอบขึ้นจากชุดของสเตตเมนต์ (statement) ซึ่งอาจปิดท้ายด้วยนิพจน์ (expression) ได้ จนถึงตอนนี้ ฟังก์ชันที่เราเขียนกันไปยังไม่มีนิพจน์ปิดท้าย แต่คุณได้เห็นนิพจน์เป็นส่วนหนึ่งของสเตตเมนต์มาบ้างแล้ว เนื่องจาก Rust เป็นภาษาที่ทำงานบนพื้นฐานของนิพจน์ (expression-based language) ความแตกต่างระหว่างสองสิ่งนี้จึงเป็นเรื่องสำคัญที่ต้องทำความเข้าใจ ภาษาโปรแกรมอื่นๆ มักไม่มีความแตกต่างในลักษณะนี้ ดังนั้นเรามาดูกันว่าสเตตเมนต์และนิพจน์คืออะไร และความแตกต่างของพวกมันส่งผลต่อเนื้อหาของฟังก์ชันอย่างไร
- สเตตเมนต์ (Statement) คือชุดคำสั่งที่ดำเนินการบางอย่างและไม่มีการคืนค่า
- นิพจน์ (Expression) คือส่วนที่ประเมินผลลัพธ์ออกมาเป็นค่าใดค่าหนึ่ง
มาดูตัวอย่างกัน
ในความเป็นจริง เราได้ใช้ทั้งสเตตเมนต์และนิพจน์กันไปแล้ว การสร้างตัวแปรและกำหนดค่าให้มันด้วยคีย์เวิร์ด let ถือเป็นสเตตเมนต์ ในลิสติ้ง 3-1 คำสั่ง let y = 6; คือสเตตเมนต์
fn main() {
let y = 6;
}
การนิยามฟังก์ชันก็เป็นสเตตเมนต์เช่นเดียวกัน ตัวอย่างฟังก์ชันทั้งหมดที่ผ่านมาล้วนเป็นสเตตเมนต์ในตัวมันเอง (ส่วนการเรียกใช้ฟังก์ชันนั้นไม่ถือเป็นสเตตเมนต์ ดังที่เราจะได้เห็นกันในไม่ช้า)
สเตตเมนต์จะไม่มีการคืนค่า ดังนั้นคุณจึงไม่สามารถนำผลลัพธ์ของสเตตเมนต์ let ไปกำหนดให้กับตัวแปรอื่นได้ เหมือนอย่างที่โค้ดต่อไปนี้พยายามจะทำ ซึ่งจะทำให้เกิดข้อผิดพลาดในการคอมไพล์:
ชื่อไฟล์: src/main.rs
fn main() {
let x = (let y = 6);
}
เมื่อคุณรันโปรแกรมนี้ จะพบกับข้อผิดพลาดลักษณะนี้:
$ cargo run
Compiling functions v0.1.0 (file:///projects/functions)
error: expected expression, found `let` statement
--> src/main.rs:2:14
|
2 | let x = (let y = 6);
| ^^^
|
= note: only supported directly in conditions of `if` and `while` expressions
warning: unnecessary parentheses around assigned value
--> src/main.rs:2:13
|
2 | let x = (let y = 6);
| ^ ^
|
= note: `#[warn(unused_parens)]` (part of `#[warn(unused)]`) on by default
help: remove these parentheses
|
2 - let x = (let y = 6);
2 + let x = let y = 6;
|
warning: `functions` (bin "functions") generated 1 warning
error: could not compile `functions` (bin "functions") due to 1 previous error; 1 warning emitted
สเตตเมนต์ let y = 6 ไม่มีการคืนค่า จึงไม่มีค่าใดๆ ที่จะนำไปผูกเข้ากับ x ได้ ซึ่งจุดนี้แตกต่างจากภาษาอื่นอย่างเช่น C และ Ruby ที่การกำหนดค่าจะคืนค่าของการกำหนดนั้นกลับมาด้วย ทำให้ในภาษาเหล่านั้นคุณสามารถเขียน x = y = 6 เพื่อกำหนดให้ทั้ง x และ y มีค่าเป็น 6 ได้ แต่สำหรับใน Rust คุณไม่สามารถทำเช่นนั้นได้
สำหรับนิพจน์ (expression) นั้นจะประเมินผลลัพธ์ออกมาเป็นค่าหนึ่งเสมอ และโค้ดส่วนใหญ่ที่คุณจะเขียนใน Rust ก็คือนิพจน์นี่เอง ลองพิจารณาการคำนวณทางคณิตศาสตร์อย่าง 5 + 6 ซึ่งเป็นนิพจน์ที่ประเมินผลได้เป็น 11 นอกจากนี้นิพจน์ยังสามารถเป็นส่วนประกอบย่อยของสเตตเมนต์ได้อีกด้วย เช่น ในลิสติ้ง 3-1 เลข 6 ในสเตตเมนต์ let y = 6; ก็คือนิพจน์ที่ประเมินผลได้ค่า 6 หรือแม้แต่การเรียกใช้ฟังก์ชัน การเรียกใช้มาโคร รวมถึงบล็อกขอบเขตใหม่ที่สร้างขึ้นด้วยวงเล็บปีกกา ต่างก็ล้วนเป็นนิพจน์ทั้งสิ้น ตัวอย่างเช่น:
ชื่อไฟล์: src/main.rs
fn main() {
let y = {
let x = 3;
x + 1
};
println!("The value of y is: {y}");
}
นิพจน์ส่วนนี้:
{
let x = 3;
x + 1
}
คือบล็อกคำสั่งซึ่งในกรณีนี้จะประเมินผลลัพธ์ออกมาได้เป็น 4 จากนั้นค่านั้นจะถูกผูกเข้ากับตัวแปร y โดยสเตตเมนต์ let โปรดสังเกตบรรทัด x + 1 ซึ่งไม่มีเครื่องหมายอัฒภาค (semicolon) ต่อท้าย ต่างจากบรรทัดส่วนใหญ่ที่คุณเคยเห็นมา นิพจน์จะไม่มีเครื่องหมายอัฒภาคปิดท้าย หากคุณใส่อัฒภาคต่อท้ายนิพจน์ มันจะกลายสภาพเป็นสเตตเมนต์ทันที และจะไม่มีการคืนค่าใดๆ ออกมาอีก ขอให้จำจุดนี้ไว้ให้ดีในระหว่างที่เราจะไปศึกษาเรื่องค่าคืนกลับของฟังก์ชันและนิพจน์กันต่อ
ฟังก์ชันที่มีการคืนค่า
ฟังก์ชันสามารถคืนค่ากลับไปยังโค้ดส่วนที่เรียกใช้ได้ เราไม่ต้องตั้งชื่อให้กับค่าคืนกลับ แต่เราจำเป็นต้องประกาศชนิดข้อมูลของมันหลังเครื่องหมายลูกศร (->) ใน Rust ค่าที่ฟังก์ชันคืนกลับจะเทียบเท่ากับค่าของนิพจน์สุดท้ายในบล็อกเนื้อหาของฟังก์ชันเสมอ คุณสามารถสั่งคืนค่าออกจากฟังก์ชันก่อนเวลาได้โดยใช้คีย์เวิร์ด return พร้อมกับระบุค่า แต่ฟังก์ชันส่วนใหญ่จะคืนค่าของนิพจน์สุดท้ายออกมาโดยปริยาย ตัวอย่างฟังก์ชันที่มีการคืนค่ามีดังนี้:
ชื่อไฟล์: src/main.rs
fn five() -> i32 {
5
}
fn main() {
let x = five();
println!("The value of x is: {x}");
}
ในฟังก์ชัน five ไม่มีทั้งการเรียกฟังก์ชันอื่น ไม่มีมาโคร และไม่มีแม้กระทั่งสเตตเมนต์ let มีเพียงตัวเลข 5 โดดๆ เท่านั้น ซึ่งนี่ถือเป็นฟังก์ชันที่ถูกต้องสมบูรณ์ในภาษา Rust โปรดสังเกตว่ามีการระบุชนิดข้อมูลคืนกลับของฟังก์ชันเป็น -> i32 ด้วย เมื่อลองรันโค้ดนี้ จะได้ผลลัพธ์ดังนี้:
$ cargo run
Compiling functions v0.1.0 (file:///projects/functions)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.30s
Running `target/debug/functions`
The value of x is: 5
เลข 5 ในฟังก์ชัน five ก็คือค่าคืนกลับของฟังก์ชัน ซึ่งสอดคล้องกับชนิดข้อมูลคืนกลับที่เป็น i32 ลองมาพิจารณาเรื่องนี้อย่างละเอียดกันสักนิด มีสองประเด็นสำคัญ: ประการแรก บรรทัด let x = five(); แสดงให้เห็นว่าเรานำค่าที่ได้จากฟังก์ชันมากำหนดเป็นค่าเริ่มต้นให้กับตัวแปร และเนื่องจากฟังก์ชัน five คืนค่า 5 บรรทัดดังกล่าวจึงทำงานเทียบเท่ากับคำสั่งนี้:
#![allow(unused)]
fn main() {
let x = 5;
}
ประการที่สอง ฟังก์ชัน five ไม่มีพารามิเตอร์และได้ระบุชนิดข้อมูลคืนกลับเอาไว้ โดยเนื้อหาของฟังก์ชันมีเพียงเลข 5 เดี่ยวๆ ที่ไม่มีเครื่องหมายอัฒภาคปิดท้าย เพราะนี่คือนิพจน์ที่ให้ค่าที่เราต้องการจะคืนกลับนั่นเอง
ลองมาดูอีกตัวอย่างหนึ่ง:
ชื่อไฟล์: src/main.rs
fn main() {
let x = plus_one(5);
println!("The value of x is: {x}");
}
fn plus_one(x: i32) -> i32 {
x + 1
}
เมื่อรันโค้ดนี้ โปรแกรมจะพิมพ์ The value of x is: 6 ออกมา แต่จะเกิดอะไรขึ้นหากเราใส่เครื่องหมายอัฒภาคไว้ท้ายบรรทัด x + 1 จนทำให้นิพจน์กลายสภาพเป็นสเตตเมนต์?
ชื่อไฟล์: src/main.rs
fn main() {
let x = plus_one(5);
println!("The value of x is: {x}");
}
fn plus_one(x: i32) -> i32 {
x + 1;
}
เมื่อนำโค้ดนี้ไปคอมไพล์ จะเกิดข้อผิดพลาดขึ้นดังนี้:
$ cargo run
Compiling functions v0.1.0 (file:///projects/functions)
error[E0308]: mismatched types
--> src/main.rs:7:24
|
7 | fn plus_one(x: i32) -> i32 {
| -------- ^^^ expected `i32`, found `()`
| |
| implicitly returns `()` as its body has no tail or `return` expression
8 | x + 1;
| - help: remove this semicolon to return this value
For more information about this error, try `rustc --explain E0308`.
error: could not compile `functions` (bin "functions") due to 1 previous error
ข้อความแจ้งข้อผิดพลาดหลักอย่าง mismatched types ได้บ่งชี้ถึงใจความสำคัญของปัญหา ในนิยามของฟังก์ชัน plus_one ระบุไว้ว่าจะคืนค่าเป็น i32 แต่สเตตเมนต์ไม่ได้ประเมินผลออกมาเป็นค่าใดๆ ซึ่งแทนด้วยชนิดข้อมูล unit หรือ () ผลก็คือฟังก์ชันไม่ได้คืนค่าใดๆ กลับไป ขัดแย้งกับข้อกำหนดในนิยามฟังก์ชันและทำให้คอมไพล์ไม่ผ่าน ในเอาต์พุตนี้ Rust ยังให้คำแนะนำที่ช่วยแก้ปัญหา โดยแนะนำให้ลบเครื่องหมายอัฒภาคออก ซึ่งจะช่วยแก้ไขข้อผิดพลาดนี้ได้