PricingLoginStart free
Belajar Pengaturcaraan Rust · Pelajaran

Pengendalian Ralat Kukuh dengan `Result`

Laksanakan pengendalian ralat idiomatik menggunakan enum `Result`, operator `?` dan jenis ralat tersuai untuk aplikasi yang tahan lasak.

Pelajaran 3 daripada 311 langkah

Pengendalian Ralat Kukuh dengan `Result` ialah pelajaran Belajar Pengaturcaraan Rust percuma di CoddyKit. Ini ialah pelajaran 3 daripada 3. Sebanyak 3 pelajaran dalam laluan pembelajaran ini boleh dibaca sepenuhnya secara percuma — selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan praktikal dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Belajar Pengaturcaraan Rust, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Belajar Pengaturcaraan Rust merangkumi sejumlah 3 pelajaran.

Mengendalikan Ralat dalam Rust

Ralat ialah sebahagian daripada pengaturcaraan. Dalam Rust, kita membezakan antara dua jenis utama: ralat boleh dipulihkan dan tidak boleh dipulihkan.

  • Ralat tidak boleh dipulihkan biasanya menandakan pepijat dan menyebabkan program berhenti dengan panic!.
  • Ralat boleh dipulihkan bermaksud sesuatu telah berlaku dengan tidak betul tetapi masih boleh dikendalikan, seperti fail yang tidak ditemui.

Rust membantu anda mengendalikan ralat boleh dipulihkan dengan baik.

`panic!` berbanding `Result`

Apabila ralat tidak boleh dipulihkan berlaku, Rust memanggil makro panic!. Makro ini menguraikan tindanan dan keluar daripada program anda, biasanya sambil mencetak mesej ralat.

Bagi ralat boleh dipulihkan, Rust menggunakan enumerasi Result. Enumerasi ini memberitahu anda sama ada sesuatu operasi berjaya (Ok) atau gagal (Err), lalu membolehkan program anda menentukan tindakan seterusnya.

Enumerasi `Result`

Enumerasi Result ditakrifkan secara konsep seperti berikut:

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

  • T mewakili jenis nilai yang dikembalikan apabila berjaya.
  • E mewakili jenis ralat yang dikembalikan apabila gagal.

Ini ialah cara yang berkuasa untuk menyatakan dengan jelas bahawa sesuatu fungsi mungkin gagal.

Memadankan `Result`

Cara yang paling biasa untuk mengendalikan Result adalah dengan menggunakan ungkapan match. Ini membolehkan anda melaksanakan blok kod yang berbeza berdasarkan sama ada Result ialah Ok atau Err.

Cuba jalankan contoh ini yang cuba menghuraikan nombor:

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),
    }
}

Menyahbungkus Result (Dengan Berhati-hati!)

Kadang-kadang anda mungkin pasti bahawa sesuatu operasi tidak akan gagal, atau anda mahu program anda ranap jika operasi itu gagal. Kaedah seperti unwrap() dan expect() mengekstrak nilai Ok.

  • unwrap(): Mengembalikan nilai Ok atau mencetuskan panik jika nilainya Err.
  • expect("message"): Sama seperti unwrap(), tetapi membolehkan anda memberikan mesej panik tersuai.

Gunakan kaedah ini secara berhemat, terutamanya dalam ujian atau apabila kegagalan benar-benar tidak boleh dipulihkan.

Memperkenalkan Operator `?`

Menulis pernyataan match untuk setiap Result boleh menjadi berulang-ulang. Operator ? menyediakan jalan pintas yang ringkas untuk menyebarkan ralat.

Apabila diletakkan selepas ungkapan yang mengembalikan Result, ? melakukan dua perkara:

  • Jika Result ialah Err, operator ini serta-merta mengembalikan Err daripada fungsi semasa.
  • Jika Result ialah Ok, operator ini menyahbungkus nilai Ok dan meneruskan pelaksanaan.

