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

Hello, World!

หลังจากที่คุณติดตั้ง Rust เรียบร้อยแล้ว ก็ถึงเวลาเขียนโปรแกรมแรกของคุณ เป็นธรรมเนียมปฏิบัติสากลเมื่อเริ่มต้นเรียนรู้ภาษาใหม่ที่จะเขียนโปรแกรมเล็กๆ เพื่อพิมพ์ข้อความ Hello, world! ออกทางหน้าจอ ซึ่งเราจะทำเช่นเดียวกันนี้ในบทเรียนนี้!

หมายเหตุ: หนังสือเล่มนี้เขียนขึ้นโดยสมมติว่าคุณคุ้นเคยกับบรรทัดคำสั่ง (command line) มาบ้างแล้ว ทั้งนี้ Rust ไม่ได้จำกัดว่าคุณต้องใช้โปรแกรมแก้ไขโค้ด เครื่องมือ หรือจัดเก็บโค้ดไว้ที่ใด ดังนั้นหากคุณถนัดใช้ IDE มากกว่าบรรทัดคำสั่ง คุณสามารถเลือกใช้ IDE ที่คุณชื่นชอบได้ตามสะดวก ปัจจุบัน IDE หลายตัวต่างรองรับภาษา Rust เป็นอย่างดี สามารถดูรายละเอียดเพิ่มเติมได้จากคู่มือของ IDE นั้นๆ นอกจากนี้ ทีมงาน Rust ยังมุ่งมั่นพัฒนาการสนับสนุน IDE ชั้นยอดผ่าน rust-analyzer อีกด้วย สามารถดูรายละเอียดเพิ่มเติมได้ที่ภาคผนวก D

การตั้งค่าไดเรกทอรีโปรเจกต์

เริ่มต้นด้วยการสร้างไดเรกทอรีสำหรับจัดเก็บโค้ด Rust ของคุณ โดยปกติแล้ว Rust ไม่ได้จำกัดว่าคุณต้องเก็บโค้ดไว้ที่ใด แต่สำหรับแบบฝึกหัดและโปรเจกต์ต่างๆ ในหนังสือเล่มนี้ เราแนะนำให้สร้างไดเรกทอรี projects ไว้ในไดเรกทอรีโฮม (home directory) ของคุณ เพื่อรวบรวมโปรเจกต์ทั้งหมดไว้ในที่เดียวกัน

เปิดเทอร์มินัลแล้วป้อนคำสั่งต่อไปนี้เพื่อสร้างไดเรกทอรี projects และสร้างไดเรกทอรีสำหรับโปรเจกต์ “Hello, world!” ไว้ข้างใน

สำหรับ Linux, macOS และ PowerShell บน Windows ให้ป้อนคำสั่งดังนี้:

$ mkdir ~/projects
$ cd ~/projects
$ mkdir hello_world
$ cd hello_world

สำหรับ Windows CMD ให้ป้อนคำสั่งดังนี้:

> mkdir "%USERPROFILE%\projects"
> cd /d "%USERPROFILE%\projects"
> mkdir hello_world
> cd hello_world

พื้นฐานของโปรแกรม Rust

ขั้นต่อไป ให้สร้างไฟล์ซอร์สโค้ดใหม่ชื่อว่า main.rs ไฟล์ของ Rust จะลงท้ายด้วยนามสกุล .rs เสมอ หากชื่อไฟล์ของคุณประกอบด้วยคำมากกว่าหนึ่งคำ ธรรมเนียมปฏิบัติคือให้ใช้เครื่องหมายขีดล่าง (underscore) คั่นระหว่างคำ เช่น ใช้ hello_world.rs แทนที่จะเป็น helloworld.rs

เปิดไฟล์ main.rs ที่เพิ่งสร้างขึ้นมา แล้วป้อนโค้ดตามลิสติ้ง 1-1

fn main() {
    println!("Hello, world!");
}

บันทึกไฟล์ให้เรียบร้อย แล้วสลับกลับมาที่หน้าต่างเทอร์มินัลในไดเรกทอรี ~/projects/hello_world บน Linux หรือ macOS ให้ป้อนคำสั่งต่อไปนี้เพื่อคอมไพล์และรันโปรแกรม:

$ rustc main.rs
$ ./main
Hello, world!

