Learn Rust Coding · Ders

`Result` ile Sağlam Hata Yönetimi

Dayanıklı uygulamalar için `Result` numaralandırmasını, `?` işleçini ve özel hata türlerini kullanarak Rust'a özgü hata yönetimi uygulayın.

3. ders / 311 adım

`Result` ile Sağlam Hata Yönetimi, CoddyKit'te ücretsiz bir Learn Rust Coding dersidir. Bu, 3 dersinin 3. 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 3 dersten oluşur.

Rust'ta Hataları Ele Alma

Hatalar programlamanın bir parçasıdır. Rust'ta iki ana türü birbirinden ayırırız: kurtarılabilir ve kurtarılamaz hatalar.

Kurtarılamaz hatalar genellikle hatalara işaret eder ve programın panic! ile durmasına neden olur.
Kurtarılabilir hatalar, bir şeylerin ters gittiği ancak bunun ele alınabildiği anlamına gelir; örneğin bir dosyanın bulunamaması.

Rust, kurtarılabilir hatalarla zarif bir şekilde başa çıkmanıza yardımcı olur.

`panic!` ve `Result` Karşılaştırması

Kurtarılamaz bir hata oluştuğunda Rust, panic! makrosunu çağırır. Yığını çözerek programınızdan çıkar ve genellikle bir hata iletisi yazdırır.

Kurtarılabilir hatalar için Rust, Result numaralandırmasını kullanır. Bu numaralandırma, bir işlemin başarılı (Ok) mı yoksa başarısız (Err) mı olduğunu bildirerek programınızın bundan sonra ne yapacağına karar vermesini sağlar.

`Result` Numaralandırması

Result numaralandırması kavramsal olarak şöyle tanımlanır:

enum Result<T, E> { Ok(T), Err(E), }

T, başarı durumunda döndürülen değerin türünü belirtir.
E, hata durumunda döndürülen hata türünü belirtir.

Bu, bir işlevin başarısız olabileceğini açıkça belirtmenin güçlü bir yoludur.

`Result` ile Eşleştirme

Bir Result değerini ele almanın en yaygın yolu match ifadesini kullanmaktır. Bu, Result değerinin Ok veya Err olmasına göre farklı kod bloklarını çalıştırmanızı sağlar.

Bir sayıyı ayrıştırmayı deneyen bu örneği çalıştırmayı deneyin:

fn parse_and_add(text: &str) -> Result<i32, std::num::ParseIntError> {
    text.parse::<i32>()
}

fn main() {
    let num_str = "123";
    let result = parse_and_add(num_str);

    match result {
        Ok(num) => println!("Parsed number: {}", num),
        Err(e) => println!("Error parsing: {}", e),
    }

    let bad_str = "abc";
    let bad_result = parse_and_add(bad_str);

    match bad_result {
        Ok(num) => println!("Parsed number: {}", num),
        Err(e) => println!("Error parsing: {}", e),
    }
}

Sonuçları Açma (Dikkatli Olun!)

Bazen bir işlemin başarısız olmayacağından emin olabilir veya başarısız olduğunda programınızın çökmesini isteyebilirsiniz. unwrap() ve expect() gibi yöntemler Ok değerini çıkarır.

unwrap(): Ok değerini döndürür; değer Err ise paniğe neden olur.
expect("message"): unwrap() ile aynıdır, ancak özel bir panik iletisi sağlamanıza olanak tanır.

Bunları özellikle testlerde veya başarısızlığın gerçekten kurtarılamaz olduğu durumlarda, ölçülü kullanın.

`?` İşlecini Tanıma

Her Result için match ifadeleri yazmak tekrarlı olabilir. ? işlecِi, hataların yayılması için kısa ve öz bir kısayol sunar.

Bir Result döndüren ifadenin arkasına yerleştirildiğinde ? iki şey yapar:

Result değeri Err ise geçerli işlevden Err değerini hemen döndürür.
Result değeri Ok ise Ok değerini açar ve yürütmeye devam eder.

`?` İşleci İş Başında

? işlecِi, başarısız olabilecek işlevlerin yazımını çok daha temiz hâle getirir. ? kullanan işlevin kendisinin de bir Result (veya Option) döndürmesi gerektiğini unutmayın.

Bu dosya okuma örneğinde ? işlecinin hata işlemeyi nasıl basitleştirdiğine bakın:

use std::fs::File;
use std::io::{self, Read};

fn read_username_from_file() -> Result<String, io::Error> {
    let mut f = File::open("hello.txt")?; // Propagates error if file not found
    let mut s = String::new();
    f.read_to_string(&mut s)?; // Propagates error if read fails
    Ok(s)
}

