Learn Rust Coding · Pelajaran

Result dan Operator ?

Meneruskan error

Result dan Operator ? adalah pelajaran Learn Rust Coding gratis di CoddyKit. Ini adalah pelajaran 1 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Learn Rust Coding, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Learn Rust Coding mencakup 4 pelajaran total.

Tipe Result

Result<T, E> merepresentasikan operasi yang dapat berhasil dengan Ok(T) atau gagal dengan Err(E). Ini adalah tipe utama Rust untuk penanganan error.

fn main() {
    let parsed: Result<i32, _> = "42".parse::<i32>();
    println!("{:?}", parsed);
}

Mencocokkan Result

Anda dapat menangani kedua hasil secara eksplisit dengan match.

fn main() {
    match "oops".parse::<i32>() {
        Ok(n) => println!("got {n}"),
        Err(e) => println!("error: {e}"),
    }
}

Mengembalikan Result

Fungsi yang dapat gagal mengembalikan Result, sehingga pemanggil dapat menentukan cara menangani error.

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 dari fungsi. Operator ini menggantikan kode match-dan-kembalikan 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"));
}

Merangkai dengan ?

Beberapa langkah yang dapat gagal menjadi mudah dibaca ketika dirangkai dengan ?; error pertama menghentikan langkah-langkah berikutnya.

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 dapat mengembalikan Result, jadi ? juga berfungsi di sana. Err yang dikembalikan mengakhiri program dengan kode keluar bukan nol.

fn main() -> Result<(), std::num::ParseIntError> {
    let n: i32 = "100".parse()?;
    println!("parsed {n}");
    Ok(())
}

Metode Result yang Berguna

Kombinator yang berguna:

unwrap_or(default) — nilai atau nilai pengganti
map — mengubah nilai Ok
map_err — mengubah error
is_ok / is_err — memeriksa varian

fn main() {
    let n = "x".parse::<i32>().unwrap_or(-1);
    println!("{n}");
}

Option menjadi Result

Konversikan Option menjadi Result dengan ok_or agar ? dapat meneruskan error 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 ? Mengonversi Error

Ketika tipe error berbeda, ? memanggil From::from untuk mengonversi error menjadi tipe error yang dinyatakan oleh fungsi. Inilah yang memungkinkan penanganan error yang praktis di berbagai lapisan.

Hindari unwrap dalam Produksi

unwrap dan expect menyebabkan panic pada Err. Keduanya cocok untuk contoh dan pengujian, tetapi dalam kode nyata sebaiknya gunakan ? atau penanganan eksplisit agar kegagalan tetap dapat dipulihkan.

Merangkai and_then

and_then menjalankan langkah berikutnya yang dapat gagal hanya jika langkah sebelumnya berhasil, sambil meneruskan nilainya.

fn main() {
    let result = "8"
        .parse::<i32>()
        .and_then(|n| Ok(n * 2));
    println!("{:?}", result);
}

Pemeriksaan Singkat

Apa yang dilakukan operator ? ketika diterapkan pada Result yang berupa Err?

Ringkasan

Anda telah mempelajari penanganan error berbasis Result:

Result<T, E> memodelkan keberhasilan atau kegagalan
? membongkar Ok atau segera mengembalikan Err
? berfungsi dalam fungsi dan main yang mengembalikan Result
Kombinator seperti map, map_err, unwrap_or, dan ok_or sangat membantu
Hindari unwrap dalam produksi

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Result dan Operator ?” gratis?

Ya — teks lengkap “Result dan Operator ?” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Learn Rust Coding, upgrade ke CoddyKit PRO. Kursus Learn Rust Coding mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Result dan Operator ?”?

Meneruskan error Kamu berlatih Learn Rust Coding dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Learn Rust Coding?

Tidak diperlukan pengalaman sebelumnya. Learn Rust Coding di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 1 dari 4.

Berapa lama pelajaran “Result dan Operator ?” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Learn Rust Coding ini?

Ya. Setiap pelajaran Learn Rust Coding menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

Result dan Operator ?
thiserror
anyhow
Konversi Error

← Kembali ke Learn Rust Coding