บน Windows ให้ป้อนคำสั่ง .\main แทน ./main:

> rustc main.rs
> .\main
Hello, world!

ไม่ว่าคุณจะใช้ระบบปฏิบัติการใด ข้อความสตริง Hello, world! ควรจะปรากฏขึ้นบนเทอร์มินัล หากคุณไม่เห็นผลลัพธ์นี้ ให้ย้อนกลับไปดูที่หัวข้อย่อย “การแก้ปัญหา” ในขั้นตอนการติดตั้ง เพื่อตรวจหาวิธีแก้ไขปัญหา

หากมีข้อความ Hello, world! แสดงขึ้นมา ขอแสดงความยินดีด้วย! คุณได้เขียนโปรแกรม Rust อย่างเป็นทางการสำเร็จแล้ว และนั่นทำให้คุณก้าวสู่การเป็นโปรแกรมเมอร์ Rust แล้ว—ยินดีต้อนรับ!

โครงสร้างของโปรแกรม Rust

มาพิจารณารายละเอียดของโปรแกรม “Hello, world!” นี้อย่างเจาะลึกกัน นี่คือจิ๊กซอว์ชิ้นแรก:

fn main() {

}

บรรทัดเหล่านี้ทำหน้าที่กำหนดฟังก์ชันชื่อ main ฟังก์ชัน main มีความพิเศษอย่างยิ่ง เพราะเป็นโค้ดจุดแรกสุดที่จะเริ่มทำงานในทุกโปรแกรมของ Rust ที่รันได้ ในที่นี้ บรรทัดแรกประกาศฟังก์ชันชื่อ main ซึ่งไม่มีพารามิเตอร์และไม่ส่งค่าใดๆ กลับมา หากฟังก์ชันมีพารามิเตอร์ พารามิเตอร์เหล่านั้นจะถูกระบุไว้ภายในวงเล็บ (())

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

หมายเหตุ: หากคุณต้องการจัดรูปแบบโค้ดให้เป็นมาตรฐานเดียวกันตลอดทุกโปรเจกต์ของ Rust คุณสามารถใช้เครื่องมือจัดรูปแบบอัตโนมัติชื่อ rustfmt เพื่อจัดโค้ดตามสไตล์มาตรฐานได้ (อ่านเพิ่มเติมเกี่ยวกับ rustfmt ได้ที่ภาคผนวก D) ทั้งนี้ ทีมงาน Rust ได้รวมเครื่องมือนี้มาพร้อมกับชุดติดตั้งมาตรฐานของ Rust เช่นเดียวกับ rustc จึงติดตั้งอยู่ในเครื่องของคุณเรียบร้อยแล้ว!

ภายในบล็อกเนื้อหาของฟังก์ชัน main มีโค้ดดังนี้:

#![allow(unused)]
fn main() {
println!("Hello, world!");
}

บรรทัดนี้คือส่วนที่ทำหน้าที่หลักทั้งหมดในโปรแกรมเล็กๆ นี้ นั่นคือการพิมพ์ข้อความออกทางหน้าจอ โดยมีรายละเอียดสำคัญ 3 ประการที่ควรสังเกต:

ประการแรก println! คือการเรียกใช้มาโครของ Rust (Rust macro) หากเป็นการเรียกใช้ฟังก์ชันทั่วไป จะเขียนเพียง println (โดยไม่มีเครื่องหมาย !) มาโครของ Rust เป็นวิธีการเขียนโค้ดที่สร้างโค้ดอื่นขึ้นมาเพื่อช่วยขยายไวยากรณ์ของภาษา ซึ่งเราจะเจาะลึกรายละเอียดกันในบทที่ 20 สำหรับตอนนี้ คุณเพียงจำไว้ว่าการมีเครื่องหมาย ! หมายถึงคุณกำลังเรียกใช้มาโคร ไม่ใช่ฟังก์ชันทั่วไป และมาโครไม่ได้ปฏิบัติตามกฎเกณฑ์เดียวกันกับฟังก์ชันเสมอไป

ประการที่สอง คุณจะเห็นสตริง "Hello, world!" เราส่งสตริงนี้เป็นอาร์กิวเมนต์ให้กับ println! เพื่อพิมพ์ข้อความดังกล่าวออกทางหน้าจอ

