《深入Rust系统编程》10.1 命令行工具开发

Rust 系统编程实战：10.1 命令行工具开发

命令行工具是系统编程中不可或缺的一部分，它们通常用于自动化任务、系统管理、数据处理等场景。Rust 作为一种高性能、内存安全的系统编程语言，非常适合用于开发命令行工具。本文将深入探讨如何使用 Rust 开发安全可靠的命令行工具，涵盖命令行参数解析、子命令、输入输出处理、错误处理、以及实际示例。

10.1.1 命令行工具开发概述

10.1.1.1 什么是命令行工具？

命令行工具是通过命令行界面（CLI）与用户交互的程序。它们通常以文本形式接收输入并输出结果，适用于自动化任务、系统管理、数据处理等场景。

10.1.1.2 命令行工具的组成部分

一个典型的命令行工具通常包括以下部分：

  1. 命令行参数解析：解析用户输入的参数和选项。
  2. 子命令：支持多个子命令，每个子命令执行不同的功能。
  3. 输入输出处理：处理标准输入、输出和错误流。
  4. 错误处理：处理运行时错误并提供友好的错误信息。
  5. 日志和监控：记录日志并监控工具的运行状态。

10.1.2 命令行参数解析

10.1.2.1 使用 clap 库解析命令行参数

clap 是一个功能强大的命令行参数解析库，支持复杂的参数和选项配置。以下是一个使用 clap 解析命令行参数的示例。

10.1.2.1.1 添加依赖

在 Cargo.toml 中添加 clap 依赖：

1
2

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

10.1.2.1.2 实现命令行参数解析

以下是一个使用 clap 解析命令行参数的示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

use clap::{ArgEnum, Parser};

#[derive(Parser)]
#[clap(author, version, about, long_about = None)]
struct Cli {
    /// 输入文件
    #[clap(short, long, value_parser)]
    input: String,

    /// 输出文件
    #[clap(short, long, value_parser)]
    output: Option<String>,

    /// 日志级别
    #[clap(short, long, arg_enum, default_value_t = LogLevel::Info)]
    log_level: LogLevel,
}

#[derive(Copy, Clone, ArgEnum)]
enum LogLevel {
    Debug,
    Info,
    Warn,
    Error,
}

fn main() {
    let cli = Cli::parse();

    println!("Input file: {}", cli.input);
    if let Some(output) = cli.output {
        println!("Output file: {}", output);
    }
    println!("Log level: {:?}", cli.log_level);
}
代码说明
  1. Cli：命令行参数结构体，使用 clap 的 Parser 派生宏。
  2. input：输入文件路径，支持短选项 -i 和长选项 --input。
  3. output：输出文件路径，支持短选项 -o 和长选项 --output，可选参数。
  4. log_level：日志级别，支持短选项 -l 和长选项 --log-level，默认值为 Info。
  5. LogLevel：日志级别枚举，使用 clap 的 ArgEnum 派生宏。

10.1.2.2 使用 structopt 库解析命令行参数

structopt 是另一个流行的命令行参数解析库，基于 clap 提供了更简洁的 API。以下是一个使用 structopt 解析命令行参数的示例。

10.1.2.2.1 添加依赖

在 Cargo.toml 中添加 structopt 依赖：

1
2

[dependencies]
structopt = "0.3"

10.1.2.2.2 实现命令行参数解析

以下是一个使用 structopt 解析命令行参数的示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

use structopt::StructOpt;

#[derive(StructOpt)]
#[structopt(name = "my-tool", about = "A simple command-line tool")]
struct Cli {
    /// 输入文件
    #[structopt(short, long)]
    input: String,

    /// 输出文件
    #[structopt(short, long)]
    output: Option<String>,

    /// 日志级别
    #[structopt(short, long, default_value = "info")]
    log_level: String,
}

fn main() {
    let cli = Cli::from_args();

    println!("Input file: {}", cli.input);
    if let Some(output) = cli.output {
        println!("Output file: {}", output);
    }
    println!("Log level: {}", cli.log_level);
}
代码说明
  1. Cli：命令行参数结构体，使用 structopt 的 StructOpt 派生宏。
  2. input：输入文件路径，支持短选项 -i 和长选项 --input。
  3. output：输出文件路径，支持短选项 -o 和长选项 --output，可选参数。
  4. log_level：日志级别，支持短选项 -l 和长选项 --log-level，默认值为 info。

10.1.3 子命令

10.1.3.1 使用 clap 实现子命令

clap 支持子命令功能，允许命令行工具支持多个子命令，每个子命令执行不同的功能。以下是一个使用 clap 实现子命令的示例。

10.1.3.1.1 实现子命令

以下是一个使用 clap 实现子命令的示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

use clap::{ArgEnum, Parser, Subcommand};

#[derive(Parser)]
#[clap(author, version, about, long_about = None)]
struct Cli {
    #[clap(subcommand)]
    command: Commands,
}

#[derive(Subcommand)]
enum Commands {
    /// 处理输入文件
    Process {
        /// 输入文件
        #[clap(short, long, value_parser)]
        input: String,

        /// 输出文件
        #[clap(short, long, value_parser)]
        output: Option<String>,
    },

    /// 显示日志
    Log {
        /// 日志级别
        #[clap(short, long, arg_enum, default_value_t = LogLevel::Info)]
        level: LogLevel,
    },
}

#[derive(Copy, Clone, ArgEnum)]
enum LogLevel {
    Debug,
    Info,
    Warn,
    Error,
}

