Οργάνωση Rust Projects με πακέτα, μονοπάτια και ενότητες

Η σκουριά είναι μια εξαιρετική επιλογή για την κατασκευή πολύπλοκων και αξιόπιστων εφαρμογών. Μία από τις βασικές δεξιότητες για την ανάπτυξη εφαρμογών Rust είναι η αποτελεσματική δόμηση των έργων σας, συμπεριλαμβανομένης της ενσωμάτωσης πακέτων τρίτων.

Η αποτελεσματική οργάνωση του έργου είναι ζωτικής σημασίας για την ανάπτυξη εφαρμογών Rust. Οι καλά δομημένες εφαρμογές Rust ενισχύουν τη συνεργασία και τις εύκολες ενσωματώσεις εφαρμογών τρίτων, μειώνοντας σημαντικά τον χρόνο και την προσπάθεια που απαιτείται για την ανάπτυξη εφαρμογών. Η Rust παρέχει έναν ενσωματωμένο διαχειριστή πακέτων και άλλα εργαλεία για αποτελεσματική οργάνωση και διαχείριση κώδικα.

Ρύθμιση Rust Projects

Η εγκατάσταση έργων Rust είναι εύκολη μόλις εγκαταστήσετε το Rust στον υπολογιστή σας; μπορείτε να χρησιμοποιήσετε το Cargo (τον ενσωματωμένο διαχειριστή πακέτων και σύστημα κατασκευής του Rust) για να δημιουργήσετε και να διαμορφώσετε ένα έργο Rust. Είναι παρόμοιο με άλλους διαχειριστές πακέτων όπως

npm για το Node.js και pip για Python. Το Cargo διαχειρίζεται εξαρτήσεις, μεταγλωττίζει κώδικα και δημιουργεί τεκμηρίωση, καθιστώντας το απαραίτητο εργαλείο για την ανάπτυξη του Rust.

Εκτελέστε αυτήν την εντολή για να επαληθεύσετε την εγκατάσταση Cargo:

φορτίο --έκδοση

Η εντολή εμφανίζει την εγκατεστημένη έκδοση Cargo.

Μπορείτε να δημιουργήσετε ένα νέο έργο Rust με το φορτίο καινούργιο εντολή. Θα χρειαστεί να καθορίσετε το όνομα του έργου.

φορτίο νέο my_project

Η εντολή θα δημιουργήσει έναν νέο κατάλογο στον τρέχοντα κατάλογο που περιέχει τα βασικά αρχεία που χρειάζεστε για το έργο Rust, συμπεριλαμβανομένου του α φορτίο.toml αρχείο για τη διαχείριση των εξαρτήσεων του έργου σας.

Χώρος ονομάτων του πακέτου Rust

Οι συσκευασίες και τα κιβώτια είναι απαραίτητα εξαρτήματα στο Rust. Τα Crates είναι βιβλιοθήκες ή δυαδικά αρχεία που οι προγραμματιστές του Rust μπορούν να χρησιμοποιήσουν και να μεταγλωττίσουν για κάποια συγκεκριμένη χρήση και τα πακέτα είναι μια συλλογή από κιβώτια. Τα πακέτα περιέχουν συνήθως ένα κιβώτιο που περιέχει τον επαναχρησιμοποιήσιμο κώδικα και ένα δυαδικό που παρέχει ένα CLI για το κιβώτιο της βιβλιοθήκης.

Τα κιβώτια πρέπει να περιέχουν το Cargo.toml αρχείο που περιέχει μεταδεδομένα σχετικά με το πακέτο, όπως το όνομα, την έκδοση, τις εξαρτήσεις και τα σενάρια έκδοσης.

Τα πακέτα Rust ακολουθούν μια σύμβαση ονομασίας για την αποφυγή διενέξεων ονομάτων μεταξύ των πακέτων. Τα ονόματα των πακέτων πρέπει να είναι μοναδικά παγκοσμίως, πεζά και να περιέχουν μόνο γράμματα, ψηφία και παύλες. Εάν ένα όνομα πακέτου περιέχει πολλές λέξεις, διαχωρίστε τις με παύλες, π.χ. υπερ-διακομιστής.

Μπορείτε να αποκτήσετε πρόσβαση στον κώδικα μέσα σε έναν χώρο ονομάτων πακέτου Rust με το χρήση λέξη-κλειδί ακολουθούμενη από τα ονόματα του πακέτου και του κιβωτίου.

Ακολουθεί ένα παράδειγμα εισαγωγής ενός Rng λειτουργία από α άκρα σακαράκα:

