Organizzazione dei progetti Rust con pacchetti, percorsi e moduli

Rust è una scelta eccellente per la creazione di applicazioni complesse e affidabili. Una delle abilità essenziali per lo sviluppo di applicazioni Rust è strutturare i tuoi progetti in modo efficace, inclusa l'incorporazione di pacchetti di terze parti.

Un'efficace organizzazione del progetto è cruciale per lo sviluppo di applicazioni Rust. Le app Rust ben strutturate migliorano la collaborazione e facilitano le integrazioni di app di terze parti, riducendo significativamente il tempo e lo sforzo necessari per lo sviluppo delle app. Rust fornisce un gestore di pacchetti integrato e altri strumenti per un'efficace organizzazione e gestione del codice.

Impostazione di progetti Rust

Configurare i progetti Rust è facile una volta installato Rust sulla tua macchina; puoi usare Cargo (il gestore di pacchetti integrato e il sistema di compilazione di Rust) per creare e configurare un progetto Rust. È simile ad altri gestori di pacchetti come

npm per Node.js E pip per Python. Cargo gestisce le dipendenze, compila codice e genera documentazione, rendendolo uno strumento essenziale per lo sviluppo di Rust.

Esegui questo comando per verificare la tua installazione di Cargo:

carico --versione

Il comando visualizza la versione di Cargo installata.

Puoi creare un nuovo progetto Rust con il file carico nuovo comando. Dovrai specificare il nome del progetto.

cargo nuovo mio_progetto

Il comando creerà una nuova directory nella directory corrente contenente i file di base necessari per il tuo progetto Rust, inclusi a cargo.toml file per la gestione delle dipendenze del tuo progetto.

Lo spazio dei nomi del pacchetto Rust

Pacchetti e casse sono componenti essenziali in Rust. I crate sono librerie o binari che gli sviluppatori di Rust possono utilizzare e compilare per un uso specifico, mentre i pacchetti sono una raccolta di crate. I pacchetti di solito contengono un crate che contiene il codice riutilizzabile e un binario che fornisce una CLI per il crate della libreria.

Le casse devono contenere il Cargo.toml file contenente metadati sul pacchetto, come nome, versione, dipendenze e script di compilazione.

I pacchetti Rust seguono una convenzione di denominazione per evitare conflitti di denominazione tra i pacchetti. I nomi dei pacchetti devono essere globalmente univoci, minuscoli e contenere solo lettere, cifre e trattini. Se il nome di un pacchetto contiene più parole, separale con trattini, ad es. iperserver.

Puoi accedere al codice all'interno di uno spazio dei nomi di un pacchetto Rust con l'estensione utilizzo parola chiave seguita dai nomi del pacchetto e della cassa.

Ecco un esempio di importazione di un file Suona funzione da a rand cassa:

utilizzo rand:: Rng;

Puoi creare più spazi dei nomi per i pacchetti. Quando crei una cartella, crei un nuovo spazio dei nomi a cui puoi accedere con la notazione punto per specificare il percorso dell'identificatore.

In Rust, possono esserci più namespace per i pacchetti. Quando crei una cartella, crei un nuovo spazio dei nomi. Per accedere al codice da un altro spazio dei nomi, si utilizza una notazione punto per specificare il percorso dell'identificatore.

Ecco un esempio di accesso a una funzione da uno spazio dei nomi diverso:

// file nello spazio dei nomi folder1
pubfncartella() -> u32 {
// qualche corpo di funzione qui
ritorno0;
}
// file nello spazio dei nomi della cartella2
utilizzo cartella1::cartella;
pubfndirectory() {
// accesso alla funzione cartella dallo spazio dei nomi folder1
permettere folder_func = cartella();
}

Il programma definisce due moduli Rust in diversi namespace, cartella1 E cartella2 rispettivamente. IL cartella1 modulo contiene una funzione pubblica cartella che restituisce un valore intero senza segno a 32 bit.

IL cartella2 modulo importa il file cartella funzione dal cartella1 spazio dei nomi con il utilizzo parola chiave, consentendo il directory funzione per accedere al cartella funzione dal cartella1 modulo. IL directory funzione chiama il cartella funzione e il valore restituito viene assegnato a cartella_funz variabile.