ประการที่สาม เราจบบรรทัดด้วยเครื่องหมายอัฒภาคหรือเซมิโคลอน (;) ซึ่งเป็นตัวบอกว่านิพจน์ (expression) นี้สิ้นสุดลงแล้ว และพร้อมเริ่มต้นนิพจน์ถัดไป โดยโค้ดของ Rust เกือบทุกบรรทัดจะลงท้ายด้วยเครื่องหมายเซมิโคลอนเสมอ

การคอมไพล์และการรัน

คุณเพิ่งได้รันโปรแกรมที่สร้างขึ้นมาใหม่ ตอนนี้มาทำความเข้าใจแต่ละขั้นตอนในกระบวนการนี้กัน

ก่อนที่จะรันโปรแกรม Rust คุณจำเป็นต้องคอมไพล์โค้ดด้วยคอมไพเลอร์ Rust เสียก่อน โดยป้อนคำสั่ง rustc แล้วตามด้วยชื่อไฟล์ซอร์สโค้ด ดังนี้:

$ rustc main.rs

หากคุณคุ้นเคยกับภาษา C หรือ C++ มาก่อน คุณจะสังเกตได้ว่าคำสั่งนี้คล้ายกับการใช้งาน gcc หรือ clang เมื่อคอมไพล์สำเร็จ คอมไพเลอร์ Rust จะสร้างไฟล์ไบนารีที่รันได้ (binary executable) ออกมา

บน Linux, macOS และ PowerShell บน Windows คุณสามารถตรวจสอบดูไฟล์ที่รันได้โดยใช้คำสั่ง ls ในเทอร์มินัล:

$ ls
main  main.rs

บน Linux และ macOS คุณจะเห็น 2 ไฟล์ ส่วนใน PowerShell บน Windows คุณจะเห็น 3 ไฟล์ เช่นเดียวกับการใช้คำสั่ง CMD บน Windows ซึ่งป้อนคำสั่งดังนี้:

> dir /B %= the /B option says to only show the file names =%
main.exe
main.pdb
main.rs

ผลลัพธ์จะแสดงไฟล์ซอร์สโค้ดที่มีนามสกุล .rs, ไฟล์โปรแกรมที่รันได้ (main.exe บน Windows หรือ main บนแพลตฟอร์มอื่นๆ) และเมื่อใช้งานบน Windows จะมีไฟล์นามสกุล .pdb เพิ่มขึ้นมา ซึ่งเก็บข้อมูลสำหรับการดีบัก (debugging information) จากจุดนี้ คุณสามารถสั่งรันไฟล์ main หรือ main.exe ได้ดังนี้:

$ ./main # or .\main on Windows

หากไฟล์ main.rs ของคุณคือโปรแกรม “Hello, world!” คำสั่งนี้จะพิมพ์ข้อความ Hello, world! แสดงขึ้นมาบนเทอร์มินัลของคุณ

หากคุณคุ้นเคยกับภาษาไดนามิกอย่าง Ruby, Python หรือ JavaScript คุณอาจไม่ชินกับการที่ขั้นตอนการคอมไพล์และการรันโปรแกรมถูกแยกออกจากกันอย่างชัดเจน Rust เป็นภาษาแบบ คอมไพล์ล่วงหน้า (ahead-of-time compiled) หมายความว่าคุณสามารถคอมไพล์โปรแกรมแล้วส่งมอบไฟล์โปรแกรมที่รันได้ (executable) ให้ผู้อื่นนำไปใช้งานได้ทันที แม้ว่าเครื่องของพวกเขาจะไม่ได้ติดตั้ง Rust ไว้เลยก็ตาม แตกต่างจากการส่งไฟล์ .rb, .py หรือ .js ให้คนอื่น ซึ่งเครื่องปลายทางจำเป็นต้องมีตัวรัน (runtime/interpreter) ของ Ruby, Python หรือ JavaScript ติดตั้งอยู่ด้วย จึงจะรันโค้ดได้ แต่สำหรับภาษาเหล่านั้น คุณอาจใช้เพียงคำสั่งเดียวเพื่อรันโปรแกรม ทุกสิ่งในการออกแบบภาษาโปรแกรมล้วนมีข้อแลกเปลี่ยนเสมอ

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