Mengatur Proyek Karat Dengan Paket, Jalur, dan Modul

Rust adalah pilihan yang sangat baik untuk membangun aplikasi yang kompleks dan andal. Salah satu keterampilan penting untuk mengembangkan aplikasi Rust adalah menyusun proyek Anda secara efektif, termasuk menggabungkan paket pihak ketiga.

Organisasi proyek yang efektif sangat penting untuk mengembangkan aplikasi Rust. Aplikasi Rust yang terstruktur dengan baik meningkatkan kolaborasi dan integrasi aplikasi pihak ketiga yang mudah, secara signifikan mengurangi waktu dan upaya yang diperlukan untuk pengembangan aplikasi. Rust menyediakan manajer paket bawaan dan alat lain untuk organisasi dan manajemen kode yang efektif.

Menyiapkan Proyek Karat

Menyiapkan proyek Rust itu mudah setelah Anda menginstal Rust di mesin Anda; Anda dapat menggunakan Cargo (pengelola paket dan sistem build bawaan Rust) untuk membuat dan mengonfigurasi proyek Rust. Ini mirip dengan manajer paket lain seperti npm untuk Node.js

Dan pip untuk Python. Cargo mengelola dependensi, mengkompilasi kode, dan membuat dokumentasi, menjadikannya alat penting untuk pengembangan Rust.

Jalankan perintah ini untuk memverifikasi pemasangan Cargo Anda:

kargo --versi

Perintah tersebut menampilkan versi Cargo yang terinstal.

Anda dapat membuat proyek Rust baru dengan kargo baru memerintah. Anda harus menentukan nama proyek.

kargo my_project baru

Perintah tersebut akan membuat direktori baru di direktori saat ini yang berisi file-file dasar yang Anda perlukan untuk proyek Rust Anda, termasuk a cargo.toml file untuk mengelola dependensi proyek Anda.

Ruang Nama Paket Karat

Paket dan peti adalah komponen penting dalam Rust. Peti adalah pustaka atau binari yang dapat digunakan dan dikompilasi oleh pengembang Rust untuk penggunaan tertentu, dan paket adalah kumpulan peti. Paket biasanya berisi peti yang menyimpan kode yang dapat digunakan kembali dan biner yang menyediakan CLI untuk peti perpustakaan.

Peti harus berisi Kargo.toml file yang berisi metadata tentang paket, seperti nama, versi, dependensi, dan skrip build.

Paket Rust mengikuti konvensi penamaan untuk menghindari konflik penamaan antar paket. Nama paket harus unik secara global, huruf kecil, dan hanya berisi huruf, angka, dan tanda hubung. Jika nama paket berisi banyak kata, pisahkan dengan tanda hubung, mis. hyper-server.

Anda dapat mengakses kode dalam namespace paket Rust dengan menggunakan kata kunci diikuti dengan nama paket dan peti.

Berikut adalah contoh mengimpor an Rng fungsi dari a rand peti:

menggunakan rand:: Rng;

Anda dapat membuat beberapa ruang nama untuk paket. Saat Anda membuat folder, Anda membuat namespace baru yang dapat Anda akses dengan notasi titik untuk menentukan jalur ke pengidentifikasi.

Di Rust, bisa ada beberapa ruang nama untuk paket. Saat Anda membuat folder, Anda membuat namespace baru. Untuk mengakses kode dari namespace lain, Anda menggunakan notasi titik untuk menentukan jalur ke pengidentifikasi.

Berikut adalah contoh mengakses fungsi dari namespace yang berbeda:

// file di ruang nama folder1
pubfnmap() -> u32 {
// beberapa fungsi tubuh di sini
kembali0;
}
// file di ruang nama folder2
menggunakan folder1::folder;
pubfndirektori() {
// mengakses fungsi folder dari namespace folder1
membiarkan folder_fungsi = folder();
}

Program ini mendefinisikan dua modul Rust di ruang nama yang berbeda, folder1 Dan folder2 masing-masing. Itu folder1 modul berisi fungsi publik map yang mengembalikan nilai integer 32-bit unsigned.

Itu folder2 modul mengimpor map fungsi dari folder1 namespace dengan menggunakan kata kunci, memungkinkan direktori berfungsi untuk mengakses map fungsi dari folder1 modul. Itu direktori fungsi memanggil map fungsi, dan nilai pengembalian ditugaskan ke folder_fungsi variabel.

