Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

ฟังก์ชัน

ฟังก์ชัน (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 ยังให้คำแนะนำที่ช่วยแก้ปัญหา โดยแนะนำให้ลบเครื่องหมายอัฒภาคออก ซึ่งจะช่วยแก้ไขข้อผิดพลาดนี้ได้