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

นิพจน์และคำสั่ง

นิพจน์สุดท้าย

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

คำสั่งกับนิพจน์

Rust แยกโค้ดออกเป็นสองประเภท:

  • คำสั่งดำเนินการบางอย่างและไม่ส่งคืนค่า
  • นิพจน์ประเมินผลออกมาเป็นค่า

ความแตกต่างนี้มีผลต่อวิธีที่ฟังก์ชันส่งคืนค่า

fn main() {
    let x = 5;      // a let statement
    let y = x + 1;  // x + 1 is an expression
    println!("{}", y);
}

let เป็นคำสั่ง

การผูกชื่อด้วย let เป็นคำสั่งและไม่ส่งคืนค่า ดังนั้นคุณจึงเขียน let a = (let b = 6); ไม่ได้

fn main() {
    let a = 6;
    // let c = (let d = 6); // error: let is not an expression
    println!("{}", a);
}

นิพจน์ประเมินผลเป็นค่า

การคำนวณทางคณิตศาสตร์ การเรียกฟังก์ชัน และค่าลิเทอรัลล้วนเป็นนิพจน์ เพราะสร้างค่าออกมา

  • 5
  • 2 + 3
  • square(4)
fn main() {
    let v = 2 + 3 * 4;
    println!("{}", v);
}

บล็อกเป็นนิพจน์

บล็อก { ... } เองก็เป็นนิพจน์ ค่าของบล็อกคือนิพจน์สุดท้ายภายใน หากไม่มีเซมิโคลอนต่อท้าย

fn main() {
    let y = {
        let x = 3;
        x + 1
    };
    println!("y is {}", y);
}

เซมิโคลอนมีความสำคัญ

การเติมเซมิโคลอนจะเปลี่ยนนิพจน์ให้เป็นคำสั่ง และทิ้งค่าของนิพจน์นั้น

  • x + 1 — นิพจน์ ซึ่งให้ค่าออกมา
  • x + 1; — คำสั่ง ซึ่งให้ค่า ()
fn main() {
    let y = {
        let x = 3;
        x + 1   // no semicolon: this is the block's value
    };
    println!("{}", y);
}

นิพจน์สุดท้ายจะถูกส่งคืน

ในฟังก์ชัน นิพจน์สุดท้ายที่ไม่มีเซมิโคลอนจะกลายเป็นค่าที่ส่งคืน นี่เป็นรูปแบบการเขียน Rust ที่ใช้กันตามธรรมเนียม

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

fn five() -> i32 {
    5
}

เซมิโคลอนทำให้การส่งคืนค่าผิดพลาด

หากเผลอเติมเซมิโคลอนในบรรทัดสุดท้าย ฟังก์ชันจะส่งคืน () แทนค่าที่ต้องการ ซึ่งเป็นข้อผิดพลาดที่ผู้เริ่มต้นพบได้บ่อย

fn main() {
    println!("{}", plus_one(10));
}

fn plus_one(n: i32) -> i32 {
    n + 1   // correct: no semicolon
}

if ในฐานะนิพจน์

เนื่องจาก if เป็นนิพจน์ คุณจึงกำหนดผลลัพธ์ของมันให้ตัวแปรได้ ทั้งสองแขนงต้องให้ชนิดข้อมูลเดียวกัน

fn main() {
    let condition = true;
    let number = if condition { 5 } else { 6 };
    println!("number is {}", number);
}

loop ในฐานะนิพจน์

loop สามารถส่งคืนค่าผ่าน break ได้ ค่าที่อยู่หลัง break จะกลายเป็นผลลัพธ์ของลูป

fn main() {
    let mut counter = 0;
    let result = loop {
        counter += 1;
        if counter == 10 {
            break counter * 2;
        }
    };
    println!("result {}", result);
}

match ในฐานะนิพจน์

match ก็เป็นนิพจน์เช่นกัน แต่ละแขนงจะสร้างค่า และค่าของแขนงที่ตรงกันจะเป็นผลลัพธ์

fn main() {
    let n = 2;
    let label = match n {
        1 => "one",
        2 => "two",
        _ => "many",
    };
    println!("{}", label);
}

นำทุกอย่างมารวมกัน

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

fn main() {
    let score = 85;
    let grade = if score >= 90 { 'A' } else if score >= 80 { 'B' } else { 'C' };
    println!("grade {}", grade);
}

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

การเติมเซมิโคลอนให้นิพจน์มีผลอย่างไร

สรุปทบทวน

นิพจน์และคำสั่งใน Rust:

  • คำสั่ง (เช่น let) ทำงานบางอย่างแต่ไม่ส่งคืนค่า
  • นิพจน์ประเมินผลออกมาเป็นค่า
  • บล็อก if match และ loop เป็นนิพจน์
  • นิพจน์สุดท้ายที่ไม่มีเซมิโคลอนคือค่าที่ส่งคืน
fn main() {
    let x = { let a = 2; a * a };
    let y = if x > 3 { "big" } else { "small" };
    println!("{} {}", x, y);
}

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

บทเรียน “นิพจน์และคำสั่ง” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “นิพจน์และคำสั่ง” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ 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 ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 2 จากทั้งหมด 4 บทเรียน

บทเรียน “นิพจน์และคำสั่ง” ใช้เวลานานแค่ไหน

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

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

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

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

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