Hello, World!
หลังจากที่คุณติดตั้ง Rust แล้ว ก็ถึงเวลาที่คุณจะได้สร้างโปรแกรมแรกของคุณเอง
เป็นเรื่องปกติในการเรียนรู้ภาษาใหม่ที่จะได้สร้างโปรแกรมเล็ก ๆ ที่แสดงข้อความ Hello, world! บนหน้าจอ ดังนั้นเราก็จะทำแบบเดียวกันที่นี่!
หมายเหตุ: หนังสือเล่มนี้ถือว่าคุณมีความคุ้นเคยอยู่บ้างเกี่ยวกับการใช้งานบรรทัดคำสั่ง Rust ไม่ได้กำหนดความต้องการเฉพาะเจาะจงเกี่ยวกับการแก้ไข เครื่องมือ หรือต่ำแหน่งของโค้ด ดังนั้น หากคุณต้องการใช้สภาพแวดล้อมสำหรับการพัฒนาแบบเบ็ดเสร็จ (IDE) แทนบรรทัดคำสั่ง คุณสามารถเลือกใช้ IDE ที่คุณชื่นชอบได้ตามสบาย ปัจจุบัน IDE จำนวนมากรองรับ Rust ในระดับหนึ่งแล้ว ตรวจสอบเอกสารคู่มือของ IDE เพื่อดูรายละเอียด ทีมงานของ Rust มุ่งเน้นไปที่การเปิดทางให้ IDE อันยอดเยี่ยมรองรับผ่าน
rust-analyzerไปที่ Appendix D เพื่อดูรายละเอียดเพิ่มเติม
การสร้างโฟลเดอร์สำหรับโปรเจกต์
คุณจะเริ่มต้นด้วยการสร้าโฟลเดอร์สำหรับเก็บโค้ด Rust ของคุณ ไม่สำคัญว่าโค้ดของคุณจะอยู่ในโฟลเดอร์ไหน แต่ในแบบฝึกหัดและโปรเจกต์ในหนังสือเล่มนี้ เราแนะนำให้สร้างโฟลเดอร์ชื่อ projects ไว้ในโฟลเดอร์โฮมของคุณ และเก็บโปรเจกต์ทั้งหมดของคุณไว้ที่นั่น
เปิดเทอร์มินัลและรันคำสั่งต่อไปนี้ เพื่อสร้างโฟลเดอร์ที่ชื่อ projects และโฟลเดอร์สำหรับโปรเจกต์ “Hello, world!” ที่อยู่ภายในโฟลเดอร์ projects
สำหรับ 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 เสมอ หากชื่อไฟล์ของคุณมีมากกว่าหนึ่งคำ ให้คั่นระหว่างคำด้วยเครื่องหมายขีดล่าง ตัวอย่างเช่น ใช้ 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.exe แทนคำสั่ง ./main:
> rustc main.rs
> .\main.exe
Hello, world!
ไม่ว่าคุณจะใช้ระบบปฏิบัติการใด ข้อความ Hello, world! ควรแสดงผลบนเทอร์มินัล
หากคุณไม่เห็นผลลัพธ์นี้ โปรดกลับไปที่ส่วน “การแก้ไขปัญหา” ในบทการติดตั้ง
สำหรับช่องทางในการขอความช่วยเหลือ
หาก Hello, world! แสดงผล ยินดีด้วย! คุณได้เขียนโปรแกรม Rust อย่างเป็นทางการแล้ว
และนั่นทำให้คุณเป็นโปรแกรมเมอร์ของ Rust ยินดีต้อนรับ!
กายวิภาคของ Rust
เรามาทบทวนรายละเอียดของโปรแกรม “Hello, world!” กัน และนี่คือปริศนาชิ้นแรก:
fn main() { }
บรรทัดเหล่านี้ประกาศฟังก์ชั่นชื่อ main โดยฟังก์ชั่น main
มีความพิเศษคือ จะเป็นส่วนแรกที่เริ่มทำงานในทุกโปรแกรมที่เขียนด้วย Rust
โดยบรรทัดแรกที่ได้ประกาศฟังก์ชั่นชื่อ main นั้นไม่มี parameters และไม่ return ค่าอะไรเลย
หากมี parameters มันจะอยู่ในวงเล็บ ()
ภายในของฟังก์ชั่นถูกครอบด้วย {} โดย Rust จำเป็นต้องมีวงเล็บปีกกาครอบภายในฟังก์ชั่นทั้งหมด
เพื่อรูปแบบการเขียนที่ดี คุณควรวางวงเล็บปีกกาเปิดไว้ในบรรทัดเดียวกับการประกาศฟังก์ชั่น
โดยเพิ่มช่องว่างคั่นกลางหนึ่งช่อง
หมายเหตุ: หากคุณต้องการใช้รูปแบบการเขียนโค้ดมาตรฐานในโปรเจกต์ Rust คุณสามารถใช้เครื่องมือจัดรูปแบบอัตโนมัติที่ชื่อ
rustfmtเพื่อจัดระเบียบโค้ดของคุณให้อยู่ในรูปแบบมาตรฐาน (ดูรายละเอียดเพิ่มเติมเกี่ยวกับrustfmtใน ภาคผนวก D) ทีมงานของ Rust ได้รวบรวมเครื่องมือไว้กับการแจกจ่าย Rust แบบมาตรฐานแล้ว เช่นเดียวกับrustcดังนั้นมันจึงควรถูกติดตั้งในเครื่องของคุณแล้วตอนนี้
ภายในฟังก์ชั่น main มีโค้ดดังต่อไปนี้:
#![allow(unused)] fn main() { println!("Hello, world!"); }
บรรทัดนี้คือการทำงานทั้งหมดของโปรแกรมเล็ก ๆ นี้ ซึ่งจะแสดงผลข้อความออกทางหน้าจอ มีรายละเอียดสำคัญสี่อย่างที่ควรสังเกตดังนี้
อย่างแรก รูปแบบการเขียน Rust คือการเยื้องบรรทัดด้วยช่องว่างสี่ช่อง ไม่ใช่แทบ
อย่างที่สอง println! คือ macro ของ Rust โดยหากต้องการเรียกใช้ฟักง์ชั่นแทน
จำเป็นจะต้องเขียนแบบนี้ println (ไม่มี !)
เราจะกล่าวถึงรายละเอียดเพิ่มเติมเกี่ยวกับ macro บน Rust ในบทที่ 20
สำหรับตอนนี้ คุณเพียงต้องรู้ว่าการใช้ ! หมายถึงคุณกำลังเรียกใช้ macro
แทนที่จะเป็นฟังก์ชั่นปกติ และ macro นั้นไม่ได้มีกฎการใช้งานเหมือนกับฟังก์ชั่นเสมอไป
อย่างที่สาม คุณจะสังเกตเห็นข้อความ "Hello, world!"
ซึ่งเราส่งข้อความนี้เป็น argument ไปยัง println!
จากนั้นข้อความจะแสดงผลออกที่หน้าจอ
อย่างที่สี่ เราปิดท้ายบรรทัดด้วยเครื่องหมายอัฒภาค (;)
ซึ่งระบุว่านิพจน์นี้จบการทำงานแล้ว และนิพจน์ถัดไปพร้อมจะเริ่มทำงาน
โค้ดส่วนใหญ่ของ Rust จะลงท้ายด้วยเครื่องหมายอัฒภาค
การคอมไพล์และการรันในแต่ละขั้นตอน
คุณเพิ่งรันโปรแกรมที่ได้สร้างขึ้นใหม่ ดังนั้นเรามาตรวจสอบกระบวนการในแต่ละขั้นตอนกัน
ก่อนที่จะรันโปรแกรม Rust คุณอาจจะต้องคอมไพล์โค้ดด้วยคอมไพเลอร์ของ Rust โดยรันคำสั่ง rustc
และใส่ชื่อไฟล์ของคุณลงไป เช่น:
$ rustc main.rs
หากคุณมีประสบการณ์กับภาษา C หรือ C++ คุณจะสังเกตเห็นว่าคำสั่งนี้คล้ายกับ gcc หรือ clang
หลังจากคอมไพล์เสร็จสมบูรณ์แล้ว Rust จะสร้างไฟล์ไบนารีที่สามารถรันได้
บน Linux MacOS และ PowerShell บน Windows คุณสามารถพบไพล์ไบนารีโดยใช้คำสั่ง ls
ที่ shell ของคุณ
$ ls
main main.rs
บน Linux MacOS คุณจะพบกับสองไฟล์ ส่วนบน PowerShell ใน Windows คุณจะพบกับไฟล์สามไฟล์ เช่นเดียวกับที่คุณเห็นโดยใช้ CMD สำหรับ CMD บน Windows ใช้คำสั่งต่อไปนี้:
> dir /B %= ตัวบงชี่ /B คือการระบุว่าให้แสดงผลชื่อไฟล์เท่านั้น =%
main.exe
main.pdb
main.rs
ซึ่งจะแสดงไฟล์ซอร์สโค้ดที่มีนามสกุล .rs และไฟล์สำหรับรัน (main.exe สำหรับ Windows, และ main สำหรับระบบอื่น ๆ ) เมื่อใช้ Windows จะมีไฟล์ข้อมูลการดีบักที่มีนามสกุล .pdb รวมอยู่ด้วย จากตรงนี้ คุณสามารถรันไพล์ main หรือ main.exe ได้ดังนี้:
$ ./main # หรือ .\main.exe สำหรับ Windows
หากไฟล์ main.rs ของคุณคือโปรแกรม “Hello, world!”
คำสั่งนี้จะแสดงข้อความ Hello, world! บนเทอร์มินัลของคุณ
หากคุณมีความคุ้นเคยกับภาษาแบบไดนามิก เช่น Ruby, Python หรือ JavaScript คุณอาจไม่คุ้นเคยกับขั้นตอนการคอมไพล์และการรันที่แยกจากกัน Rust เป็นภาษาที่คอมไพล์ล่วงหน้า ซึ่งหมายความว่าคุณสามารถคอมไพล์โปรแกรม และส่งต่อไฟล์ที่ใช้รันให้กับคนอื่นได้ นอกจากนั้นพวกเขายังสามารถรันได้โดยไม่ต้องติดตั้ง Rust ในขณะที่ หากคุณให้ไฟล์ .rb, .py และ .js กับคนอื่น พวกเขาจำเป็นต้องติดตั้งโปรแกรมสำหรับรัน Ruby, Python หรือ JavaScript แต่ในภาษาเหล่านี้ คุณสามารถใช้เพียงคำสั่งเดียวในการคอมไพล์และรันโปรแกรมของคุณ ในการออกแบบภาษาแล้ว มีได้ย่อมมีเสีย
แค่คอมไพล์ด้วย rustc ก็เพียงพอแล้วสำหรับโปรแกรมง่าย ๆ แต่เมื่อโปรเจกต์ของคุณมีขนาดที่ใหญ่ขึ้น
คุณจะต้องการจัดการตัวเลือกทั้งหมดและทำให้การแบ่งปันโค้ดของคุณง่ายขึ้น
ถัดไป เราจะแนะนำให้คุณรู้จักกับเครื่องมือ Cargo ซึ่งจะช่วยคุณเขียนโปรแกรม Rust ในโลกแห่งความเป็นจริงได้