Hadi gelin, bu hataları nasıl daha kolay anlayabileceğimizi ve bunlardan nasıl kaçınabileceğimizi konuşalım. Rust’ta karşılaştığınız ilk hata: Ownership ve Borrowing hataları. Bu hata, her şeyden önce, dilin bellek güvenliği özellikleriyle bağlantılı. Yani, bu hataları anlamak ve çözmek, kodunuzu daha güvenli ve stabil hale getirecektir. Hazırsanız, başlıyoruz!
Ownership (Sahiplik) Nedir?
Rust’ın sahiplik sistemi, bellek güvenliğini sağlamak için oldukça güçlü bir yöntemdir. Ama ne yazık ki, bu sistem bazen kafa karıştırıcı olabilir. İşte temel bir kural: Rust’da her değerin bir sahibi vardır. Bir değer bir değişkene atandığında, o değişken değerin sahibi olur. Değeri bir başkasına geçirmek isterseniz, bu "ownership" devri yapılır ve eski değişkenin o değere erişimi sona erer.
Örnek üzerinden bakalım:
fn main() {
let s1 = String::from("Merhaba Rust!");
let s2 = s1; // s1'in ownership'i s2'ye geçiyor
println!("{}", s1); // Hata! s1 artık geçerli değil
}
Yukarıdaki kodda, `s1` değişkeni bir `String` değerini tutuyor ve `s2`'ye atandığında, `s1` değişkeninin sahipliği `s2`'ye geçiyor. Ancak, `s1`'e yeniden erişmeye çalıştığınızda, Rust bir hata veriyor çünkü `s1` artık geçerli değil. İşte bu, *ownership* hatasının temel örneği.
Borrowing (Ödünç Alma) Nedir?
Ödünç alma, bir değerin sahipliğini devretmeden geçici olarak başka bir değişkene erişim sağlama işlemidir. Bu, Rust’ın sahiplik modelinin daha esnek bir yönüdür. Ancak burada da bazı kurallar var.
Rust, iki tür ödünç alma sunar:
- Immutable (Değiştirilemez) Borrowing: Bir değerin sadece okunmasına izin verir.
- Mutable (Değiştirilebilir) Borrowing: Bir değerin değiştirilmesine izin verir, ancak aynı anda sadece bir değişkenin bu değeri değiştirmesine izin verir.
İlk önce immutable borrowing örneğine bakalım:
fn main() {
let s = String::from("Rust borrows!");
let r1 = &s; // Immutable borrow
let r2 = &s; // Başka bir immutable borrow
println!("{} ve {}", r1, r2); // Kod sorunsuz çalışır
}
Burada, `s` değişkeninin hem `r1` hem de `r2` tarafından okunmasına izin verdik. Çünkü her iki ödünç alma da sadece okuma erişimi sağlıyor ve hiçbir değişiklik yapılmıyor.
Ancak mutable borrowing'de dikkat etmemiz gereken birkaç şey var. Sadece bir değişkenin aynı anda değiştirilebileceğine dikkat etmeliyiz:
fn main() {
let mut s = String::from("Rust borrows!");
let r1 = &mut s; // Mutable borrow
let r2 = &mut s; // Hata! Aynı anda iki mutable borrow yapamazsınız
println!("{}", r1);
}
Burada, `r1` ve `r2` aynı anda mutable olarak `s` değişkenine erişmeye çalışıyor. Rust bunu kabul etmiyor çünkü aynı anda birden fazla mutable borrow yapılmasına izin vermiyor. Bu, veri yarışlarını engellemeye yönelik bir güvenlik özelliğidir.
Ownership ve Borrowing Hatalarıyla Başa Çıkmak
Şimdi gelin, bu hata türlerini nasıl daha iyi anlayabiliriz. Öncelikle, hataların genellikle ne zaman ortaya çıktığını düşünelim. Eğer bir değer üzerinde değişiklik yapmaya çalışırken birden fazla referans varsa ya da bir değerin sahipliğini devretmeye çalışırken eski referansı kullanmaya kalkarsanız, Rust sizi hemen uyaracaktır. Ancak bu, Rust'ın sizi koruduğu bir durumdur ve sonunda hatayı bulup düzelttiğinizde kodunuz daha güvenli ve kararlı hale gelir.
Rust Hataları İçin İpuçları
1. Değişkenlerinizi izleyin: Özellikle büyük projelerde, hangi değişkenin hangi değeri tuttuğunu anlamak zor olabilir. Bu yüzden değişkenlerinizi dikkatlice izleyin. Bir değişkenin sahibi olduğu veriye başka bir değişkenin erişimine izin vermediğinizden emin olun.
2. Immutable ve Mutable Borrowing arasındaki farkı anlamak: İki tür borrowing arasındaki farkları iyi kavrayın. Eğer sadece okumak istiyorsanız, immutable borrowing’i tercih edin. Eğer değeri değiştirecekseniz, yalnızca bir mutable borrow kullanın.
3. Hataları okuyun ve sabırlı olun: Rust, hatalar konusunda oldukça açıklayıcıdır. Hata mesajları bazen kafa karıştırıcı olabilir, ancak dikkatli bir şekilde okuduğunuzda neyin yanlış olduğunu anlamak genellikle kolaylaşır.
