package，crate，module

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

crate

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

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

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

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

package

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

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

模塊 Module

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

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

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

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

一個(gè)項(xiàng)目的模塊樹可能如下所示。在一個(gè)package下可以有多個(gè)crate，crate下可以有多個(gè)module。

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

引用module路徑

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

路徑有兩種形式：

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

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

假設(shè)我們希望調(diào)用 add_to_waitlist 函數(shù)，該如何做？我們在 crate 根定義了一個(gè)新函數(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();
}

此時(shí)，你會(huì)發(fā)現(xiàn)編輯器報(bào)錯(cuò)了，你無法編譯通過(cargo build)。編譯器告訴你

module `hosting` is private

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

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

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

這時(shí)，你發(fā)現(xiàn)編輯器的報(bào)錯(cuò)從hosting變成了add_to_waitlist了。還是不能通過cargo build。這表明使模塊公有并不使其內(nèi)容也是公有。模塊上的 pub 關(guān)鍵字只允許其父模塊引用它，而不允許訪問內(nèi)部代碼。因?yàn)槟K是一個(gè)容器，只是將模塊變?yōu)楣心茏龅钠鋵?shí)并不太多；同時(shí)需要更深入地選擇將一個(gè)或多個(gè)項(xiàng)變?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();
}

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

如果你計(jì)劃讓eat_at_restaurant 函數(shù)成為 crate 庫的一個(gè)公共 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，使用的是相對路徑。這個(gè)路徑以 front_of_house 為起始，這個(gè)模塊在模塊樹中，與 eat_at_restaurant 定義在同一層級。與之等價(jià)的文件系統(tǒng)路徑就是 front_of_house/hosting/add_to_waitlist。以模塊名開頭意味著該路徑是相對路徑。

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

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

super

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

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è)計(jì)公有的結(jié)構(gòu)體和枚舉，不過關(guān)于在結(jié)構(gòu)體和枚舉上使用 pub 還有一些額外的細(xì)節(jié)需要注意。如果我們在一個(gè)結(jié)構(gòu)體定義的前面使用了 pub ，這個(gè)結(jié)構(gòu)體會(huì)變成公有的，但是這個(gè)結(jié)構(gòu)體的字段仍然是私有的。我們可以根據(jù)情況決定每個(gè)字段是否公有。與之相反，如果我們將枚舉設(shè)為公有，則它的所有成員都將變?yōu)楣?。我們只需要?enum 關(guān)鍵字前面加上 pub。如果枚舉成員不是公有的，那么枚舉會(huì)顯得用處不大；給枚舉的所有成員挨個(gè)添加 pub 是很令人惱火的，因此枚舉成員默認(rèn)就是公有的。結(jié)構(gòu)體通常使用時(shí)，不必將它們的字段公有化，因此結(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() {
    // 在夏天訂購一個(gè)黑麥土司作為早餐
    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 時(shí)，都必須指定front_of_house 和 hosting。幸運(yùn)的是，有一種方法可以簡化這個(gè)過程。我們可以使用 use 關(guān)鍵字創(chuàng)建一個(gè)短路徑，然后就可以在作用域中的任何地方使用這個(gè)更短的名字。例如：

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 引入作用域的路徑也會(huì)檢查私有性。

注意 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ù)移動(dòng)到了一個(gè)叫 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 路徑

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

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)鍵字，將某個(gè)名稱導(dǎo)入當(dāng)前作用域后，這個(gè)名稱在此作用域中就可以使用了，但它對此作用域之外還是私有的。如果想讓其他人調(diào)用我們的代碼時(shí)，也能夠正常使用這個(gè)名稱，就好像它本來就在當(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)需要引入很多定義于相同包或相同模塊的項(xiàng)時(shí)，為每一項(xiàng)單獨(dú)列出一行會(huì)占用源碼很大的空間。例如：

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

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

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

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

通過 glob 運(yùn)算符將所有的公有定義引入作用域

如果希望將一個(gè)路徑下 所有 公有項(xiàng)引入作用域，可以指定路徑后跟 *，glob 運(yùn)算符：

use std::collections::*;

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

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

將模塊拆分成多個(gè)文件

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

// 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)的代碼放入一個(gè)名叫 src/front_of_house.rs 的新文件中。可以通過編譯。

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

接下來我們同樣將 hosting 模塊提取到自己的文件中。這個(gè)過程會(huì)有所不同，因?yàn)?hosting 是 front_of_house 的子模塊而不是根模塊。我們將 hosting 的文件放在與模塊樹中它的父級模塊同名的目錄中，在這里是 src/front_of_house/。為了移動(dòng) hosting，修改 src/front_of_house.rs 使之僅包含 hosting 模塊的聲明。接著我們創(chuàng)建一個(gè) src/front_of_house 目錄和一個(gè)包含 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() {}     // 實(shí)現(xiàn)add_to_waitlist

那么目錄如下所示：

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

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

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

另一種文件路徑

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

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

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

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

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

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

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

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

參考資料

rust程序設(shè)計(jì)語言

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

最新評論