เขียนโปรแกรมเกมทายตัวเลข
มาเริ่มต้นเรียนรู้ Rust ผ่านการลงมือพัฒนาโปรเจกต์จริงไปด้วยกัน! บทนี้จะแนะนำให้คุณรู้จักแนวคิดพื้นฐานที่สำคัญหลากหลายประการของ Rust โดยแสดงให้เห็นวิธีนำไปใช้งานจริงในโปรแกรม คุณจะได้เรียนรู้เกี่ยวกับคำสำคัญ let, match, เมธอด (method), ฟังก์ชันประจำชนิดข้อมูล (associated function), การเรียกใช้เครตภายนอก (external crates) และอื่นๆ อีกมากมาย! ซึ่งในบทต่อๆ ไป เราจะได้เจาะลึกแต่ละแนวคิดอย่างละเอียด ส่วนในบทนี้ เราจะเน้นการฝึกฝนและทำความคุ้นเคยกับพื้นฐานเป็นหลัก
เราจะร่วมกันสร้างโจทย์คลาสสิกสำหรับผู้เริ่มต้นเขียนโปรแกรม นั่นคือ “เกมทายตัวเลข” โดยมีกติกาการทำงานดังนี้: โปรแกรมจะสุ่มจำนวนเต็ม (integer) ระหว่าง 1 ถึง 100 ขึ้นมาหนึ่งตัว จากนั้นจะแจ้งให้ผู้เล่นป้อนตัวเลขที่ต้องการทาย เมื่อผู้เล่นป้อนตัวเลขแล้ว โปรแกรมจะบอกว่าตัวเลขที่ทายนั้นน้อยเกินไปหรือมากเกินไป หากทายถูกต้อง โปรแกรมจะแสดงข้อความแสดงความยินดีและสิ้นสุดการทำงาน
การตั้งค่าโปรเจกต์ใหม่
ในการเริ่มต้นโปรเจกต์ใหม่ ให้เปิดเทอร์มินัลไปยังไดเรกทอรี projects ที่คุณสร้างไว้ในบทที่ 1 แล้วสร้างโปรเจกต์ใหม่ด้วย Cargo ดังนี้:
$ cargo new guessing_game
$ cd guessing_game
คำสั่งแรก cargo new รับชื่อโปรเจกต์ (guessing_game) เป็นอาร์กิวเมนต์แรก ส่วนคำสั่งที่สองจะสลับเข้าไปยังไดเรกทอรีของโปรเจกต์ใหม่
มาดูไฟล์ Cargo.toml ที่ถูกสร้างขึ้นกัน:
ชื่อไฟล์: Cargo.toml
[package]
name = "guessing_game"
version = "0.1.0"
edition = "2024"
[dependencies]
ดังที่คุณได้เห็นในบทที่ 1 คำสั่ง cargo new จะสร้างโปรแกรม “Hello, world!” เริ่มต้นมาให้ ลองเปิดดูไฟล์ src/main.rs:
ชื่อไฟล์: src/main.rs
fn main() {
println!("Hello, world!");
}
คราวนี้มาคอมไพล์โปรแกรม “Hello, world!” และสั่งรันในขั้นตอนเดียวด้วยคำสั่ง cargo run:
$ cargo run
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.08s
Running `target/debug/guessing_game`
Hello, world!
คำสั่ง run มีประโยชน์อย่างยิ่งเมื่อคุณต้องการทดสอบและพัฒนาโปรแกรมแบบวนซ้ำอย่างรวดเร็ว ดังที่เราจะทำในโปรเจกต์เกมนี้ เพื่อทดสอบโค้ดในแต่ละรอบให้มั่นใจก่อนจะไปต่อยังขั้นตอนถัดไป
เปิดไฟล์ src/main.rs ขึ้นมาอีกครั้ง เราจะเขียนโค้ดทั้งหมดลงในไฟล์นี้
การประมวลผลคำทาย
ส่วนแรกของโปรแกรมเกมทายตัวเลขจะรับข้อมูลอินพุตจากผู้ใช้ นำมาประมวลผล และตรวจสอบว่าข้อมูลที่ป้อนเข้ามาถูกต้องตามรูปแบบที่ต้องการหรือไม่ เริ่มต้นด้วยการให้ผู้เล่นป้อนตัวเลขคำทาย โดยใส่โค้ดตามลิสติ้ง 2-1 ลงในไฟล์ src/main.rs
use std::io;
fn main() {
println!("Guess the number!");
println!("Please input your guess.");
let mut guess = String::new();
io::stdin()
.read_line(&mut guess)
.expect("Failed to read line");
println!("You guessed: {guess}");
}
โค้ดชุดนี้มีรายละเอียดที่น่าสนใจอยู่หลายจุด เรามาทำความเข้าใจทีละบรรทัดกัน ในการรับอินพุตจากผู้ใช้และพิมพ์ผลลัพธ์ออกทางหน้าจอ เราจำเป็นต้องนำไลบรารีอินพุต/เอาต์พุต io เข้ามาสู่สโคป (scope) การทำงาน โดยไลบรารี io มาจากไลบรารีมาตรฐานที่เรียกว่า std:
use std::io;
fn main() {
println!("Guess the number!");
println!("Please input your guess.");
let mut guess = String::new();
io::stdin()
.read_line(&mut guess)
.expect("Failed to read line");
println!("You guessed: {guess}");
}
โดยค่าเริ่มต้น Rust ได้กำหนดชุดรายการพื้นฐานจากไลบรารีมาตรฐานที่นำเข้าสู่สโคปของทุกโปรแกรมไว้ให้อัตโนมัติ ชุดรายการนี้เรียกว่า พรีลูด (prelude) ซึ่งคุณสามารถดูรายการทั้งหมดที่มีในพรีลูดได้จากเอกสารของไลบรารีมาตรฐาน
หากคุณต้องการใช้ชนิดข้อมูลหรือฟังก์ชันที่ไม่ได้อยู่ในพรีลูด คุณจะต้องนำเข้าสู่สโคปอย่างชัดแจ้งด้วยคำสั่ง use ซึ่งการนำเข้าไลบรารี std::io จะช่วยให้คุณเข้าถึงฟังก์ชันที่มีประโยชน์มากมาย รวมถึงความสามารถในการรับอินพุตจากผู้ใช้ด้วย
ดังที่ได้เรียนรู้ในบทที่ 1 ฟังก์ชัน main คือจุดเริ่มต้นการทำงานของโปรแกรม:
use std::io;
fn main() {
println!("Guess the number!");
println!("Please input your guess.");
let mut guess = String::new();
io::stdin()
.read_line(&mut guess)
.expect("Failed to read line");
println!("You guessed: {guess}");
}
ไวยากรณ์ fn ใช้สำหรับประกาศฟังก์ชันใหม่ เครื่องหมายวงเล็บ () บ่งบอกว่าฟังก์ชันนี้ไม่ได้รับพารามิเตอร์ใดๆ และเครื่องหมายปีกกาเปิด { เป็นจุดเริ่มต้นของบล็อกเนื้อหาฟังก์ชัน
และตามที่ได้เรียนรู้มาเช่นกัน println! เป็นมาโครที่ทำหน้าที่พิมพ์ข้อความสตริงออกทางหน้าจอ:
use std::io;
fn main() {
println!("Guess the number!");
println!("Please input your guess.");
let mut guess = String::new();
io::stdin()
.read_line(&mut guess)
.expect("Failed to read line");
println!("You guessed: {guess}");
}
โค้ดส่วนนี้จะพิมพ์ข้อความต้อนรับเข้าสู่เกม และแจ้งให้ผู้เล่นป้อนตัวเลขคำทาย
การเก็บค่าด้วยตัวแปร
ถัดไป เราจะสร้าง_ตัวแปร_ขึ้นมาเพื่อใช้เก็บค่าอินพุตของผู้เล่น ดังนี้:
use std::io;
fn main() {
println!("Guess the number!");
println!("Please input your guess.");
let mut guess = String::new();
io::stdin()
.read_line(&mut guess)
.expect("Failed to read line");
println!("You guessed: {guess}");
}
ตอนนี้โปรแกรมเริ่มน่าสนใจขึ้นแล้ว! มีหลายสิ่งเกิดขึ้นในบรรทัดสั้นๆ นี้ เราใช้คำสั่ง let ในการประกาศสร้างตัวแปร ลองดูตัวอย่างนี้:
let apples = 5;
บรรทัดนี้จะสร้างตัวแปรใหม่ชื่อว่า apples และผูกค่า 5 เข้ากับตัวแปร ใน Rust ตัวแปรทุกตัวจะเป็นแบบเปลี่ยนแปลงค่าไม่ได้ (immutable) โดยค่าเริ่มต้น หมายความว่าเมื่อกำหนดค่าเริ่มต้นให้แล้ว จะไม่สามารถเปลี่ยนค่านั้นได้อีก เราจะเจาะลึกแนวคิดนี้ในหัวข้อ “ตัวแปรและความสามารถในการเปลี่ยนแปลงค่า” ในบทที่ 3 หากต้องการให้ตัวแปรสามารถเปลี่ยนค่าได้ (mutable) เราจะใส่คำว่า mut ไว้ข้างหน้าชื่อตัวแปร:
let apples = 5; // immutable
let mut bananas = 5; // mutable
หมายเหตุ: ไวยากรณ์
//เป็นจุดเริ่มต้นของการเขียนคอมเมนต์ (comment) ซึ่งจะดำเนินไปจนจบบรรทัด โดยคอมไพเลอร์ Rust จะมองข้ามข้อความในคอมเมนต์ทั้งหมด เราจะพูดถึงคอมเมนต์อย่างละเอียดในบทที่ 3
กลับมาดูที่โปรแกรมเกมทายตัวเลข ตอนนี้คุณทราบแล้วว่า let mut guess คือการประกาศตัวแปรที่เปลี่ยนแปลงค่าได้ชื่อว่า guess เครื่องหมายเท่ากับ (=) บอก Rust ว่าเราต้องการผูกค่าบางอย่างเข้ากับตัวแปร ณ จุดนี้ โดยทางด้านขวาของเครื่องหมายเท่ากับคือค่าที่จะนำมาผูกกับ guess ซึ่งได้มาจากผลลัพธ์ของการเรียก String::new อันเป็นฟังก์ชันที่สร้างอินสแตนซ์ใหม่ของชนิดข้อมูล String โดย String เป็นชนิดข้อมูลสตริงที่ไลบรารีมาตรฐานจัดเตรียมไว้ ซึ่งสามารถปรับขยายขนาดได้และเข้ารหัสด้วย UTF-8
สัญลักษณ์ :: ใน String::new บ่งบอกว่า new เป็นฟังก์ชันประจำชนิดข้อมูล (associated function) ของชนิด String โดย_ฟังก์ชันประจำชนิดข้อมูล_คือฟังก์ชันที่อิมพลีเมนต์อยู่บนชนิดข้อมูลนั้นๆ ซึ่งในที่นี้คือ String ฟังก์ชัน new จะสร้างสตริงใหม่ที่ว่างเปล่าขึ้นมา คุณจะพบเห็นฟังก์ชันชื่อ new ได้บ่อยครั้งในชนิดข้อมูลต่างๆ ของ Rust เนื่องจากเป็นชื่อมาตรฐานที่นิยมใช้สำหรับฟังก์ชันที่สร้างค่าใหม่ของชนิดข้อมูลนั้นๆ
สรุปแล้ว บรรทัด let mut guess = String::new(); คือการประกาศตัวแปรที่แก้ไขค่าได้ ซึ่งปัจจุบันถือครองอินสแตนซ์ของสตริงว่างตัวใหม่อยู่ เห็นไหมว่าบรรทัดเดียวมีรายละเอียดซ่อนอยู่ไม่น้อยเลย!
การรับอินพุตจากผู้ใช้
จำได้ไหมว่าเราได้นำเข้าฟังก์ชันอินพุต/เอาต์พุตจากไลบรารีมาตรฐานด้วย use std::io; ไว้ที่บรรทัดแรกของโปรแกรม คราวนี้เราจะเรียกฟังก์ชัน stdin จากมอดูล io เพื่อช่วยจัดการการรับอินพุตจากผู้ใช้:
use std::io;
fn main() {
println!("Guess the number!");
println!("Please input your guess.");
let mut guess = String::new();
io::stdin()
.read_line(&mut guess)
.expect("Failed to read line");
println!("You guessed: {guess}");
}
หากเราไม่ได้นำเข้ามอดูล io ด้วย use std::io; ไว้ที่ตอนต้น เราก็ยังสามารถเรียกใช้ฟังก์ชันนี้ได้โดยเขียนพาธเต็มว่า std::io::stdin โดยฟังก์ชัน stdin จะส่งกลับอินสแตนซ์ของ std::io::Stdin ซึ่งเป็นชนิดข้อมูลที่เป็นตัวแทนของช่องทางอินพุตมาตรฐาน (standard input handle) ในเทอร์มินัลของคุณ
ถัดมา ส่วน .read_line(&mut guess) จะเรียกเมธอด read_line บนแฮนเดิลอินพุตมาตรฐานเพื่อรอรับข้อมูลจากผู้ใช้ และเราได้ส่ง &mut guess เข้าไปเป็นอาร์กิวเมนต์ให้กับ read_line เพื่อระบุว่าจะให้นำข้อความที่ผู้ใช้พิมพ์ไปจัดเก็บไว้ในสตริงใด หน้าที่ของ read_line คือรับสิ่งที่ผู้ใช้พิมพ์จากช่องทางอินพุตมาตรฐาน แล้วนำไปต่อท้าย (append) สตริงที่ส่งเข้าไป (โดยไม่เขียนทับข้อมูลเดิม) เราจึงต้องส่งสตริงนั้นเข้าไปเป็นอาร์กิวเมนต์ และอาร์กิวเมนต์สตริงนี้จำเป็นต้องเป็นแบบที่เปลี่ยนแปลงค่าได้ (mut) เพื่อให้เมธอดสามารถแก้ไขเพิ่มเนื้อหาลงไปในสตริงได้
สัญลักษณ์ & ด้านหน้าบ่งบอกว่าอาร์กิวเมนต์นี้เป็น_เรเฟอเรนซ์_ (reference) ซึ่งเป็นกลไกที่เปิดให้โค้ดหลายๆ จุดสามารถเข้าถึงข้อมูลชิ้นเดียวกันได้ โดยไม่ต้องคัดลอกข้อมูลนั้นซ้ำซ้อนในหน่วยความจำ เรเฟอเรนซ์เป็นฟีเจอร์ที่สำคัญและซับซ้อน แต่จุดเด่นอย่างยิ่งของ Rust คือการออกแบบให้การใช้งานเรเฟอเรนซ์มีความปลอดภัยและสะดวกสบาย คุณไม่จำเป็นต้องกังวลกับรายละเอียดเชิงลึกในตอนนี้เพื่อทำโปรแกรมนี้ให้เสร็จ สิ่งที่คุณต้องทราบเบื้องต้นคือ เรเฟอเรนซ์ก็เหมือนกับตัวแปร กล่าวคือเป็นแบบเปลี่ยนแปลงค่าไม่ได้โดยค่าเริ่มต้น ดังนั้นเราจึงต้องเขียน &mut guess แทนที่จะเป็น &guess เพื่อเปิดให้สามารถแก้ไขค่าในตัวแปรเป้าหมายได้ (บทที่ 4 จะอธิบายเรื่องเรเฟอเรนซ์อย่างละเอียด)
การจัดการความล้มเหลวที่อาจเกิดขึ้นด้วย Result
เรายังคงอยู่ในกลุ่มคำสั่งเดิม โดยตอนนี้มาดูส่วนที่สาม ซึ่งแม้จะเขียนแยกอีกบรรทัดหนึ่ง แต่ในเชิงตรรกะแล้วถือเป็นส่วนหนึ่งของประโยคคำสั่งเดียวกัน นั่นคือเมธอดต่อไปนี้:
use std::io;
fn main() {
println!("Guess the number!");
println!("Please input your guess.");
let mut guess = String::new();
io::stdin()
.read_line(&mut guess)
.expect("Failed to read line");
println!("You guessed: {guess}");
}
ความจริงแล้วเราสามารถเขียนคำสั่งทั้งหมดรวมในบรรทัดเดียวได้ดังนี้:
io::stdin().read_line(&mut guess).expect("Failed to read line");
ทว่าการเขียนคำสั่งยาวๆ ติดกันในบรรทัดเดียวทำให้โค้ดอ่านยาก การแยกบรรทัดและจัดย่อหน้าเว้นวรรคเมื่อเรียกใช้เมธอดต่อเนื่องด้วยไวยากรณ์ .method_name() จึงเป็นแนวทางที่ช่วยให้อ่านโค้ดได้ง่ายและสบายตากว่ามาก ตอนนี้มาดูกันว่าบรรทัดนี้ทำหน้าที่อะไร
ดังที่ได้อธิบายไปแล้วว่า read_line จะนำข้อความที่ผู้ใช้พิมพ์ไปใส่ไว้ในสตริงที่เราส่งเข้าไป แต่ยิ่งไปกว่านั้น เมธอดนี้ยังส่งคืนค่าชนิด Result กลับมาด้วย โดย Result เป็นชนิดข้อมูลแบบอีนูเมอเรชัน (enumeration) หรือที่เรียกสั้นๆ ว่า enum ซึ่งเป็นชนิดข้อมูลที่สามารถมีสถานะได้หลากหลายรูปแบบตามที่กำหนดไว้ และเราเรียกแต่ละสถานะที่เป็นไปได้ว่า วาเรียนต์ (variant)
บทที่ 6 จะอธิบายเรื่อง enum อย่างละเอียด สำหรับตอนนี้ จุดประสงค์หลักของชนิด Result คือการใช้สื่อสารและจัดการกับข้อมูลเกี่ยวกับข้อผิดพลาด (error handling)
วาเรียนต์ของ Result ประกอบด้วย Ok และ Err โดยวาเรียนต์ Ok บ่งบอกว่าการทำงานสำเร็จเรียบร้อย และภายในจะบรรจุค่าผลลัพธ์ที่ได้จากการทำงานนั้น ส่วนวาเรียนต์ Err บ่งบอกว่าเกิดความล้มเหลว และภายในจะบรรจุข้อมูลที่อธิบายว่าเกิดข้อผิดพลาดขึ้นอย่างไรหรือเพราะเหตุใด
ค่าชนิด Result ก็เหมือนกับชนิดข้อมูลอื่นๆ ใน Rust ตรงที่มีเมธอดต่างๆ ที่นิยามไว้ให้ใช้งาน โดยอินสแตนซ์ของ Result จะมีเมธอด expect ให้คุณเรียกใช้ หากอินสแตนซ์ของ Result นั้นเป็นค่า Err เมธอด expect จะทำให้โปรแกรมหยุดทำงานกะทันหัน (crash/panic) พร้อมทั้งแสดงข้อความที่คุณระบุไว้ในอาร์กิวเมนต์ของ expect ออกมา หากเมธอด read_line ส่งค่า Err กลับมา มักเกิดจากข้อผิดพลาดในระดับระบบปฏิบัติการ แต่หากอินสแตนซ์ของ Result เป็นค่า Ok เมธอด expect จะดึงค่าผลลัพธ์ที่อยู่ภายใน Ok ออกมาให้คุณนำไปใช้งานต่อทันที ซึ่งในกรณีนี้ ค่าดังกล่าวคือจำนวนไบต์ของข้อความที่ผู้ใช้ป้อนเข้ามา
หากคุณไม่เรียกใช้ expect โปรแกรมจะยังคงคอมไพล์ผ่านได้ แต่คุณจะได้รับข้อความคำเตือน (warning) จากคอมไพเลอร์:
$ cargo build
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
warning: unused `Result` that must be used
--> src/main.rs:10:5
|
10 | io::stdin().read_line(&mut guess);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= note: this `Result` may be an `Err` variant, which should be handled
= note: `#[warn(unused_must_use)]` (part of `#[warn(unused)]`) on by default
help: use `let _ = ...` to ignore the resulting value
|
10 | let _ = io::stdin().read_line(&mut guess);
| +++++++
warning: `guessing_game` (bin "guessing_game") generated 1 warning
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.59s
Rust ส่งสัญญาณเตือนว่าคุณยังไม่ได้นำค่า Result ที่ได้จาก read_line ไปใช้งาน ซึ่งหมายความว่าโปรแกรมของคุณยังไม่ได้จัดการกับกรณีที่อาจเกิดข้อผิดพลาดขึ้น
วิธีแก้ไขคำเตือนที่ถูกต้องคือการเขียนโค้ดเพื่อจัดการข้อผิดพลาดอย่างเหมาะสม แต่สำหรับโปรแกรมตัวอย่างนี้ เราตั้งใจให้โปรแกรมหยุดทำงานทันทีหากเกิดปัญหาขึ้น การใช้ expect จึงตอบโจทย์ได้เป็นอย่างดี คุณจะได้เรียนรู้วิธีการกู้คืนและจัดการข้อผิดพลาดอย่างเต็มรูปแบบในบทที่ 9
การพิมพ์ค่าด้วยตัวยึดตำแหน่งของ println!
นอกจากเครื่องหมายปีกกาปิดแล้ว ยังมีโค้ดอีกหนึ่งบรรทัดที่เราต้องทำความเข้าใจ:
use std::io;
fn main() {
println!("Guess the number!");
println!("Please input your guess.");
let mut guess = String::new();
io::stdin()
.read_line(&mut guess)
.expect("Failed to read line");
println!("You guessed: {guess}");
}
บรรทัดนี้ทำหน้าที่พิมพ์ข้อความสตริงที่เก็บคำทายของผู้เล่นออกมา โดยเครื่องหมายปีกกา {} ทำหน้าที่เป็นตัวยึดตำแหน่ง (placeholder) ให้จินตนาการว่า {} เหมือนก้ามปูน้อยๆ ของเจ้าปู Ferris ที่ช่วยจับค่ามาวางไว้ตรงจุดนี้ เมื่อต้องการพิมพ์ค่าของตัวแปร คุณสามารถใส่ชื่อตัวแปรไว้ในปีกกาได้โดยตรง และเมื่อต้องการพิมพ์ผลลัพธ์จากการประเมินค่านิพจน์ (expression) ให้ใส่วงเล็บปีกกาเปล่า {} ไว้ในสตริงรูปแบบ (format string) แล้วตามด้วยรายการนิพจน์ที่คั่นด้วยเครื่องหมายจุลภาคต่อท้ายสตริง เพื่อนำค่ามาแสดงตามลำดับของตัวยึดตำแหน่ง การพิมพ์ทั้งตัวแปรและผลลัพธ์ของนิพจน์ในคำสั่ง println! บรรทัดเดียวจะมีรูปแบบดังนี้:
#![allow(unused)]
fn main() {
let x = 5;
let y = 10;
println!("x = {x} and y + 2 = {}", y + 2);
}
โค้ดนี้จะพิมพ์ผลลัพธ์ว่า x = 5 and y + 2 = 12
การทดสอบส่วนแรก
มาลองทดสอบการทำงานของเกมทายตัวเลขในส่วนแรกกัน โดยสั่งรันด้วย cargo run:
$ cargo run
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 6.44s
Running `target/debug/guessing_game`
Guess the number!
Please input your guess.
6
You guessed: 6
มาถึงจุดนี้ ส่วนแรกของเกมก็ทำงานได้อย่างสมบูรณ์แล้ว โปรแกรมสามารถรับค่าอินพุตจากแป้นพิมพ์และนำมาแสดงผลออกทางหน้าจอได้อย่างถูกต้อง
การสร้างตัวเลขลับ
ขั้นตอนต่อไป เราจำเป็นต้องสร้างตัวเลขลับที่ผู้เล่นจะต้องทายขึ้นมา โดยตัวเลขนี้ควรเปลี่ยนไปในแต่ละรอบเพื่อให้เกมมีความสนุกสนานและสามารถเล่นซ้ำได้ เราจะกำหนดให้สุ่มตัวเลขระหว่าง 1 ถึง 100 เพื่อไม่ให้เกมยากจนเกินไป ทั้งนี้ ภาษา Rust ยังไม่มีฟังก์ชันการสุ่มตัวเลขมาให้ในไลบรารีมาตรฐาน แต่ทีมงาน Rust ได้จัดเตรียมเครตชื่อ rand ไว้ให้เราเรียกใช้งานความสามารถนี้ได้อย่างสะดวก
เพิ่มฟังก์ชันการทำงานด้วยเครต
จำได้ไหมว่าเครต (crate) คือชุดของไฟล์ซอร์สโค้ดในภาษา Rust โปรเจกต์ที่เรากำลังพัฒนานี้เรียกว่าเครตไบนารี (binary crate) ซึ่งสามารถคอมไพล์ออกมาเป็นไฟล์โปรแกรมที่รันได้ (executable) ส่วนเครต rand จัดเป็นเครตไลบรารี (library crate) ซึ่งประกอบด้วยโค้ดที่สร้างขึ้นเพื่อให้โปรแกรมอื่นนำไปใช้ต่อ และไม่สามารถสั่งรันได้ด้วยตัวมันเอง
การที่ Cargo ช่วยบริหารจัดการเครตภายนอกได้อย่างราบรื่นคือจุดเด่นที่ทำให้เครื่องมือนี้ยอดเยี่ยมอย่างยิ่ง ก่อนที่เราจะสามารถเรียกใช้ฟังก์ชันจาก rand ได้ เราจำเป็นต้องแก้ไขไฟล์ Cargo.toml เพื่อเพิ่มเครต rand เข้ามาเป็นดีเพนเดนซีเสียก่อน เปิดไฟล์นั้นขึ้นมาแล้วเพิ่มข้อความต่อไปนี้ไว้ด้านล่างใต้หัวข้อ [dependencies] ที่ Cargo สร้างไว้ให้ โปรดระบุชื่อ rand และหมายเลขเวอร์ชันให้ตรงกับที่ระบุไว้นี้ทุกประการ เพื่อให้โค้ดตัวอย่างในบทเรียนทำงานได้อย่างถูกต้อง:
ชื่อไฟล์: Cargo.toml
[dependencies]
rand = "0.10.1"
ในไฟล์ Cargo.toml ทุกบรรทัดที่อยู่ถัดจากหัวข้อหมวดหมู่จะถือเป็นส่วนหนึ่งของหมวดหมู่นั้น จนกว่าจะพบหัวข้อหมวดหมู่ใหม่ ในส่วน [dependencies] คุณจะเป็นผู้บอก Cargo ว่าโปรเจกต์นี้ต้องพึ่งพาเครตภายนอกตัวใดบ้าง และต้องการใช้งานเวอร์ชันใด ในที่นี้ เราได้ระบุเครต rand พร้อมหมายเลขเวอร์ชันเชิงความหมาย 0.10.1 โดย Cargo รองรับระบบการกำหนดเวอร์ชันเชิงความหมาย (semantic versioning) (มักเรียกย่อว่า SemVer) ซึ่งเป็นมาตรฐานสากลในการกำหนดหมายเลขเวอร์ชัน โดยเลข 0.10.1 เป็นรูปย่อของ ^0.10.1 ซึ่งหมายถึงเวอร์ชันใดก็ได้ตั้งแต่ 0.10.1 ขึ้นไป แต่ต้องต่ำกว่า 0.11.0
Cargo ถือว่าเวอร์ชันในช่วงนี้มี API สาธารณะที่ทำงานเข้ากันได้กับเวอร์ชัน 0.10.1 ข้อกำหนดนี้ช่วยรับประกันว่าคุณจะได้รับแพตช์แก้ไขล่าสุดที่ยังคงคอมไพล์ร่วมกับโค้ดในบทนี้ได้อย่างราบรื่น แต่จะไม่ข้ามไปใช้เวอร์ชัน 0.11.0 ขึ้นไปซึ่งอาจมีการเปลี่ยนแปลง API จนไม่ตรงกับโค้ดตัวอย่าง
ตอนนี้ โดยที่ยังไม่ต้องแก้ไขโค้ดใดๆ ให้ลองสั่งบิลด์โปรเจกต์ดู ดังแสดงในลิสติ้ง 2-2
$ cargo build
Updating crates.io index
Locking 8 packages to latest Rust 1.96.0 compatible versions
Downloaded rand_core v0.10.1
Downloaded chacha20 v0.10.1
Downloaded rand v0.10.1
Downloaded 3 crates (162.9KiB) in 0.59s
Compiling libc v0.2.186
Compiling rand_core v0.10.1
Compiling getrandom v0.4.3
Compiling cfg-if v1.0.4
Compiling chacha20 v0.10.1
Compiling rand v0.10.1
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 2.03s
คุณอาจเห็นหมายเลขเวอร์ชันย่อยที่แตกต่างไปจากนี้เล็กน้อย (แต่ทั้งหมดจะทำงานร่วมกันได้อย่างแน่นอนตามมาตรฐาน SemVer!) รวมถึงข้อความหรือลำดับบรรทัดอาจต่างไปตามระบบปฏิบัติการของคุณ
เมื่อเราเพิ่มดีเพนเดนซีภายนอกเข้ามา Cargo จะดึงข้อมูลเวอร์ชันล่าสุดของแพ็กเกจที่เกี่ยวข้องทั้งหมดมาจาก_เรจิสทรี_ (registry) ซึ่งเป็นแหล่งข้อมูลส่วนกลางที่คัดลอกมาจาก Crates.io โดย Crates.io คือพื้นที่ที่ชุมชนนักพัฒนา Rust นำโปรเจกต์โอเพนซอร์สมาแบ่งปันให้ผู้อื่นนำไปใช้งาน
หลังจากอัปเดตข้อมูลเรจิสทรีแล้ว Cargo จะตรวจสอบรายการในส่วน [dependencies] และดาวน์โหลดเครตที่ยังไม่มีในเครื่อง ในกรณีนี้ แม้ว่าเราจะระบุเพียง rand เป็นดีเพนเดนซี แต่ Cargo จะดึงเครตอื่นๆ ที่จำเป็นต่อการทำงานของ rand มาให้โดยอัตโนมัติ เมื่อดาวน์โหลดครบแล้ว Rust จะคอมไพล์เครตเหล่านั้น แล้วจึงคอมไพล์โปรเจกต์ของเราพร้อมเชื่อมโยงดีเพนเดนซีให้พร้อมใช้งาน
หากคุณสั่งรัน cargo build ซ้ำอีกครั้งทันทีโดยไม่ได้แก้ไขอะไร คุณจะไม่เห็นข้อความใดๆ ปรากฏขึ้นนอกจากบรรทัด Finished นั่นเป็นเพราะ Cargo ทราบว่าได้ดาวน์โหลดและคอมไพล์ดีเพนเดนซีเหล่านั้นเรียบร้อยแล้ว และไฟล์ Cargo.toml ก็ไม่มีการเปลี่ยนแปลงใดๆ อีกทั้งซอร์สโค้ดของคุณก็ยังคงเดิม Cargo จึงไม่จำเป็นต้องคอมไพล์ใหม่ให้เสียเวลา
แต่หากคุณเปิดไฟล์ src/main.rs แล้วแก้ไขโค้ดเล็กน้อย บันทึกไฟล์ และสั่งบิลด์ใหม่อีกครั้ง คุณจะเห็นข้อความเพียง 2 บรรทัดดังนี้:
$ cargo build
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.13s
ข้อความเหล่านี้แสดงให้เห็นว่า Cargo คอมไพล์เฉพาะส่วนที่คุณแก้ไขในไฟล์ src/main.rs เท่านั้น เนื่องจากดีเพนเดนซีต่างๆ ไม่มีการเปลี่ยนแปลง Cargo จึงนำผลลัพธ์ที่เคยคอมไพล์ไว้แล้วกลับมาใช้ใหม่ได้ทันที
การรับประกันผลการบิลด์ที่เหมือนเดิมทุกครั้ง
Cargo มีกลไกที่ช่วยรับประกันว่าผลลัพธ์จากการบิลด์โค้ดของคุณจะคงเดิมเสมอ ไม่ว่าคุณหรือใครก็ตามจะบิลด์โค้ดนี้เมื่อใด: Cargo จะยึดตามเวอร์ชันของดีเพนเดนซีที่บันทึกไว้เสมอ จนกว่าคุณจะสั่งอัปเกรดอย่างชัดเจน ตัวอย่างเช่น สมมติว่าสัปดาห์หน้ามีเครต rand เวอร์ชัน 0.10.2 ปล่อยออกมา แม้ว่าเวอร์ชันนั้นจะมีการแก้ไขบั๊กที่สำคัญ แต่ก็อาจมีข้อผิดพลาดใหม่ (regression) ที่ส่งผลกระทบต่อโค้ดของคุณได้ เพื่อป้องกันปัญหานี้ Rust จะสร้างไฟล์ Cargo.lock ขึ้นมาในการรัน cargo build ครั้งแรก ซึ่งในตอนนี้คุณจะพบไฟล์นี้อยู่ในไดเรกทอรี guessing_game เช่นกัน
เมื่อคุณสั่งบิลด์โปรเจกต์เป็นครั้งแรก Cargo จะคำนวณเวอร์ชันของดีเพนเดนซีทั้งหมดที่ตรงตามเงื่อนไข แล้วบันทึกเวอร์ชันที่แน่นอนเหล่านั้นลงในไฟล์ Cargo.lock และเมื่อสั่งบิลด์ในครั้งต่อๆ ไป Cargo จะตรวจพบว่ามีไฟล์ Cargo.lock อยู่แล้ว จึงเลือกใช้เวอร์ชันตามที่ระบุไว้ในไฟล์ทันทีโดยไม่ต้องคำนวณเวอร์ชันใหม่อีก กลไกนี้ทำให้ผลการบิลด์ของโปรเจกต์มีความแน่นอนและทำซ้ำได้ (reproducible builds) เสมอ นั่นหมายความว่าโปรเจกต์ของคุณจะยังคงใช้เวอร์ชัน 0.10.1 ต่อไปจนกว่าคุณจะสั่งอัปเกรดด้วยตนเอง และเนื่องจากไฟล์ Cargo.lock มีความสำคัญต่อการรักษาความสม่ำเสมอของโปรเจกต์ จึงเป็นแนวปฏิบัติที่ดีที่จะบันทึกไฟล์นี้ลงในระบบควบคุมเวอร์ชัน (Git) ร่วมกับซอร์สโค้ดเสมอ
การอัปเดตเครตเพื่อรับเวอร์ชันใหม่
เมื่อคุณ_ต้องการ_อัปเดตเวอร์ชันของเครตจริงๆ Cargo มีคำสั่ง update ซึ่งจะข้ามการตรวจสอบจากไฟล์ Cargo.lock แล้วค้นหาเวอร์ชันล่าสุดที่ยังคงสอดคล้องกับเงื่อนไขใน Cargo.toml จากนั้นจึงบันทึกเวอร์ชันใหม่เหล่านั้นลงใน Cargo.lock ให้โดยอัตโนมัติ โดยค่าเริ่มต้น Cargo จะมองหาเฉพาะเวอร์ชันที่มากกว่า 0.10.1 แต่ยังน้อยกว่า 0.11.0 หากเครต rand มีการปล่อยเวอร์ชันใหม่ 2 รุ่น ได้แก่ 0.10.2 และ 0.999.0 เมื่อคุณรันคำสั่ง cargo update จะปรากฏข้อความดังนี้:
$ cargo update
Updating crates.io index
Locking 1 package to latest Rust 1.96.0 compatible version
Updating rand v0.10.1 -> v0.10.2 (available: v0.999.0)
Cargo จะไม่ข้ามไปใช้เวอร์ชัน 0.999.0 และเมื่อตรวจดูในไฟล์ Cargo.lock คุณจะพบว่าเวอร์ชันของเครต rand ได้รับการปรับเป็น 0.10.2 เรียบร้อยแล้ว หากคุณต้องการเปลี่ยนไปใช้ rand เวอร์ชัน 0.999.0 หรือรุ่นใดๆ ในตระกูล 0.999.x คุณจะต้องเข้าไปแก้ไขไฟล์ Cargo.toml โดยตรงดังนี้ (โปรดอย่าเพิ่งแก้ไขตามนี้จริงๆ เนื่องจากตัวอย่างโค้ดถัดไปถูกเขียนขึ้นสำหรับ rand เวอร์ชัน 0.10):
[dependencies]
rand = "0.999.0"
เมื่อคุณสั่งรัน cargo build ในครั้งต่อไป Cargo จะอัปเดตข้อมูลเรจิสทรีและประเมินข้อกำหนดของ rand ใหม่ตามเวอร์ชันที่คุณระบุ
ยังมีรายละเอียดอีกมากมายเกี่ยวกับ Cargo และระบบนิเวศของมัน ซึ่งเราจะได้เจาะลึกกันในบทที่ 14 แต่สำหรับตอนนี้ เท่านี้ก็เพียงพอแล้วสำหรับการเริ่มต้น Cargo ช่วยให้การนำไลบรารีภายนอกมาใช้งานเป็นเรื่องง่ายดาย ส่งผลให้นักพัฒนา Rust นิยมแยกโครงสร้างโปรเจกต์ออกเป็นแพ็กเกจย่อยๆ ที่ประกอบเข้าด้วยกันได้อย่างลงตัว
การสร้างตัวเลขสุ่ม
มาเริ่มใช้งาน rand เพื่อสร้างตัวเลขสำหรับทายกัน ขั้นตอนถัดไปคือการอัปเดตไฟล์ src/main.rs ตามลิสติ้ง 2-3
use std::io;
use rand::prelude::*;
fn main() {
println!("Guess the number!");
let secret_number = rand::rng().random_range(1..=100);
println!("The secret number is: {secret_number}");
println!("Please input your guess.");
let mut guess = String::new();
io::stdin()
.read_line(&mut guess)
.expect("Failed to read line");
println!("You guessed: {guess}");
}
ขั้นแรก เราเพิ่มบรรทัด use rand::prelude::*; เข้ามา โดยมอดูล prelude จะรวบรวมฟังก์ชันและเทรตที่นิยมใช้งานบ่อยที่สุดของเครต rand ไว้ และคำสั่ง use จะช่วยนำรายการเหล่านั้นเข้ามาสู่สโคปของโปรแกรมเพื่อให้พร้อมเรียกใช้ได้ทันที
ถัดมา เราเพิ่มโค้ดอีก 2 บรรทัดในฟังก์ชัน main บรรทัดแรกคือการเรียกฟังก์ชัน rand::rng ซึ่งจะส่งกลับตัวสร้างตัวเลขสุ่ม (random number generator) เฉพาะตัวที่เราจะใช้งาน ซึ่งทำงานอยู่ภายในเธรด (thread) ปัจจุบัน และได้รับการกำหนดค่าตั้งต้น (seed) มาจากระบบปฏิบัติการ จากนั้นเราจึงเรียกเมธอด random_range บนตัวสร้างตัวเลขสุ่มดังกล่าว โดยเมธอดนี้ถูกนิยามไว้ในเทรต RngExt ซึ่งเป็นส่วนหนึ่งของมอดูล rand::prelude ที่เรานำเข้ามาด้วย use rand::prelude::*; นั่นเอง เมธอด random_range จะรับนิพจน์แบบช่วง (range expression) เข้ามาเป็นอาร์กิวเมนต์ เพื่อสร้างตัวเลขสุ่มที่อยู่ภายในขอบเขตนั้น นิพจน์แบบช่วงที่เราเลือกใช้ในที่นี้อยู่ในรูปแบบ start..=end ซึ่งนับรวมทั้งค่าขอบเขตล่างและขอบเขตบนด้วย ดังนั้นการระบุ 1..=100 จึงหมายถึงการขอตัวเลขสุ่มระหว่าง 1 ถึง 100
หมายเหตุ: ในการใช้งานจริง คงไม่มีใครสามารถจดจำได้ทั้งหมดว่าจะต้องนำเข้าสิ่งใดหรือเรียกใช้เมธอดไหนจากเครตภายนอก ด้วยเหตุนี้ เครตแต่ละตัวจึงมักจัดทำเอกสารคู่มือพร้อมตัวอย่างการใช้งานไว้อย่างละเอียด อีกหนึ่งฟีเจอร์ที่ยอดเยี่ยมของ Cargo คือคำสั่ง
cargo doc --openซึ่งจะทำการบิลด์เอกสารคู่มือของดีเพนเดนซีทั้งหมดในเครื่องของคุณ แล้วเปิดขึ้นมาบนเว็บเบราว์เซอร์ให้โดยอัตโนมัติ หากคุณสนใจศึกษาความสามารถอื่นๆ ของเครตrandสามารถรันคำสั่งcargo doc --openแล้วคลิกเลือกrandจากแถบเมนูด้านซ้ายเพื่ออ่านเพิ่มเติมได้ทันที
บรรทัดถัดมาคือการสั่งพิมพ์ตัวเลขลับออกมาทางหน้าจอ ซึ่งมีประโยชน์อย่างยิ่งในระหว่างขั้นตอนการพัฒนาและทดสอบโค้ด แต่เราจะลบบรรทัดนี้ออกในเวอร์ชันสุดท้าย เพราะคงไม่สนุกเท่าไรหากเกมเฉลยคำตอบออกมาตั้งแต่เริ่มเล่น!
ลองสั่งรันโปรแกรมดูสักสองสามครั้ง:
$ cargo run
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.02s
Running `target/debug/guessing_game`
Guess the number!
The secret number is: 7
Please input your guess.
4
You guessed: 4
$ cargo run
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.02s
Running `target/debug/guessing_game`
Guess the number!
The secret number is: 83
Please input your guess.
5
You guessed: 5
คุณควรจะได้ตัวเลขสุ่มที่ไม่ซ้ำกันในแต่ละรอบ และทุกค่าต้องอยู่ระหว่าง 1 ถึง 100 หากมีข้อความแจ้งเตือน (warning) ปรากฏขึ้น สามารถมองข้ามไปก่อนได้ แต่หากพบข้อผิดพลาด กรุณาตรวจสอบให้แน่ใจว่าได้ระบุ rand = "0.10.1" ไว้ใน Cargo.toml เรียบร้อยแล้ว เนื่องจากเวอร์ชันใหม่ในอนาคตของ rand อาจมีการเปลี่ยนแปลง API แต่เวอร์ชันใดๆ ในตระกูล 0.10 จะยังคงทำงานร่วมกับโค้ดในบทนี้ได้อย่างสมบูรณ์
การเปรียบเทียบคำทายกับตัวเลขลับ
เมื่อเรามีทั้งข้อมูลอินพุตจากผู้เล่นและตัวเลขสุ่มแล้ว ขั้นต่อไปคือการนำค่าทั้งสองมาเปรียบเทียบกัน ดังที่แสดงในลิสติ้ง 2-4 โปรดทราบว่าโค้ดชุดนี้จะยังคอมไพล์ไม่ผ่านในตอนนี้ ซึ่งเราจะอธิบายสาเหตุให้เข้าใจในลำดับถัดไป
use std::cmp::Ordering;
use std::io;
use rand::prelude::*;
fn main() {
// --snip--
println!("Guess the number!");
let secret_number = rand::rng().random_range(1..=100);
println!("The secret number is: {secret_number}");
println!("Please input your guess.");
let mut guess = String::new();
io::stdin()
.read_line(&mut guess)
.expect("Failed to read line");
println!("You guessed: {guess}");
match guess.cmp(&secret_number) {
Ordering::Less => println!("Too small!"),
Ordering::Greater => println!("Too big!"),
Ordering::Equal => println!("You win!"),
}
}
อันดับแรก เราเพิ่มคำสั่ง use อีกหนึ่งรายการ เพื่อนำชนิดข้อมูล std::cmp::Ordering จากไลบรารีมาตรฐานเข้ามาสู่สโคป ชนิด Ordering เป็น enum อีกตัวหนึ่งที่มีวาเรียนต์ให้ใช้งาน 3 ค่า ได้แก่ Less, Greater และ Equal ซึ่งเป็นผลลัพธ์ที่เป็นไปได้ทั้งหมดเมื่อนำค่าสองค่ามาเปรียบเทียบกัน
จากนั้น เราเพิ่มโค้ดใหม่อีก 5 บรรทัดที่ด้านล่างซึ่งมีการเรียกใช้ชนิด Ordering โดยเมธอด cmp จะเปรียบเทียบค่าสองค่าเข้าด้วยกัน และสามารถเรียกใช้ได้กับข้อมูลทุกชนิดที่รองรับการเปรียบเทียบ เมธอดนี้จะรับเรเฟอเรนซ์ของค่าที่ต้องการเปรียบเทียบด้วยเข้ามาเป็นอาร์กิวเมนต์ ในที่นี้คือการนำ guess ไปเปรียบเทียบกับ secret_number แล้วส่งคืนวาเรียนต์ของ enum Ordering ที่เรานำเข้ามาด้วยคำสั่ง use กลับออกมา เราจะใช้นิพจน์ match ในการตัดสินใจว่าควรทำสิ่งใดต่อไป โดยพิจารณาจากวาเรียนต์ของ Ordering ที่ได้จากการเปรียบเทียบค่าระหว่าง guess กับ secret_number
นิพจน์ match ประกอบด้วย_อาร์ม_หรือกิ่งกรณี (arms) หลายๆ กิ่ง โดยในแต่ละอาร์มจะประกอบด้วย_รูปแบบ_ (pattern) ที่ใช้สำหรับจับคู่เงื่อนไข และโค้ดที่จะทำงานหากค่านั้นตรงกับรูปแบบดังกล่าว คอมไพเลอร์ Rust จะนำค่าที่ส่งให้ match มาตรวจสอบเปรียบเทียบกับรูปแบบของแต่ละอาร์มเรียงตามลำดับจากบนลงล่าง ทั้งนี้ รูปแบบและโครงสร้าง match ถือเป็นฟีเจอร์อันทรงพลังอย่างยิ่งของ Rust เพราะช่วยให้คุณสามารถครอบคลุมทุกสถานการณ์ที่โค้ดอาจพบเจอได้อย่างรอบคอบ และมั่นใจได้ว่าจะไม่มีกรณีใดถูกละเลย ซึ่งเราจะกล่าวถึงฟีเจอร์เหล่านี้อย่างละเอียดในบทที่ 6 และบทที่ 19 ตามลำดับ
ลองมาติดตามการทำงานของนิพจน์ match ในตัวอย่างนี้กัน สมมติว่าผู้เล่นทายเลข 50 และตัวเลขลับที่สุ่มได้ในรอบนี้คือ 38
เมื่อโปรแกรมนำ 50 ไปเปรียบเทียบกับ 38 เมธอด cmp จะส่งค่า Ordering::Greater กลับมา เนื่องจาก 50 มีค่ามากกว่า 38 นิพจน์ match จึงได้รับค่า Ordering::Greater แล้วเริ่มตรวจสอบรูปแบบในแต่ละอาร์ม โดยเริ่มจากอาร์มแรกคือ Ordering::Less ซึ่งพบว่าไม่ตรงกัน จึงข้ามไปยังอาร์มถัดไป รูปแบบของอาร์มถัดมาคือ Ordering::Greater ซึ่ง_ตรงกัน_พอดีกับค่าที่ได้รับ! โค้ดในอาร์มนั้นจึงเริ่มทำงานและพิมพ์ข้อความ Too big! ออกทางหน้าจอ เมื่อการจับคู่ในนิพจน์ match สำเร็จเรียบร้อยแล้ว การทำงานของโครงสร้าง match จะสิ้นสุดลงทันที จึงไม่มีการตรวจสอบอาร์มที่เหลือต่อในสถานการณ์นี้
อย่างไรก็ดี โค้ดในลิสติ้ง 2-4 ยังคอมไพล์ไม่ผ่านในตอนนี้ ลองสั่งคอมไพล์เพื่อดูผลลัพธ์กัน:
$ cargo build
Compiling libc v0.2.186
Compiling rand_core v0.10.1
Compiling cfg-if v1.0.0
Compiling getrandom v0.4.3
Compiling chacha20 v0.10.1
Compiling rand v0.10.1
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
error[E0308]: mismatched types
--> src/main.rs:23:21
|
23 | match guess.cmp(&secret_number) {
| --- ^^^^^^^^^^^^^^ expected `&String`, found `&{integer}`
| |
| arguments to this method are incorrect
|
= note: expected reference `&String`
found reference `&{integer}`
note: method defined here
--> /rustc/88d9e12ae178fab0fb5cc050a94da85685d449ea/library/core/src/cmp.rs:1000:7
For more information about this error, try `rustc --explain E0308`.
error: could not compile `guessing_game` (bin "guessing_game") due to 1 previous error
ใจความสำคัญของข้อผิดพลาดระบุว่าเกิดปัญหา_ชนิดข้อมูลไม่ตรงกัน_ (mismatched types) เนื่องจาก Rust เป็นภาษาที่มีระบบชนิดข้อมูลแบบสแตติกที่เข้มงวด (strongly typed) อย่างไรก็ตาม Rust ก็มีระบบอนุมานชนิดข้อมูล (type inference) ที่ชาญฉลาด เมื่อเราเขียน let mut guess = String::new() คอมไพเลอร์สามารถอนุมานได้เองว่า guess ควรเป็นชนิด String จึงไม่ได้บังคับให้เราต้องระบุชนิดข้อมูลด้วยตนเอง ในทางตรงกันข้าม ตัวแปร secret_number มีชนิดข้อมูลเป็นตัวเลข ซึ่ง Rust มีชนิดข้อมูลตัวเลขหลายแบบที่สามารถเก็บค่า 1 ถึง 100 ได้ เช่น i32 (จำนวนเต็ม 32 บิตแบบมีเครื่องหมาย), u32 (จำนวนเต็ม 32 บิตแบบไม่มีเครื่องหมาย), i64 (จำนวนเต็ม 64 บิต) และอื่นๆ หากเราไม่ได้ระบุไว้เป็นอย่างอื่น Rust จะกำหนดให้เป็นชนิด i32 ตามค่าเริ่มต้น ซึ่งทำให้ secret_number มีชนิดเป็น i32 เว้นแต่เราจะใส่ข้อมูลชนิดอื่นที่ทำให้คอมไพเลอร์อนุมานเป็นชนิดอื่นแทน สาเหตุของข้อผิดพลาดในครั้งนี้จึงเกิดจากการที่ Rust ไม่อนุญาตให้นำสตริง (String) มาเปรียบเทียบกับชนิดข้อมูลตัวเลขโดยตรงได้นั่นเอง
ดังนั้น เราจึงต้องแปลงค่า String ที่อ่านเข้ามาจากผู้ใช้ให้กลายเป็นชนิดข้อมูลตัวเลขเสียก่อน เพื่อให้สามารถนำไปเปรียบเทียบเชิงตัวเลขกับ secret_number ได้ เราทำสิ่งนี้ได้โดยการเพิ่มบรรทัดต่อไปนี้เข้าไปในฟังก์ชัน main:
ชื่อไฟล์: src/main.rs
use std::cmp::Ordering;
use std::io;
use rand::prelude::*;
fn main() {
println!("Guess the number!");
let secret_number = rand::rng().random_range(1..=100);
println!("The secret number is: {secret_number}");
println!("Please input your guess.");
// --snip--
let mut guess = String::new();
io::stdin()
.read_line(&mut guess)
.expect("Failed to read line");
let guess: u32 = guess.trim().parse().expect("Please type a number!");
println!("You guessed: {guess}");
match guess.cmp(&secret_number) {
Ordering::Less => println!("Too small!"),
Ordering::Greater => println!("Too big!"),
Ordering::Equal => println!("You win!"),
}
}
บรรทัดที่เพิ่มเข้ามาคือ:
let guess: u32 = guess.trim().parse().expect("Please type a number!");
เราประกาศตัวแปรชื่อ guess ขึ้นมาใหม่อีกครั้ง แต่โปรแกรมของเรามีตัวแปรชื่อ guess อยู่แล้วไม่ใช่หรือ? ใช่แล้ว! แต่ใน Rust เรามีความสามารถในการประกาศตัวแปรใหม่ที่มีชื่อซ้ำกับตัวแปรเดิมได้ ซึ่งเรียกว่า_การบดบังตัวแปร_ (shadowing) ฟีเจอร์นี้ช่วยให้เราสามารถนำชื่อตัวแปร guess กลับมาใช้ซ้ำได้ โดยไม่ต้องคอยตั้งชื่อตัวแปรใหม่ที่ไม่ซ้ำกัน เช่น guess_str กับ guess เราจะกล่าวถึงเรื่องนี้โดยละเอียดในบทที่ 3 แต่สำหรับตอนนี้ ให้จำไว้ว่าฟีเจอร์นี้มักถูกนำมาใช้บ่อยครั้งเมื่อเราต้องการแปลงค่าจากชนิดข้อมูลหนึ่งไปเป็นอีกชนิดหนึ่ง
เราผูกตัวแปรใหม่นี้เข้ากับผลลัพธ์ของนิพจน์ guess.trim().parse() โดย guess ในนิพจน์นี้หมายถึงตัวแปร guess ตัวเดิมที่เก็บสตริงอินพุตไว้ เมธอด trim บนอินสแตนซ์ของ String จะช่วยตัดช่องว่างทั้งหมดที่อยู่บริเวณหัวและท้ายข้อความออก ซึ่งจำเป็นต้องทำก่อนจะแปลงสตริงไปเป็น u32 ที่รองรับเฉพาะตัวเลขเท่านั้น เนื่องจากเวลาที่ผู้ใช้พิมพ์ตัวเลขแล้วกด Enter เมธอด read_line จะบันทึกอักขระขึ้นบรรทัดใหม่ติดมาด้วยเสมอ ตัวอย่างเช่น หากผู้ใช้พิมพ์ 5 แล้วกด Enter ตัวแปร guess จะมีค่าเป็น 5\n (บน Windows การกด Enter จะให้ผลเป็น carriage return และ newline คือ \r\n) เมธอด trim จึงทำหน้าที่ตัด \n หรือ \r\n ทิ้งไป ทำให้เหลือเพียงข้อความ 5 เท่านั้น
เมธอด parse บนสตริง ทำหน้าที่แปลงข้อความสตริงให้เป็นชนิดข้อมูลอื่น ในกรณีนี้ เราใช้เพื่อแปลงสตริงเป็นตัวเลข โดยเราต้องระบุชนิดข้อมูลตัวเลขที่ต้องการให้ชัดเจนด้วย let guess: u32 เครื่องหมายโคลอน (:) หลังชื่อ guess จะบอกคอมไพเลอร์ว่าเรากำลังระบุชนิดข้อมูล (type annotation) ให้กับตัวแปร ทั้งนี้ Rust มีชนิดข้อมูลตัวเลขพื้นฐานหลายประเภท โดย u32 คือจำนวนเต็ม 32 บิตแบบไม่มีเครื่องหมาย ซึ่งเหมาะอย่างยิ่งสำหรับเก็บตัวเลขจำนวนเต็มบวกขนาดเล็ก คุณจะได้ศึกษาชนิดตัวเลขอื่นๆ เพิ่มเติมในบทที่ 3
นอกจากนี้ การระบุชนิด u32 ให้กับตัวแปรและนำไปเปรียบเทียบกับ secret_number ยังส่งผลให้คอมไพเลอร์ Rust อนุมานให้ secret_number มีชนิดข้อมูลเป็น u32 ตามไปด้วยโดยอัตโนมัติ ทำให้ตอนนี้การเปรียบเทียบเกิดขึ้นระหว่างค่าของชนิดข้อมูลเดียวกันแล้ว!
เนื่องจากเมธอด parse จะแปลงค่าได้สำเร็จเฉพาะกับข้อความที่เป็นตัวเลขจริงๆ เท่านั้น การเรียกใช้จึงมีโอกาสเกิดข้อผิดพลาดได้ง่าย เช่น หากสตริงมีข้อความอย่าง A👍% เมธอดนี้จะไม่สามารถแปลงเป็นตัวเลขได้ ด้วยเหตุนี้ parse จึงส่งผลลัพธ์กลับมาเป็นชนิด Result เช่นเดียวกับที่เมธอด read_line ทำ (ดังที่ได้อธิบายไว้ในหัวข้อ “การจัดการความล้มเหลวที่อาจเกิดขึ้นด้วย Result”) เราจึงสามารถจัดการผลลัพธ์ของ Result ได้ด้วยวิธีเดิม นั่นคือการเรียกเมธอด expect หาก parse ส่งคืนวาเรียนต์ Err เนื่องจากแปลงตัวเลขไม่สำเร็จ เมธอด expect จะทำให้โปรแกรมหยุดทำงานพร้อมแสดงข้อความเตือนที่เรากำหนดไว้ แต่หาก parse แปลงสตริงเป็นตัวเลขได้สำเร็จ จะส่งคืนวาเรียนต์ Ok และ expect จะดึงค่าตัวเลขที่อยู่ภายในออกมาให้เรานำไปใช้งานต่อได้อย่างราบรื่น
มาลองสั่งรันโปรแกรมดูอีกครั้ง:
$ cargo run
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.26s
Running `target/debug/guessing_game`
Guess the number!
The secret number is: 58
Please input your guess.
76
You guessed: 76
Too big!
ยอดเยี่ยมมาก! แม้ว่าผู้ใช้จะเผลอเคาะเว้นวรรคไว้หน้าตัวเลข โปรแกรมก็ยังคงฉลาดพอที่จะตัดช่องว่างออกและทราบว่าผู้ใช้ทายเลข 76 ลองทดสอบรันโปรแกรมหลายๆ ครั้งด้วยข้อมูลที่หลากหลายดู เช่น ทายเลขที่ถูกต้อง ทายเลขที่มากเกินไป และทายเลขที่น้อยเกินไป
ถึงตอนนี้ ส่วนประกอบหลักของเกมทำงานได้เกือบสมบูรณ์แล้ว ขาดเพียงแต่ผู้เล่นยังสามารถทายตัวเลขได้เพียงครั้งเดียวเท่านั้น เรามาแก้ไขจุดนี้ด้วยการเพิ่มลูป (loop) กัน!
รองรับการทายหลายครั้งด้วยลูป
คำสงวน loop ใช้สำหรับสร้างลูปที่ทำงานวนซ้ำอย่างไม่รู้จบ เราจะนำลูปนี้มาใช้เพื่อเปิดโอกาสให้ผู้เล่นสามารถทายตัวเลขซ้ำได้เรื่อยๆ:
ชื่อไฟล์: src/main.rs
use std::cmp::Ordering;
use std::io;
use rand::prelude::*;
fn main() {
println!("Guess the number!");
let secret_number = rand::rng().random_range(1..=100);
// --snip--
println!("The secret number is: {secret_number}");
loop {
println!("Please input your guess.");
// --snip--
let mut guess = String::new();
io::stdin()
.read_line(&mut guess)
.expect("Failed to read line");
let guess: u32 = guess.trim().parse().expect("Please type a number!");
println!("You guessed: {guess}");
match guess.cmp(&secret_number) {
Ordering::Less => println!("Too small!"),
Ordering::Greater => println!("Too big!"),
Ordering::Equal => println!("You win!"),
}
}
}
ดังที่คุณเห็น เราได้ย้ายคำสั่งทั้งหมดตั้งแต่การแจ้งให้ป้อนคำทายเป็นต้นไปเข้ามาไว้ภายในลูป อย่าลืมจัดย่อหน้าเว้นวรรคเพิ่มอีก 4 ช่องสำหรับโค้ดที่อยู่ภายในลูป แล้วลองสั่งรันโปรแกรมใหม่อีกครั้ง คราวนี้โปรแกรมจะวนถามคำทายไปเรื่อยๆ อย่างไม่มีที่สิ้นสุด ซึ่งทำให้เราพบปัญหาใหม่ นั่นคือผู้เล่นไม่สามารถออกจากเกมได้เลย!
แม้ว่าผู้เล่นจะสามารถสั่งหยุดโปรแกรมได้เสมอด้วยคีย์ลัด Ctrl-C แต่ก็ยังมีอีกวิธีหนึ่งที่จะหลุดออกจากวงวนที่ไม่สิ้นสุดนี้ได้ นั่นคือสิ่งที่เราได้กล่าวไว้ในหัวข้อ “การเปรียบเทียบคำทายกับตัวเลขลับ” ว่าหากผู้ใช้ป้อนข้อมูลที่ไม่ใช่ตัวเลข โปรแกรมจะหยุดทำงานทันที เราสามารถใช้ประโยชน์จากพฤติกรรมนี้เพื่อให้ผู้เล่นออกจากเกมได้ ดังตัวอย่างนี้:
$ cargo run
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.23s
Running `target/debug/guessing_game`
Guess the number!
The secret number is: 59
Please input your guess.
45
You guessed: 45
Too small!
Please input your guess.
60
You guessed: 60
Too big!
Please input your guess.
59
You guessed: 59
You win!
Please input your guess.
quit
thread 'main' (6694925) panicked at src/main.rs:28:47:
Please type a number!: ParseIntError { kind: InvalidDigit }
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
การพิมพ์คำว่า quit ช่วยให้เราออกจากเกมได้ แต่การป้อนข้อความอื่นๆ ที่ไม่ใช่ตัวเลขก็ทำให้เกิดผลแบบเดียวกัน ซึ่งวิธีนี้อาจดูไม่ค่อยเรียบร้อยเท่าใดนัก และเราต้องการให้เกมสามารถจบการทำงานได้อย่างสง่างามเมื่อผู้เล่นทายตัวเลขได้ถูกต้องอีกด้วย
ออกจากเกมเมื่อทายถูก
มาปรับปรุงให้เกมจบการทำงานโดยอัตโนมัติเมื่อผู้เล่นชนะ ด้วยการเพิ่มคำสั่ง break:
ชื่อไฟล์: src/main.rs
use std::cmp::Ordering;
use std::io;
use rand::prelude::*;
fn main() {
println!("Guess the number!");
let secret_number = rand::rng().random_range(1..=100);
println!("The secret number is: {secret_number}");
loop {
println!("Please input your guess.");
let mut guess = String::new();
io::stdin()
.read_line(&mut guess)
.expect("Failed to read line");
let guess: u32 = guess.trim().parse().expect("Please type a number!");
println!("You guessed: {guess}");
// --snip--
match guess.cmp(&secret_number) {
Ordering::Less => println!("Too small!"),
Ordering::Greater => println!("Too big!"),
Ordering::Equal => {
println!("You win!");
break;
}
}
}
}
การใส่คำสั่ง break ต่อท้ายข้อความ You win! จะสั่งให้โปรแกรมกระโดดออกจากลูปทันทีเมื่อผู้เล่นทายตัวเลขลับได้ถูกต้อง และเนื่องจากลูปนี้เป็นคำสั่งส่วนสุดท้ายในฟังก์ชัน main การออกจากลูปจึงทำให้โปรแกรมจบการทำงานไปโดยปริยาย
การจัดการกับอินพุตที่ไม่ถูกต้อง
เพื่อยกระดับประสบการณ์การเล่นเกมให้ดียิ่งขึ้น แทนที่จะปล่อยให้โปรแกรมแครชหยุดทำงานเมื่อผู้เล่นป้อนข้อความที่ไม่ใช่ตัวเลข เรามาปรับให้โปรแกรมมองข้ามอินพุตที่ไม่ถูกต้องเหล่านั้น แล้วเปิดโอกาสให้ผู้เล่นป้อนคำทายใหม่ต่อไปได้ โดยแก้ไขบรรทัดที่แปลงค่า guess จาก String ไปเป็น u32 ตามลิสติ้ง 2-5
use std::cmp::Ordering;
use std::io;
use rand::prelude::*;
fn main() {
println!("Guess the number!");
let secret_number = rand::rng().random_range(1..=100);
println!("The secret number is: {secret_number}");
loop {
println!("Please input your guess.");
let mut guess = String::new();
// --snip--
io::stdin()
.read_line(&mut guess)
.expect("Failed to read line");
let guess: u32 = match guess.trim().parse() {
Ok(num) => num,
Err(_) => continue,
};
println!("You guessed: {guess}");
// --snip--
match guess.cmp(&secret_number) {
Ordering::Less => println!("Too small!"),
Ordering::Greater => println!("Too big!"),
Ordering::Equal => {
println!("You win!");
break;
}
}
}
}
เราเปลี่ยนจากการเรียกใช้ expect มาใช้นิพจน์ match แทน เพื่อเปลี่ยนจากการหยุดทำงานเมื่อเกิดข้อผิดพลาด มาเป็นการควบคุมและจัดการข้อผิดพลาดด้วยตนเอง จำได้ไหมว่า parse จะส่งผลลัพธ์เป็นชนิด Result ซึ่งเป็น enum ที่มีวาเรียนต์คือ Ok และ Err เราจึงสามารถใช้ match เพื่อตรวจสอบผลลัพธ์ได้ในลักษณะเดียวกับที่เราเคยทำกับผลลัพธ์ Ordering จากเมธอด cmp
หาก parse แปลงสตริงเป็นตัวเลขได้สำเร็จ จะส่งคืนค่า Ok ที่บรรจุตัวเลขผลลัพธ์ไว้ ซึ่งจะตรงกับรูปแบบในอาร์มแรกของ match และทำให้นิพจน์ match ส่งคืนค่า num ที่ได้ออกมา ค่าตัวเลขนั้นจึงถูกนำไปจัดเก็บไว้ในตัวแปร guess ตัวใหม่ที่เราสร้างขึ้นได้อย่างสมบูรณ์
แต่หาก parse _ไม่_สามารถแปลงสตริงเป็นตัวเลขได้ จะส่งคืนค่า Err ที่บรรจุรายละเอียดของข้อผิดพลาดออกมา ซึ่งค่า Err นี้จะไม่ตรงกับรูปแบบ Ok(num) ในอาร์มแรก แต่จะไปตรงกับรูปแบบ Err(_) ในอาร์มที่สองแทน โดยสัญลักษณ์ขีดล่าง _ ทำหน้าที่เป็นรูปแบบที่จับคู่ได้กับทุกค่า (catch-all) ในตัวอย่างนี้เราบอกว่าต้องการจับคู่กับค่า Err ทั้งหมดโดยไม่สนใจว่าภายในจะมีข้อมูลข้อผิดพลาดอะไรอยู่ จากนั้นโปรแกรมจะรันคำสั่งในอาร์มที่สอง นั่นคือ continue ซึ่งสั่งให้ข้ามไปยังรอบการวนซ้ำ (iteration) ถัดไปของ loop ทันที และแสดงข้อความขอคำทายใหม่อีกครั้ง ทำให้โปรแกรมสามารถมองข้ามข้อมูลที่ไม่ถูกต้องได้อย่างนุ่มนวลโดยไม่หยุดทำงานกะทันหัน!
ตอนนี้ ทุกฟังก์ชันการทำงานของเกมควรพร้อมใช้งานอย่างสมบูรณ์แล้ว ลองสั่งรันโปรแกรมดู:
$ cargo run
Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.13s
Running `target/debug/guessing_game`
Guess the number!
The secret number is: 61
Please input your guess.
10
You guessed: 10
Too small!
Please input your guess.
99
You guessed: 99
Too big!
Please input your guess.
foo
Please input your guess.
61
You guessed: 61
You win!
ยอดเยี่ยมมาก! เหลือเพียงการปรับแต่งเล็กๆ อีกข้อเดียวเพื่อให้เกมของเราเสร็จสมบูรณ์อย่างแท้จริง จำได้ไหมว่าโปรแกรมยังคงพิมพ์ตัวเลขลับออกมาให้เห็นอยู่ ซึ่งมีประโยชน์ในตอนพัฒนา แต่ทำให้ตัวเกมขาดความท้าทาย เรามาลบคำสั่ง println! ที่แสดงตัวเลขลับออกกัน โดยลิสติ้ง 2-6 แสดงโค้ดฉบับสมบูรณ์ของเกมนี้
use std::cmp::Ordering;
use std::io;
use rand::prelude::*;
fn main() {
println!("Guess the number!");
let secret_number = rand::rng().random_range(1..=100);
loop {
println!("Please input your guess.");
let mut guess = String::new();
io::stdin()
.read_line(&mut guess)
.expect("Failed to read line");
let guess: u32 = match guess.trim().parse() {
Ok(num) => num,
Err(_) => continue,
};
println!("You guessed: {guess}");
match guess.cmp(&secret_number) {
Ordering::Less => println!("Too small!"),
Ordering::Greater => println!("Too big!"),
Ordering::Equal => {
println!("You win!");
break;
}
}
}
}
มาถึงตรงนี้ คุณได้สร้างโปรเจกต์เกมทายตัวเลขด้วยภาษา Rust ได้สำเร็จเรียบร้อยแล้ว ขอแสดงความยินดีด้วยอย่างยิ่ง!
สรุป
โปรเจกต์นี้เป็นการปูพื้นฐานภาคปฏิบัติที่ช่วยแนะนำให้คุณรู้จักกับแนวคิดใหม่ๆ มากมายในภาษา Rust เช่น คำสั่ง let, match, ฟังก์ชัน, การเรียกใช้งานเครตภายนอก และอื่นๆ อีกมากมาย ในบทต่อๆ ไป คุณจะได้ศึกษาแต่ละแนวคิดเหล่านี้ในมิติที่ลึกซึ้งยิ่งขึ้น โดยในบทที่ 3 จะครอบคลุมแนวคิดพื้นฐานที่มีในภาษาโปรแกรมทั่วไป เช่น ตัวแปร, ชนิดข้อมูล (data types) และฟังก์ชัน พร้อมแสดงวิธีเขียนสิ่งเหล่านี้ใน Rust บทที่ 4 จะพาไปเจาะลึกระบบสิทธิ์ความเป็นเจ้าของ (ownership) ซึ่งเป็นฟีเจอร์อันโดดเด่นที่ทำให้ Rust แตกต่างจากภาษาอื่นๆ บทที่ 5 จะอธิบาย struct และเมธอด ส่วนบทที่ 6 จะอธิบายการทำงานของ enum อย่างละเอียด