Rust字符串解析库quoted-string-parser使用指南

简介

quoted-string-parser是一个专门用于解析带引号字符串的Rust库，特别适合处理需要识别引号内容、处理转义字符的场景。它提供了高效、灵活的解析能力，是处理配置文件、命令行参数或任何需要引号字符串解析场景的理想选择。

主要特性

• 支持单引号和双引号字符串
• 自动处理转义字符
• 高性能的解析实现
• 简单直观的API设计
• 良好的错误处理机制

安装

在Cargo.toml中添加依赖：

[dependencies]
quoted-string-parser = "0.1"

基本使用方法

1. 简单解析

use quoted_string_parser::parse_quoted_string;

fn main() {
    let input = r#""Hello, \"Rust\"!""#;
    match parse_quoted_string(input) {
        Ok((remaining, parsed)) => {
            println!("Parsed: {}", parsed); // 输出: Hello, "Rust"!
            println!("Remaining: {}", remaining); // 输出空字符串
        }
        Err(e) => eprintln!("Error: {}", e),
    }
}

2. 处理单引号

use quoted_string_parser::parse_quoted_string;

fn main() {
    let input = r#"'It\'s a single-quoted string'"#;
    let (_, result) = parse_quoted_string(input).unwrap();
    println!("{}", result); // 输出: It's a single-quoted string
}

3. 处理混合内容

use quoted_string_parser::{parse_quoted_string, parse_until_quoted};

fn main() {
    let input = r#"text before "quoted part" text after"#;
    let (input, before) = parse_until_quoted(input).unwrap();
    let (input, quoted) = parse_quoted_string(input).unwrap();
    
    println!("Before: {}", before); // 输出: text before 
    println!("Quoted: {}", quoted); // 输出: quoted part
    println!("After: {}", input); // 输出:  text after
}

高级用法

1. 自定义转义字符

use quoted_string_parser::ParserBuilder;

fn main() {
    let custom_parser = ParserBuilder::new()
        .with_escape_char('\\')
        .with_quote_chars(&[''','"'])
        .build();
    
    let input = r#""Custom \\ escape""#;
    let (_, result) = custom_parser.parse(input).unwrap();
    println!("{}", result); // 输出: Custom \ escape
}

2. 处理多行引号字符串

use quoted_string_parser::parse_quoted_string;

fn main() {
    let input = r#"""
This is a
multi-line
string
"""#;
    let (_, result) = parse_quoted_string(input).unwrap();
    println!("{}", result); // 保留换行符的输出
}

3. 错误处理

use quoted_string_parser::parse_quoted_string;

fn main() {
    let input = r#""Unterminated string"#;
    match parse_quoted_string(input) {
        Ok(_) => println!("Success"),
        Err(e) => eprintln!("Error: {}", e), // 输出: Error: Unterminated quoted string
    }
}

性能提示

1. 如果需要重复解析，建议创建并重用Parser实例
2. 对于已知格式的输入，使用特定的解析方法比通用方法更快
3. 避免在热循环中重复构建解析器

实际应用示例

解析命令行参数

use quoted_string_parser::parse_quoted_string;

fn parse_args(input: &str) -> Vec<String> {
    let mut args = Vec::new();
    let mut remaining = input.trim();
    
    while !remaining.is_empty() {
        if remaining.starts_with('"') || remaining.starts_with('\'') {
            let (new_remaining, arg) = parse_quoted_string(remaining).unwrap();
            args.push(arg.to_string());
            remaining = new_remaining.trim_start();
        } else {
            let split_pos = remaining.find(char::is_whitespace).unwrap_or(remaining.len());
            let (arg, new_remaining) = remaining.split_at(split_pos);
            args.push(arg.to_string());
            remaining = new_remaining.trim_start();
        }
    }
    
    args
}

fn main() {
    let input = r#"cmd -o "output file.txt" --name 'John Doe'"#;
    let args = parse_args(input);
    println!("{:?}", args); // ["cmd", "-o", "output file.txt", "--name", "John Doe"]
}

完整示例代码

下面是一个结合了多种功能的完整示例，展示如何在实际项目中使用quoted-string-parser：

use quoted_string_parser::{parse_quoted_string, ParserBuilder};

fn main() {
    // 示例1: 解析带转义字符的字符串
    let input1 = r#""This is a \"test\" string""#;
    match parse_quoted_string(input1) {
        Ok((remaining, parsed)) => {
            println!("示例1 - 解析结果: {}", parsed);
            println!("示例1 - 剩余内容: '{}'", remaining);
        }
        Err(e) => eprintln!("示例1 - 错误: {}", e),
    }

    // 示例2: 使用自定义解析器
    let custom_parser = ParserBuilder::new()
        .with_escape_char('$')  // 使用$作为转义字符
        .with_quote_chars(&['"', '\''])
        .build();
    
    let input2 = r#""Escape with $$ dollar sign""#;
    match custom_parser.parse(input2) {
        Ok((_, result)) => println!("示例2 - 自定义解析结果: {}", result),
        Err(e) => eprintln!("示例2 - 错误: {}", e),
    }

    // 示例3: 解析配置文件格式
    let config_input = r#"key1 = "value1" 
    key2 = 'value2 with spaces'
    key3 = unquoted_value"#;
    
    let mut config = std::collections::HashMap::new();
    for line in config_input.lines() {
        let line = line.trim();
        if line.is_empty() {
            continue;
        }
        
        if let Some(equal_pos) = line.find('=') {
            let key = line[..equal_pos].trim();
            let value_part = line[equal_pos+1..].trim();
            
            // 尝试解析引号字符串
            if let Ok((_, value)) = parse_quoted_string(value_part) {
                config.insert(key.to_string(), value.to_string());
            } else {
                // 如果不是引号字符串，直接使用整个值
                config.insert(key.to_string(), value_part.to_string());
            }
        }
    }
    
    println!("示例3 - 配置解析结果:");
    for (key, value) in &config {
        println!("  {} = {}", key, value);
    }
}

这个完整示例展示了：

1. 基本引号字符串解析
2. 自定义解析器的创建和使用
3. 实际应用场景中的配置文件解析

输出结果将会是：

示例1 - 解析结果: This is a "test" string
示例1 - 剩余内容: ''
示例2 - 自定义解析结果: Escape with $ dollar sign
示例3 - 配置解析结果:
  key1 = value1
  key2 = value2 with spaces
  key3 = unquoted_value