0Pricing
Learn Rust Coding · บทเรียน

การกำหนดฟังก์ชัน

พารามิเตอร์และค่าที่ส่งคืน

การกำหนดฟังก์ชัน เป็นบทเรียน Learn Rust Coding ฟรีบน CoddyKit นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Learn Rust Coding และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Learn Rust Coding มีบทเรียนทั้งหมด 4 บทเรียน

การประกาศฟังก์ชัน

คุณกำหนดฟังก์ชันด้วยคีย์เวิร์ด fn ตามด้วยชื่อ วงเล็บ และส่วนเนื้อหาภายในวงเล็บปีกกา

ตามธรรมเนียม Rust ใช้รูปแบบ snake_case สำหรับชื่อฟังก์ชัน

fn main() {
    greet();
}

fn greet() {
    println!("Hello from a function!");
}

ฟังก์ชัน main

โปรแกรม Rust ที่ทำงานได้ทุกโปรแกรมเริ่มต้นที่ fn main() ซึ่งเป็นจุดเริ่มต้นที่ระบบขณะทำงานเรียกเป็นอันดับแรก

fn main() {
    println!("Program starts here");
}

พารามิเตอร์

ฟังก์ชันสามารถรับพารามิเตอร์ได้ พารามิเตอร์แต่ละตัวต้องประกาศชนิดข้อมูลไว้หลังเครื่องหมายโคลอน

fn main() {
    print_number(7);
}

fn print_number(x: i32) {
    println!("The number is {}", x);
}

พารามิเตอร์หลายตัว

คั่นพารามิเตอร์หลายตัวด้วยจุลภาค แต่ละตัวต้องมีคำอธิบายชนิดข้อมูลของตัวเอง

fn main() {
    describe("Rust", 2010);
}

fn describe(name: &str, year: i32) {
    println!("{} was released in {}", name, year);
}

ค่าที่ส่งคืน

ประกาศชนิดค่าที่ส่งคืนหลังลูกศร -> ฟังก์ชันจะส่งคืนค่าที่มีชนิดนั้น

นิพจน์สุดท้ายที่ไม่มีเครื่องหมายเซมิโคลอนจะกลายเป็นค่าที่ส่งคืน

fn main() {
    let result = square(5);
    println!("square is {}", result);
}

fn square(n: i32) -> i32 {
    n * n
}

คีย์เวิร์ด return

คุณยังสามารถส่งคืนค่าก่อนถึงจุดสิ้นสุดได้ด้วยคีย์เวิร์ด return ซึ่งมีประโยชน์สำหรับเงื่อนไขตรวจสอบเบื้องต้น

fn main() {
    println!("{}", abs_value(-8));
}

fn abs_value(n: i32) -> i32 {
    if n < 0 {
        return -n;
    }
    n
}

การรวมพารามิเตอร์กับค่าที่ส่งคืน

โดยทั่วไปฟังก์ชันจะรับข้อมูลเข้าและสร้างข้อมูลออก ในที่นี้เราจะบวกตัวเลขสองตัว

fn main() {
    let total = add(3, 4);
    println!("total {}", total);
}

fn add(a: i32, b: i32) -> i32 {
    a + b
}

ฟังก์ชันเรียกใช้ฟังก์ชัน

ฟังก์ชันสามารถเรียกใช้ฟังก์ชันอื่นได้ ทำให้คุณสร้างการทำงานที่ซับซ้อนขึ้นจากส่วนประกอบเล็ก ๆ ที่นำกลับมาใช้ใหม่ได้

fn main() {
    println!("{}", double_then_add(5));
}

fn double(n: i32) -> i32 { n * 2 }

fn double_then_add(n: i32) -> i32 {
    double(n) + 1
}

การส่งคืนชนิดข้อมูลอื่น

ฟังก์ชันสามารถส่งคืนชนิดข้อมูลใดก็ได้ เช่น สตริง ค่าบูลีน ทูเพิล และอื่น ๆ

fn main() {
    let (sum, product) = compute(3, 4);
    println!("sum {} product {}", sum, product);
}

fn compute(a: i32, b: i32) -> (i32, i32) {
    (a + b, a * b)
}

ฟังก์ชันที่ไม่ส่งคืนค่า

ฟังก์ชันที่ไม่มีลูกศรจะส่งคืนชนิดข้อมูลยูนิต () โดยทำงานผ่านผลข้างเคียง เช่น การพิมพ์ข้อมูล

fn main() {
    log_message("saving file");
}

fn log_message(msg: &str) {
    println!("[LOG] {}", msg);
}

ลำดับไม่สำคัญ

ต่างจากบางภาษา ใน Rust คุณสามารถเรียกใช้ฟังก์ชันที่ประกาศไว้ภายหลังในไฟล์ได้ คอมไพเลอร์จะมองเห็นฟังก์ชันทั้งหมดก่อนเริ่มทำงาน

fn main() {
    println!("{}", helper());
}

fn helper() -> i32 {
    99
}

ตรวจสอบความเข้าใจอย่างรวดเร็ว

ทบทวนวิธีที่ฟังก์ชัน Rust ส่งคืนค่า

สรุปทบทวน

ฟังก์ชันใน Rust:

  • กำหนดด้วย fn name(params) -> ReturnType { ... }
  • พารามิเตอร์ต้องระบุชนิดข้อมูลอย่างชัดเจน
  • นิพจน์สุดท้ายที่ไม่มีเซมิโคลอนคือค่าที่ส่งคืน หรือใช้ return เพื่อส่งคืนก่อน
  • หากไม่ระบุชนิดค่าที่ส่งคืน ฟังก์ชันจะส่งคืน ()
fn main() {
    let area = rectangle_area(4, 6);
    println!("area {}", area);
}

fn rectangle_area(w: i32, h: i32) -> i32 {
    w * h
}

คำถามที่พบบ่อย

บทเรียน “การกำหนดฟังก์ชัน” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “การกำหนดฟังก์ชัน” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Learn Rust Coding ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Learn Rust Coding มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “การกำหนดฟังก์ชัน”

พารามิเตอร์และค่าที่ส่งคืน คุณปฏิบัติ Learn Rust Coding ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Learn Rust Coding หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Learn Rust Coding บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน

บทเรียน “การกำหนดฟังก์ชัน” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Learn Rust Coding นี้ได้ไหม

ได้ บทเรียน Learn Rust Coding ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

  1. การกำหนดฟังก์ชัน
  2. นิพจน์และคำสั่ง
  3. คลอเชอร์
  4. Fn, FnMut, FnOnce
← กลับไปที่ Learn Rust Coding