0Pricing
Learn Rust Coding · บทเรียน

คำสั่งย่อย

CLI ที่มีโครงสร้าง

คำสั่งย่อย เป็นบทเรียน Learn Rust Coding ฟรีบน CoddyKit นี่คือบทเรียนที่ 2 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Learn Rust Coding และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Learn Rust Coding มีบทเรียนทั้งหมด 4 บทเรียน

คำสั่งย่อยคืออะไร

คำสั่งย่อยทำให้ไบนารีหนึ่งตัวเปิดให้ใช้การทำงานหลายอย่างได้ เช่น git commit และ git push

  • คำสั่งย่อยแต่ละคำสั่งมีอาร์กิวเมนต์ของตนเอง
  • โครงสร้างจะขยายได้เมื่อ CLI ของคุณเติบโตขึ้น

clap จำลองโครงสร้างเหล่านี้ด้วยค่า Command ที่ซ้อนกัน

เพิ่มคำสั่งย่อย

แนบคำสั่งลูกด้วย .subcommand() จากนั้นคำสั่งแม่จะทำหน้าที่กระจายงาน

use clap::Command;

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

จับคู่กับคำสั่งย่อยที่เลือก

หลังการแยกวิเคราะห์ subcommand() จะบอกว่าคำสั่งลูกใดทำงาน ให้จับคู่ตามชื่อเพื่อกระจายงาน

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 ภายในคำสั่งย่อย

คำสั่งย่อยมีอาร์กิวเมนต์ของตนเอง คำสั่ง add ด้านล่างรับคำอธิบายงาน

use clap::{Command, Arg};

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

อ่าน args ของคำสั่งย่อย

สมาชิกตัวที่สองของทูเพิลคือ ArgMatches ของคำสั่งย่อย ให้ดึงค่าจากมันเช่นเดียวกับระดับบนสุด

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);
    }
}

บังคับให้มีคำสั่งย่อย

ใช้ subcommand_required(true) เพื่อให้การเรียกใช้ไบนารีเปล่า ๆ แสดงความช่วยเหลือแทนที่จะไม่ทำอะไร

use clap::Command;

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

จำลองการกระจายงานด้วย Rust แบบธรรมดา

แก่นของ CLI ที่มีคำสั่งย่อยคือการจับคู่กับสตริง ตัวอย่างที่เรียกใช้ได้นี้จำลองตรรกะการกระจายงานดังกล่าว

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

คำสั่งย่อยที่ซ้อนกัน

คำสั่งย่อยสามารถมีคำสั่งย่อยของตัวเองได้ เช่น cargo build --release หรือโครงสร้างที่ลึกกว่านั้น เพียงซ้อนการเรียกใช้ .subcommand() เพิ่มเติม

use clap::Command;

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

วิธีใช้แยกตามคำสั่งย่อย

คำสั่งย่อยแต่ละคำสั่งจะมีหน้า --help ของตัวเอง เพิ่มสตริง about เพื่ออธิบายคำสั่งนั้น

use clap::Command;

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

ชื่อเรียกย่อ

มอบทางลัดให้ผู้ใช้ด้วย visible_alias ตอนนี้ ls จึงใช้งานได้เช่นเดียวกับ list

use clap::Command;

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

การคืนรหัสออกจากโปรแกรม

CLI ที่สมบูรณ์ควรสื่อได้ว่าการทำงานสำเร็จหรือล้มเหลว คุณสามารถคืนรหัสที่ไม่ใช่ศูนย์จากคำสั่งย่อยโดยใช้ std::process::exit หรือคืนค่า Result จาก main

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

ตรวจสอบความเข้าใจอย่างรวดเร็ว

ทดสอบความเข้าใจเกี่ยวกับคำสั่งย่อยของคุณ

ทบทวน

ตอนนี้คุณสามารถสร้าง CLI ที่มีโครงสร้างด้วย คำสั่งย่อย ได้แล้ว:

  • เพิ่มคำสั่งลูกด้วย .subcommand()
  • เลือกส่งต่อการทำงานโดยจับคู่กับ m.subcommand()
  • คำสั่งย่อยแต่ละคำสั่งมีอาร์กิวเมนต์และหน้าวิธีใช้ของตัวเอง
  • ใช้ subcommand_required และชื่อเรียกย่อเพื่อขัดเกลาการใช้งาน

ถัดไป: derive API จะเปลี่ยนโครงสร้างให้เป็นตัวแยกวิเคราะห์อาร์กิวเมนต์

คำถามที่พบบ่อย

บทเรียน “คำสั่งย่อย” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “คำสั่งย่อย” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Learn Rust Coding ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Learn Rust Coding มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “คำสั่งย่อย”

CLI ที่มีโครงสร้าง คุณปฏิบัติ Learn Rust Coding ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Learn Rust Coding หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Learn Rust Coding บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 2 จากทั้งหมด 4 บทเรียน

บทเรียน “คำสั่งย่อย” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Learn Rust Coding นี้ได้ไหม

ได้ บทเรียน Learn Rust Coding ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

  1. พื้นฐาน clap
  2. คำสั่งย่อย
  3. API สำหรับ derive
  4. การตรวจสอบและวิธีใช้
← กลับไปที่ Learn Rust Coding