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, Cargo!

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

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

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

$ cargo --version

หากพบข้อความแสดงหมายเลขเวอร์ชัน แสดงว่าติดตั้งเรียบร้อยแล้ว! แต่หากพบข้อความแจ้งข้อผิดพลาดอย่าง command not found ให้เปิดดูคู่มือของวิธีการติดตั้งที่คุณใช้เพื่อดูวิธีติดตั้ง Cargo แยกต่างหาก

การสร้างโปรเจกต์ด้วย Cargo

มาลองสร้างโปรเจกต์ใหม่ด้วย Cargo และดูความแตกต่างระหว่างโปรเจกต์นี้กับโปรเจกต์ “Hello, world!” เดิมของเรากัน เริ่มจากกลับไปที่ไดเรกทอรี projects ของคุณ (หรือโฟลเดอร์ที่คุณเลือกใช้เก็บโค้ด) จากนั้นรันคำสั่งต่อไปนี้ในเทอร์มินัล:

$ cargo new hello_cargo
$ cd hello_cargo

คำสั่งแรกจะสร้างไดเรกทอรีและโปรเจกต์ใหม่ชื่อว่า hello_cargo โดย Cargo จะสร้างไฟล์โครงสร้างต่างๆ ไว้ภายในไดเรกทอรีชื่อเดียวกันนี้

เมื่อเข้าไปในไดเรกทอรี hello_cargo แล้วสั่งแสดงรายการไฟล์ คุณจะพบว่า Cargo ได้สร้างไฟล์ 2 ไฟล์และ 1 ไดเรกทอรีให้โดยอัตโนมัติ ได้แก่ ไฟล์ Cargo.toml และไดเรกทอรี src ซึ่งมีไฟล์ main.rs บรรจุอยู่ข้างใน

นอกจากนี้ Cargo ยังสร้างและตั้งค่าที่เก็บ Git (Git repository) เริ่มต้น พร้อมกับไฟล์ .gitignore ให้ทันที โดยไฟล์และประวัติ Git จะไม่ถูกสร้างขึ้นหากคุณรันคำสั่ง cargo new ภายในที่เก็บ Git ที่มีอยู่เดิมแล้ว ทั้งนี้ คุณสามารถเปลี่ยนพฤติกรรมนี้ได้ด้วยตัวเลือก cargo new --vcs=git

หมายเหตุ: Git เป็นระบบควบคุมเวอร์ชัน (version control system) ยอดนิยม คุณสามารถสั่งให้ cargo new ใช้ระบบควบคุมเวอร์ชันอื่นหรือไม่ใช้เลยก็ได้โดยระบุแฟล็ก --vcs สามารถรัน cargo new --help เพื่อดูตัวเลือกที่มีทั้งหมด

ลองเปิดไฟล์ Cargo.toml ด้วยโปรแกรมแก้ไขโค้ดที่คุณถนัด คุณจะเห็นเนื้อหาที่คล้ายคลึงกับโค้ดในลิสติ้ง 1-2

[package]
name = "hello_cargo"
version = "0.1.0"
edition = "2024"

[dependencies]

ไฟล์นี้ใช้รูปแบบข้อมูลแบบ TOML (Tom’s Obvious, Minimal Language) ซึ่งเป็นรูปแบบไฟล์การตั้งค่ามาตรฐานของ Cargo

บรรทัดแรก [package] เป็นหัวข้อกำกับส่วน (section header) ที่ระบุว่าคำสั่งถัดจากนี้ไปเป็นการตั้งค่าแพ็กเกจ เมื่อเราต้องการระบุข้อมูลอื่นๆ เพิ่มเติมในไฟล์นี้ เราจะเพิ่มส่วนใหม่อื่นๆ ตามมา

สามบรรทัดถัดมาเป็นการกำหนดค่าที่ Cargo จำเป็นต้องใช้ในการคอมไพล์โปรแกรมของคุณ ได้แก่ ชื่อโปรเจกต์ เวอร์ชัน และฉบับของภาษา Rust (edition) ที่ต้องการใช้งาน เราจะพูดถึงคีย์ edition อย่างละเอียดในภาคผนวก E

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

ตอนนี้ลองเปิดไฟล์ src/main.rs ขึ้นมาดู:

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

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

Cargo ได้สร้างโปรแกรม “Hello, world!” ให้คุณเรียบร้อยแล้ว ซึ่งมีหน้าตาเหมือนกับโค้ดที่เราเขียนเองในลิสติ้ง 1-1 ทุกประการ! จุดที่แตกต่างระหว่างโปรเจกต์เดิมกับโปรเจกต์ที่สร้างด้วย Cargo มีเพียงการที่ Cargo นำโค้ดไปจัดเก็บไว้ในไดเรกทอรี src และมีไฟล์การตั้งค่า Cargo.toml อยู่ที่ไดเรกทอรีหลักด้านนอกสุด

