Result dan Operator ?
Menyebarkan ralat
Result dan Operator ? ialah pelajaran Belajar Pengaturcaraan Rust percuma di CoddyKit. Ini ialah pelajaran 1 daripada 4. 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 4 pelajaran.
Jenis Result
Result<T, E> mewakili operasi yang boleh berjaya dengan Ok(T) atau gagal dengan Err(E). Ia ialah jenis utama Rust untuk pengendalian ralat.
fn main() {
let parsed: Result<i32, _> = "42".parse::<i32>();
println!("{:?}", parsed);
}Memadankan Result
Anda boleh mengendalikan kedua-dua hasil secara jelas dengan match.
fn main() {
match "oops".parse::<i32>() {
Ok(n) => println!("got {n}"),
Err(e) => println!("error: {e}"),
}
}Mengembalikan Result
Fungsi yang boleh gagal mengembalikan Result, lalu membolehkan pemanggil menentukan cara mengendalikan ralat.
fn halve(n: i32) -> Result<i32, String> {
if n % 2 == 0 {
Ok(n / 2)
} else {
Err("odd number".to_string())
}
}
fn main() {
println!("{:?}", halve(10));
println!("{:?}", halve(7));
}Operator ?
Operator ? membuka nilai Ok atau mengembalikan Err lebih awal daripada fungsi. Ia menggantikan kod match-dan-kembali yang panjang.
fn double_str(s: &str) -> Result<i32, std::num::ParseIntError> {
let n = s.parse::<i32>()?;
Ok(n * 2)
}
fn main() {
println!("{:?}", double_str("21"));
println!("{:?}", double_str("x"));
}Merangkaikan dengan ?
Beberapa langkah yang boleh gagal lebih mudah dibaca apabila dirangkaikan dengan ?; ralat pertama menghentikan langkah-langkah seterusnya.
fn sum_two(a: &str, b: &str) -> Result<i32, std::num::ParseIntError> {
let x = a.parse::<i32>()?;
let y = b.parse::<i32>()?;
Ok(x + y)
}
fn main() {
println!("{:?}", sum_two("3", "4"));
}? dalam main
main boleh mengembalikan Result, jadi ? juga berfungsi di situ. Err yang dikembalikan menamatkan program dengan kod keluar bukan sifar.
fn main() -> Result<(), std::num::ParseIntError> {
let n: i32 = "100".parse()?;
println!("parsed {n}");
Ok(())
}Kaedah Result yang Berguna
Penggabung yang berguna:
unwrap_or(default)— nilai atau nilai sandaranmap— mengubah nilai Okmap_err— mengubah ralatis_ok/is_err— menyemak varian
fn main() {
let n = "x".parse::<i32>().unwrap_or(-1);
println!("{n}");
}Option kepada Result
Tukarkan Option kepada Result dengan ok_or supaya ? boleh menyebarkan ralat yang bermakna.
fn first_char(s: &str) -> Result<char, String> {
let c = s.chars().next().ok_or("empty string".to_string())?;
Ok(c)
}
fn main() {
println!("{:?}", first_char("hi"));
println!("{:?}", first_char(""));
}Cara ? Menukarkan Ralat
Apabila jenis ralat berbeza, ? memanggil From::from untuk menukarkan ralat kepada jenis ralat yang diisytiharkan oleh fungsi. Ini membolehkan pengendalian ralat yang mudah merentasi lapisan.
Elakkan unwrap dalam Pengeluaran
unwrap dan expect menyebabkan panik apabila menerima Err. Ia sesuai untuk contoh dan ujian, tetapi dalam kod sebenar, utamakan ? atau pengendalian yang jelas supaya kegagalan boleh dipulihkan.
Merangkaikan and_then
and_then menjalankan langkah seterusnya yang boleh gagal hanya jika langkah sebelumnya berjaya, sambil meneruskan nilai itu.
fn main() {
let result = "8"
.parse::<i32>()
.and_then(|n| Ok(n * 2));
println!("{:?}", result);
}Semakan Pantas
Apakah yang dilakukan oleh operator ? apabila digunakan pada Result yang bernilai Err?
Ringkasan
Anda telah mempelajari pengendalian ralat berasaskan Result:
Result<T, E>memodelkan kejayaan atau kegagalan?membuka Ok atau mengembalikan Err lebih awal?berfungsi dalam fungsi danmainyang mengembalikan Result- Penggabung seperti
map,map_err,unwrap_ordanok_orsangat membantu - Elakkan
unwrapdalam kod produksi
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
Soalan Lazim
Adakah pelajaran “Result dan Operator ?” percuma?
Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Belajar Pengaturcaraan Rust, termasuk “Result dan Operator ?”, 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 4 pelajaran.
Apakah yang akan saya pelajari dalam “Result dan Operator ?”?
Menyebarkan ralat 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 1 daripada 4.
Berapa lamakah pelajaran “Result dan Operator ?” 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
- Result dan Operator ?
- thiserror
- anyhow
- Penukaran Ralat