Dovrai scrivere in maiuscolo il nome degli identificatori di un pacchetto o di una cassa per esportarli. Quando esporti un identificatore, lo rendi accessibile in altri pacchetti che utilizzano il codice.

Ecco un esempio di una funzione pubblica che può essere esportata.

// funzione esportata in altri pacchetti e casse
pubfnLa mia funzione() {
// qualche corpo di funzione qui
}

Dovrai anche usare il pub parola chiave. In Ruggine, il pub parola chiave è l'abbreviazione di pubblico. Quando una funzione, struct, enum, qualsiasi tipo di dati Rust o il modulo è contrassegnato con la parola chiave pub, diventa accessibile al di fuori del suo modulo. L'elemento è privato del suo modulo senza la parola chiave pub e vi si può accedere solo dall'interno.

Definizione dei moduli per il controllo dell'ambito e della privacy

Puoi utilizzare i moduli per controllare l'ambito e la privacy nei programmi Rust. I moduli consentono di organizzare il codice in unità logiche più facili da gestire e mantenere.

Puoi dichiarare i moduli con l'estensione mod parola chiave seguita dal nome del modulo e dalle parentesi graffe. La definizione di un nuovo modulo crea un nuovo spazio dei nomi per il suo contenuto, il che significa che funzioni, strutture o altri elementi definiti all'interno del modulo sono accessibili solo all'interno del modulo, a meno che tu non esporti esplicitamente loro.

I moduli aiutano a prevenire i conflitti di denominazione, rendendo il codice più intuitivo da comprendere.

Ecco la sintassi per un semplice modulo:

mod mio_modulo {
// il contenuto del modulo va qui
}

All'interno del modulo è possibile definire variabili, funzioni, struct, enum e altri tipi.

mod mio_modulo {
fnadd_numbers(UN: io32, B: io32) -> io32 {
 un + b
 }
}

Puoi usare il pub parola chiave per esportare la funzione e accedere alla funzione in altre parti del programma.

mod mio_modulo {
pubfnadd_numbers(UN: io32, B: io32) -> io32 {
 un + b
 }
}

Ora puoi chiamare il add_numbers funzione da altre parti del programma.

Puoi anche controllare la privacy dei moduli con il pub parola chiave sulle definizioni dei moduli.

pubmod mio_modulo {
pubfnadd_numbers(UN: io32, B: io32) -> io32 {
 un + b
 }
}

Ora il mio_modulo module è pubblico e puoi accedervi da altri moduli.

Se è necessario rendere un modulo o un elemento accessibile a un modulo specifico o a un insieme di moduli, è possibile utilizzare il file pub (cassa) parola chiave. IL pub (cassa) la parola chiave rende l'elemento accessibile dai moduli all'interno dello stesso crate ma non dai moduli in altri crate.

mod mio_modulo {
pubstructMyStruct {
pub(cassa) some_field: u32,
 }
}

È ora possibile accedere all'elemento specifico (in questo caso, il file some_field campo del MyStruct struct) in altre parti del programma.

fnprincipale() {
permettere my_struct = my_module:: MyStruct { some_field: 42 };
stampa!("{}", my_struct.some_field);
}

IL mia_struttura variabile è un'istanza di MyStruct struct. La variabile accede alla struttura con il separatore di percorso (::). IL principale funzione stampa il file some_field campo della struttura con il stampa! macro.

Il modello di proprietà di Rust garantisce la sicurezza della memoria

Organizzare il codice Rust è un modo per garantire che il tuo codice sia facile da mantenere e supportare nel tempo. È più facile affrontare i bug e garantire la sicurezza in un codice ben organizzato che segue le regole e le convenzioni della community di Rust.

Per impostazione predefinita, Rust garantisce che i programmi siano protetti dalla memoria con un modello di proprietà integrato. Il modello di proprietà garantisce la sicurezza della memoria assicurando che le variabili in memoria abbiano un proprietario univoco. Il modello di proprietà impedisce tracce di dati e molti tipi di errori di memoria.