package，crate，module

rust提供了非常優(yōu)秀的包管理器cargo，我們可以使用crate，module，package來組織代碼。

crate

crate是rust在編譯時最小的單元。crate可以包含模塊，模塊可以定義在其他文件，然后和crate一起編譯。

crate 有兩種形式：二進(jìn)制項和庫。二進(jìn)制項 可以被編譯為可執(zhí)行程序，比如一個命令行程序或者一個服務(wù)器。它們必須有一個 main 函數(shù)來定義當(dāng)程序被執(zhí)行的時候所需要做的事情。目前我們所創(chuàng)建的 crate 都是二進(jìn)制項。

庫 并沒有 main 函數(shù)，它們也不會編譯為可執(zhí)行程序，它們提供一些諸如函數(shù)之類的東西，使其他項目也能使用這些東西。crate庫和其它編程語言中的library概念一致。

crate root 是一個源文件，Rust 編譯器在crate根文件中尋找需要被編譯的代碼。

package

package是提供一系列功能的一個或者多個 crate。一個package會包含一個 Cargo.toml 文件，闡述如何去構(gòu)建這些 crate。package中可以包含至多一個庫 crate(library crate)。package中可以包含任意多個二進(jìn)制 crate(binary crate)，但是必須至少包含一個 crate（無論是庫的還是二進(jìn)制的）。

當(dāng)我們使用cargo new的時候，就會創(chuàng)建一個package。Cargo 會給我們的package創(chuàng)建一個 Cargo.toml 文件。查看 Cargo.toml 的內(nèi)容，會發(fā)現(xiàn)并沒有提到 src/main.rs，因為 Cargo 遵循的一個約定：src/main.rs 就是一個與package同名的二進(jìn)制 crate 的 crate 根。同樣的，Cargo 知道如果包目錄中包含 src/lib.rs，則package帶有與其同名的庫 crate，且 src/lib.rs 是 crate 根。crate 根文件將由 Cargo 傳遞給 rustc 來實際構(gòu)建庫或者二進(jìn)制項目。

模塊 Module

使用模塊可以將 crate 中的代碼按照功能性進(jìn)行重組，最終實現(xiàn)更好的可讀性及易用性。同時，我們還能非常靈活地去控制代碼的可見性，進(jìn)一步強(qiáng)化 Rust 的安全性。在crate根文件中，你可以聲明module，例如使用mod garden聲明一個叫做garden的模塊。下面是一個例子，用來說明package，crate，module分別都是什么。
首先，我們使用cargo new --lib restaurant，來創(chuàng)建一個新的名為 restaurant 的庫，并在src/lib.rs中寫入下面的代碼

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

        fn seat_at_table() {}
    }

    mod serving {
        fn take_order() {}

        fn serve_order() {}

        fn take_payment() {}
    }
}

我們定義一個模塊，是以 mod 關(guān)鍵字為起始，然后指定模塊的名字（本例中叫做 front_of_house），并且用花括號包圍模塊的主體。在模塊內(nèi)，我們還可以定義其他的模塊，就像本例中的 hosting 和 serving 模塊。模塊還可以保存一些定義的其他項，比如結(jié)構(gòu)體、枚舉、常量、特性、或者函數(shù)。

通過使用模塊，我們可以將相關(guān)的定義分組到一起，并指出他們?yōu)槭裁聪嚓P(guān)。程序員可以通過使用這段代碼，更加容易地找到他們想要的定義，因為他們可以基于分組來對代碼進(jìn)行導(dǎo)航，而不需要閱讀所有的定義。程序員向這段代碼中添加一個新的功能時，他們也會知道代碼應(yīng)該放置在何處，可以保持程序的組織性。

上面這段代碼在front_of_house中定義了兩個子模塊hosting和serving，在子模塊內(nèi)部又分別定義了多個函數(shù)。整個結(jié)構(gòu)看起來就像一棵樹。和我們的電腦上文件系統(tǒng)的目錄樹非常類似。你可以使用模塊來組織你的代碼。

一個項目的模塊樹可能如下所示。在一個package下可以有多個crate，crate下可以有多個module。

package
└──crate
    └── front_of_house
        ├── hosting
        │   ├── add_to_waitlist
        │   └── seat_at_table
        └── serving
            ├── take_order
            ├── serve_order
            └── take_payment

引用module路徑