Cargo กำหนดมาตรฐานไว้ว่าไฟล์ซอร์สโค้ดของคุณควรอยู่ภายในไดเรกทอรี src เสมอ ส่วนไดเรกทอรีโปรเจกต์ระดับบนสุดจะมีไว้สำหรับเก็บไฟล์ README ข้อมูลสัญญาอนุญาต (license) ไฟล์การตั้งค่าต่างๆ และสิ่งอื่นๆ ที่ไม่ใช่ซอร์สโค้ด การจัดระเบียบตามแนวทางของ Cargo ช่วยให้โปรเจกต์ของคุณเป็นระเบียบเรียบร้อย ทุกสิ่งมีที่อยู่ของตัวเองอย่างชัดเจน

หากคุณเริ่มโปรเจกต์โดยไม่ได้ใช้ Cargo มาก่อน เหมือนอย่างที่เราทำกับโปรเจกต์ “Hello, world!” ก่อนหน้านี้ คุณสามารถเปลี่ยนมาใช้ Cargo ได้ง่ายๆ เพียงย้ายโค้ดทั้งหมดเข้าไปไว้ในไดเรกทอรี src แล้วสร้างไฟล์ Cargo.toml ขึ้นมา ซึ่งวิธีที่สะดวกที่สุดคือการรันคำสั่ง cargo init ในไดเรกทอรีโปรเจกต์ แล้วระบบจะสร้างโครงสร้างที่จำเป็นให้โดยอัตโนมัติ

การบิลด์และรันโปรเจกต์ Cargo

คราวนี้มาดูความแตกต่างเมื่อเราสั่งบิลด์และรันโปรแกรม “Hello, world!” ผ่าน Cargo กัน! จากภายในไดเรกทอรี hello_cargo ให้สั่งบิลด์โปรเจกต์ด้วยคำสั่งต่อไปนี้:

