Organizarea proiectelor Rust cu pachete, căi și module

Rugina este o alegere excelentă pentru construirea de aplicații complexe și fiabile. Una dintre abilitățile esențiale pentru dezvoltarea aplicațiilor Rust este structurarea eficientă a proiectelor, inclusiv încorporarea pachetelor terțe.

Organizarea eficientă a proiectelor este crucială pentru dezvoltarea aplicațiilor Rust. Aplicațiile Rust bine structurate îmbunătățesc colaborarea și integrările ușoare ale aplicațiilor terțe, reducând semnificativ timpul și efortul necesar dezvoltării aplicațiilor. Rust oferă un manager de pachete încorporat și alte instrumente pentru organizarea și gestionarea eficientă a codului.

Configurarea proiectelor Rust

Configurarea proiectelor Rust este ușoară odată ce ați instalat Rust pe mașina dvs; puteți folosi Cargo (managerul de pachete încorporat și sistemul de compilare al lui Rust) pentru a crea și configura un proiect Rust. Este similar cu alți manageri de pachete, cum ar fi

npm pentru Node.js și pip pentru Python. Cargo gestionează dependențele, compilează cod și generează documentație, făcându-l un instrument esențial pentru dezvoltarea Rust.

Rulați această comandă pentru a verifica instalarea Cargo:

cargo --versiune

Comanda afișează versiunea Cargo instalată.

Puteți crea un nou proiect Rust cu marfa noua comanda. Va trebui să specificați numele proiectului.

cargo new my_project

Comanda va crea un director nou în directorul curent, care conține fișierele de bază de care aveți nevoie pentru proiectul dvs. Rust, inclusiv un încărcătură.toml fișier pentru gestionarea dependențelor proiectului dvs.

Spațiul de nume al pachetului Rust

Pachetele și lăzile sunt componente esențiale în Rust. Lăzile sunt biblioteci sau binare pe care dezvoltatorii Rust le pot folosi și compila pentru o anumită utilizare, iar pachetele sunt o colecție de lăzi. Pachetele conțin de obicei o cutie care conține codul reutilizabil și un binar care oferă un CLI pentru cutia bibliotecii.

Lăzile trebuie să conțină Marfă.toml fișier care conține metadate despre pachet, cum ar fi numele, versiunea, dependențele și scripturile de compilare.

Pachetele Rust urmează o convenție de denumire pentru a evita conflictele de denumire între pachete. Numele pachetelor trebuie să fie unice la nivel global, cu litere mici și să conțină numai litere, cifre și cratime. Dacă numele unui pachet conține mai multe cuvinte, separați-le cu cratime, de ex. hiper-server.

Puteți accesa codul într-un spațiu de nume de pachet Rust cu ajutorul utilizare cuvânt cheie urmat de numele pachetului și al cutiei.

Iată un exemplu de importare a unui Rng funcția de la a rand ladă:

utilizare rand:: Rng;

Puteți crea mai multe spații de nume pentru pachete. Când creați un folder, creați un nou spațiu de nume pe care îl puteți accesa cu notația punct pentru a specifica calea către identificator.

În Rust, pot exista mai multe spații de nume pentru pachete. Când creați un folder, creați un nou spațiu de nume. Pentru a accesa codul dintr-un alt spațiu de nume, utilizați o notație cu puncte pentru a specifica calea către identificator.

Iată un exemplu de accesare a unei funcții dintr-un spațiu de nume diferit:

// fișier în spațiul de nume folder1
cârciumăfnpliant() -> u32 {
// un corp funcțional aici
întoarcere0;
}
// fișier în spațiul de nume folder2
utilizare folder1::folder;
cârciumăfndirector() {
// accesarea funcției folder din spațiul de nume folder1
lăsa folder_func = folder();
}

Programul definește două module Rust în spații de nume diferite, folder1 și folderul 2 respectiv. The folder1 modulul conține o funcție publică pliant care returnează o valoare întreagă fără semn pe 32 de biți.

The folderul 2 modulul importă pliant funcția de la folder1 spatiu de nume cu utilizare cuvânt cheie, permițând director funcția pentru a accesa pliant funcția de la folder1 modul. The director funcția apelează pliant funcția, iar valoarea returnată este atribuită lui folder_func variabil.