Anda harus mengkapitalisasi nama pengidentifikasi dari paket atau peti untuk mengekspornya. Saat Anda mengekspor pengidentifikasi, Anda membuatnya dapat diakses di paket lain yang menggunakan kode tersebut.

Berikut adalah contoh fungsi publik yang dapat diekspor.

// fungsi diekspor ke paket dan peti lain
pubfnFungsiku() {
// beberapa fungsi tubuh di sini
}

Anda juga harus menggunakan pub kata kunci. Di Rust, pub kata kunci adalah kependekan dari publik. Ketika sebuah fungsi, struct, enum, semua tipe data Rust atau modul ditandai dengan kata kunci pub, itu dapat diakses di luar modulnya. Item bersifat pribadi untuk modulnya tanpa kata kunci pub dan hanya dapat diakses dari dalamnya.

Mendefinisikan Modul untuk Mengontrol Ruang Lingkup dan Privasi

Anda dapat menggunakan modul untuk mengontrol ruang lingkup dan privasi dalam program Rust. Modul memungkinkan Anda mengatur kode menjadi unit logis yang lebih mudah dikelola dan dipelihara.

Anda dapat mendeklarasikan modul dengan mod kata kunci diikuti dengan nama modul dan kurung kurawal. Mendefinisikan modul baru akan membuat ruang nama baru untuk isinya, artinya fungsi, struktur, atau item lain yang ditentukan dalam modul hanya dapat diakses di dalam modul kecuali Anda mengekspor secara eksplisit mereka.

Modul membantu mencegah konflik penamaan, membuat kode lebih intuitif untuk dipahami.

Berikut sintaks untuk modul sederhana:

mod modul_saya {
// konten modul pergi ke sini
}

Di dalam modul, Anda dapat menentukan variabel, fungsi, struct, enum, dan jenis lainnya.

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

Anda dapat menggunakan pub kata kunci untuk mengekspor fungsi dan mengakses fungsi di bagian lain program.

mod modul_saya {
pubfnadd_numbers(A: i32, B: i32) -> i32 {
 a + b
 }
}

Sekarang, Anda dapat memanggil add_numbers fungsi dari bagian lain dari program Anda.

Anda juga dapat mengontrol privasi modul dengan pub kata kunci pada definisi modul.

pubmod modul_saya {
pubfnadd_numbers(A: i32, B: i32) -> i32 {
 a + b
 }
}

Sekarang, my_module modul bersifat publik, dan Anda dapat mengakses modul dari modul lain.

Jika Anda perlu membuat modul atau item dapat diakses oleh modul atau set modul tertentu, Anda dapat menggunakan pub (peti) kata kunci. Itu pub (peti) kata kunci membuat item dapat diakses dari modul di dalam peti yang sama tetapi tidak dari modul di peti lain.

mod modul_saya {
pubstructStruktur Saya {
pub(peti) beberapa_bidang: u32,
 }
}

Anda sekarang dapat mengakses item tertentu (dalam hal ini, file beberapa_bidang bidang dari Struktur Saya struct) di bagian lain dari program Anda.

fnutama() {
membiarkan my_struct = my_module:: MyStruct { beberapa_bidang: 42 };
cetak!("{}", my_struct.some_field);
}

Itu my_struct variabel adalah turunan dari Struktur Saya struct. Variabel mengakses struct dengan pemisah jalur (::). Itu utama fungsi mencetak beberapa_bidang bidang struct dengan cetak! makro.

Model Kepemilikan Rust Memastikan Keamanan Memori

Mengatur kode Rust adalah salah satu cara untuk memastikan kode Anda mudah dipelihara dan didukung dari waktu ke waktu. Lebih mudah untuk mengatasi bug dan memastikan keamanan dalam kode yang terorganisir dengan baik yang mengikuti aturan dan konvensi komunitas Rust.

Secara default, Rust memastikan program aman dari memori dengan model kepemilikan bawaan. Model kepemilikan memastikan keamanan memori dengan memastikan bahwa variabel dalam memori memiliki satu pemilik unik. Model kepemilikan mencegah jejak data dan berbagai jenis kesalahan memori.