Organizowanie projektów Rust za pomocą pakietów, ścieżek i modułów

Rust to doskonały wybór do tworzenia złożonych i niezawodnych aplikacji. Jedną z podstawowych umiejętności tworzenia aplikacji w języku Rust jest efektywne organizowanie projektów, w tym włączanie pakietów innych firm.

Efektywna organizacja projektu ma kluczowe znaczenie dla tworzenia aplikacji Rust. Dobrze ustrukturyzowane aplikacje Rust usprawniają współpracę i ułatwiają integrację aplikacji innych firm, znacznie skracając czas i wysiłek wymagany do tworzenia aplikacji. Rust zapewnia wbudowanego menedżera pakietów i inne narzędzia do efektywnej organizacji kodu i zarządzania nim.

Konfigurowanie projektów Rust

Konfigurowanie projektów Rust jest łatwe po zainstalowaniu Rust na swoim komputerze; możesz użyć Cargo (wbudowanego w Rusta menedżera pakietów i systemu kompilacji) do stworzenia i skonfigurowania projektu Rust. Jest podobny do innych menedżerów pakietów, takich jak npm dla Node.js I

pip dla Pythona. Cargo zarządza zależnościami, kompiluje kod i generuje dokumentację, co czyni go niezbędnym narzędziem do rozwoju Rusta.

Uruchom to polecenie, aby zweryfikować instalację Cargo:

ładunek -- wersja

Polecenie wyświetla zainstalowaną wersję Cargo.

Możesz utworzyć nowy projekt Rust za pomocą ładunek nowy Komenda. Musisz podać nazwę projektu.

ładunek nowy mój_projekt

Polecenie utworzy nowy katalog w bieżącym katalogu zawierający podstawowe pliki potrzebne do projektu Rust, w tym plik ładunek.toml plik do zarządzania zależnościami twojego projektu.

Przestrzeń nazw pakietu Rust

Paczki i skrzynie są niezbędnymi komponentami w Rust. Skrzynki to biblioteki lub pliki binarne, których programiści Rust mogą używać i kompilować do określonych zastosowań, a pakiety to zbiór skrzynek. Pakiety zwykle zawierają skrzynkę zawierającą kod wielokrotnego użytku oraz plik binarny, który zapewnia CLI dla skrzynki bibliotecznej.

Skrzynie muszą zawierać Cargo.toml plik zawierający metadane dotyczące pakietu, takie jak jego nazwa, wersja, zależności i skrypty kompilacji.

Pakiety Rust są zgodne z konwencją nazewnictwa, aby uniknąć konfliktów nazw między pakietami. Nazwy pakietów muszą być globalnie unikalne, pisane małymi literami i zawierać tylko litery, cyfry i łączniki. Jeśli nazwa pakietu zawiera wiele słów, oddziel je myślnikami, np. hiperserwer.

Możesz uzyskać dostęp do kodu w przestrzeni nazw pakietu Rust za pomocą używać słowo kluczowe, po którym następuje nazwa paczki i skrzynki.

Oto przykład importowania pliku Rng funkcja od A skraj skrzynia:

używać Rand:: Rng;

Możesz utworzyć wiele przestrzeni nazw dla pakietów. Tworząc folder, tworzysz nową przestrzeń nazw, do której można uzyskać dostęp za pomocą notacji kropkowej w celu określenia ścieżki do identyfikatora.

W Rust może istnieć wiele przestrzeni nazw dla pakietów. Tworząc folder, tworzysz nową przestrzeń nazw. Aby uzyskać dostęp do kodu z innej przestrzeni nazw, użyj notacji kropkowej, aby określić ścieżkę do identyfikatora.

Oto przykład uzyskiwania dostępu do funkcji z innej przestrzeni nazw:

// plik w przestrzeni nazw folder1
pubprzypteczka() -> u32 {
// część ciała funkcji tutaj
powrót0;
}
// plik w przestrzeni nazw folder2
używać folder1::folder;
pubprzypinformator() {
// dostęp do funkcji folderu z przestrzeni nazw folder1
pozwalać funkcja_folderu = folder();
}

Program definiuje dwa moduły Rust w różnych przestrzeniach nazw, folder1 I folder2 odpowiednio. The folder1 moduł zawiera funkcję publiczną teczka która zwraca 32-bitową liczbę całkowitą bez znaku.

The folder2 moduł importuje plik teczka funkcja od folder1 przestrzeń nazw z używać słowo kluczowe, pozwalające na informator funkcję dostępu do teczka funkcja od folder1 moduł. The informator funkcja wywołuje teczka funkcja, a zwracana wartość jest przypisywana do funkcji folder_funkcja zmienny.