上面的代碼組織方法構(gòu)成了一個模塊樹， 而 rust 在模塊樹中找到一個項的位置是使用路徑的方式，就像在文件系統(tǒng)使用路徑一樣。為了調(diào)用一個函數(shù)，我們需要知道它的路徑。

路徑有兩種形式：

• 絕對路徑（absolute path）是以 crate 根（root）開頭的全路徑；對于外部 crate 的代碼，是以 crate 名開頭的絕對路徑，對于對于當(dāng)前 crate 的代碼，則以字面值 crate 開頭。
• 相對路徑（relative path）從當(dāng)前模塊開始，以 self、super 或當(dāng)前模塊的標(biāo)識符開頭。

絕對路徑和相對路徑都后跟一個或多個由雙冒號（::）分割的標(biāo)識符。

假設(shè)我們希望調(diào)用 add_to_waitlist 函數(shù)，該如何做？我們在 crate 根定義了一個新函數(shù) eat_at_restaurant，并在其中展示調(diào)用 add_to_waitlist 函數(shù)的兩種方法。

// lib.rs
pub fn eat_at_restaurant() {
    // 絕對路徑
    crate::front_of_house::hosting::add_to_waitlist();

    // 相對路徑
    front_of_house::hosting::add_to_waitlist();
}

此時，你會發(fā)現(xiàn)編輯器報錯了，你無法編譯通過(cargo build)。編譯器告訴你

module `hosting` is private

錯誤信息說 hosting 模塊是私有的。換句話說，我們擁有 hosting 模塊和 add_to_waitlist 函數(shù)的的正確路徑，但是 Rust 不讓我們使用，因為它不能訪問私有片段。在 Rust 中，默認(rèn)所有項（函數(shù)、方法、結(jié)構(gòu)體、枚舉、模塊和常量）對父模塊都是私有的。如果希望創(chuàng)建一個私有函數(shù)或結(jié)構(gòu)體，你可以將其放入一個模塊。

父模塊中的項不能使用子模塊中的私有項，但是子模塊中的項可以使用他們父模塊中的項。

Rust 選擇以這種方式來實現(xiàn)模塊系統(tǒng)功能，因此默認(rèn)隱藏內(nèi)部實現(xiàn)細(xì)節(jié)。這樣一來，你就知道可以更改內(nèi)部代碼的哪些部分而不會破壞外部代碼。不過 Rust 也提供了通過使用 pub 關(guān)鍵字來創(chuàng)建公共項，使子模塊的內(nèi)部部分暴露給上級模塊。

修改上面的代碼，給hosting模塊前面加上pub關(guān)鍵字來試試。

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

        fn seat_at_table() {}
    }

    mod serving {
        fn take_order() {}

        fn serve_order() {}

        fn take_payment() {}
    }
}


fn eat_at_restaurant() {
    // 絕對路徑
    crate::front_of_house::hosting::add_to_waitlist();

    // 相對路徑
    front_of_house::hosting::add_to_waitlist();
}

這時，你發(fā)現(xiàn)編輯器的報錯從hosting變成了add_to_waitlist了。還是不能通過cargo build。這表明使模塊公有并不使其內(nèi)容也是公有。模塊上的 pub 關(guān)鍵字只允許其父模塊引用它，而不允許訪問內(nèi)部代碼。因為模塊是一個容器，只是將模塊變?yōu)楣心茏龅钠鋵嵅⒉惶?；同時需要更深入地選擇將一個或多個項變?yōu)楣小?/p>

那么OK，我們再給add_to_waitlist函數(shù)加上pub關(guān)鍵字。

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

        fn seat_at_table() {}
    }

    mod serving {
        fn take_order() {}

        fn serve_order() {}

        fn take_payment() {}
    }
}


fn eat_at_restaurant() {
    // 絕對路徑
    crate::front_of_house::hosting::add_to_waitlist();

    // 相對路徑
    front_of_house::hosting::add_to_waitlist();
}

這時候，錯誤消失，可以通過cargo build。不過帶給我們的疑問是，為什么front_of_house不需要聲明為pub，這是因為，雖然 front_of_house 模塊不是公有的，不過因為 eat_at_restaurant 函數(shù)與 front_of_house 定義于同一模塊中。

如果你計劃讓eat_at_restaurant 函數(shù)成為 crate 庫的一個公共 API，那么還需要在eat_at_restaurant函數(shù)前加上pub。

我們剛才解決了編譯問題，現(xiàn)在來解釋一下絕對路徑和相對路徑。

