Learn Rust Coding · Ders

Fn, FnMut, FnOnce

Kapanış özellikleri

Fn, FnMut, FnOnce, 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.

Closure Özellikleri

Her closure, yakalanan değerleri nasıl kullandığına bağlı olarak üç özellikten birini veya daha fazlasını otomatik olarak uygular:

Fn — değişmez olarak ödünç alır.
FnMut — değişebilir olarak ödünç alır.
FnOnce — sahipliği alır ve bir kez çağrılabilir.

fn main() {
    let x = 5;
    let show = || println!("x is {}", x); // implements Fn
    show();
    show();
}

Fn: Değişmez Ödünç Alma

Yalnızca yakalanan değerleri okuyan bir closure, Fn özelliğini uygular. Hiçbir şeyi değiştirmeden birçok kez çağrılabilir.

fn main() {
    let greeting = String::from("Hi");
    let say = || println!("{}", greeting);
    say();
    say();
}

FnMut: Değişebilir Ödünç Alma

Yakalanan bir değeri değiştiren bir closure, FnMut özelliğini uygular. Çağırabilmek için closure değişkeninin kendisi mut olmalıdır.

fn main() {
    let mut count = 0;
    let mut increment = || {
        count += 1;
        println!("count {}", count);
    };
    increment();
    increment();
}

FnOnce: Sahipliği Alma

Yakalanan bir değeri ortamdan dışarı taşıyan bir closure, FnOnce özelliğini uygular. Yalnızca bir kez çağrılabilir.

fn main() {
    let name = String::from("Ada");
    let consume = move || {
        let owned = name;
        println!("consumed {}", owned);
    };
    consume();
}

Özellik Hiyerarşisi

Özellikler bir hiyerarşi oluşturur:

Her Fn aynı zamanda FnMut ve FnOnce'tır.
Her FnMut aynı zamanda FnOnce'tır.

Dolayısıyla Fn en esnek, FnOnce ise en az esnek özelliktir.

fn main() {
    let value = 42;
    let read = || value; // Fn, so also FnMut and FnOnce
    println!("{}", read());
}

İşlevlere Fn Geçirme

Bir işlev, hangi özelliğe ihtiyaç duyduğunu belirterek closure kabul edebilir. Bir özellik sınırıyla birlikte genel türler kullanın.

fn apply<F: Fn(i32) -> i32>(f: F, x: i32) -> i32 {
    f(x)
}

fn main() {
    let double = |n| n * 2;
    println!("{}", apply(double, 9));
}

FnMut Kabul Etme

İşlevinizin yakalanan durumu değiştirmesi gerekiyorsa FnMut isteyin ve parametreyi mut olarak işaretleyin.

fn call_twice<F: FnMut()>(mut f: F) {
    f();
    f();
}

fn main() {
    let mut total = 0;
    call_twice(|| total += 1);
    // note: total is borrowed during the call
}

FnOnce Kabul Etme

Bir işlev closure'ı yalnızca bir kez çağırıyor ve değerleri tüketmesine izin verebiliyorsa FnOnce isteyin.

fn run_once<F: FnOnce() -> String>(f: F) {
    let result = f();
    println!("{}", result);
}

fn main() {
    let s = String::from("done");
    run_once(move || s);
}

move Anahtar Sözcüğü

move anahtar sözcüğü, bir closure'ı yakalanan değişkenleri ödünç almak yerine onların sahipliğini almaya zorlar.

Bu, bir closure'ın oluşturulduğu kapsamdan daha uzun süre yaşaması gerektiğinde, örneğin iş parçacıklarında, zorunludur.

fn main() {
    let data = vec![1, 2, 3];
    let printer = move || println!("{:?}", data);
    printer();
}

Rust Özelliği Nasıl Seçer?

Özelliği elle seçmezsiniz. Derleyici, closure gövdesine göre karar verir:

Yalnızca okur → Fn
Değiştirir → FnMut
Yakalanan bir değeri dışarı taşır → FnOnce

fn main() {
    let mut log = Vec::new();
    let mut record = |x: i32| log.push(x); // FnMut
    record(1);
    record(2);
    println!("{:?}", log);
}

Doğru Sınırı Seçme

Genel kural olarak:

Yalnızca çağırmanız ve okumanız gerekiyorsa Fn kabul edin.
Closure durumu değiştiriyorsa FnMut kabul edin.
Bir kez çağırmak yeterliyse FnOnce kabul edin.

İhtiyacınızı karşılayan en esnek sınırı seçin.

fn each<F: Fn(i32)>(items: &[i32], f: F) {
    for &i in items {
        f(i);
    }
}

fn main() {
    each(&[1, 2, 3], |n| println!("got {}", n));
}

Hızlı Kontrol

Bir closure davranışını ilgili özelliğiyle eşleştirin.

Tekrar

Üç closure özelliği:

Fn — değişmez olarak ödünç alır, tekrar tekrar çağrılabilir.
FnMut — değişebilir olarak ödünç alır, durumu değiştirebilir.
FnOnce — sahipliği alır, bir kez çağrılabilir.

Derleyici özelliği çıkarır; move sahipliğin yakalanmasını zorunlu kılar.

fn main() {
    let base = 5;
    let adder = move |x: i32| x + base; // Fn, captures base by move
    println!("{}", adder(10));
}

Sıkça Sorulan Sorular

“Fn, FnMut, FnOnce” dersi ücretsiz mi?

Evet — “Fn, FnMut, FnOnce” 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.

“Fn, FnMut, FnOnce” dersinde ne öğreneceğim?

Kapanış özellikleri 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.

“Fn, FnMut, FnOnce” 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