Learn Rust Coding · บทเรียน

ฟังก์ชันและลำดับการควบคุม

เรียนรู้การกำหนดฟังก์ชัน และใช้ นิพจน์ `if`/`else`, `loop`, `while` และ `for` เพื่อควบคุมลำดับการทำงานของโปรแกรม

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

ฟังก์ชันคืออะไร

ฟังก์ชันคือกลุ่มคำสั่งที่มีชื่อและทำงานเฉพาะอย่าง ฟังก์ชันเป็นพื้นฐานสำคัญในการจัดระเบียบโค้ดและทำให้สามารถนำกลับมาใช้ซ้ำได้

การนำโค้ดกลับมาใช้ซ้ำ: เขียนตรรกะส่วนหนึ่งเพียงครั้งเดียว แล้วนำไปใช้ได้หลายครั้ง
การแบ่งเป็นส่วนย่อย: แบ่งปัญหาที่ซับซ้อนออกเป็นส่วนเล็ก ๆ ที่จัดการได้ง่าย
ความอ่านง่าย: ตั้งชื่อที่สื่อความหมายให้กลุ่มคำสั่ง ทำให้เข้าใจได้ง่ายขึ้น

ฟังก์ชัน Rust แรกของคุณ

ใน Rust คุณกำหนดฟังก์ชันโดยใช้คำสำคัญ fn ฟังก์ชัน main คือจุดเริ่มต้นของโปรแกรม Rust ทุกโปรแกรม

ต่อไปนี้คือวิธีประกาศและเรียกใช้ฟังก์ชันอย่างง่าย:

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

fn main() {
    say_hello(); // Call the function
    println!("Back in main.");
}

ฟังก์ชันที่มีพารามิเตอร์

ฟังก์ชันสามารถรับค่าข้อมูลเข้า ซึ่งเรียกว่าพารามิเตอร์ได้ พารามิเตอร์ช่วยให้ฟังก์ชันทำงานกับข้อมูลที่แตกต่างกันในแต่ละครั้งที่เรียกใช้

พารามิเตอร์จะกำหนดด้วยชื่อและชนิดข้อมูล โดยคั่นด้วยเครื่องหมายทวิภาค

fn greet(name: &str) {
    println!("Hello, {}!", name);
}

fn main() {
    greet("Alice");
    greet("Bob");
}

ฟังก์ชันที่มีค่าที่ส่งกลับ

ฟังก์ชันยังสามารถส่งค่ากลับไปยังผู้เรียกได้ คุณระบุชนิดของค่าที่ส่งกลับหลังลูกศร (->)

นิพจน์สุดท้ายในตัวฟังก์ชันจะถูกส่งกลับโดยอัตโนมัติ ไม่ต้องใส่อัฒภาคสำหรับนิพจน์ที่ส่งกลับ

fn add_numbers(x: i32, y: i32) -> i32 {
    x + y // No semicolon: this expression is returned
}

fn main() {
    let sum = add_numbers(5, 7);
    println!("The sum is: {}", sum);
}

การตัดสินใจ: `if`/`else`

นิพจน์ if ช่วยให้โปรแกรมเรียกใช้กลุ่มคำสั่งที่แตกต่างกันตามเงื่อนไข เงื่อนไขต้องเป็นค่า bool (true/false) เสมอ

ใช้ if สำหรับเงื่อนไขแรก
ใช้ else if สำหรับเงื่อนไขเพิ่มเติม
ใช้ else เป็นทางเลือกสำรองเมื่อไม่มีเงื่อนไขอื่นเป็นจริง

if ของ Rust เป็นนิพจน์ ซึ่งหมายความว่าสามารถส่งค่ากลับได้

นิพจน์ If-Else ในการใช้งานจริง

ต่อไปนี้คือวิธีใช้ if และ else เพื่อกำหนดค่าตามเงื่อนไข โปรดสังเกตว่าการทำงานคล้ายกับตัวดำเนินการแบบสามส่วนในภาษาอื่น

