Learn Rust Coding · Pelajaran

Dasar-Dasar clap

Mengurai argumen

Dasar-Dasar clap 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.

Mengapa clap?

clap (Command Line Argument Parser) adalah crate standar de facto untuk membangun CLI dalam Rust.

Mengurai argumen, flag, dan opsi
Secara otomatis menghasilkan --help dan --version
Memvalidasi input dan melaporkan error yang mudah dipahami

Tanpanya, Anda harus mengiterasi std::env::args() secara manual dan menangani setiap kasus khusus sendiri.

Membaca args Secara Manual

Sebelum menggunakan clap, ada baiknya Anda melihat pendekatan mentahnya. std::env::args() menghasilkan iterator dengan item pertama berupa nama program.

fn main() {
    let args: Vec<String> = std::env::args().collect();
    println!("Program: {}", args[0]);
    println!("Got {} extra arg(s)", args.len() - 1);
}

Menambahkan clap ke Cargo.toml

Untuk menggunakan clap, Anda mendeklarasikannya sebagai dependensi. Fitur derive mengaktifkan API berbasis makro.

cargo add clap --features derive

Langkah ini dijalankan di terminal dan mengubah file proyek Anda, sehingga tidak kami jalankan di sini.

[dependencies]
clap = { version = "4", features = ["derive"] }

API builder

clap memiliki dua gaya. API builder membuat Command saat runtime dengan merangkai pemanggilan metode.

use clap::{Command, Arg};

fn main() {
    let cmd = Command::new("greet")
        .arg(Arg::new("name"));
    let matches = cmd.get_matches();
    // access values from matches
}

Argumen Posisional

Argumen posisional diberikan berdasarkan urutan, bukan melalui flag. Di sini name dibaca langsung dari baris perintah.

greet Alice menetapkan name ke Alice

use clap::{Command, Arg};

fn main() {
    let m = Command::new("greet")
        .arg(Arg::new("name").required(true))
        .get_matches();
    let name = m.get_one::<String>("name").unwrap();
    println!("Hello, {}!", name);
}

Flag Opsional

Flag adalah sakelar boolean. Gunakan ArgAction::SetTrue agar keberadaannya mengubah nilai bool menjadi true.

--loud mengaktifkan flag

use clap::{Command, Arg, ArgAction};

fn main() {
    let m = Command::new("greet")
        .arg(Arg::new("loud").long("loud").action(ArgAction::SetTrue))
        .get_matches();
    let loud = m.get_flag("loud");
    println!("loud = {}", loud);
}

Opsi dengan Nilai

Opsi menerima nilai, seperti --count 3. Berikan nama short dan long agar lebih praktis digunakan.

use clap::{Command, Arg};

fn main() {
    let m = Command::new("greet")
        .arg(Arg::new("count").short('c').long("count"))
        .get_matches();
    if let Some(c) = m.get_one::<String>("count") {
        println!("count = {}", c);
    }
}

Nilai Bawaan

Berikan fallback pada argumen dengan default_value agar pengguna dapat mengabaikannya.

Jika --count tidak ada, nilainya menjadi 1

use clap::{Command, Arg};

fn main() {
    let m = Command::new("greet")
        .arg(Arg::new("count").long("count").default_value("1"))
        .get_matches();
    let count = m.get_one::<String>("count").unwrap();
    println!("count = {}", count);
}

Menyimulasikan Hasil

Meskipun clap belum terpasang, kita dapat memodelkan bentuk nilai yang telah diurai. Berikut pengganti berbasis Rust biasa yang menunjukkan logika yang dilakukan clap untuk kita.

fn main() {
    let name = "Alice";
    let count: u32 = 3;
    for _ in 0..count {
        println!("Hello, {}!", name);
    }
}

Bantuan yang Dibuat Otomatis

clap membuat --help secara otomatis dari metadata argumen Anda. Tambahkan string about dan help agar hasilnya lebih berguna.

use clap::{Command, Arg};

fn main() {
    Command::new("greet")
        .about("Greets a person")
        .arg(Arg::new("name").help("Who to greet"))
        .get_matches();
}

Flag Versi

Tetapkan versi sekali, lalu clap menyiapkan --version. Makro crate_version! mengambilnya dari Cargo.toml.

use clap::Command;

fn main() {
    Command::new("greet")
        .version("1.0.0")
        .get_matches();
}

Pemeriksaan Singkat

Uji pemahaman Anda tentang dasar-dasar clap.

Ringkasan

Anda telah mempelajari dasar-dasar clap:

Tambahkan dengan fitur derive
API builder menggunakan Command dan Arg
Argumen posisional mengikuti urutan; flag menggunakan SetTrue; opsi menerima nilai
default_value menyediakan fallback
--help dan --version dibuat secara otomatis

Selanjutnya, Anda akan menyusun CLI yang lebih besar dengan subperintah.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Dasar-Dasar clap” gratis?

Ya — teks lengkap “Dasar-Dasar clap” 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 “Dasar-Dasar clap”?

Mengurai argumen 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 “Dasar-Dasar clap” 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