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

การตรวจสอบและวิธีใช้

CLI ที่เรียบร้อยสมบูรณ์

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

ขัดเกลา CLI ของคุณ

CLI ที่ดีควรตรวจสอบ input ตั้งแต่เนิ่น ๆ และมีวิธีใช้ที่ชัดเจน clap รองรับทั้งสองอย่างด้วยคำกำกับและตัวแยกวิเคราะห์ค่า

  • ปฏิเสธค่าที่ไม่ถูกต้องพร้อมข้อความที่เข้าใจง่าย
  • อธิบายอาร์กิวเมนต์ทุกตัว

ช่วงของค่า

จำกัดอาร์กิวเมนต์ตัวเลขให้อยู่ในช่วงที่กำหนดด้วย value_parser input ที่อยู่นอกช่วงจะถูกปฏิเสธโดยอัตโนมัติ

use clap::Parser;

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

ตัวเลือกจากชุดค่าที่กำหนด

ใช้ #[derive(ValueEnum)] เพื่อจำกัดอาร์กิวเมนต์ให้อยู่ในชุดสตริงที่กำหนดตายตัว

use clap::{Parser, ValueEnum};

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

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

ฟังก์ชันตรวจสอบค่าแบบกำหนดเอง

ส่งฟังก์ชันให้ value_parser โดยฟังก์ชันนั้นคืนค่า Result clap จะเปลี่ยน 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()) }
}

ทดลองตรรกะการตรวจสอบค่า

ฟังก์ชันตรวจสอบค่าเป็น Rust ธรรมดา ลองรันเพื่อดูว่าการตรวจสอบเลขคู่หรือเลขคี่คืนค่า Ok หรือ 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"));
}

กลุ่มที่จำเป็นและความขัดแย้ง

กำหนดความสัมพันธ์ระหว่างอาร์กิวเมนต์ได้ conflicts_with จะป้องกันไม่ให้ใช้แฟล็กที่เข้ากันไม่ได้สองตัวพร้อมกัน

use clap::Parser;

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

ข้อความวิธีใช้ของแต่ละฟิลด์

ความคิดเห็นเอกสารเหนือฟิลด์จะกลายเป็นข้อความวิธีใช้ วิธีนี้เป็นแนวทางตามสำนวนของภาษาในการอธิบายอาร์กิวเมนต์

use clap::Parser;

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

วิธีใช้แบบยาวเทียบกับแบบสั้น

clap แสดงสรุปสั้น ๆ สำหรับ -h และแสดงข้อความฉบับเต็มสำหรับ --help หากจำเป็น ให้แยกทั้งสองแบบด้วย #[arg(short_help, long_help)]

use clap::Parser;

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

การคืนค่า Result จาก main

สำหรับข้อผิดพลาดขณะทำงานที่เกิดหลังการแยกวิเคราะห์ ให้คืนค่า Result จาก main ตัวดำเนินการ ? จะส่งต่อข้อผิดพลาด และโปรแกรมที่ไม่มี clap จะแสดงข้อผิดพลาดพร้อมรหัสออกที่ไม่ใช่ศูนย์

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

การจัดรูปแบบข้อผิดพลาดแบบกำหนดเอง

clap จัดรูปแบบข้อผิดพลาดด้านการใช้งานให้โดยอัตโนมัติ แต่คุณสามารถสร้างรูปแบบของตนเองด้วย clap::Error และ cmd.error() เพื่อแสดงข้อความตามบริบท

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

สรุปการตรวจสอบค่าใน Rust ธรรมดา

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

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

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

ทดสอบความเข้าใจเกี่ยวกับการตรวจสอบค่าและวิธีใช้ของคุณ

ทบทวน

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

  • value_parser บังคับใช้ช่วงค่าและกฎแบบกำหนดเอง
  • ValueEnum จำกัดตัวเลือก
  • conflicts_with ใช้สร้างแบบจำลองแฟล็กที่เข้ากันไม่ได้
  • ความคิดเห็นเอกสารจะกลายเป็นข้อความวิธีใช้
  • คืนค่า Result จาก main สำหรับข้อผิดพลาดขณะทำงาน

หลักสูตร clap จบลงเพียงเท่านี้

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

บทเรียน “การตรวจสอบและวิธีใช้” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “การตรวจสอบและวิธีใช้” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ 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 ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน

บทเรียน “การตรวจสอบและวิธีใช้” ใช้เวลานานแค่ไหน

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

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

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

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

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