Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

ตัวแปรและความสามารถในการเปลี่ยนแปลงค่า

ดังที่ได้อธิบายไว้ในหัวข้อ “การเก็บค่าด้วยตัวแปร” ตัวแปรใน Rust จะเป็นแบบเปลี่ยนแปลงค่าไม่ได้ (immutable) โดยค่าเริ่มต้น นี่เป็นหนึ่งในการส่งเสริมแนวทางของ Rust เพื่อช่วยให้คุณเขียนโค้ดที่ได้รับประโยชน์จากความปลอดภัยและการจัดการการทำงานพร้อมกัน (concurrency) ได้อย่างง่ายดาย อย่างไรก็ตาม คุณยังคงมีทางเลือกในการกำหนดให้ตัวแปรสามารถเปลี่ยนแปลงค่าได้ (mutable) มาสำรวจกันว่า Rust สนับสนุนให้คุณเลือกใช้ตัวแปรแบบเปลี่ยนแปลงค่าไม่ได้อย่างไรและด้วยเหตุผลใด ตลอดจนเหตุใดในบางสถานการณ์คุณจึงอาจจำเป็นต้องปรับให้เปลี่ยนแปลงค่าได้

เมื่อตัวแปรเป็นแบบเปลี่ยนแปลงค่าไม่ได้ เมื่อผูกค่าเข้ากับชื่อตัวแปรแล้ว คุณจะไม่สามารถแก้ไขค่านั้นได้อีก เพื่อทำความเข้าใจเรื่องนี้ ให้สร้างโปรเจกต์ใหม่ชื่อว่า variables ในไดเรกทอรี projects ของคุณด้วยคำสั่ง cargo new variables

จากนั้น สลับเข้าไปยังไดเรกทอรี variables เปิดไฟล์ src/main.rs แล้วแทนที่โค้ดเดิมด้วยโค้ดต่อไปนี้ ซึ่งจะยังคอมไพล์ไม่ผ่านในตอนนี้:

ชื่อไฟล์: src/main.rs

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

บันทึกไฟล์แล้วสั่งรันโปรแกรมด้วย cargo run คุณจะได้รับข้อความแจ้งข้อผิดพลาดเกี่ยวกับการพยายามแก้ไขค่าตัวแปรที่ไม่สามารถเปลี่ยนแปลงค่าได้ ดังที่แสดงในผลลัพธ์นี้:

$ cargo run
   Compiling variables v0.1.0 (file:///projects/variables)
error[E0384]: cannot assign twice to immutable variable `x`
 --> src/main.rs:4:5
  |
2 |     let x = 5;
  |         - first assignment to `x`
3 |     println!("The value of x is: {x}");
4 |     x = 6;
  |     ^^^^^ cannot assign twice to immutable variable
  |
help: consider making this binding mutable
  |
2 |     let mut x = 5;
  |         +++

For more information about this error, try `rustc --explain E0384`.
error: could not compile `variables` (bin "variables") due to 1 previous error

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

คุณได้รับข้อความแจ้งข้อผิดพลาด cannot assign twice to immutable variable `x` เนื่องจากคุณพยายามกำหนดค่าใหม่ให้กับตัวแปร x ที่เป็นแบบเปลี่ยนแปลงค่าไม่ได้เป็นครั้งที่สอง

สิ่งสำคัญคือ คอมไพเลอร์จะตรวจจับและแจ้งข้อผิดพลาดให้เราทราบตั้งแต่ตอนคอมไพล์ทันทีที่เราพยายามเปลี่ยนแปลงค่าที่ถูกกำหนดให้แก้ไขไม่ได้ เพื่อป้องกันไม่ให้เกิดบั๊กขึ้นในระบบ หากโค้ดส่วนหนึ่งทำงานบนสมมติฐานว่าค่านั้นจะไม่มีวันเปลี่ยนแปลง แต่โค้ดอีกส่วนหนึ่งกลับไปแก้ไขค่านั้น โค้ดส่วนแรกก็ย่อมมีโอกาสที่จะทำงานผิดพลาดไปจากที่ออกแบบไว้ได้ ซึ่งสาเหตุของบั๊กในลักษณะนี้มักยากต่อการแกะรอยภายหลัง โดยเฉพาะอย่างยิ่งหากโค้ดส่วนหลังเปลี่ยนค่าเพียง_บางครั้ง_เท่านั้น แต่คอมไพเลอร์ Rust รับประกันว่าเมื่อคุณระบุว่าค่าใดจะไม่เปลี่ยนแปลง ค่านั้นจะไม่เปลี่ยนแปลงจริงๆ คุณจึงไม่ต้องคอยกังวลและติดตามตรวจสอบด้วยตนเอง ทำให้โค้ดของคุณเข้าใจง่ายและไว้ใจได้ยิ่งขึ้น

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

ตัวอย่างเช่น ลองแก้ไขไฟล์ src/main.rs ให้เป็นดังนี้:

ชื่อไฟล์: src/main.rs

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

เมื่อสั่งรันโปรแกรมตอนนี้ เราจะได้ผลลัพธ์ดังนี้:

$ cargo run
   Compiling variables v0.1.0 (file:///projects/variables)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.30s
     Running `target/debug/variables`
The value of x is: 5
The value of x is: 6

เมื่อใช้ mut เราจึงได้รับอนุญาตให้เปลี่ยนค่าที่ผูกอยู่กับ x จาก 5 ไปเป็น 6 ได้ ท้ายที่สุดแล้ว การตัดสินใจว่าจะให้ตัวแปรเปลี่ยนแปลงค่าได้หรือไม่นั้นขึ้นอยู่กับคุณและวิจารณญาณว่าสิ่งใดจะทำให้โค้ดมีความชัดเจนและปลอดภัยที่สุดในสถานการณ์นั้นๆ

การประกาศค่าคงที่

เช่นเดียวกับตัวแปรที่เปลี่ยนแปลงค่าไม่ได้ ค่าคงที่ (constant) คือค่าที่ผูกไว้กับชื่อและไม่อนุญาตให้เปลี่ยนแปลงค่า แต่มีข้อแตกต่างสำคัญระหว่างค่าคงที่กับตัวแปรอยู่สองสามประการ

ประการแรก คุณไม่สามารถใช้ mut ร่วมกับค่าคงที่ได้ ค่าคงที่ไม่เพียงแต่เปลี่ยนแปลงค่าไม่ได้โดยค่าเริ่มต้นเท่านั้น แต่เป็นสิ่งที่เปลี่ยนแปลงค่าไม่ได้ตลอดกาล คุณประกาศค่าคงที่โดยใช้คำสงวน const แทนคำว่า let และ_จำเป็นต้อง_ระบุชนิดข้อมูลกำกับไว้เสมอ เราจะกล่าวถึงชนิดข้อมูล (data types) และการระบุชนิดข้อมูล (type annotations) ในหัวข้อถัดไป “ชนิดข้อมูล” ดังนั้นจึงยังไม่ต้องกังวลกับรายละเอียดในตอนนี้ เพียงจำไว้ว่าต้องระบุชนิดข้อมูลให้ค่าคงที่เสมอ

ค่าคงที่สามารถประกาศได้ในทุกสโคป รวมถึงระดับโกลบอล (global scope) ซึ่งมีประโยชน์อย่างยิ่งสำหรับค่าที่โค้ดในหลายๆ ส่วนจำเป็นต้องเข้าถึงร่วมกัน

ข้อแตกต่างประการสุดท้ายคือ ค่าคงที่จะต้องถูกกำหนดค่าด้วยนิพจน์ค่าคงที่ (constant expression) เท่านั้น ไม่สามารถกำหนดด้วยผลลัพธ์ของค่าที่ต้องคำนวณขณะรันไทม์ (runtime)

ตัวอย่างการประกาศค่าคงที่:

#![allow(unused)]
fn main() {
const THREE_HOURS_IN_SECONDS: u32 = 60 * 60 * 3;
}

ชื่อของค่าคงที่นี้คือ THREE_HOURS_IN_SECONDS และถูกกำหนดค่าเป็นผลลัพธ์จากการคูณ 60 (วินาทีในหนึ่งนาที) ด้วย 60 (นาทีในหนึ่งชั่วโมง) และด้วย 3 (จำนวนชั่วโมงที่ต้องการคำนวณในโปรแกรมนี้) โดยธรรมเนียมการตั้งชื่อค่าคงที่ของ Rust คือการใช้ตัวพิมพ์ใหญ่ทั้งหมดและคั่นระหว่างคำด้วยเครื่องหมายขีดล่าง ทั้งนี้ คอมไพเลอร์สามารถคำนวณการดำเนินการทางคณิตศาสตร์พื้นฐานได้ตั้งแต่ตอนคอมไพล์ ทำให้เราเลือกเขียนที่มาของค่าออกมาอย่างชัดเจนและตรวจสอบได้ง่าย แทนที่จะต้องเขียนตัวเลข 10,800 ตรงๆ สามารถดูข้อมูลเพิ่มเติมเกี่ยวกับการดำเนินการที่รองรับได้จากหัวข้อเกี่ยวกับการประเมินค่าคงที่ใน Rust Reference

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

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

การบังเงา

ดังที่คุณได้เห็นในบทเรียนเกมทายตัวเลขในบทที่ 2 คุณสามารถประกาศตัวแปรใหม่ที่มีชื่อซ้ำกับตัวแปรก่อนหน้าได้ ชาว Rustacean เรียกสิ่งนี้ว่าตัวแปรแรก_ถูกบังเงาหรือบดบัง_ (shadowed) โดยตัวแปรที่สอง ซึ่งหมายความว่าคอมไพเลอร์จะมองเห็นตัวแปรที่สองเมื่อคุณเรียกใช้ชื่อตัวแปรนั้น ในทางปฏิบัติ ตัวแปรที่สองจะบดบังตัวแปรแรก โดยดึงการเรียกใช้ชื่อตัวแปรทั้งหมดมาเป็นของตนเอง จนกว่าตัวมันเองจะถูกบดบังซ้ำหรือจนกระทั่งสโคปนั้นสิ้นสุดลง เราสามารถทำแชโดวิงตัวแปรได้โดยใช้ชื่อตัวแปรเดิมและประกาศด้วยคำสงวน let ซ้ำอีกครั้ง ดังนี้:

ชื่อไฟล์: src/main.rs

fn main() {
    let x = 5;

    let x = x + 1;

    {
        let x = x * 2;
        println!("The value of x in the inner scope is: {x}");
    }

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

โปรแกรมนี้เริ่มต้นด้วยการผูกค่า 5 เข้ากับ x จากนั้นสร้างตัวแปร x ตัวใหม่ขึ้นมาด้วย let x = โดยนำค่าเดิมมาบวก 1 ทำให้ค่าของ x กลายเป็น 6 ต่อมา ภายในสโคปย่อยด้านในที่สร้างขึ้นด้วยวงเล็บปีกกา คำสั่ง let ตัวที่สามก็ทำการบดบัง x และสร้างตัวแปรใหม่ขึ้นมาอีกตัว โดยนำค่าก่อนหน้ามาคูณด้วย 2 ทำให้ x ในสโคปนี้มีค่าเป็น 12 เมื่อสโคปย่อยนั้นสิ้นสุดลง การบดบังเฉพาะในสโคปก็จบลงตามไปด้วย ส่งผลให้ x กลับมามีค่าเป็น 6 เช่นเดิม เมื่อสั่งรันโปรแกรมนี้ จะได้ผลลัพธ์ดังนี้:

$ cargo run
   Compiling variables v0.1.0 (file:///projects/variables)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.31s
     Running `target/debug/variables`
The value of x in the inner scope is: 12
The value of x is: 6

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

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

fn main() {
    let spaces = "   ";
    let spaces = spaces.len();
}

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

fn main() {
    let mut spaces = "   ";
    spaces = spaces.len();
}

ข้อผิดพลาดจะระบุชัดเจนว่าเราไม่ได้รับอนุญาตให้เปลี่ยนชนิดข้อมูลของตัวแปร:

$ cargo run
   Compiling variables v0.1.0 (file:///projects/variables)
error[E0308]: mismatched types
 --> src/main.rs:3:14
  |
2 |     let mut spaces = "   ";
  |                      ----- expected due to this value
3 |     spaces = spaces.len();
  |              ^^^^^^^^^^^^ expected `&str`, found `usize`

For more information about this error, try `rustc --explain E0308`.
error: could not compile `variables` (bin "variables") due to 1 previous error

เมื่อเราได้เรียนรู้การทำงานของตัวแปรกันแล้ว ในหัวข้อถัดไปเราจะมาดูชนิดข้อมูลต่างๆ ที่มีให้ใช้งานใน Rust กันต่อ