Organisera rostprojekt med paket, vägar och moduler

Rust är ett utmärkt val för att bygga komplexa och pålitliga applikationer. En av de väsentliga färdigheterna för att utveckla Rust-applikationer är att strukturera dina projekt effektivt, inklusive att införliva tredjepartspaket.

En effektiv projektorganisation är avgörande för att utveckla Rust-applikationer. Välstrukturerade Rust-appar förbättrar samarbetet och enkla tredjepartsappintegrationer, vilket avsevärt minskar tiden och ansträngningen som krävs för apputveckling. Rust tillhandahåller en inbyggd pakethanterare och andra verktyg för effektiv kodorganisation och hantering.

Ställa in rostprojekt

Det är enkelt att sätta upp Rust-projekt när du har installerat Rust på din maskin; du kan använda Cargo (Rusts inbyggda pakethanterare och byggsystem) för att skapa och konfigurera ett Rust-projekt. Det liknar andra pakethanterare som npm för Node.js och pip för Python. Cargo hanterar beroenden, kompilerar kod och genererar dokumentation, vilket gör det till ett viktigt verktyg för Rust-utveckling.

Kör det här kommandot för att verifiera din Cargo-installation:

last --version

Kommandot visar den installerade Cargo-versionen.

Du kan skapa ett nytt Rust-projekt med last ny kommando. Du måste ange projektnamnet.

last nytt mitt_projekt

Kommandot kommer att skapa en ny katalog i den aktuella katalogen som innehåller de grundläggande filerna du behöver för ditt Rust-projekt, inklusive en cargo.toml fil för att hantera ditt projekts beroenden.

Namnutrymmet Rust Package

Förpackningar och lådor är viktiga komponenter i Rust. Lådor är bibliotek eller binärer som Rust-utvecklarna kan använda och kompilera för någon specifik användning, och paket är en samling av lådor. Paket innehåller vanligtvis en låda som innehåller den återanvändbara koden och en binär som tillhandahåller en CLI för bibliotekslådan.

Lådor måste innehålla Cargo.toml fil som innehåller metadata om paketet, såsom dess namn, version, beroenden och byggskript.

Rustpaket följer en namnkonvention för att undvika namnkonflikter mellan paket. Paketnamn måste vara globalt unika, gemener och endast innehålla bokstäver, siffror och bindestreck. Om ett paketnamn innehåller flera ord, separera dem med bindestreck, t.ex. hyper-server.

Du kan komma åt koden i ett Rust-paketnamnområde med använda sig av nyckelord följt av paketets och lådornas namn.

Här är ett exempel på import av en Rng funktion från en rand spjällåda:

använda sig av rand:: Rng;

Du kan skapa flera namnområden för paket. När du skapar en mapp skapar du ett nytt namnområde som du kan komma åt med punktnotationen för att ange sökvägen till identifieraren.

I Rust kan det finnas flera namnutrymmen för paket. När du skapar en mapp skapar du ett nytt namnområde. För att komma åt kod från ett annat namnområde använder du en punktnotation för att ange sökvägen till identifieraren.

Här är ett exempel på hur du kommer åt en funktion från ett annat namnområde:

// fil i mapp1 namnutrymme
pubfnmapp() -> u32 {
// någon funktionskropp här
lämna tillbaka0;
}
// fil i mapp2 namnutrymme
använda sig av folder1::folder;
pubfnkatalog() {
// åtkomst till mappfunktionen från mapp1-namnområdet
låta folder_func = folder();
}

Programmet definierar två Rust-moduler i olika namnutrymmen, mapp1 och mapp2 respektive. De mapp1 modulen innehåller en offentlig funktion mapp som returnerar ett 32-bitars heltalsvärde utan tecken.

De mapp2 modulen importerar mapp funktion från mapp1 namnutrymme med använda sig av nyckelord, vilket tillåter katalog funktion för att komma åt mapp funktion från mapp1 modul. De katalog funktionen anropar mapp funktion, och returvärdet tilldelas till folder_func variabel.

Du måste använda versaler i namnet på identifierarna från ett paket eller en låda för att exportera dem. När du exporterar en identifierare gör du den tillgänglig i andra paket som använder koden.

Här är ett exempel på en offentlig funktion som kan exporteras.

//-funktionen exporteras till andra paket och lådor
pubfnMyFunction() {
// någon funktionskropp här
}

Du måste också använda pub nyckelord. I Rust, den pub nyckelord är förkortning för offentlig. När en funktion, struktur, enum, någon typ av rostdata eller modul är märkt med pubnyckelordet, blir den tillgänglig utanför sin modul. Objektet är privat för sin modul utan pub-nyckelordet och kan endast nås inifrån det.

Definiera moduler för att kontrollera omfattning och integritet

Du kan använda moduler för att kontrollera omfattning och integritet i Rust-program. Moduler låter dig organisera kod i logiska enheter som är lättare att hantera och underhålla.

Du kan deklarera moduler med mod nyckelord följt av modulnamnet och hängslen. Genom att definiera en ny modul skapas ett nytt namnområde för dess innehåll, vilket betyder att funktioner, strukturer eller andra objekt som definieras i modulen är endast tillgängliga inom modulen förutom att du explicit exporterar dem.

Moduler hjälper till att förhindra namnkonflikter, vilket gör koden mer intuitiv att förstå.

Här är syntaxen för en enkel modul:

mod min_modul {
// modulinnehåll finns här
}

Inom modulen kan du definiera variabler, funktioner, strukturer, uppräkningar och andra typer.

mod min_modul {
fnadd_numbers(en: i32, b: i32) -> i32 {
 a + b
 }
}

Du kan använda pub nyckelord för att exportera funktionen och komma åt funktionen i andra delar av programmet.

mod min_modul {
pubfnadd_numbers(en: i32, b: i32) -> i32 {
 a + b
 }
}

Nu kan du ringa till add_numbers funktion från andra delar av ditt program.

Du kan också kontrollera modulernas integritet med pub nyckelord på moduldefinitioner.

pubmod min_modul {
pubfnadd_numbers(en: i32, b: i32) -> i32 {
 a + b
 }
}

Nu den min_modul modulen är offentlig och du kan komma åt modulen från andra moduler.

Om du behöver göra en modul eller artikel tillgänglig för en specifik modul eller uppsättning moduler kan du använda pub (låda) nyckelord. De pub (låda) nyckelordet gör objektet tillgängligt från moduler i samma låda men inte från moduler i andra lådor.

mod min_modul {
pubstrukturMyStruct {
pub(spjällåda) some_field: u32,
 }
}

Du kan nu komma åt det specifika objektet (i det här fallet något_fält fältet av MyStruct struct) i andra delar av ditt program.

fnhuvud() {
låta my_struct = my_module:: MyStruct { some_field: 42 };
println!("{}", my_struct.some_field);
}

De min_struktur variabel är en instans av MyStruct struktur. Variabeln får åtkomst till strukturen med sökvägsavgränsaren (::). De huvud funktionen skriver ut något_fält fältet av strukturen med println! makro.

Rusts ägarmodell säkerställer minnessäkerhet

Att organisera rostkod är ett sätt att säkerställa att din kod är enkel att underhålla och stödja över tid. Det är lättare att ta itu med buggar och säkerställa säkerheten i välorganiserad kod som följer Rust-gemenskapens regler och konventioner.

Som standard ser Rust till att programmen är minnessäkra med en inbyggd ägarmodell. Ägarmodellen säkerställer minnessäkerhet genom att säkerställa att variabler i minnet har en unik ägare. Ägarmodellen förhindrar dataspår och många typer av minnesfel.