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

นำพาธเข้าสู่สโคปด้วยคำสงวน use

การต้องคอยเขียนพาธเต็มยาวๆ เพื่อเรียกใช้งานฟังก์ชันอาจทำให้รู้สึกไม่สะดวกและดูซ้ำซ้อน ในลิสติ้ง 7-7 ไม่ว่าเราจะเลือกใช้พาธแบบสัมบูรณ์หรือแบบสัมพัทธ์ในการเรียกฟังก์ชัน add_to_waitlist เราก็ยังต้องระบุ front_of_house และ hosting ทุกครั้งที่ต้องการเรียกใช้งาน แต่โชคดีที่ Rust มีวิธีช่วยลดทอนขั้นตอนนี้ให้เรียบง่ายขึ้น: นั่นคือเราสามารถสร้างทางลัดไปยังพาธนั้นด้วยคีย์เวิร์ด use เพียงครั้งเดียว จากนั้นก็สามารถใช้ชื่อที่สั้นลงได้ในทุกๆ จุดภายในสโคป (scope) นั้น

ในลิสติ้ง 7-11 เราได้นำมอดูล crate::front_of_house::hosting เข้ามาไว้ในสโคปของฟังก์ชัน eat_at_restaurant ทำให้เราสามารถเรียกใช้ฟังก์ชัน add_to_waitlist ได้อย่างสะดวก โดยระบุเพียงแค่ hosting::add_to_waitlist เท่านั้น

mod front_of_house {
    pub mod hosting {
        pub fn add_to_waitlist() {}
    }
}

use crate::front_of_house::hosting;

pub fn eat_at_restaurant() {
    hosting::add_to_waitlist();
}

การใส่คำสั่ง use พร้อมระบุพาธลงในสโคป เปรียบเสมือนการสร้างลิงก์เชิงสัญลักษณ์ (symbolic link) ในระบบไฟล์ เมื่อเราเพิ่มคำสั่ง use crate::front_of_house::hosting ไว้ที่รากของเครต ชื่อ hosting ก็จะกลายเป็นชื่อที่ใช้งานได้อย่างถูกต้องในสโคปนั้น ราวกับว่ามอดูล hosting ถูกนิยามขึ้นที่รากของเครตโดยตรง และพาธที่นำเข้ามาด้วย use ก็ยังคงถูกตรวจสอบกฎความเป็นส่วนตัว (privacy) อย่างเข้มงวดเช่นเดียวกับพาธอื่นๆ

โปรดสังเกตว่า use จะสร้างทางลัดให้เฉพาะสำหรับสโคปที่คำสั่ง use นั้นปรากฏอยู่เท่านั้น ในลิสติ้ง 7-12 ได้มีการย้ายฟังก์ชัน eat_at_restaurant ไปไว้ในมอดูลลูกใหม่ชื่อ customer ซึ่งกลายเป็นคนละสโคปกับสเตตเมนต์ use เดิม ส่งผลให้โค้ดภายในฟังก์ชันคอมไพล์ไม่ผ่าน

mod front_of_house {
    pub mod hosting {
        pub fn add_to_waitlist() {}
    }
}

use crate::front_of_house::hosting;

mod customer {
    pub fn eat_at_restaurant() {
        hosting::add_to_waitlist();
    }
}

ข้อผิดพลาดจากคอมไพเลอร์ชี้ให้เห็นว่า ทางลัดดังกล่าวไม่สามารถใช้งานได้อีกต่อไปเมื่ออยู่ภายในมอดูล customer:

$ cargo build
   Compiling restaurant v0.1.0 (file:///projects/restaurant)
error[E0433]: cannot find module or crate `hosting` in this scope
  --> src/lib.rs:11:9
   |
11 |         hosting::add_to_waitlist();
   |         ^^^^^^^ use of unresolved module or unlinked crate `hosting`
   |
   = help: if you wanted to use a crate named `hosting`, use `cargo add hosting` to add it to your `Cargo.toml`
help: consider importing this module through its public re-export
   |
10 +     use crate::hosting;
   |

warning: unused import: `crate::front_of_house::hosting`
 --> src/lib.rs:7:5
  |
7 | use crate::front_of_house::hosting;
  |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  |
  = note: `#[warn(unused_imports)]` (part of `#[warn(unused)]`) on by default

For more information about this error, try `rustc --explain E0433`.
warning: `restaurant` (lib) generated 1 warning
error: could not compile `restaurant` (lib) due to 1 previous error; 1 warning emitted

สังเกตว่าคอมไพเลอร์ยังได้แจ้งเตือน (warning) อีกด้วยว่า คำสั่ง use นั้นไม่ได้ถูกใช้งานในสโคปเดิมของมันแล้ว! วิธีแก้ไขปัญหานี้คือ การย้ายคำสั่ง use เข้าไปไว้ในมอดูล customer ด้วยเช่นกัน หรือเลือกอ้างอิงทางลัดที่อยู่ในมอดูลแม่ผ่านคำว่า super::hosting จากภายในมอดูลลูก customer

การสร้างพาธ use ตามสำนวนนิยม

ในลิสติ้ง 7-11 คุณอาจสงสัยว่า ทำไมเราถึงเขียน use crate::front_of_house::hosting แล้วค่อยเรียก hosting::add_to_waitlist ใน eat_at_restaurant แทนที่จะระบุพาธของ use ให้ยาวไปจนถึงฟังก์ชัน add_to_waitlist เลย เพื่อให้สามารถเรียกชื่อฟังก์ชันโดดๆ ได้เหมือนในลิสติ้ง 7-13

mod front_of_house {
    pub mod hosting {
        pub fn add_to_waitlist() {}
    }
}

use crate::front_of_house::hosting::add_to_waitlist;

pub fn eat_at_restaurant() {
    add_to_waitlist();
}

แม้ว่าทั้งลิสติ้ง 7-11 และลิสติ้ง 7-13 จะให้ผลลัพธ์การทำงานที่เหมือนกันทุกประการ แต่แนวทางในลิสติ้ง 7-11 ถือเป็น สำนวนนิยม (idiomatic way) ในการนำฟังก์ชันเข้าสู่สโคปด้วย use เพราะการนำเฉพาะมอดูลแม่ของฟังก์ชันเข้ามาในสโคป จะบีบให้เราต้องระบุชื่อมอดูลแม่ตอนเรียกใช้งานฟังก์ชันเสมอ ซึ่งการระบุชื่อมอดูลแม่ตอนเรียกฟังก์ชันนั้นจะช่วยให้ผู้อ่านโค้ดเข้าใจได้อย่างชัดเจนทันทีว่า ฟังก์ชันนี้ไม่ได้ถูกนิยามขึ้นภายในไฟล์หรือมอดูลปัจจุบัน ในขณะเดียวกันก็ยังช่วยลดความเยิ่นเย้อของการพิมพ์พาธแบบเต็มลงไปได้มาก ตรงกันข้ามกับโค้ดในลิสติ้ง 7-13 ที่มองเผินๆ จะไม่ชัดเจนเลยว่า add_to_waitlist ถูกนิยามมาจากที่ใด

ในทางกลับกัน เมื่อเป็นการนำ struct, enum หรือไอเทมอื่นๆ เข้าสู่สโคปด้วย use สำนวนนิยมกลับเป็นการระบุพาธแบบเต็มไปจนถึงตัวไอเทมนั้นๆ ลิสติ้ง 7-14 แสดงแนวทางตามสำนวนนิยมในการนำ struct HashMap ของไลบรารีมาตรฐานเข้ามาใช้งานในสโคปของเครตไบนารี

use std::collections::HashMap;

fn main() {
    let mut map = HashMap::new();
    map.insert(1, 2);
}

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

อย่างไรก็ตาม ข้อยกเว้นสำหรับสำนวนนิยมนี้คือ กรณีที่เราจำเป็นต้องนำไอเทม 2 ตัวที่มีชื่อซ้ำกันเข้ามาไว้ในสโคปด้วยคำสั่ง use เนื่องจาก Rust ไม่อนุญาตให้มีชื่อซ้ำกันในสโคปเดียวกัน ลิสติ้ง 7-15 แสดงตัวอย่างการนำชนิดข้อมูล Result 2 ตัวที่มีชื่อเหมือนกันแต่อยู่คนละมอดูลแม่เข้ามาใช้งานในสโคปเดียวกัน พร้อมทั้งวิธีเรียกใช้งานพวกมัน

use std::fmt;
use std::io;

fn function1() -> fmt::Result {
    // --snip--
    Ok(())
}

fn function2() -> io::Result<()> {
    // --snip--
    Ok(())
}

ดังที่คุณจะเห็นได้ว่า การอ้างอิงผ่านมอดูลแม่ช่วยให้สามารถแยกแยะความแตกต่างระหว่างชนิดข้อมูล Result ทั้งสองตัวได้อย่างชัดเจน หากเราเปลี่ยนไปเขียนเป็น use std::fmt::Result; และ use std::io::Result; เราจะมีชนิดข้อมูลชื่อ Result 2 ตัวอยู่ในสโคปเดียวกัน ซึ่ง Rust จะไม่สามารถรู้ได้เลยว่าเมื่อเราเขียนคำว่า Result เราหมายถึงตัวใดกันแน่

การตั้งชื่อใหม่ด้วยคำสงวน as

ยังมีอีกวิธีหนึ่งที่ช่วยแก้ปัญหาการนำสองชนิดข้อมูลที่มีชื่อซ้ำกันเข้ามาในสโคปเดียวกันด้วย use: นั่นคือเราสามารถใส่คำว่า as ต่อท้ายพาธ แล้วตามด้วยชื่อเรียกเฉพาะในสโคปนั้น หรือ นามแฝง (alias) สำหรับชนิดข้อมูลดังกล่าว ลิสติ้ง 7-16 แสดงอีกหนึ่งทางเลือกในการเขียนโค้ดของลิสติ้ง 7-15 โดยการเปลี่ยนชื่อชนิดข้อมูล Result ตัวใดตัวหนึ่งด้วย as

use std::fmt::Result;
use std::io::Result as IoResult;

fn function1() -> Result {
    // --snip--
    Ok(())
}

fn function2() -> IoResult<()> {
    // --snip--
    Ok(())
}

ในคำสั่ง use บรรทัดที่สอง เราได้ตั้งชื่อใหม่ให้กับชนิดข้อมูล std::io::Result ว่า IoResult ซึ่งจะไม่ชนกับชื่อ Result จาก std::fmt ที่เรานำเข้ามาในสโคปด้วย ทั้งรูปแบบในลิสติ้ง 7-15 และลิสติ้ง 7-16 ต่างถือเป็นสำนวนนิยมที่ยอมรับได้ทั้งคู่ คุณจึงสามารถเลือกใช้ได้ตามความเหมาะสมและความชอบของคุณ!

การส่งออกชื่ออีกครั้งด้วย pub use

เมื่อเรานำชื่อใดๆ เข้ามาไว้ในสโคปด้วยคีย์เวิร์ด use ชื่อนั้นจะมีสถานะเป็นแบบส่วนตัว (private) ต่อสโคปที่เรานำมันเข้ามาโดยอัตโนมัติ หากเราต้องการเปิดโอกาสให้โค้ดภายนอกสโคปนั้นสามารถอ้างอิงถึงชื่อดังกล่าวได้ ราวกับว่ามันถูกนิยามขึ้นในสโคปนั้นโดยตรง เราสามารถนำ pub และ use มารวมเข้าด้วยกันได้ ซึ่งเทคนิคนี้เรียกว่า การส่งออกอีกครั้ง (re-exporting) เพราะเราไม่ได้เพียงแค่นำไอเทมนั้นเข้ามาไว้ในสโคปของเราเท่านั้น แต่เรายังเปิดทางให้ผู้อื่นสามารถนำไอเทมนั้นไปใช้ต่อในสโคปของพวกเขาได้อีกด้วย

ลิสติ้ง 7-17 แสดงโค้ดจากลิสติ้ง 7-11 โดยเปลี่ยนคำสั่ง use ในมอดูลรากให้กลายเป็น pub use

mod front_of_house {
    pub mod hosting {
        pub fn add_to_waitlist() {}
    }
}

pub use crate::front_of_house::hosting;

pub fn eat_at_restaurant() {
    hosting::add_to_waitlist();
}

ก่อนหน้าที่จะทำการเปลี่ยนแปลงนี้ โค้ดภายนอกจะต้องเรียกฟังก์ชัน add_to_waitlist ผ่านพาธเต็มอย่าง restaurant::front_of_house::hosting::add_to_waitlist() ซึ่งบังคับว่ามอดูล front_of_house จะต้องถูกกำหนดให้เป็น pub ด้วย แต่เมื่อเราใช้ pub use เพื่อส่งออกมอดูล hosting ออกมาจากมอดูลรากอีกครั้ง โค้ดภายนอกก็สามารถเรียกใช้ผ่านพาธที่สั้นลงอย่าง restaurant::hosting::add_to_waitlist() ได้ทันที

การส่งออกชื่ออีกครั้งนี้มีประโยชน์อย่างยิ่งเมื่อโครงสร้างภายในของโค้ดที่คุณเขียน แตกต่างจากมุมมองของโปรแกรมเมอร์ที่จะเข้ามาเรียกใช้โค้ดของคุณ ตัวอย่างเช่น ในการเปรียบเทียบร้านอาหาร ผู้บริหารร้านอาหารอาจคิดแยกเป็นส่วน “หน้าร้าน (front of house)” และ “หลังร้าน (back of house)” แต่ลูกค้าที่เข้ามาใช้บริการในร้านย่อมไม่ได้มองส่วนต่างๆ ของร้านในแง่มุมนั้น ด้วยการใช้ pub use เราจึงสามารถเขียนจัดโครงสร้างโค้ดภายในในรูปแบบหนึ่ง แต่เปิดเผยอินเทอร์เฟซภายนอกออกมาอีกรูปแบบหนึ่งได้ ซึ่งช่วยให้ไลบรารีของเราจัดระเบียบได้อย่างสวยงาม ทั้งสำหรับโปรแกรมเมอร์ที่พัฒนาตัวไลบรารี และสำหรับโปรแกรมเมอร์ที่นำไลบรารีไปเรียกใช้งาน เราจะได้เห็นอีกหนึ่งตัวอย่างของการใช้ pub use และผลกระทบต่อเอกสารประกอบเครตของคุณในหัวข้อ “การส่งออก API สาธารณะที่สะดวกต่อการใช้งาน” ในบทที่ 14

การใช้แพ็กเกจภายนอก

ในบทที่ 2 เราได้พัฒนาโปรเจกต์เกมทายตัวเลขซึ่งมีการเรียกใช้แพ็กเกจภายนอกชื่อ rand เพื่อสุ่มตัวเลข และในการนำ rand มาใช้งานในโปรเจกต์ เราได้เพิ่มบรรทัดนี้ลงในไฟล์ Cargo.toml:

rand = "0.10.1"

การเพิ่ม rand เป็นดีเพนเดนซี (dependency) ใน Cargo.toml จะเป็นการบอกให้ Cargo ช่วยดาวน์โหลดแพ็กเกจ rand ตลอดจนดีเพนเดนซีอื่นๆ ที่เกี่ยวข้องมาจาก crates.io และเตรียม rand ให้พร้อมสำหรับเรียกใช้งานในโปรเจกต์ของเรา

จากนั้น เพื่อนำนิยามต่างๆ ของ rand เข้ามาไว้ในสโคปของแพ็กเกจ เราจึงเพิ่มบรรทัด use ที่ขึ้นต้นด้วยชื่อเครต rand พร้อมระบุไอเทมที่ต้องการนำเข้ามา ย้อนกลับไปในหัวข้อ “การสร้างตัวเลขสุ่ม” ในบทที่ 2 เราได้นำไอเทมในมอดูลพรีลูด rand::prelude เข้าสู่สโคป และเรียกใช้งานฟังก์ชัน rand::rng:

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}");
}

