Förstå begrepp bakom kodorganisation

Slutförd

Innan vi börjar är det viktigt att förklara begreppen bakom kodorganisationen i Rust-program:

  • Ett paket:
    • Innehåller funktioner i en eller flera-.
    • Innehåller information om hur du skapar dessa backar. Informationen finns i Cargo.toml filen .
  • En låda:
    • Är en kompileringsenhet, som är den minsta mängd kod som Kompilatorn kan arbeta med.
    • När den har kompilerats skapar den antingen en körbar fil eller ett bibliotek.
    • Innehåller en implicit, namnlös toppnivåmodul.
  • En modul:
    • Är en (eventuellt kapslad) kodorganisationsenhet i en crate.
    • Kan ha rekursiva definitioner som sträcker sig över ytterligare moduler.

Paket

När vi kör kommandot $ cargo new <project-name> skapar Cargo ett paket åt oss:

$ cargo new my-project
     Created binary (application) `my-project` package

Här har vi ett paket som bara innehåller src/main.rs , vilket innebär att det bara innehåller en binär crate med namnet my-project :

my-project
├── src
│  └── main.rs
└── Cargo.toml

Ett paket kan ha flera binära paket genom att placera filer i src/bin katalogen . Varje fil kommer att vara en separat binär crate.

Om ett paket src/main.rs innehåller och har det två src/lib.rs samlingar: ett bibliotek och en binär fil. Båda har samma namn som paketet.

Lådor

Rusts kompileringsmodell handlar om artefakter som kallas för samlingar som kan kompileras till en binär fil eller till ett bibliotek.

Varje projekt som du skapar med cargo new kommandot är en själva lådan. All kod från tredje part som du kan använda som beroenden i projektet är också, var och en, en enda lådan.

Bibliotekslådor

Vi har redan gått in på hur du skapar ett binärt program, och det är lika enkelt att skapa ett bibliotek. Om du vill skapa ett bibliotek skickar --lib du kommandoradsparametern till cargo new kommandot :

$ cargo new --lib my-library
     Created library `my-library` package

Du kan se att du i stället src/main.rs för en fil nu får en =src/lib.rs-fil.

my-library
├── src
│  └── lib.rs
└── Cargo.toml

När du säger till Cargo att kompilera den här lådan får du en biblioteksfil med namnet libmy_library.rlib som kan publiceras och länkas till andra projekt.

Moduler

Prak tillhandahåller ett kraftfullt modulsystem som kan användas för att hierarkiskt dela upp kod i logiska enheter som också underlättar läsbarhet och återanvändning.

En modul är en samling objekt:

  • Konstanter
  • Typalias
  • Functions
  • Strukturer
  • Uppräkningar
  • Egenskaper
  • impl Block
  • Andra moduler

Modulerna styr även objektsekretessen. Objektsekretess identifierar ett objekt som antingen offentligt eller privat. Offentligt innebär att objektet kan användas av extern kod. Privat innebär att objektet är en intern implementeringsdetalj och inte tillgängligt för extern användning.

Ett exempel på en modul:

mod math {
    type Complex = (f64, f64);
    pub fn sin(f: f64) -> f64 { /* ... */ }
    pub fn cos(f: f64) -> f64 { /* ... */ }
    pub fn tan(f: f64) -> f64 { /* ... */ }
}

println!("{}", math::cos(45.0));

Om en källfil innehåller deklarationer infogas innehållet i modulfilerna på platser där deklarationer i källfilen hittas innan kompilatorn mod mod körs över den. Moduler kompileras med andra ord inte individuellt, bara paket kompileras.

Du kanske har lagt märke pub till nyckelordet i början av funktionsdefinitionerna i math modulen.

Kompileraren Gör en kontroll för att se om objekt kan användas i flera moduler eller inte. Som standard är allt i Prat privat och kan bara nås av den aktuella modulen och dess underordnade. När ett objekt däremot deklareras som kan det anses vara pub tillgängligt för världen utanför. Exempel:

// Declare a private struct
struct Foo;

// Declare a public struct with a private field
pub struct Bar {
    field: i32,
}

// Declare a public enum with two public variants
pub enum State {
    PubliclyAccessibleVariant,
    PubliclyAccessibleVariant2,
}

Rusts sekretessregler är överraskande kraftfulla för att skapa modulhierarkier som exponerar offentliga API:er samtidigt som den interna implementeringsinformationen döljs.