第一種方式，我們在 eat_at_restaurant 中調(diào)用 add_to_waitlist 函數(shù)，使用的是絕對路徑。add_to_waitlist 函數(shù)與 eat_at_restaurant 被定義在同一 crate 中，這意味著我們可以使用 crate 關(guān)鍵字為起始的絕對路徑。

第二種方式，我們在 eat_at_restaurant 中調(diào)用 add_to_waitlist，使用的是相對路徑。這個路徑以 front_of_house 為起始，這個模塊在模塊樹中，與 eat_at_restaurant 定義在同一層級。與之等價的文件系統(tǒng)路徑就是 front_of_house/hosting/add_to_waitlist。以模塊名開頭意味著該路徑是相對路徑。

選擇使用相對路徑還是絕對路徑，要取決于你的項目，也取決于你是更傾向于將項的定義代碼與使用該項的代碼分開來移動，還是一起移動。舉一個例子，如果我們要將 front_of_house 模塊和 eat_at_restaurant 函數(shù)一起移動到一個名為 customer_experience 的模塊中，我們需要更新 add_to_waitlist 的絕對路徑，但是相對路徑還是可用的。然而，如果我們要將 eat_at_restaurant 函數(shù)單獨移到一個名為 dining 的模塊中，還是可以使用原本的絕對路徑來調(diào)用 add_to_waitlist，但是相對路徑必須要更新。我們更傾向于使用絕對路徑，因為把代碼定義和項調(diào)用各自獨立地移動是更常見的。

模塊樹應(yīng)該定義在 src/lib.rs 中。這樣通過以包名開頭的路徑，公有項就可以在二進(jìn)制 crate 中使用。二進(jìn)制 crate 就完全變成了同其它 外部 crate 一樣的庫 crate 的用戶：它只能使用公有 API。這有助于你設(shè)計一個好的 API；你不僅僅是作者，也是用戶！

super

我們還可以使用 super 而不是當(dāng)前模塊或者 crate 根來開頭來構(gòu)建從父模塊開始的相對路徑。這么做類似于文件系統(tǒng)中以 … 開頭的語法。使用 super 允許我們引用已知的父模塊中的項，當(dāng)模塊與父模塊關(guān)聯(lián)的很緊密的時候，如果某天可能需要父模塊要移動到模塊樹的其它位置，這使得重新組織模塊樹變得更容易。例如：

fn deliver_order() {}

mod back_of_house {
    fn fix_incorrect_order() {
        cook_order();
        super::deliver_order();
    }

    fn cook_order() {}
}

fix_incorrect_order 函數(shù)在 back_of_house 模塊中，所以我們可以使用 super 進(jìn)入 back_of_house 父模塊，也就是本例中的 crate 根。在這里，我們可以找到 deliver_order。

創(chuàng)建公有的結(jié)構(gòu)體和枚舉

我們還可以使用 pub 來設(shè)計公有的結(jié)構(gòu)體和枚舉，不過關(guān)于在結(jié)構(gòu)體和枚舉上使用 pub 還有一些額外的細(xì)節(jié)需要注意。如果我們在一個結(jié)構(gòu)體定義的前面使用了 pub ，這個結(jié)構(gòu)體會變成公有的，但是這個結(jié)構(gòu)體的字段仍然是私有的。我們可以根據(jù)情況決定每個字段是否公有。與之相反，如果我們將枚舉設(shè)為公有，則它的所有成員都將變?yōu)楣?。我們只需要?enum 關(guān)鍵字前面加上 pub。如果枚舉成員不是公有的，那么枚舉會顯得用處不大；給枚舉的所有成員挨個添加 pub 是很令人惱火的，因此枚舉成員默認(rèn)就是公有的。結(jié)構(gòu)體通常使用時，不必將它們的字段公有化，因此結(jié)構(gòu)體遵循常規(guī)，內(nèi)容全部是私有的，除非使用 pub 關(guān)鍵字。例如：

mod back_of_house {
    pub struct Breakfast {
        pub toast: String,
        seasonal_fruit: String,
    }

    impl Breakfast {
        pub fn summer(toast: &str) -> Breakfast {
            Breakfast {
                toast: String::from(toast),
                seasonal_fruit: String::from("peaches"),
            }
        }
    }
}

pub fn eat_at_restaurant() {
    // 在夏天訂購一個黑麥土司作為早餐
    let mut meal = back_of_house::Breakfast::summer("Rye");
    // 改變主意更換想要面包的類型
    meal.toast = String::from("Wheat");
    println!("I'd like {} toast please", meal.toast);

    // 如果取消下一行的注釋代碼不能編譯；
    // 不允許查看或修改早餐附帶的季節(jié)水果
    // meal.seasonal_fruit = String::from("blueberries");
}

