นิพจน์และคำสั่ง
นิพจน์สุดท้าย
นิพจน์และคำสั่ง เป็นบทเรียน 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);
}นิพจน์ประเมินผลเป็นค่า
การคำนวณทางคณิตศาสตร์ การเรียกฟังก์ชัน และค่าลิเทอรัลล้วนเป็นนิพจน์ เพราะสร้างค่าออกมา
52 + 3square(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) ทำงานบางอย่างแต่ไม่ส่งคืนค่า - นิพจน์ประเมินผลออกมาเป็นค่า
- บล็อก
ifmatchและ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 ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ
บทเรียนทั้งหมดในหลักสูตรนี้
- การกำหนดฟังก์ชัน
- นิพจน์และคำสั่ง
- คลอเชอร์
- Fn, FnMut, FnOnce