ตัวแปรและความสามารถในการเปลี่ยนแปลงค่า
ดังที่ได้อธิบายไว้ในหัวข้อ “การเก็บค่าด้วยตัวแปร” ตัวแปรใน 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 กันต่อ