mod back_of_house {
    pub enum Appetizer {
        Soup,
        Salad,
    }
}

pub fn eat_at_restaurant() {
    let order1 = back_of_house::Appetizer::Soup;
    let order2 = back_of_house::Appetizer::Salad;
}

use

無論我們選擇 add_to_waitlist 函數(shù)的絕對路徑還是相對路徑，每次我們想要調(diào)用 add_to_waitlist 時，都必須指定front_of_house 和 hosting。幸運的是，有一種方法可以簡化這個過程。我們可以使用 use 關(guān)鍵字創(chuàng)建一個短路徑，然后就可以在作用域中的任何地方使用這個更短的名字。例如：

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

// 使用use縮短名稱
use crate::front_of_house::hosting;

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

通過在 crate 根增加 use crate::front_of_house::hosting，現(xiàn)在 hosting 在作用域中就是有效的名稱了，如同 hosting 模塊被定義于 crate 根一樣。通過 use 引入作用域的路徑也會檢查私有性。

注意 use 只能創(chuàng)建 use 所在的特定作用域內(nèi)的短路徑。

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

將 eat_at_restaurant 函數(shù)移動到了一個叫 customer 的子模塊后，hosting對于子模塊是不可見的，無法編譯?？梢酝ㄟ^前面所講述的super來告訴程序，hosting的位置。例如:

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() {
        super::hosting::add_to_waitlist();
    }
}

創(chuàng)建慣用的 use 路徑

如果需要使用某個模塊中的函數(shù)，那么慣例是使用 use 將函數(shù)的父模塊引入作用域，我們必須在調(diào)用函數(shù)時指定父模塊，這樣可以清晰地表明函數(shù)是不是在本地定義的，同時使完整路徑的重復(fù)度最小化。另一方面，使用 use 引入結(jié)構(gòu)體、枚舉和其他項時，習(xí)慣是指定它們的完整路徑。例如，我們使用標(biāo)準(zhǔn)庫的hashmap時，use std::collections::HashMap; ，例如下面的例子，如果不使用模塊路徑，那么將會引入兩個同名的函數(shù)，這是rust不允許的。

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

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

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

而引入父模塊則可以避免這種問題。

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

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

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

除此之外，還可以使用as關(guān)鍵字指定一個本地名稱。

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

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

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

使用 pub use 重導(dǎo)出名稱

使用 use 關(guān)鍵字，將某個名稱導(dǎo)入當(dāng)前作用域后，這個名稱在此作用域中就可以使用了，但它對此作用域之外還是私有的。如果想讓其他人調(diào)用我們的代碼時，也能夠正常使用這個名稱，就好像它本來就在當(dāng)前作用域一樣，那我們可以將 pub 和 use 合起來使用。這種技術(shù)被稱為 “重導(dǎo)出（re-exporting）”

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

現(xiàn)在外部代碼也可以直接調(diào)用hosting模塊了。外部代碼現(xiàn)在可以使用路徑 restaurant::hosting::add_to_waitlist來調(diào)用add_to_waitlist函數(shù)。相當(dāng)于hosting成為了restaurant模塊的一部分。

嵌套路徑來消除大量的 use 行

當(dāng)需要引入很多定義于相同包或相同模塊的項時，為每一項單獨列出一行會占用源碼很大的空間。例如：

use std::cmp::Ordering;
use std::io;

我們可以使用嵌套路徑將相同的項在一行中引入作用域。這么做需要指定路徑的相同部分，接著是兩個冒號，接著是大括號中的各自不同的路徑部分。

use std::{cmp::Ordering, io};

在較大的程序中，使用嵌套路徑從相同包或模塊中引入很多項，可以顯著減少所需的獨立 use 語句的數(shù)量！

通過 glob 運算符將所有的公有定義引入作用域

如果希望將一個路徑下 所有 公有項引入作用域，可以指定路徑后跟 *，glob 運算符：

use std::collections::*;

這個 use 語句將 std::collections 中定義的所有公有項引入當(dāng)前作用域。使用 glob 運算符時請多加小心！Glob 會使得我們難以推導(dǎo)作用域中有什么名稱和它們是在何處定義的。

glob 運算符經(jīng)常用于測試模塊 tests 中，這時會將所有內(nèi)容引入作用域。