Operator `?` dalam Tindakan

Operator ? menjadikan fungsi yang mungkin gagal lebih mudah ditulis. Ingat, fungsi yang menggunakan ? mestilah mengembalikan Result (atau Option) sendiri.

Perhatikan cara ? memudahkan pengendalian ralat dalam contoh pembacaan fail ini:

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();
}

Jenis Ralat Tersuai

Kadang-kadang jenis ralat terbina dalam tidak cukup khusus. Anda boleh mentakrifkan jenis ralat tersuai sendiri menggunakan enumerasi untuk mewakili mod kegagalan yang berbeza dalam aplikasi anda.

Ini menjadikan mesej ralat anda lebih jelas dan membolehkan pemanggil mengendalikan ralat tertentu dengan cara yang berbeza.

Corak yang biasa digunakan ialah mencipta enumerasi yang menyenaraikan semua ralat yang mungkin dihasilkan oleh sesuatu fungsi atau modul.

Menjadikan `?` Berfungsi dengan Ralat Tersuai

Supaya operator ? dapat menukar ralat aras rendah secara automatik (seperti io::Error) kepada jenis ralat tersuai anda, enumerasi ralat tersuai tersebut mesti melaksanakan sifat From untuk ralat aras rendah itu.

Ini memberitahu Rust cara menukar satu jenis ralat kepada jenis yang lain, lalu menjadikan penyebaran ralat berjalan lancar.

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),
    }
}

Uji Pemahaman Anda

Perhatikan petikan kod Rust berikut. Apakah outputnya jika fail data.txt TIDAK wujud?

Jawab dalam pelajaran interaktif

Ulang Kaji: Pengendalian Ralat yang Kukuh

Anda telah menguasai pengendalian ralat yang kukuh dalam Rust!

  • Enumerasi Result: Membezakan antara Ok(T) untuk kejayaan dan Err(E) untuk kegagalan.
  • match: Cara asas untuk mengendalikan varian Result.
  • Operator ?: Jalan pintas yang berkuasa untuk menyebarkan nilai Err ke atas tindanan panggilan.
  • Ralat Tersuai: Mentakrifkan jenis ralat anda sendiri menggunakan enumerasi untuk kejelasan dan pengendalian khusus.
  • Sifat From: Membolehkan penukaran ralat aras rendah kepada jenis ralat tersuai anda dengan lancar apabila menggunakan ?.

Seterusnya, terokai ciri sistem jenis yang lebih lanjut!

Percuma untuk bermula

Pelajari Rust dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus
39
Pelajaran
144
Mula belajar secara percumaLihat kursus penuh

Soalan Lazim

Adakah pelajaran “Pengendalian Ralat Kukuh dengan `Result`” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Belajar Pengaturcaraan Rust, termasuk “Pengendalian Ralat Kukuh dengan `Result`”, boleh dibaca sepenuhnya secara percuma di web ini. Selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan interaktif dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Kursus Belajar Pengaturcaraan Rust merangkumi sejumlah 3 pelajaran.

Apakah yang akan saya pelajari dalam “Pengendalian Ralat Kukuh dengan `Result`”?

Laksanakan pengendalian ralat idiomatik menggunakan enum `Result`, operator `?` dan jenis ralat tersuai untuk aplikasi yang tahan lasak. Anda berlatih Belajar Pengaturcaraan Rust menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Belajar Pengaturcaraan Rust?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Belajar Pengaturcaraan Rust di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 3 daripada 3.

Berapa lamakah pelajaran “Pengendalian Ralat Kukuh dengan `Result`” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Belajar Pengaturcaraan Rust ini?

Ya. Setiap pelajaran Belajar Pengaturcaraan Rust menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

  1. Menyusun Kod dengan Modul
  2. Mengurus Kebergantungan dengan Crate
  3. Pengendalian Ralat Kukuh dengan `Result`
← Kembali ke Belajar Pengaturcaraan Rust