Learn Rust Coding · Ders

Gölgeleme

Değişkenleri yeniden bağlama

Gölgeleme, CoddyKit'te ücretsiz bir Learn Rust Coding dersidir. Bu, 4 dersinin 4. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, Learn Rust Coding öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Learn Rust Coding kursu toplamda 4 dersten oluşur.

Gölgeleme Nedir?

Gölgeleme, öncekiyle aynı ada sahip yeni bir değişken tanımlamak demektir. Yeni bağlama eskisini 'gölgeler'.

Bunu aynı adı taşıyan let ifadesini tekrarlayarak yaparsınız.

fn main() {
    let x = 5;
    let x = x + 1;
    let x = x * 2;
    println!("x is {}", x);
}

Gölgeleme Değiştirme Değildir

Gölgeleme yepyeni bir değişken oluşturur. Bu, aynı değişkeni yeniden kullanan mut'tan farklıdır.

Her let yeni bir bağlama olduğundan değerlerin türleri bile farklı olabilir.

fn main() {
    let y = 10;        // immutable
    let y = y + 5;     // new binding, also immutable
    println!("y is {}", y);
}

Gölgelemeyle Türleri Değiştirme

Gölgelemenin güçlü kullanım alanlarından biri, türünü değiştirirken bir adı yeniden kullanmaktır.

Burada bir dize, aynı ad altında sayıya ayrıştırılır.

fn main() {
    let spaces = "   ";
    let spaces = spaces.len();
    println!("count is {}", spaces);
}

mut Neden Türü Değiştiremez?

mut ile değeri değiştirebilirsiniz, ancak türü değiştiremezsiniz.

Bu kod derlenemez:

let mut spaces = " ";
spaces = spaces.len(); — tür uyuşmazlığı hatası.

Gölgeleme, yeni bir değişken oluşturduğu için bu sorunu önler.

fn main() {
    let mut count = 3;
    count = 4; // ok, same type
    println!("{}", count);
}

İç Kapsamlarda Gölgeleme

Bir değişken, içteki bir blok içinde gölgelenebilir. Blok sona erdiğinde dıştaki bağlama yeniden görünür olur.

fn main() {
    let n = 1;
    {
        let n = n * 10;
        println!("inner {}", n);
    }
    println!("outer {}", n);
}

Adım Adım Dönüştürme

Gölgeleme, tek ve anlaşılır bir adı korurken bir değeri birkaç adımda dönüştürmenizi sağlar.

fn main() {
    let input = "42";
    let input: i32 = input.trim().parse().unwrap();
    let input = input * 2;
    println!("result {}", input);
}

Gölgeleme Değişmezliği Korur

Gölgelenen her bağlama değişmez kalır. Bir dönüşümden sonra x2 veya x_temp gibi yeni adlar uydurmadan değişmezliğin güvenliğini korursunuz.

fn main() {
    let price = 100;
    let price = price - 20;   // discount applied
    let price = price + 5;    // shipping added
    println!("final price {}", price);
}

Farklı Mantıkla Gölgeleme

Yeni değeri, işlev çağrıları veya ifadeler de dâhil olmak üzere istediğiniz yöntemle hesaplayabilirsiniz.

fn main() {
    let text = "hello";
    let text = text.to_uppercase();
    println!("{}", text);
}

Karışıklığı Önleme

Gölgeleme kullanışlıdır, ancak aşırı kullanımı okuyucuların kafasını karıştırabilir. Bunu adları rastgele yeniden kullanmak için değil, her adım aynı kavramın açık bir dönüşümüyse kullanın.

fn main() {
    let raw = "  Rust  ";
    let raw = raw.trim();      // clean version
    println!("[{}]", raw);
}

Gölgeleme ve Yeniden Atama Özeti

Bir ada yeni bir değer vermenin iki yolu:

Gölgeleme: let x = ...; ifadesini yeniden kullanma — yeni değişken oluşturur, türü değiştirebilir ve değişmez kalır.
Yeniden atama: mut ile x = ...; — aynı değişkendir ve aynı tür gerekir.

fn main() {
    let val = "7";
    let val: i32 = val.parse().unwrap(); // shadow + type change
    let mut val = val;
    val += 1;                            // reassign, same type
    println!("{}", val);
}

Uygulamalı Bir Örnek

Kullanıcı verilerini okuma ve dönüştürme, gölgelemenin klasik bir kullanım alanıdır: tür metinden sayıya değişirken anlamlı age adını koruyabilirsiniz.

fn main() {
    let age = "25";
    let age: u32 = age.parse().unwrap();
    let age = age + 1; // next birthday
    println!("next year you will be {}", age);
}

Hızlı Kontrol

Gölgelemeyi mut kullanmaktan ayıran özelliği belirleyin.

Özet

Rust'ta gölgeleme:

Aynı ada sahip let ifadesini tekrarlayarak yeni bir bağlama oluşturun.
Yeni bağlamanın türü farklı olabilir.
Gölgelenen her değer değişmez kalır.
Aynı değişkeni değiştiren ve türünü koruyan mut'tan farklıdır.

fn main() {
    let data = "100";
    let data: i32 = data.parse().unwrap();
    let data = data / 4;
    println!("final {}", data);
}

Sıkça Sorulan Sorular

“Gölgeleme” dersi ücretsiz mi?

Evet — “Gölgeleme” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve Learn Rust Coding kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Learn Rust Coding kursu toplamda 4 dersten oluşur.

“Gölgeleme” dersinde ne öğreneceğim?

Değişkenleri yeniden bağlama Learn Rust Coding ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

Learn Rust Coding öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te Learn Rust Coding, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 4. dersidir.

“Gölgeleme” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu Learn Rust Coding dersinde kod yazıp çalıştırabilir miyim?

Evet. Her Learn Rust Coding dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

← Learn Rust Coding Sayfasına Dön