Ana içeriğe geç
Modül 1 · Ders 1 ders 2Kurstaki 1/14~10 min
Modül dersleri (1/2)

Değişkenler ve Değişebilirlik

Rust'ta değişken ve bellek yönetimi iki temel ilkeye göre yönlendirilir: güvenlik ve kontrol. Bu nedenle, diğer birçok programlama dilinin aksine, Rust'taki değişkenler varsayılan olarak değişmezdir.

Bu, bir değişkene bir değer atandıktan sonra değiştirilemeyeceği anlamına gelir. Eğer onu değiştirmeye çalışırsanız, derleyici bir hata verecektir.

Değişmez Değişkenler ve mut Anahtar Kelimesi

Bir değişken bildirmek için let anahtar kelimesini kullanırız:

Rust
let x = 5; // Immutable by default
// x = 6; // ERROR! The compiler will refuse to build this code.

Bir değişkenin değerini değiştirmeniz gerekiyorsa, let'den hemen sonra mut anahtar sözcüğünü kullanarak onu açıkça değiştirilebilir hale getirmelisiniz:

Rust
let mut y = 10; // Mutable
println!("Il valore di y e: {}", y);
y = 15; // Valid!
println!("Il valore modificato di y e: {}", y);

mut önekini kullanmak, derleyiciye ve kodu okuyan herkese, yürütme sırasında değerin değişeceğini açıkça bildirir.

Gölgeleme

Rust ayrıca, aynı ada sahip bir değişkenin let anahtar sözcüğü kullanılarak yeniden bildirilmesi anlamına gelen gölgeleme kavramına da izin verir. Yeni değişken öncekini "gölgeler" (veya örter):

Rust
let x = 5;
let x = x + 1; // Shadowing: x is now 6
let x = x * 2; // Shadowing: x is now 12

mut'dan farklı olarak gölgeleme şunları yapmanızı sağlar:

  1. Aynı adı koruyarak bir değişkenin veri türünü değiştirin.
  2. Dönüşümlerden sonra değişkenin değişmezliğini koruyun.
Rust
let spaces = "   "; // Type: &str (string)
let spaces = spaces.len(); // Type: usize (number)

Gölgelendirmenin Yararlılığı ve Kapsamları

Gölgelendirme aynı blokla sınırlı değildir; bir değeri geçici olarak geçersiz kılmak için iç içe bloklar ({}) içinde kullanılabilir. İç blok sona erdiğinde orijinal değişken tekrar görünür hale gelir:

Rust
let x = 5;
{
    let x = x * 2; // Shadowing valid only inside the block
    println!("Value in the inner block: {}", x); // Prints 10
}
println!("Value in the outer block: {}", x); // Prints 5

Bu mekanizma son derece güvenli ve etkilidir çünkü tamamen derleme zamanında gerçekleşir ve herhangi bir çalışma zamanı performansı ek yükü olmadan tür güvenliği sağlar.


Kendin dene

Egzersiz#rust.m1.l1.e1
Denemeler: 0Yükleniyor…

Başlangıç ​​değeri 5 olan x adında değiştirilebilir bir değişken bildirin. Daha sonra, x'e 10 ekleyin ve println! komutunu kullanarak bunu ekrana yazdırın. makro.

Düzenleyici yükleniyor…
İpucu göster

Değişkeni `let mut x = 5;` ile bildirin, ardından onu `x += 10;` (veya `x = x + 10;`) ile artırın ve son olarak `println!('{}', x);` ile yazdırın.

3 denemeden sonra çözüm mevcut

Egzersiz#rust.m1.l1.e2
Denemeler: 0Yükleniyor…

10 değerine sahip değişmez bir y değişkeni bildirin. Gölge y'yi let ile tekrar bildirerek önceki değerini 2 ile çarpın ve son olarak println! kullanarak yazdırın.

Düzenleyici yükleniyor…
İpucu göster

Use `let y = 10;`, then shadow it by declaring it again with `let y = y * 2;` and finally use `println!` to display it.

3 denemeden sonra çözüm mevcut

Egzersiz#rust.m1.l1.e3
Denemeler: 0Yükleniyor…

Declare an immutable variable named input containing the string value "42". Shadow input by declaring it as an integer of type i32, converting the original value via input.parse::<i32>().unwrap(). Finally, print it using the println! macro.

Düzenleyici yükleniyor…
İpucu göster

Declare `let input = "42";`, then shadow it with `let input: i32 = input.parse().unwrap();` and print it using `println!("{}", input);`.

3 denemeden sonra çözüm mevcut