Aby je wyeksportować, musisz pisać wielkimi literami nazwy identyfikatorów z paczki lub skrzyni. Eksportując identyfikator, udostępniasz go w innych pakietach, które używają tego kodu.

Oto przykład funkcji publicznej, którą można wyeksportować.

// funkcja wyeksportowana do innych pakietów i skrzynek
pubprzypMojaFunkcja() {
// część ciała funkcji tutaj
}

Będziesz także musiał użyć pub słowo kluczowe. W Rust, pub słowo kluczowe jest skrótem od publiczny. Kiedy funkcja, struct, enum, dowolny typ danych Rust lub moduł jest oznaczony słowem kluczowym pub, staje się dostępny poza swoim modułem. Element jest prywatny dla swojego modułu bez słowa kluczowego pub i można uzyskać do niego dostęp tylko z jego poziomu.

Definiowanie modułów do kontroli zakresu i prywatności

Możesz używać modułów do kontrolowania zakresu i prywatności w programach Rust. Moduły umożliwiają organizowanie kodu w logiczne jednostki, które są łatwiejsze w zarządzaniu i utrzymaniu.

Możesz zadeklarować moduły za pomocą mod słowo kluczowe, po którym następuje nazwa modułu i nawiasy klamrowe. Zdefiniowanie nowego modułu tworzy nową przestrzeń nazw dla jego zawartości, co oznacza, że ​​funkcje, struktury lub inne elementy zdefiniowane w module są dostępne tylko w module, z wyjątkiem jawnego eksportu ich.

Moduły pomagają zapobiegać konfliktom nazewnictwa, czyniąc kod bardziej intuicyjnym do zrozumienia.

Oto składnia prostego modułu:

mod mój_moduł {
// zawartość modułu przejdź tutaj
}

W ramach modułu możesz definiować zmienne, funkcje, struktury, wyliczenia i inne typy.

mod mój_moduł {
przypdodaj_liczby(A: i32, B: i32) -> i32 {
 a + b
 }
}

Możesz użyć pub słowo kluczowe, aby wyeksportować funkcję i uzyskać dostęp do funkcji w innych częściach programu.

mod mój_moduł {
pubprzypdodaj_liczby(A: i32, B: i32) -> i32 {
 a + b
 }
}

Teraz możesz zadzwonić do dodaj_liczby funkcji z innych części programu.

Możesz także kontrolować prywatność modułów za pomocą pub słowo kluczowe w definicjach modułów.

pubmod mój_moduł {
pubprzypdodaj_liczby(A: i32, B: i32) -> i32 {
 a + b
 }
}

Teraz mój_moduł moduł jest publiczny i możesz uzyskać dostęp do modułu z innych modułów.

Jeśli chcesz udostępnić moduł lub element określonemu modułowi lub zestawowi modułów, możesz użyć metody pub (skrzynia) słowo kluczowe. The pub (skrzynia) Słowo kluczowe sprawia, że ​​przedmiot jest dostępny z modułów w tej samej skrzyni, ale nie z modułów w innych skrzyniach.

mod mój_moduł {
pubstrukturaMojaStruktura {
pub(skrzynia) jakieś_pole: u32,
 }
}

Możesz teraz uzyskać dostęp do określonego elementu (w tym przypadku pliku jakieś_pole pole MojaStruktura struct) w innych częściach programu.

przypgłówny() {
pozwalać moja_struktura = mój_moduł:: MojaStruktura { niektóre_pole: 42 };
drukuj!("{}", moja_struktura.jakie_pole);
}

The moja_struktura zmienna jest instancją MojaStruktura struktura. Zmienna uzyskuje dostęp do struktury za pomocą separatora ścieżki (::). The główny funkcja drukuje jakieś_pole pole struktury z drukuj! makro.

Model własności w Rust zapewnia bezpieczeństwo pamięci

Organizacja kodu Rust to jeden ze sposobów na zapewnienie, że Twój kod jest łatwy w utrzymaniu i obsłudze przez długi czas. Łatwiej jest usuwać błędy i zapewniać bezpieczeństwo w dobrze zorganizowanym kodzie, który jest zgodny z zasadami i konwencjami społeczności Rust.

Domyślnie Rust zapewnia, że ​​programy są bezpieczne dla pamięci dzięki wbudowanemu modelowi własności. Model własności zapewnia bezpieczeństwo pamięci poprzez zapewnienie, że zmienne w pamięci mają jednego unikalnego właściciela. Model własności zapobiega śledzeniu danych i wielu rodzajom błędów pamięci.