Learn Rust Coding · บทเรียน

let และความเปลี่ยนแปลงได้

การผูกค่าและความเปลี่ยนแปลงได้

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

การผูกค่าด้วย let

ใน Rust คุณสร้างตัวแปรด้วยคีย์เวิร์ด let ซึ่งเป็นการผูกชื่อเข้ากับค่า

โดยค่าเริ่มต้น การผูกทุกแบบจะเป็นค่าคงที่ — เมื่อกำหนดค่าให้แล้ว คุณจะเปลี่ยนค่าไม่ได้

fn main() {
    let x = 5;
    println!("The value of x is: {}", x);
}

ไม่เปลี่ยนแปลงเป็นค่าเริ่มต้น

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

การพยายามกำหนดค่าใหม่ให้การผูกที่ไม่เปลี่ยนแปลงได้จะทำให้เกิดข้อผิดพลาดขณะคอมไพล์ ไม่ใช่โปรแกรมขัดข้องขณะทำงาน

let x = 5; ตามด้วย x = 6; จะไม่สามารถคอมไพล์ได้

fn main() {
    let x = 5;
    // x = 6; // this would cause a compile error
    println!("x stays {}", x);
}

ทำให้ตัวแปรเปลี่ยนแปลงได้

เมื่อคุณต้องการเปลี่ยนค่า ให้เพิ่มคีย์เวิร์ด mut ซึ่งจะระบุว่าการผูกนั้นเปลี่ยนแปลงได้

จากนั้นคุณจะกำหนดค่าใหม่ให้ตัวแปรกี่ครั้งก็ได้ตามต้องการ

fn main() {
    let mut count = 0;
    count = count + 1;
    count += 1;
    println!("count is {}", count);
}

การอนุมานชนิดข้อมูล

โดยทั่วไป Rust จะอนุมานชนิดของตัวแปรจากค่าของตัวแปรเอง กระบวนการนี้เรียกว่าการอนุมานชนิดข้อมูล

let x = 5; จะกำหนดให้ x มีชนิดเป็น i32 โดยอัตโนมัติ

fn main() {
    let n = 42;      // inferred as i32
    let pi = 3.14;   // inferred as f64
    println!("{} and {}", n, pi);
}

การระบุชนิดข้อมูล

คุณสามารถระบุชนิดข้อมูลอย่างชัดเจนด้วยเครื่องหมายโคลอนและชื่อชนิดข้อมูล ซึ่งเรียกว่าการระบุชนิดข้อมูล

การระบุชนิดมีประโยชน์เมื่อคอมไพเลอร์อนุมานชนิดข้อมูลไม่ได้ หรือเมื่อคุณต้องการให้โค้ดชัดเจนขึ้น

fn main() {
    let age: u32 = 30;
    let price: f64 = 9.99;
    println!("age {} price {}", age, price);
}

ค่าคงที่

const จะไม่เปลี่ยนแปลงเสมอและต้องมีการระบุชนิดข้อมูล ค่าของมันต้องทราบได้ตั้งแต่เวลาคอมไพล์

ตามธรรมเนียม ค่าคงที่จะใช้รูปแบบ SCREAMING_SNAKE_CASE

fn main() {
    const MAX_POINTS: u32 = 100_000;
    println!("Max is {}", MAX_POINTS);
}

const เทียบกับ let

ความแตกต่างสำคัญระหว่าง const และ let:

const ไม่สามารถเป็น mut ได้
const ต้องมีการระบุชนิดข้อมูล
const ต้องเป็นนิพจน์ค่าคงที่ที่คำนวณได้ขณะคอมไพล์
ค่าแบบ let สามารถคำนวณขณะทำงานได้

fn main() {
    const SECONDS_PER_HOUR: u32 = 60 * 60;
    let hours = 3;
    println!("{} seconds", SECONDS_PER_HOUR * hours);
}

การเปลี่ยนค่าในลูป

ตัวแปรที่เปลี่ยนแปลงได้มักใช้ในลูปที่ค่าจะสะสมเพิ่มขึ้นตามเวลา

ในตัวอย่างนี้ เราหาผลรวมของตัวเลขโดยใช้ตัวสะสมแบบ mut

fn main() {
    let mut total = 0;
    for i in 1..=5 {
        total += i;
    }
    println!("Sum is {}", total);
}

ใช้ขีดล่างกับค่าที่ไม่ได้ใช้

หากคุณผูกค่าไว้แต่ไม่เคยใช้งาน Rust จะแสดงคำเตือน ให้เติมขีดล่างไว้หน้าชื่อเพื่อปิดคำเตือนนั้น

let _unused = 10; แจ้งคอมไพเลอร์ว่าการไม่ใช้งานนี้เป็นสิ่งที่ตั้งใจ

fn main() {
    let _temp = 99;
    let used = 1;
    println!("{}", used);
}

การผูกหลายค่า

คุณสามารถประกาศตัวแปรหลายตัวในคนละบรรทัด โดยใช้ let ของแต่ละตัวเอง

การผูกแต่ละรายการเป็นอิสระต่อกันและไม่เปลี่ยนแปลง เว้นแต่จะระบุด้วย mut

fn main() {
    let name = "Rust";
    let year = 2010;
    let mut version = 1;
    version += 1;
    println!("{} born {} v{}", name, year, version);
}

เหตุใดการไม่เปลี่ยนแปลงจึงมีประโยชน์

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

เลือกใช้การเปลี่ยนค่าโดยใช้ mut เฉพาะเมื่อจำเป็นจริง ๆ

fn main() {
    let config = "production";
    // config is guaranteed not to change
    println!("Running in {}", config);
}

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

คีย์เวิร์ดใดทำให้ตัวแปร Rust เปลี่ยนค่าได้

ทบทวน

คุณได้เรียนรู้พื้นฐานของการผูกค่าใน Rust:

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

fn main() {
    let mut score: u32 = 0;
    const BONUS: u32 = 10;
    score += BONUS;
    println!("Final score: {}", score);
}

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

บทเรียน “let และความเปลี่ยนแปลงได้” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “let และความเปลี่ยนแปลงได้”

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

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

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

บทเรียน “let และความเปลี่ยนแปลงได้” ใช้เวลานานแค่ไหน

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

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

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

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

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