Belajar Pengaturcaraan Rust · Pelajaran

Subperintah

CLI berstruktur

Pelajaran 2 daripada 413 langkah

Subperintah ialah pelajaran Belajar Pengaturcaraan Rust percuma di CoddyKit. Ini ialah pelajaran 2 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.

Apakah subperintah?

Subperintah membolehkan satu binari mendedahkan beberapa tindakan, seperti git commit dan git push.

Setiap subperintah mempunyai hujahnya sendiri
Strukturnya boleh dikembangkan apabila CLI Anda berkembang

clap memodelkan semua ini dengan nilai Command bersarang.

Menambah subperintah

Pasangkan perintah anak dengan .subcommand(). Perintah induk menjadi penghantar.

use clap::Command;

fn main() {
    Command::new("todo")
        .subcommand(Command::new("add"))
        .subcommand(Command::new("list"))
        .get_matches();
}

Memadankan subperintah yang dipilih

Selepas penghuraian, subcommand() memberitahu Anda perintah anak yang dijalankan. Gunakan match pada namanya untuk menghantar kawalan.

use clap::Command;

fn main() {
    let m = Command::new("todo")
        .subcommand(Command::new("add"))
        .subcommand(Command::new("list"))
        .get_matches();
    match m.subcommand() {
        Some(("add", _)) => println!("adding"),
        Some(("list", _)) => println!("listing"),
        _ => println!("no subcommand"),
    }
}

Args dalam subperintah

Subperintah membawa hujahnya sendiri. Perintah add di bawah menerima penerangan tugasan.

use clap::{Command, Arg};

fn main() {
    Command::new("todo")
        .subcommand(
            Command::new("add")
                .arg(Arg::new("task").required(true))
        )
        .get_matches();
}

Membaca args subperintah

Elemen kedua tuple ialah ArgMatches subperintah. Ambil nilai daripadanya sama seperti pada aras teratas.

use clap::{Command, Arg};

fn main() {
    let m = Command::new("todo")
        .subcommand(Command::new("add").arg(Arg::new("task")))
        .get_matches();
    if let Some(("add", sub)) = m.subcommand() {
        let task = sub.get_one::<String>("task").unwrap();
        println!("add: {}", task);
    }
}

Mewajibkan subperintah

Gunakan subcommand_required(true) supaya menjalankan binari tanpa hujah mencetak bantuan dan bukannya tidak melakukan apa-apa.

use clap::Command;

fn main() {
    Command::new("todo")
        .subcommand_required(true)
        .arg_required_else_help(true)
        .subcommand(Command::new("list"))
        .get_matches();
}

Memodelkan penghantaran dalam Rust biasa

Teras CLI subperintah ialah match pada rentetan. Contoh yang boleh dijalankan ini mencerminkan logik penghantaran tersebut.

fn main() {
    let cmd = "add";
    let task = "Buy milk";
    match cmd {
        "add" => println!("Added: {}", task),
        "list" => println!("Listing tasks"),
        other => println!("Unknown command: {}", other),
    }
}

Subperintah bersarang

Subperintah juga boleh mempunyai subperintahnya sendiri, contohnya cargo build --release berbanding pepohon yang lebih mendalam. Anda hanya perlu menyusun lebih banyak panggilan .subcommand().

use clap::Command;

fn main() {
    Command::new("app")
        .subcommand(
            Command::new("config")
                .subcommand(Command::new("get"))
                .subcommand(Command::new("set"))
        )
        .get_matches();
}

Bantuan bagi setiap subperintah

Setiap subperintah mendapat halaman --help sendiri. Tambahkan rentetan about untuk menerangkannya.

use clap::Command;

fn main() {
    Command::new("todo")
        .subcommand(
            Command::new("add").about("Add a new task")
        )
        .get_matches();
}

Alias

Berikan pintasan kepada pengguna dengan visible_alias. Kini ls berfungsi sama seperti list.

use clap::Command;

fn main() {
    Command::new("todo")
        .subcommand(
            Command::new("list").visible_alias("ls")
        )
        .get_matches();
}

Mengembalikan kod keluar

CLI yang lengkap memberi isyarat tentang kejayaan atau kegagalan. Kembalikan kod bukan sifar daripada subperintah menggunakan std::process::exit atau dengan mengembalikan Result daripada main.

fn main() {
    let success = true;
    if !success {
        std::process::exit(1);
    }
    println!("ok");
}

Semakan pantas

Uji pemahaman anda tentang subperintah.

Jawab dalam pelajaran interaktif

Ringkasan

Kini anda boleh membina CLI berstruktur dengan subperintah:

Tambahkan anak dengan .subcommand()
Lakukan penghantaran dengan memadankan m.subcommand()
Setiap subperintah mempunyai argumen dan halaman bantuan sendiri
Gunakan subcommand_required dan alias untuk hasil yang lebih kemas

Seterusnya: API derive menukarkan struct menjadi penghurai argumen.

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 percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Subperintah” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Belajar Pengaturcaraan Rust, termasuk “Subperintah”, 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 “Subperintah”?

CLI berstruktur 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 2 daripada 4.

Berapa lamakah pelajaran “Subperintah” 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

← Kembali ke Belajar Pengaturcaraan Rust