สมาชิกในชุมชน Rust ได้ร่วมกันแบ่งปันแพ็กเกจที่มีประโยชน์ไว้มากมายบน crates.io และขั้นตอนในการดึงแพ็กเกจเหล่านั้นมาใช้งานในโปรเจกต์ของคุณก็ใช้วิธีการเดียวกันทั้งหมด: นั่นคือระบุชื่อแพ็กเกจในไฟล์ Cargo.toml ของคุณ แล้วใช้คำสั่ง use เพื่อนำไอเทมจากเครตเหล่านั้นเข้ามาในสโคป

โปรดทราบว่า ไลบรารีมาตรฐาน std ก็ถือเป็นเครตตัวหนึ่งที่อยู่ภายนอกแพ็กเกจของเราเช่นกัน เพียงแต่เนื่องจากไลบรารีมาตรฐานถูกติดตั้งมาพร้อมกับตัวภาษา Rust อยู่แล้ว เราจึงไม่จำเป็นต้องไปแก้ไขไฟล์ Cargo.toml เพื่อรวม std เข้ามา แต่เรายังคงจำเป็นต้องใช้คำสั่ง use เพื่อดึงไอเทมจากในนั้นเข้ามาไว้ในสโคปของโปรเจกต์เรา เช่น การใช้งาน HashMap เราจะต้องเขียนคำสั่งดังนี้:

#![allow(unused)]
fn main() {
use std::collections::HashMap;
}

ซึ่งนี่คือพาธแบบสัมบูรณ์ (absolute path) ที่เริ่มต้นด้วย std อันเป็นชื่อของเครตไลบรารีมาตรฐานนั่นเอง

การใช้พาธแบบซ้อนเพื่อจัดระเบียบรายการ use

หากเรามีการเรียกใช้หลายๆ ไอเทมที่นิยามอยู่ภายใต้เครตเดียวกันหรือมอดูลเดียวกัน การเขียนคำสั่งแยกบรรทัดละหนึ่งไอเทมอาจทำให้เปลืองพื้นที่ตามแนวตั้งในไฟล์โค้ดของเราอย่างมาก ตัวอย่างเช่น สเตตเมนต์ use 2 บรรทัดที่เราเคยใช้ในเกมทายตัวเลขในลิสติ้ง 2-4 เพื่อนำไอเทมจาก std เข้าสู่สโคป:

// --snip--
use std::cmp::Ordering;
use std::io;
// --snip--

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}");

    match guess.cmp(&secret_number) {
        Ordering::Less => println!("Too small!"),
        Ordering::Greater => println!("Too big!"),
        Ordering::Equal => println!("You win!"),
    }
}

แต่เราสามารถใช้ พาธแบบซ้อน (nested paths) เพื่อนำไอเทมเหล่านั้นเข้ามาในสโคปพร้อมกันภายในบรรทัดเดียวได้ โดยการระบุส่วนของพาธที่เหมือนกันไว้ข้างหน้า ตามด้วยเครื่องหมายโคลอนคู่ (::) จากนั้นเปิดวงเล็บปีกกาครอบรายการของพาธส่วนที่แตกต่างกันเอาไว้ ดังที่แสดงในลิสติ้ง 7-18

