ตัวแปรและการเปลี่ยนแปลงใน Rust: ทำไมต้อง Immutable? | Rust The Series EP.4

หลังจากที่เราได้ทำความรู้จักกับ Cargo และลองสร้างโปรเจกต์แรกกันไปแล้วใน EP.3 ถึงเวลาที่เราจะมาเริ่มเขียนโค้ดจริงๆ กันเสียที! และจุดเริ่มต้นที่สำคัญที่สุดของทุกภาษาโปรแกรมก็คือ "ตัวแปร" (Variables)

แต่สำหรับ Rust นั้น เรื่องของตัวแปรมีความพิเศษและ "เข้มงวด" กว่าภาษาอื่นที่คุณอาจเคยเจอมาครับ

1. Immutable by Default: ค่าเริ่มต้นที่เปลี่ยนไม่ได้

ในภาษาโปรแกรมส่วนใหญ่ เมื่อเราประกาศตัวแปร เรามักจะเปลี่ยนค่ามันได้ตลอดเวลา แต่ใน Rust "ตัวแปรทุกตัวจะเป็น Immutable (เปลี่ยนค่าไม่ได้) โดยค่าเริ่มต้น"

ลองดูตัวอย่างโค้ดนี้ครับ:

Rust

fn main() {
    let x = 5;
    println!("The value of x is: {x}");
    
    x = 6; // ❌ บรรทัดนี้จะทำให้เกิด Error ทันที!
    println!("The value of x is: {x}");
}

ทำไม Rust ถึงออกแบบมาแบบนี้?

เหตุผลหลักคือ Safety (ความปลอดภัย) และ Concurrency (การทำงานขนาน)

• ลด Bug: ถ้าเรากำหนดค่าบางอย่างไว้แล้วเผลอไปเปลี่ยนมันในส่วนอื่นของโปรแกรมโดยไม่ตั้งใจ อาจทำให้เกิดข้อผิดพลาดที่หายาก

• อ่านง่าย: เมื่อคุณเห็น let x = ... คุณจะมั่นใจได้เลยว่าค่าของ x จะไม่เปลี่ยนไปแน่นอนตลอด Scope นั้น

• ประสิทธิภาพ: Compiler สามารถ Optimize โค้ดได้ดีขึ้นเพราะรู้ว่าค่านั้นคงที่

2. การใช้ mut เพื่อทำให้เปลี่ยนค่าได้

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

Rust

fn main() {
    let mut x = 5; // ✅ เพิ่ม mut เข้าไป
    println!("The value of x is: {x}");
    
    x = 6; // ✅ เปลี่ยนค่าได้แล้ว!
    println!("The value of x is: {x}");
}

การใส่ mut เป็นการบอกทั้ง Compiler และเพื่อนร่วมทีมว่า "ตัวแปรนี้ตั้งใจให้เปลี่ยนค่าได้นะ" ซึ่งเป็นการสื่อสารที่ชัดเจนมากในเชิง Code Quality

3. Constants (ค่าคงที่)

หลายคนอาจจะสงสัยว่า "ถ้า Immutable มันเปลี่ยนค่าไม่ได้ แล้วมันต่างจาก Constants ตรงไหน?"

ตัวอย่างการใช้ Const:

Rust

const THREE_HOURS_IN_SECONDS: u32 = 60 * 60 * 3;

4. Shadowing: การประกาศตัวแปรทับชื่อเดิม

นี่คือฟีเจอร์เด็ดของ Rust ครับ เราสามารถประกาศตัวแปรใหม่โดยใช้ชื่อเดิมได้ เรียกว่า Shadowing

Rust

fn main() {
    let x = 5;
    let x = x + 1; // Shadowing ครั้งที่ 1
    
    {
        let x = x * 2; // Shadowing เฉพาะใน Scope นี้
        println!("The value of x in the inner scope is: {x}"); // 12
    }

    println!("The value of x is: {x}"); // 6
}

Shadowing ต่างจาก mut อย่างไร?

1. Shadowing คือการสร้างตัวแปรใหม่ (ค่าเดิมจะถูกบดบังไป) แต่ mut คือการเปลี่ยนค่าในตัวแปรเดิม

2. เราสามารถเปลี่ยน Data Type ได้ด้วย Shadowing เช่น เปลี่ยนจาก String เป็น Number โดยใช้ชื่อเดิมได้เลย

สรุป

ใน Rust การตัดสินใจเลือกระหว่าง Immutable, mut หรือ Shadowing จะช่วยให้โค้ดของคุณปลอดภัยและจัดการหน่วยความจำได้ดีเยี่ยมครับ

ใน EP.5 เราจะมาเจาะลึกสิ่งที่คู่กับตัวแปรเสมอ นั่นคือ Data Types พื้นฐาน เราจะไปดูกันว่า Rust จัดการกับตัวเลข, ตัวอักษร และข้อมูลแบบกลุ่ม (Compound types) อย่างไรบ้าง ห้ามพลาดครับ!

Happy Coding กับ Rust นะครับ

🎯 ติดตามความรู้สาย Dev แบบสุดจัดได้ที่:

ไม่อยากพลาดบทความเทคนิคเชิงลึกและอัปเดตใหม่ๆ จากเรา ติดตาม Superdev Academy ได้ทุกช่องทางที่นี่ครับ:

• 🔵 Facebook: Superdev Academy Thailand (อัปเดตข่าวสารและบทความใหม่)

• 🎬 YouTube: Superdev Academy Channel (ติวเข้มแบบวิดีโอ)

• 📸 Instagram: @superdevacademy (เกร็ดความรู้สั้นๆ และเบื้องหลังการทำงาน)

• 🎬 TikTok: @superdevacademy (Tips & Tricks ฉบับย่อยง่าย)

• 🌐 Website: superdevacademy.com (คลังบทความและคอร์สเรียนฉบับเต็ม)