χρήση rand:: Rng;

Μπορείτε να δημιουργήσετε πολλούς χώρους ονομάτων για πακέτα. Όταν δημιουργείτε έναν φάκελο, δημιουργείτε ένα νέο χώρο ονομάτων στον οποίο μπορείτε να αποκτήσετε πρόσβαση με τη σημείωση κουκκίδων για να καθορίσετε τη διαδρομή προς το αναγνωριστικό.

Στο Rust, μπορεί να υπάρχουν πολλοί χώροι ονομάτων για πακέτα. Όταν δημιουργείτε έναν φάκελο, δημιουργείτε έναν νέο χώρο ονομάτων. Για να αποκτήσετε πρόσβαση σε κώδικα από άλλο χώρο ονομάτων, χρησιμοποιείτε μια σημειογραφία για να καθορίσετε τη διαδρομή προς το αναγνωριστικό.

Ακολουθεί ένα παράδειγμα πρόσβασης σε μια συνάρτηση από διαφορετικό χώρο ονομάτων:

// αρχείο στον χώρο ονομάτων folder1
καπηλειόστντοσιέ() -> u32 {
// κάποιο σώμα συνάρτησης εδώ
ΕΠΙΣΤΡΟΦΗ0;
}
// αρχείο στον χώρο ονομάτων folder2
χρήση folder1::folder;
καπηλειόστΕυρετήριο() {
// πρόσβαση στη συνάρτηση φακέλου από τον χώρο ονομάτων folder1
αφήνω folder_func = folder();
}

Το πρόγραμμα ορίζει δύο ενότητες Rust σε διαφορετικούς χώρους ονομάτων, φάκελο 1 και φάκελο 2 αντίστοιχα. ο φάκελο 1 Η ενότητα περιέχει μια δημόσια λειτουργία ντοσιέ που επιστρέφει μια ακέραια τιμή χωρίς υπογραφή 32 bit.

ο φάκελο 2 η μονάδα εισάγει το ντοσιέ λειτουργία από το φάκελο 1 χώρο ονομάτων με το χρήση λέξη-κλειδί, επιτρέποντας την Ευρετήριο λειτουργία για πρόσβαση στο ντοσιέ λειτουργία από το φάκελο 1 μονάδα μέτρησης. ο Ευρετήριο η συνάρτηση καλεί το ντοσιέ συνάρτηση και η επιστρεφόμενη τιμή εκχωρείται στο folder_func μεταβλητός.

Θα χρειαστεί να γράψετε κεφαλαία το όνομα των αναγνωριστικών από ένα πακέτο ή κιβώτιο για να τα εξαγάγετε. Όταν εξάγετε ένα αναγνωριστικό, το κάνετε προσβάσιμο σε άλλα πακέτα που χρησιμοποιούν τον κωδικό.

Ακολουθεί ένα παράδειγμα δημόσιας λειτουργίας που μπορεί να εξαχθεί.

Η λειτουργία // εξάγεται σε άλλα πακέτα και κιβώτια
καπηλειόστMyFunction() {
// κάποιο σώμα συνάρτησης εδώ
}

Θα χρειαστεί επίσης να χρησιμοποιήσετε το καπηλειό λέξη-κλειδί. Στο Rust, το καπηλειό λέξη-κλειδί είναι σύντομη για δημόσιο. Όταν μια συνάρτηση, δομή, enum, οποιονδήποτε τύπο δεδομένων Rust ή το module επισημαίνεται με τη λέξη-κλειδί pub, γίνεται προσβάσιμο εκτός της ενότητας του. Το στοιχείο είναι ιδιωτικό στη μονάδα του χωρίς τη λέξη-κλειδί pub και μπορεί να προσπελαστεί μόνο μέσα από αυτό.

Καθορισμός ενοτήτων για τον έλεγχο του εύρους και του απορρήτου

Μπορείτε να χρησιμοποιήσετε μονάδες για να ελέγξετε το εύρος και το απόρρητο στα προγράμματα Rust. Οι μονάδες σάς επιτρέπουν να οργανώνετε τον κώδικα σε λογικές μονάδες που είναι πιο εύκολο να διαχειριστείτε και να διατηρήσετε.