use rand::prelude::*;
// --snip--
use std::{cmp::Ordering, io};
// --snip--

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");

    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!"),
    }
}

ในโปรแกรมขนาดใหญ่ การนำไอเทมจำนวนมากจากเครตหรือมอดูลเดียวกันเข้ามาในสโคปโดยใช้พาธแบบซ้อน จะช่วยลดจำนวนบรรทัดของสเตตเมนต์ use ลงไปได้อย่างมหาศาล!

เราสามารถใช้พาธแบบซ้อนได้ในทุกระดับของพาธ ซึ่งมีประโยชน์อย่างมากเมื่อต้องรวมสเตตเมนต์ use 2 บรรทัดที่มีพาธย่อย (subpath) ร่วมกัน ตัวอย่างเช่น ลิสติ้ง 7-19 แสดงสเตตเมนต์ use 2 บรรทัด: โดยบรรทัดหนึ่งนำ std::io เข้าสู่สโคป และอีกบรรทัดนำ std::io::Write เข้าสู่สโคป

use std::io;
use std::io::Write;

ส่วนที่ซ้ำกันของทั้งสองพาธนี้คือ std::io ซึ่งตรงกับพาธแรกทั้งหมด หากต้องการรวมพาธทั้งสองนี้เข้าเป็นคำสั่ง use เดียว เราสามารถใช้คำว่า self ไว้ภายในพาธแบบซ้อนได้ ดังแสดงในลิสติ้ง 7-20