Va trebui să scrieți cu majuscule numele identificatorilor dintr-un pachet sau cutie pentru a le exporta. Când exportați un identificator, îl faceți accesibil în alte pachete care folosesc codul.

Iată un exemplu de funcție publică care poate fi exportată.

// funcție exportată în alte pachete și lăzi
cârciumăfnFuncția mea() {
// un corp funcțional aici
}

De asemenea, va trebui să utilizați cârciumă cuvânt cheie. În Rust, cel cârciumă cuvântul cheie este prescurtarea pentru public. Când o funcție, struct, enumerare, orice tip de date Rust sau module este marcat cu cuvântul cheie pub, acesta devine accesibil în afara modulului său. Articolul este privat pentru modulul său fără cuvântul cheie pub și poate fi accesat numai din interiorul acestuia.

Definirea modulelor pentru controlul domeniului și confidențialitatea

Puteți utiliza module pentru a controla domeniul și confidențialitatea în programele Rust. Modulele vă permit să organizați codul în unități logice care sunt mai ușor de gestionat și întreținut.

Puteți declara module cu ajutorul mod cuvânt cheie urmat de numele modulului și acolade. Definirea unui modul nou creează un nou spațiu de nume pentru conținutul său, ceea ce înseamnă că funcționează, structurează sau alte elemente definite în modul sunt accesibile numai în cadrul modulului, cu excepția faptului că exportați în mod explicit lor.

Modulele ajută la prevenirea conflictelor de denumire, făcând codul mai intuitiv de înțeles.

Iată sintaxa pentru un modul simplu:

mod modulul_meu {
// conținutul modulului merge aici
}

În cadrul modulului, puteți defini variabile, funcții, structuri, enumerari și alte tipuri.

mod modulul_meu {
fnadd_numbers(A: i32, b: i32) -> i32 {
 a + b
 }
}

Puteți folosi cârciumă cuvânt cheie pentru a exporta funcția și a accesa funcția în alte părți ale programului.

mod modulul_meu {
cârciumăfnadd_numbers(A: i32, b: i32) -> i32 {
 a + b
 }
}

Acum, puteți suna la add_numbers funcția din alte părți ale programului dvs.

De asemenea, puteți controla confidențialitatea modulelor cu ajutorul cârciumă cuvânt cheie despre definițiile modulelor.

cârciumămod modulul_meu {
cârciumăfnadd_numbers(A: i32, b: i32) -> i32 {
 a + b
 }
}

Acum modulul_meu modulul este public și puteți accesa modulul din alte module.

Dacă trebuie să faceți un modul sau un articol accesibil unui anumit modul sau set de module, puteți utiliza cârciumă (ladă) cuvânt cheie. The cârciumă (ladă) cuvântul cheie face obiectul accesibil din modulele din aceeași cutie, dar nu din modulele din alte cutii.

mod modulul_meu {
cârciumăstructMyStruct {
cârciumă(ladă) some_field: u32,
 }
}

Acum puteți accesa elementul specific (în acest caz, fișierul un_câmp domeniul MyStruct struct) în alte părți ale programului dvs.

fnprincipal() {
lăsa my_struct = my_module:: MyStruct { some_field: 42 };
println!("{}", structura_mea.un_câmp);
}

The my_struct variabila este o instanță a MyStruct struct. Variabila accesează structura cu separatorul de cale (::). The principal funcția imprimă un_câmp câmp al structurii cu println! macro.

Modelul de proprietate al lui Rust asigură siguranța memoriei

Organizarea codului Rust este o modalitate de a vă asigura că codul dvs. este ușor de întreținut și susținut în timp. Este mai ușor să abordezi erorile și să asigure siguranța într-un cod bine organizat, care urmează regulile și convențiile comunității Rust.

În mod implicit, Rust asigură că programele sunt sigure pentru memorie cu un model de proprietate încorporat. Modelul de proprietate asigură siguranța memoriei, asigurându-se că variabilele din memorie au un singur proprietar. Modelul de proprietate previne urmele datelor și multe tipuri de erori de memorie.