將模塊拆分成多個文件

當(dāng)模塊變得更大時，你可能想要將它們的定義移動到單獨的文件中，從而使代碼更容易閱讀。例如，我們會將模塊提取到各自的文件中，而不是將所有模塊都定義到 crate 根文件中。以前面的restaurant為例，我們將其拆分為多個文件。

// src/lib.rs
mod front_of_house;     // 聲明front_of_house,
pub use crate::front_of_house::hosting;
pub fn eat_at_restaurant() {
    hosting::add_to_waitlist();
}

// src/fron_of_house.rs
pub mod hosting { 
    pub fn add_to_waitlist() {}
}

現(xiàn)在的目錄結(jié)構(gòu)如下所示：

src
├── front_of_house.rs
└── lib.rs

首先將 front_of_house 模塊提取到其自己的文件中。刪除 front_of_house 模塊的大括號中的代碼，只留下 mod front_of_house;聲明；接下來將之前大括號內(nèi)的代碼放入一個名叫 src/front_of_house.rs 的新文件中?？梢酝ㄟ^編譯。

注意你只需在模塊樹中的某處使用一次 mod 聲明就可以加載這個文件。一旦編譯器知道了這個文件是項目的一部分（并且通過 mod 語句的位置知道了代碼在模塊樹中的位置），項目中的其他文件應(yīng)該使用其所聲明的位置的路徑來引用那個文件的代碼，這在“引用模塊項目的路徑”部分有講到。換句話說，mod 不是你可能會在其他編程語言中看到的 “include” 操作。

接下來我們同樣將 hosting 模塊提取到自己的文件中。這個過程會有所不同，因為 hosting 是 front_of_house 的子模塊而不是根模塊。我們將 hosting 的文件放在與模塊樹中它的父級模塊同名的目錄中，在這里是 src/front_of_house/。為了移動 hosting，修改 src/front_of_house.rs 使之僅包含 hosting 模塊的聲明。接著我們創(chuàng)建一個 src/front_of_house 目錄和一個包含 hosting 模塊定義的 hosting.rs 文件。例如：

// src/lib.rs
mod front_of_house;     // 聲明front_of_house,
pub use crate::front_of_house::hosting;

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

// src/front_of_house.rs
pub mod hosting;        // 聲明hosting模塊

// src/front_of_house/hosting.rs
pub fn add_to_waitlist() {}     // 實現(xiàn)add_to_waitlist

那么目錄如下所示：

src
├── front_of_house
│   └── hosting.rs
├── front_of_house.rs
└── lib.rs

我們將各個模塊的代碼移動到獨立文件了，同時模塊樹依舊相同。eat_at_restaurant 中的函數(shù)調(diào)用也無需修改繼續(xù)保持有效，即便其定義存在于不同的文件中。這個技巧讓你可以在模塊代碼增長時，將它們移動到新文件中。

注意，src/lib.rs 中的 pub use crate::front_of_house::hosting 語句是沒有改變的，在文件作為 crate 的一部分而編譯時，use 不會有任何影響。mod 關(guān)鍵字聲明了模塊，Rust 會在與模塊同名的文件中查找模塊的代碼。

另一種文件路徑

目前為止我們介紹了 Rust 編譯器所最常用的文件路徑；不過一種更老的文件路徑也仍然是支持的。

對于聲明于 crate 根的 front_of_house 模塊，編譯器會在如下位置查找模塊代碼：

src/front_of_house.rs（我們所介紹的）

src/front_of_house/mod.rs（老風(fēng)格，不過仍然支持） 對于 front_of_house 的子模塊 hosting，編譯器會在如下位置查找模塊代碼：

src/front_of_house/hosting.rs（我們所介紹的）

src/front_of_house/hosting/mod.rs（老風(fēng)格，不過仍然支持）

如果你對同一模塊同時使用這兩種路徑風(fēng)格，會得到一個編譯錯誤。在同一項目中的不同模塊混用不同的路徑風(fēng)格是允許的，不過這會使他人感到疑惑。

使用 mod.rs 這一文件名的風(fēng)格的主要缺點是會導(dǎo)致項目中出現(xiàn)很多 mod.rs 文件，當(dāng)你在編輯器中同時打開他們時會感到疑惑。

參考資料

rust程序設(shè)計語言

到此這篇關(guān)于rust的package,crate,module的文章就介紹到這了,更多相關(guān)rust的package crate module內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

最新評論