use std::io::{self, Write};

คำสั่งบรรทัดนี้จะนำทั้ง std::io และ std::io::Write เข้ามาไว้ในสโคปพร้อมกันทันที

การนำเข้ารายการด้วยตัวดำเนินการ glob

หากเราต้องการนำไอเทมสาธารณะ (public) ทั้งหมด ที่นิยามอยู่ภายใต้พาธหนึ่งเข้ามาไว้ในสโคป เราสามารถระบุพาธนั้นแล้วตามด้วยตัวดำเนินการ glob (glob operator) คือเครื่องหมายดอกจัน *:

#![allow(unused)]
fn main() {
use std::collections::*;
}

สเตตเมนต์ use บรรทัดนี้จะนำทุกๆ ไอเทมสาธารณะที่นิยามอยู่ใน std::collections เข้ามาไว้ในสโคปปัจจุบันทั้งหมด แต่จงใช้ตัวดำเนินการ glob ด้วยความระมัดระวัง! เพราะ glob อาจทำให้ยากต่อการตรวจสอบว่ามีชื่ออะไรบ้างที่อยู่ในสโคป และชื่อแต่ละชื่อที่ถูกเรียกใช้ในโปรแกรมนั้นถูกนิยามมาจากที่ใดกันแน่ ยิ่งไปกว่านั้น หากดีเพนเดนซีภายนอกมีการปรับเปลี่ยนนิยามในเวอร์ชันใหม่ สิ่งที่คุณนำเข้ามาก็จะเปลี่ยนตามไปด้วย ซึ่งอาจก่อให้เกิดข้อผิดพลาดในการคอมไพล์เมื่อคุณอัปเกรดเวอร์ชันของดีเพนเดนซี ตัวอย่างเช่น หากดีเพนเดนซีนั้นเพิ่มนิยามใหม่ที่มีชื่อตรงกับชื่อที่คุณเคยนิยามไว้ในสโคปเดียวกัน

ตัวดำเนินการ glob มักถูกนำไปใช้ในกระบวนการเขียนเทสต์ เพื่อนำโค้ดทั้งหมดที่ต้องการทดสอบเข้ามาไว้ในมอดูล tests ซึ่งเราจะได้เรียนรู้กันในหัวข้อ “วิธีเขียนเทสต์” ในบทที่ 11 นอกจากนี้ ตัวดำเนินการ glob ยังถูกนำมาใช้เป็นส่วนหนึ่งของรูปแบบพรีลูด (prelude pattern) อีกด้วย โดยคุณสามารถดูรายละเอียดเพิ่มเติมได้ที่ เอกสารของไลบรารีมาตรฐาน