fn main() {
    let number = 7;

    let message = if number < 10 {
        "Small number"
    } else {
        "Large number"
    };

    println!("The number is: {}", message);

    let other_num = 15;
    if other_num % 2 == 0 {
        println!("{} is even", other_num);
    } else {
        println!("{} is odd", other_num);
    }
}

การทำคำสั่งซ้ำ: `loop`

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

ใช้ break เพื่อออกจากการวนซ้ำ คุณยังสามารถส่งค่ากลับจากนิพจน์ loop ด้วย break ได้ด้วย

fn main() {
    let mut counter = 0;

    let result = loop {
        counter += 1;

        if counter == 10 {
            break counter * 2; // Break and return a value
        }
    };

    println!("The result is {}", result);
}

การทำซ้ำตามเงื่อนไข: `while`

การวนซ้ำด้วย while จะเรียกใช้กลุ่มคำสั่งตราบใดที่เงื่อนไขที่ระบุยังคงเป็นจริง เหมาะอย่างยิ่งเมื่อคุณไม่ทราบแน่ชัดว่าจะต้องวนซ้ำกี่ครั้ง

fn main() {
    let mut count = 3;

    while count != 0 {
        println!("{}!", count);
        count -= 1;
    }

    println!("LIFTOFF!!!");
}

การวนซ้ำด้วยลูป `for`

ลูป for ใช้สำหรับวนดูสมาชิกในชุดข้อมูลหรือช่วงของตัวเลข เป็นโครงสร้างการวนซ้ำที่ใช้บ่อยที่สุดใน Rust ทำให้โค้ดปลอดภัยและกระชับ

มักใช้ร่วมกับช่วง (เช่น 1..4 สำหรับ 1, 2, 3 หรือ 1..=4 สำหรับ 1, 2, 3, 4)
ใช้ได้กับชนิดข้อมูลใด ๆ ที่นำคุณลักษณะ Iterator ไปใช้

fn main() {
    // Loop through a range
    for number in 1..4 { // 1, 2, 3
        println!("Number: {}", number);
    }

    // Loop through an array
    let a = [10, 20, 30, 40, 50];
    for element in a.iter() {
        println!("The value is: {}", element);
    }
}

โจทย์ท้าทายการควบคุมลำดับการทำงาน

พิจารณาโค้ด Rust ต่อไปนี้ ค่าสุดท้ายของ result จะเป็นเท่าใด

fn calculate_value(input: i32) -> i32 {
    if input > 10 {
        input * 2
    } else if input == 5 {
        input + 5
    } else {
        input
    }
}

fn main() {
    let result = calculate_value(5);
    // What is result?
}

ทบทวน: ฟังก์ชันและการควบคุมลำดับการทำงาน

คุณเรียนรู้พื้นฐานสำคัญสำหรับสร้างโปรแกรมแบบไดนามิกได้อย่างเชี่ยวชาญแล้ว

ฟังก์ชัน: จัดระเบียบและนำโค้ดกลับมาใช้ซ้ำด้วย fn พารามิเตอร์ และค่าที่ส่งกลับ
if/else: ใช้ตัดสินใจและเรียกใช้โค้ดตามเงื่อนไข โปรดจำไว้ว่านี่คือนิพจน์
loop: สร้างการวนซ้ำไม่สิ้นสุด ออกด้วย break และส่งค่ากลับได้
while: วนซ้ำตราบใดที่เงื่อนไขเป็นจริง
for: วนดูชุดข้อมูลและช่วงต่าง ๆ อย่างปลอดภัย

เครื่องมือเหล่านี้จำเป็นสำหรับการเขียนโปรแกรม Rust ที่มีโครงสร้างและมีประสิทธิภาพ

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

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

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

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

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

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

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

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

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

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

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

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

ตัวแปร การเปลี่ยนแปลงค่าได้ และการบดบังชื่อ
ชนิดข้อมูลพื้นฐานและตัวดำเนินการ
ฟังก์ชันและลำดับการควบคุม

← กลับไปที่ Learn Rust Coding