Bahasa pemrograman berbeda dalam cara menangani memori dan menerapkan aturan manajemen memori. Go dan Python mempekerjakan pengumpul sampah, sehingga pengembang dapat fokus pada penulisan kode. C dan C++ memberikan tanggung jawab programmer untuk mengelola memori pada tingkat yang lebih rendah.
Rust memperlakukan manajemen memori secara berbeda, menggunakan konsep yang disebut kepemilikan dan peminjaman. Ini menggunakan "pemeriksa pinjaman" untuk menegakkan keamanan memori secara efisien.
Apa Itu Kepemilikan?
Kepemilikan adalah fitur dan konvensi Rust yang membantu memastikan keamanan memori program tanpa pengumpul sampah. Ini cara lain untuk mengatasi masalah kebocoran memori dalam kode Anda.
Kompilator Rust memeriksa apakah suatu program mematuhi aturan kepemilikan pada waktu kompilasi. Jika program mengikuti aturan ini, program dapat berjalan. Jika tidak, kompiler menolak untuk menghasilkan executable.
Rust memverifikasi aturan kepemilikan menggunakan pinjam pemeriksa. Pemeriksa peminjam memverifikasi model kepemilikan dan memutuskan apakah suatu nilai dalam memori (
tumpukan atau tumpukan) di luar jangkauan atau tidak. Jika suatu nilai berada di luar cakupannya, nilai tersebut tidak dapat diakses oleh bagian lain dari program kecuali jika dipinjam.Aturan Kepemilikan
Di Rust, setiap variabel memiliki nilai yang diinisialisasinya, dan hanya ada satu pemilik. Setelah pemilik berada di luar ruang lingkup, nilainya dijatuhkan. Penting untuk memahami detail aturan kepemilikan.
Aturan kepemilikan pertama adalah bahwa setiap variabel memiliki nilai yang diinisialisasi.
membiarkan pemilik = Rangkaian::dari satu");
Itu pemilik variabel di atas memiliki string satu dan, tidak seperti bahasa seperti Python dan Go, nilai tersebut akan dihapus pada penugasan ulang variabel.
Aturan kepemilikan kedua adalah bahwa dua variabel tidak dapat menunjuk ke lokasi memori yang sama; setiap nilai hanya dapat memiliki satu pemilik.
membiarkan pemilik_baru = pemilik;
Itu pemilik baru variabel sekarang memiliki nilai yang disimpan di lokasi memori dari pemilik variabel. Jika Anda mencoba menggunakan pemilik variabel, compiler akan panik, dan akan menolak untuk menghasilkan executable.
Di sebagian besar bahasa yang menggunakan pengumpul sampah, dua variabel dapat menunjuk ke lokasi memori yang sama. Berikut ini contoh kode JavaScript yang setara:
membiarkan pemilik = "pemilik";
membiarkan pemilik_baru = pemilik;
menghibur.log (pemilik_baru);
Menjalankan kode JavaScript di atas berfungsi tanpa kesalahan, dan jika Anda melakukan hal yang sama di Go atau Python, program Anda juga akan berfungsi tanpa kesalahan.
Aturan kepemilikan ketiga adalah bahwa begitu sebuah variabel keluar dari ruang lingkup yang dideklarasikan, nilainya akan dihapus, dan memori tidak dialokasikan.
// variabel dalam lingkup terpisah
{
membiarkan contoh = Rangkaian::from("Ini adalah ruang lingkup baru");
}
mencetak!("{}", contoh)
Anda tidak dapat mengakses contoh variabel di luar ruang lingkupnya; mencoba melakukannya akan menyebabkan kompiler panik.
Kepemilikan dalam Fungsi
Saat Anda meneruskan nilai ke fungsi sebagai argumen, fungsi tersebut dapat mengakses variabel tersebut meskipun tidak dideklarasikan dalam cakupannya:
fnpencetak(nilai: Rangkaian) -> Rangkaian {
kembali nilai
}fnutama() {
membiarkan x = Rangkaian::from("Mencetak nilai"); // x memiliki nilai string
// kepemilikan dipindahkan ke fungsi printer di sini
mencetak!("{} The Hasil dari Printing X adalah -:", printer (x));
}
Fungsi dapat mengakses variabel itu karena Rust memindahkan kepemilikannya ke fungsi pada waktu kompilasi.
Anda mungkin berpikir masih mungkin untuk menggunakan variabel nanti dalam cakupan aslinya:
fnpencetak(nilai: Rangkaian) -> Rangkaian {
kembali nilai
}fnutama() {
membiarkan x = Rangkaian::from("Mencetak nilai");
mencetak!("{} The Hasil dari Mencetak x apakah itu -:", printer (x));
// Mencoba menggunakan variabel setelah kepemilikan nilainya telah ditransfer
cetak!("{} seharusnya tidak bisa diakses", x)
}
Tetapi jika Anda mencoba ini, kompiler akan panik dan menolak untuk menghasilkan yang dapat dieksekusi:
Rust Memprioritaskan Penggunaan Kembali Kode
Penggunaan kembali kode adalah praktik penting, tetapi untuk mempraktikkan penggunaan kembali kode, Anda perlu memahami aturan kepemilikan Rust.
Rust adalah bahasa pemrograman yang sangat fleksibel. Ini memberikan konsep seperti meminjam, memindahkan, menyalin, dan mengkloning kepemilikan untuk penggunaan kembali variabel.