fn main() {
    // Create a dummy file for the example to work
    // In a real scenario, this file might not exist
    std::fs::write("hello.txt", "CoddyKit User").unwrap();

    match read_username_from_file() {
        Ok(username) => println!("Username: {}", username),
        Err(e) => println!("Error reading username: {}", e),
    }

    // Clean up the dummy file
    std::fs::remove_file("hello.txt").unwrap();
}

Özel Hata Türleri

Bazen yerleşik hata türleri yeterince açıklayıcı değildir. Uygulamanızın farklı başarısızlık biçimlerini temsil etmek için numaralandırmaları kullanarak kendi özel hata türlerinizi tanımlayabilirsiniz.

Bu, hata iletilerinizi daha anlaşılır hâle getirir ve çağıranların belirli hataları farklı şekilde ele almasını sağlar.

Yaygın bir yaklaşım, bir işlevin veya modülün üretebileceği tüm olası hataları listeleyen bir numaralandırma oluşturmaktır.

`?` İşlecini Özel Hatalarla Kullanma

? işlecinin düşük düzeyli bir hatayı (örneğin io::Error) özel hata türünüze otomatik olarak dönüştürebilmesi için özel hata numaralandırmanızın, bu düşük düzeyli hata için From özelliğini uygulaması gerekir.

Bu, Rust'a bir hata türünü diğerine nasıl dönüştüreceğini söyler ve hata yayılımını sorunsuz hâle getirir.

use std::io;
use std::fs::File;
use std::io::Read;

#[derive(Debug)]
enum MyError {
    Io(io::Error),
    Parse(std::num::ParseIntError)
}

impl From<io::Error> for MyError {
    fn from(error: io::Error) -> Self {
        MyError::Io(error)
    }
}

impl From<std::num::ParseIntError> for MyError {
    fn from(error: std::num::ParseIntError) -> Self {
        MyError::Parse(error)
    }
}

fn read_config(path: &str) -> Result<i32, MyError> {
    let mut file = File::open(path)?; // io::Error converted to MyError::Io
    let mut contents = String::new();
    file.read_to_string(&mut contents)?; // io::Error converted to MyError::Io
    let value = contents.trim().parse::<i32>()?; // ParseIntError converted to MyError::Parse
    Ok(value)
}

fn main() {
    // Create a dummy file for the example
    std::fs::write("config.txt", "123").unwrap();

    match read_config("config.txt") {
        Ok(val) => println!("Config value: {}", val),
        Err(e) => println!("Failed to read config: {:?}", e),
    }

    std::fs::remove_file("config.txt").unwrap(); // Clean up

    // Example with a non-existent file
    match read_config("non_existent.txt") {
        Ok(val) => println!("Config value: {}", val),
        Err(e) => println!("Failed to read config: {:?}", e),
    }
}

Anlayışınızı Denetleyin

Aşağıdaki Rust kod parçacığını inceleyin. data.txt dosyası mevcut değilse çıktı ne olur?

İnteraktif derste cevapla

Özet: Sağlam Hata İşleme

Rust'ta sağlam hata yönetiminde ustalaştınız!

Result Enum'u: Başarılı durum için Ok(T) ile başarısız durum için Err(E) değerlerini birbirinden ayırır.
match: Result varyantlarını ele almanın temel yoludur.
? Operatörü: Err değerlerini çağrı yığını boyunca üst katmanlara aktarmak için güçlü bir kısayoldur.
Özel Hatalar: Açıklık sağlamak ve hataları belirli biçimde ele almak için enum'ları kullanarak kendi hata türlerinizi tanımlayabilirsiniz.
From Özelliği: ? kullanırken alt düzey hataların özel hata türlerinize sorunsuz biçimde dönüştürülmesini sağlar.

Sırada, gelişmiş tür sistemi özelliklerini keşfedin!

Başlamak ücretsiz

Yapay zeka eğitmeniyle Rust öğren — ücretsiz

Tarayıcında gerçek kod yaz ve çalıştır, 7/24 yapay zeka eğitmeninden anında yardım al; web'de ya da uygulamada kaldığın yerden devam et.

Kurslar: 39
Dersler: 144

Ücretsiz öğrenmeye başla Tüm kursu görüntüle

Sıkça Sorulan Sorular

“`Result` ile Sağlam Hata Yönetimi” dersi ücretsiz mi?

Evet — “`Result` ile Sağlam Hata Yönetimi” 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 3 dersten oluşur.

“`Result` ile Sağlam Hata Yönetimi” dersinde ne öğreneceğim?

Dayanıklı uygulamalar için `Result` numaralandırmasını, `?` işleçini ve özel hata türlerini kullanarak Rust'a özgü hata yönetimi uygulayın. 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, 3 dersinin 3. dersidir.

“`Result` ile Sağlam Hata Yönetimi” 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