fn main() {
    let cli = Cli::parse();

    match cli.command {
        Commands::Process { input, output } => {
            println!("Processing input file: {}", input);
            if let Some(output) = output {
                println!("Output file: {}", output);
            }
        }
        Commands::Log { level } => {
            println!("Log level: {:?}", level);
        }
    }
}
代码说明
  1. Cli：命令行参数结构体，包含一个子命令枚举。
  2. Commands：子命令枚举，包含 Process 和 Log 两个子命令。
  3. Process：处理输入文件的子命令，包含 input 和 output 两个参数。
  4. Log：显示日志的子命令，包含 level 一个参数。

10.1.3.2 使用 structopt 实现子命令

structopt 也支持子命令功能，以下是一个使用 structopt 实现子命令的示例。

10.1.3.2.1 实现子命令

以下是一个使用 structopt 实现子命令的示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

use structopt::StructOpt;

#[derive(StructOpt)]
#[structopt(name = "my-tool", about = "A simple command-line tool")]
struct Cli {
    #[structopt(subcommand)]
    command: Commands,
}

#[derive(StructOpt)]
enum Commands {
    /// 处理输入文件
    Process {
        /// 输入文件
        #[structopt(short, long)]
        input: String,

        /// 输出文件
        #[structopt(short, long)]
        output: Option<String>,
    },

    /// 显示日志
    Log {
        /// 日志级别
        #[structopt(short, long, default_value = "info")]
        level: String,
    },
}

fn main() {
    let cli = Cli::from_args();

    match cli.command {
        Commands::Process { input, output } => {
            println!("Processing input file: {}", input);
            if let Some(output) = output {
                println!("Output file: {}", output);
            }
        }
        Commands::Log { level } => {
            println!("Log level: {}", level);
        }
    }
}
代码说明
  1. Cli：命令行参数结构体，包含一个子命令枚举。
  2. Commands：子命令枚举，包含 Process 和 Log 两个子命令。
  3. Process：处理输入文件的子命令，包含 input 和 output 两个参数。
  4. Log：显示日志的子命令，包含 level 一个参数。

10.1.4 输入输出处理

10.1.4.1 处理标准输入

命令行工具通常需要处理标准输入（stdin）。以下是一个处理标准输入的示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

use std::io::{self, BufRead};

fn main() {
    let stdin = io::stdin();
    for line in stdin.lock().lines() {
        if let Ok(line) = line {
            println!("{}", line);
        }
    }
}
代码说明
  1. io::stdin：获取标准输入句柄。
  2. stdin.lock().lines()：逐行读取标准输入。

10.1.4.2 处理标准输出和错误

命令行工具通常需要将结果输出到标准输出（stdout）或标准错误（stderr）。以下是一个处理标准输出和错误的示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

use std::io::{self, Write};

fn main() {
    let stdout = io::stdout();
    let mut handle = stdout.lock();
    writeln!(handle, "This is stdout").unwrap();

    let stderr = io::stderr();
    let mut handle = stderr.lock();
    writeln!(handle, "This is stderr").unwrap();
}
代码说明
  1. io::stdout：获取标准输出句柄。
  2. io::stderr：获取标准错误句柄。
  3. writeln!：将内容写入标准输出或标准错误。

10.1.5 错误处理

10.1.5.1 使用 anyhow 处理错误

anyhow 是一个灵活的错误处理库，适用于命令行工具。以下是一个使用 anyhow 处理错误的示例。

10.1.5.1.1 添加依赖

在 Cargo.toml 中添加 anyhow 依赖：

1
2

[dependencies]
anyhow = "1.0"

10.1.5.1.2 实现错误处理

以下是一个使用 anyhow 处理错误的示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

use anyhow::{Context, Result};
use std::fs::File;
use std::io::Read;

fn read_file(path: &str) -> Result<String> {
    let mut file = File::open(path).context("Failed to open file")?;
    let mut contents = String::new();
    file.read_to_string(&mut contents).context("Failed to read file")?;
    Ok(contents)
}

fn main() -> Result<()> {
    let contents = read_file("input.txt")?;
    println!("{}", contents);
    Ok(())
}
代码说明
  1. anyhow::Result：通用的错误类型。
  2. context：为错误添加上下文信息。
  3. ?：传播错误。

10.1.5.2 使用 thiserror 定义自定义错误

thiserror 是一个用于定义自定义错误类型的库。以下是一个使用 thiserror 定义自定义错误的示例。

10.1.5.2.1 添加依赖

在 Cargo.toml 中添加 thiserror 依赖：

1
2

[dependencies]
thiserror = "1.0"

10.1.5.2.2 实现自定义错误

以下是一个使用 thiserror 定义自定义错误的示例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

use thiserror::Error;
use std::fs::File;
use std::io::Read;

#[derive(Error, Debug)]
enum MyError {
    #[error("Failed to open file: {0}")]
    FileOpenError(String),
    #[error("Failed to read file: {0}")]
    FileReadError(String),
}

fn read_file(path: &str) -> Result<String, MyError> {
    let mut file = File::open(path).map_err(|e| MyError::FileOpenError(e.to_string()))?;
    let mut contents = String::new();
    file.read_to_string(&mut contents).map_err(|e| MyError::FileReadError(e.to_string()))?;
    Ok(contents)
}

fn main() -> Result<(), MyError> {
    let contents = read_file("input.txt")?;
    println!("{}", contents);
    Ok(())
}
代码说明
  1. MyError：自定义错误枚举，使用 thiserror 的 Error 派生宏。
  2. FileOpenError：文件打开错误。
  3. FileReadError：文件读取错误。

10.1.6 总结

命令行工具开发是系统编程中的重要部分。本文详细介绍了如何使用 Rust 开发安全可靠的命令行工具，涵盖命令行参数解析、子命令、输入输出处理、错误处理等内容。通过 Rust 的高性能和内存安全性，开发者可以构建高效、可靠的命令行工具。