Μπορείτε να δηλώσετε ενότητες με το mod λέξη-κλειδί ακολουθούμενη από το όνομα της μονάδας και τα σγουρά σιδεράκια. Ο καθορισμός μιας νέας λειτουργικής μονάδας δημιουργεί έναν νέο χώρο ονομάτων για τα περιεχόμενά της, που σημαίνει ότι λειτουργεί, δομές ή άλλα στοιχεία που ορίζονται στη λειτουργική μονάδα είναι προσβάσιμα μόνο εντός της λειτουργικής μονάδας εκτός από τη ρητή εξαγωγή τους.

Οι μονάδες βοηθούν στην αποφυγή διενέξεων ονομάτων, καθιστώντας τον κώδικα πιο διαισθητικό στην κατανόηση.

Ακολουθεί η σύνταξη για μια απλή ενότητα:

mod my_module {
// τα περιεχόμενα της ενότητας πηγαίνουν εδώ
}

Εντός της λειτουργικής μονάδας, μπορείτε να ορίσετε μεταβλητές, συναρτήσεις, δομές, αριθμούς και άλλους τύπους.

mod my_module {
στadd_numbers(ένα: i32, β: i32) -> i32 {
 α + β
 }
}

Μπορείτε να χρησιμοποιήσετε το καπηλειό λέξη-κλειδί για εξαγωγή της συνάρτησης και πρόσβαση στη λειτουργία σε άλλα μέρη του προγράμματος.

mod my_module {
καπηλειόστadd_numbers(ένα: i32, β: i32) -> i32 {
 α + β
 }
}

Τώρα, μπορείτε να καλέσετε το add_numbers λειτουργία από άλλα μέρη του προγράμματός σας.

Μπορείτε επίσης να ελέγξετε το απόρρητο των μονάδων με το καπηλειό λέξη-κλειδί για τους ορισμούς της ενότητας.

καπηλειόmod my_module {
καπηλειόστadd_numbers(ένα: i32, β: i32) -> i32 {
 α + β
 }
}

Τώρα το my_module Η ενότητα είναι δημόσια και μπορείτε να έχετε πρόσβαση στη λειτουργική μονάδα από άλλες λειτουργικές μονάδες.

Εάν πρέπει να κάνετε μια λειτουργική μονάδα ή ένα στοιχείο προσβάσιμο σε μια συγκεκριμένη λειτουργική μονάδα ή σύνολο λειτουργιών, μπορείτε να χρησιμοποιήσετε το παμπ (κιβώτιο) λέξη-κλειδί. ο παμπ (κιβώτιο) Η λέξη-κλειδί καθιστά το αντικείμενο προσβάσιμο από μονάδες εντός του ίδιου κιβωτίου αλλά όχι από μονάδες σε άλλα κιβώτια.

mod my_module {
καπηλειόstructMyStruct {
καπηλειό(σακαράκα) some_field: u32,
 }
}

Τώρα μπορείτε να αποκτήσετε πρόσβαση στο συγκεκριμένο στοιχείο (σε αυτήν την περίπτωση, το some_field πεδίο του MyStruct struct) σε άλλα μέρη του προγράμματός σας.

στκύριος() {
αφήνω my_struct = my_module:: MyStruct { some_field: 42 };
println!("{}", my_struct.some_field);
}

ο my_struct η μεταβλητή είναι ένα παράδειγμα του MyStruct struct. Η μεταβλητή έχει πρόσβαση στη δομή με το διαχωριστικό διαδρομής (::). ο κύριος η λειτουργία εκτυπώνει το some_field πεδίο της κατασκευής με το println! μακροεντολή.

Το μοντέλο ιδιοκτησίας της Rust διασφαλίζει την ασφάλεια της μνήμης

Η οργάνωση του κώδικα Rust είναι ένας τρόπος για να διασφαλίσετε ότι ο κώδικας σας είναι εύκολο να διατηρηθεί και να υποστηριχθεί με την πάροδο του χρόνου. Είναι πιο εύκολο να αντιμετωπίσετε σφάλματα και να διασφαλίσετε την ασφάλεια σε καλά οργανωμένο κώδικα που ακολουθεί τους κανόνες και τις συμβάσεις της κοινότητας Rust.

Από προεπιλογή, το Rust διασφαλίζει ότι τα προγράμματα είναι ασφαλή στη μνήμη με ένα ενσωματωμένο μοντέλο ιδιοκτησίας. Το μοντέλο ιδιοκτησίας διασφαλίζει την ασφάλεια της μνήμης διασφαλίζοντας ότι οι μεταβλητές στη μνήμη έχουν έναν μοναδικό ιδιοκτήτη. Το μοντέλο ιδιοκτησίας αποτρέπει τα ίχνη δεδομένων και πολλούς τύπους σφαλμάτων μνήμης.