Learn Rust Coding · Pelajaran

Validasi dan Bantuan

CLI yang lebih rapi

Validasi dan Bantuan adalah pelajaran Learn Rust Coding gratis di CoddyKit. Ini adalah pelajaran 4 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.

Merapikan CLI Anda

CLI yang baik memvalidasi input sejak awal dan menyediakan bantuan yang jelas. clap mendukung keduanya melalui atribut dan pengurai nilai.

Tolak nilai yang salah dengan pesan yang mudah dipahami
Dokumentasikan setiap argumen

Rentang nilai

Batasi argumen numerik ke suatu rentang dengan value_parser. Input di luar rentang akan ditolak secara otomatis.

use clap::Parser;

#[derive(Parser)]
struct Cli {
    #[arg(long, value_parser = clap::value_parser!(u16).range(1..=65535))]
    port: u16,
}

Pilihan yang telah ditentukan

Gunakan #[derive(ValueEnum)] untuk membatasi argumen ke sekumpulan string tertentu.

use clap::{Parser, ValueEnum};

#[derive(Clone, ValueEnum)]
enum Mode { Fast, Safe }

#[derive(Parser)]
struct Cli {
    #[arg(long, value_enum)]
    mode: Mode,
}

Fungsi validasi khusus

Berikan fungsi kepada value_parser yang mengembalikan Result. clap mengubah Err menjadi kesalahan penggunaan.

fn parse_even(s: &str) -> Result<u32, String> {
    let n: u32 = s.parse().map_err(|_| "not a number".to_string())?;
    if n % 2 == 0 { Ok(n) } else { Err("must be even".to_string()) }
}

Mencoba logika validasi

Fungsi validasi adalah Rust biasa. Jalankan untuk melihat bagaimana pemeriksaan genap/ganjil mengembalikan Ok atau Err.

fn parse_even(s: &str) -> Result<u32, String> {
    let n: u32 = s.parse().map_err(|_| "not a number".to_string())?;
    if n % 2 == 0 { Ok(n) } else { Err("must be even".to_string()) }
}

fn main() {
    println!("{:?}", parse_even("4"));
    println!("{:?}", parse_even("7"));
}

Grup wajib dan konflik

Nyatakan hubungan antarkumpulan argumen. conflicts_with mencegah dua flag yang tidak kompatibel digunakan bersamaan.

use clap::Parser;

#[derive(Parser)]
struct Cli {
    #[arg(long)]
    quiet: bool,
    #[arg(long, conflicts_with = "quiet")]
    verbose: bool,
}

Teks bantuan untuk setiap field

Komentar dokumentasi di atas field menjadi teks bantuannya. Inilah cara idiomatis untuk mendokumentasikan argumen.

use clap::Parser;

#[derive(Parser)]
struct Cli {
    /// The file to process
    input: String,
}

Bantuan panjang dan bantuan singkat

clap menampilkan ringkasan singkat untuk -h dan teks lengkap untuk --help. Pisahkan keduanya dengan #[arg(short_help, long_help)] jika diperlukan.

use clap::Parser;

#[derive(Parser)]
struct Cli {
    #[arg(long, long_help = "A detailed explanation shown only with --help")]
    flag: bool,
}

Mengembalikan Result dari main

Untuk kesalahan saat runtime setelah penguraian, kembalikan Result dari main. Operator ? meneruskan kesalahan, dan program tanpa clap mencetaknya dengan kode keluar nonnol.

fn main() -> Result<(), String> {
    let value = "42";
    let n: i32 = value.parse().map_err(|_| "bad number".to_string())?;
    println!("parsed {}", n);
    Ok(())
}

Penataan gaya kesalahan khusus

clap memformat kesalahan penggunaan secara otomatis, tetapi Anda dapat membuatnya sendiri dengan clap::Error dan cmd.error() untuk pesan yang sesuai konteks.

use clap::{CommandFactory, Parser};

#[derive(Parser)]
struct Cli { value: i32 }

fn fail() {
    let mut cmd = Cli::command();
    cmd.error(clap::error::ErrorKind::ValueValidation, "value too large").exit();
}

Ringkasan validasi dalam Rust biasa

Inti validasi CLI adalah memeriksa nilai dan melaporkan kesalahan yang jelas. Berikut prosesnya dari awal hingga akhir.

fn validate_port(p: u32) -> Result<u32, String> {
    if (1..=65535).contains(&p) { Ok(p) }
    else { Err(format!("port {} out of range", p)) }
}

fn main() {
    match validate_port(8080) {
        Ok(p) => println!("using port {}", p),
        Err(e) => eprintln!("error: {}", e),
    }
}

Pemeriksaan Singkat

Uji pemahaman Anda tentang validasi dan bantuan.

Rangkuman

Sekarang Anda dapat membangun CLI yang rapi:

value_parser memberlakukan rentang dan aturan khusus
ValueEnum membatasi pilihan
conflicts_with memodelkan flag yang tidak kompatibel
Komentar dokumentasi menjadi teks bantuan
Kembalikan Result dari main untuk kesalahan saat runtime

Dengan ini, kursus clap selesai.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Validasi dan Bantuan” gratis?

Ya — teks lengkap “Validasi dan Bantuan” 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 “Validasi dan Bantuan”?

CLI yang lebih rapi 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 4 dari 4.

Berapa lama pelajaran “Validasi dan Bantuan” 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

← Kembali ke Learn Rust Coding