$ cargo build
   Compiling hello_cargo v0.1.0 (file:///projects/hello_cargo)
    Finished dev [unoptimized + debuginfo] target(s) in 2.85 secs

คำสั่งนี้จะสร้างไฟล์โปรแกรมที่รันได้ขึ้นมาใน target/debug/hello_cargo (หรือ target\debug\hello_cargo.exe บน Windows) แทนที่จะสร้างไว้ในไดเรกทอรีปัจจุบัน เนื่องจากการบิลด์ตามค่าเริ่มต้นจะเป็นโหมดดีบัก Cargo จึงจัดเก็บไฟล์ไบนารีไว้ในไดเรกทอรีชื่อ debug คุณสามารถสั่งรันโปรแกรมดังกล่าวได้ด้วยคำสั่งนี้:

$ ./target/debug/hello_cargo # or .\target\debug\hello_cargo.exe on Windows
Hello, world!

หากทุกอย่างเรียบร้อย ข้อความ Hello, world! จะปรากฏขึ้นบนเทอร์มินัลของคุณ นอกจากนี้ การรันคำสั่ง cargo build เป็นครั้งแรกจะทำให้ Cargo สร้างไฟล์ใหม่ขึ้นมาที่ไดเรกทอรีระดับบนสุด นั่นคือ Cargo.lock ไฟล์นี้ทำหน้าที่บันทึกเวอร์ชันที่แน่นอนของดีเพนเดนซีต่างๆ ในโปรเจกต์ของคุณ เนื่องจากโปรเจกต์นี้ยังไม่มีดีเพนเดนซี ไฟล์นี้จึงแทบจะว่างเปล่า คุณไม่จำเป็นต้องเข้าไปแก้ไขไฟล์นี้ด้วยตนเองแต่อย่างใด เพราะ Cargo จะจัดการเนื้อหาภายในไฟล์นี้ให้คุณโดยอัตโนมัติ

เมื่อสักครู่เราสั่งบิลด์โปรเจกต์ด้วย cargo build แล้วสั่งรันด้วย ./target/debug/hello_cargo แต่นอกจากนั้น เรายังสามารถใช้คำสั่ง cargo run เพื่อสั่งคอมไพล์โค้ดและรันโปรแกรมที่ได้ให้จบในคำสั่งเดียวได้ทันที:

$ cargo run
    Finished dev [unoptimized + debuginfo] target(s) in 0.0 secs
     Running `target/debug/hello_cargo`
Hello, world!

การใช้คำสั่ง cargo run สะดวกสบายกว่าการต้องคอยจำรัน cargo build แล้วค่อยพิมพ์พาธยาวๆ เพื่อเปิดไฟล์ไบนารี นักพัฒนาส่วนใหญ่จึงนิยมใช้ cargo run เป็นหลัก

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

$ cargo run
   Compiling hello_cargo v0.1.0 (file:///projects/hello_cargo)
    Finished dev [unoptimized + debuginfo] target(s) in 0.33 secs
     Running `target/debug/hello_cargo`
Hello, world!

นอกจากนี้ Cargo ยังมีคำสั่ง cargo check ซึ่งทำหน้าที่ตรวจสอบโค้ดของคุณอย่างรวดเร็วเพื่อให้มั่นใจว่าโค้ดคอมไพล์ผ่าน โดยไม่เสียเวลาสร้างไฟล์โปรแกรมที่รันได้ออกมา:

$ cargo check
   Checking hello_cargo v0.1.0 (file:///projects/hello_cargo)
    Finished dev [unoptimized + debuginfo] target(s) in 0.32 secs

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

มาสรุปสิ่งที่เราได้เรียนรู้เกี่ยวกับ Cargo จนถึงตอนนี้กัน:

  • เราสามารถสร้างโปรเจกต์ใหม่ได้ด้วย cargo new
  • เราสามารถบิลด์โปรเจกต์ได้ด้วย cargo build
  • เราสามารถบิลด์และรันโปรเจกต์ได้ในขั้นตอนเดียวด้วย cargo run
  • เราสามารถตรวจสอบข้อผิดพลาดในโค้ดโดยไม่ต้องสร้างไฟล์ไบนารีได้ด้วย cargo check
  • แทนที่จะเก็บผลลัพธ์การบิลด์ไว้ปะปนกับโค้ด Cargo จะจัดเก็บไว้ในไดเรกทอรี target/debug อย่างเป็นสัดส่วน

ข้อดีที่สำคัญอีกประการหนึ่งของ Cargo คือคำสั่งต่างๆ จะทำงานเหมือนกันในทุกระบบปฏิบัติการ ดังนั้นนับจากจุดนี้เป็นต้นไป เราจะไม่ต้องแยกคำสั่งระหว่าง Linux, macOS และ Windows อีกต่อไป

การบิลด์สำหรับการรีลีส

เมื่อโปรเจกต์ของคุณพัฒนาจนพร้อมสำหรับการเผยแพร่ใช้งานจริงในที่สุด คุณสามารถใช้คำสั่ง cargo build --release เพื่อคอมไพล์โค้ดพร้อมเปิดใช้งานการปรับแต่งประสิทธิภาพ (optimizations) คำสั่งนี้จะสร้างไฟล์โปรแกรมที่รันได้ไว้ใน target/release แทนที่จะเป็น target/debug การเปิดใช้ตัวเลือกปรับแต่งประสิทธิภาพจะช่วยให้โค้ด Rust ของคุณทำงานได้รวดเร็วขึ้นอย่างมาก แต่ก็จะแลกมาด้วยระยะเวลาในการคอมไพล์ที่ยาวนานขึ้น ด้วยเหตุนี้ Cargo จึงแบ่งโหมดการทำงานออกเป็นสองโปรไฟล์: โปรไฟล์สำหรับการพัฒนา (development) เพื่อให้คอมไพล์ซ้ำได้บ่อยๆ อย่างรวดเร็ว และโปรไฟล์สำหรับการบิลด์เวอร์ชันสุดท้ายเพื่อส่งมอบให้ผู้ใช้งาน ซึ่งไม่ต้องบิลด์ซ้ำบ่อยและต้องการประสิทธิภาพการทำงานที่เร็วที่สุด หากคุณต้องการวัดประสิทธิภาพความเร็ว (benchmark) ในการรันโค้ด อย่าลืมบิลด์ด้วย cargo build --release แล้วทดสอบกับไฟล์ที่อยู่ใน target/release เสมอ

ใช้ประโยชน์จากธรรมเนียมปฏิบัติของ Cargo

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

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

$ git clone example.org/someproject
$ cd someproject
$ cargo build

สำหรับข้อมูลเพิ่มเติมเกี่ยวกับ Cargo สามารถศึกษาได้จากคู่มือการใช้งานของ Cargo

สรุป

คุณได้เริ่มต้นก้าวแรกบนเส้นทางของ Rust ได้อย่างยอดเยี่ยมแล้ว! ในบทนี้ คุณได้เรียนรู้วิธีการ:

  • ติดตั้ง Rust เวอร์ชันเสถียรล่าสุดด้วย rustup
  • อัปเดต Rust ให้เป็นเวอร์ชันใหม่อยู่เสมอ
  • เปิดอ่านเอกสารคู่มือที่ติดตั้งไว้ในเครื่อง
  • เขียนและสั่งรันโปรแกรม “Hello, world!” ด้วย rustc โดยตรง
  • สร้างและสั่งรันโปรเจกต์ใหม่ตามแบบแผนมาตรฐานของ Cargo

นี่เป็นจังหวะเวลาที่ดีในการเริ่มต้นสร้างโปรแกรมที่มีความสมบูรณ์ยิ่งขึ้น เพื่อฝึกฝนทักษะการอ่านและเขียนโค้ด Rust ให้คุ้นเคย ในบทที่ 2 เราจะร่วมกันสร้างโปรเจกต์เกมทายตัวเลข แต่หากคุณต้องการเริ่มต้นด้วยการทำความเข้าใจแนวคิดพื้นฐานทั่วไปในการเขียนโปรแกรมของ Rust ก่อน สามารถข้ามไปอ่านบทที่ 3 แล้วค่อยย้อนกลับมาทำโปรเจกต์ในบทที่ 2 ได้เช่นกัน