Rust: Rust 字符串全面解析：&str 与 String 的奥秘

fn main() {
    // &str：字符串字面量，编译时就存在二进制里
    let title_book1: &str = "百年孤独";

    // String：堆分配的，可变长，自动管理内存
    let mut title_book2 = String::from("How to Make a Complete Map of an Infinite Universe");
    title_book2.push_str(" (Second Edition)");  // 追加内容

    println!("书 1: {} (长度: {} 字节)", title_book1, title_book1.len());
    println!("书 2: {} (长度: {} 字节)", title_book2, title_book2.len());
    // String 离开作用域时自动释放，不需要手动 free
}

// &str 创建
let s1: &str = "hello, world";       // 字符串字面量
let s2: &str = r"raw string\n";      // 原始字符串（不转义）

// String 创建
let s3 = String::from("hello");
let s4 = "world".to_string();
let s5 = format!("{}-{}", s3, s4);   // 格式化创建
let s6: String = "hi".into();         // 通过类型转换

// ============================================
// String 的创建、追加和拼接
// ============================================

fn main() {
    // 创建
    let mut s = String::from("Hello");

    // 追加
    s.push_str(", ");       // 追加字符串切片
    s.push('R');            // 追加单个字符
    s.push_str("ust!");
    println!("追加后: {}", s);

    // 拼接（+ 操作符会消费左侧 String）
    let s1 = String::from("Hello, ");
    let s2 = String::from("World!");
    let s3 = s1 + &s2;      // s1 被移动，不能再用了
    println!("拼接后: {}", s3);

    // format! 宏（不消费任何变量）
    let a = String::from("tic");
    let b = String::from("tac");
    let c = String::from("toe");
    let result = format!("{}-{}-{}", a, b, c);
    println!("format 结果: {}", result);
}

追加后: Hello, Rust!
拼接后: Hello, World!
format 结果: tic-tac-toe

// ============================================
// 字符串切片——注意 UTF-8 边界！
// ============================================

fn main() {
    let s = String::from("Rust编程");

    // 获取字符串长度（字节数，不是字符数）
    println!("字节长度: {}", s.len());         // 10（4 字节 ASCII + 6 字节 UTF-8 中文）

    // 字符串切片（按字节索引，且必须在字符边界上）
    let slice1 = &s[0..4];                     // "Rust"（前 4 字节正好是一个完整字符边界）
    println!("前 4 字节切片: {}", slice1);

    // &s[0..5] 会 panic!（因为 4-5 字节是中文的第一个字节中间）

    // 按字符数遍历
    for c in s.chars() {
        print!("{} ", c);
    }
    println!();

    // 按字节遍历
    for b in s.bytes() {
        print!("{:02x} ", b);
    }
    println!();
}

字节长度: 10
前 4 字节切片: Rust
R u s t 编 程
52 75 73 74 e7 bc 96 e7 a8 8b

// ============================================
// 字符串常用的查询、替换、裁剪方法
// ============================================

fn main() {
    let s = "  Hello, Rust World!  ";

    // 去除两端空白
    println!("trim: '{}'", s.trim());

    // 包含判断
    println!("contains 'Rust': {}", s.contains("Rust"));

    // 替换
    let replaced = s.replace("Rust", "Go");
    println!("replace: '{}'", replaced);

    // 分割
    let parts: Vec<&str> = "apple,banana,cherry".split(',').collect();
    println!("split: {:?}", parts);

    // 大小写转换
    let lower = "HELLO".to_lowercase();
    let upper = "world".to_uppercase();
    println!("lower: {}, upper: {}", lower, upper);
}

trim: 'Hello, Rust World!'
contains 'Rust': true
replace: '  Hello, Go World!  '
split: ["apple", "banana", "cherry"]
lower: hello, upper: WORLD

// ============================================
// UTF-8 字符串的字节、字符和图素簇
// ============================================

fn main() {
    let s = "Rust🦀你好";

    println!("字符串: {}", s);
    println!("字节长度: {}", s.len());
    println!("字符数量: {}", s.chars().count());

    println!("\n--- 逐字符遍历 ---");
    for (i, c) in s.chars().enumerate() {
        println!("字符 {}: '{}' (Unicode: U+{:04X})", i, c, c as u32);
    }

    println!("\n--- 逐字节遍历 ---");
    for (i, b) in s.bytes().enumerate() {
        print!("{:02x} ", b);
        if (i + 1) % 8 == 0 { println!(); }
    }
    println!();

    println!("\n--- 安全切片 ---");
    let ascii_part = &s[0..4];
    println!("ASCII 部分 &s[0..4]: '{}'", ascii_part);

    let emoji_start = 4;
    let emoji_end = emoji_start + 4;
    let emoji_part = &s[emoji_start..emoji_end];
    println!("Emoji 部分 &s[{}..{}]: '{}'", emoji_start, emoji_end, emoji_part);

    let chinese_start = emoji_end;
    let chinese_end = chinese_start + 6;
    let chinese_part = &s[chinese_start..chinese_end];
    println!("中文部分 &s[{}..{}]: '{}'", chinese_start, chinese_end, chinese_part);

    let combined = format!("{}{}{}", ascii_part, emoji_part, chinese_part);
    println!("拼接还原: {}", combined);
}

字符串: Rust🦀你好
字节长度: 14
字符数量: 7

--- 逐字符遍历 ---
字符 0: 'R' (Unicode: U+0052)
字符 1: 'u' (Unicode: U+0075)
字符 2: 's' (Unicode: U+0073)
字符 3: 't' (Unicode: U+0074)
字符 4: '🦀' (Unicode: U+1F980)
字符 5: '你' (Unicode: U+4F60)
字符 6: '好' (Unicode: U+597D)

--- 逐字节遍历 ---
52 75 73 74 f0 9f a6 80
e4 bd a0 e5 a5 bd 

--- 安全切片 ---
ASCII 部分 &s[0..4]: 'Rust'
Emoji 部分 &s[4..8]: '🦀'
中文部分 &s[8..14]: '你好'
拼接还原: Rust🦀你好

// ============================================
// 字符串解析、格式化和连接的综合运用
// ============================================

fn main() {
    let raw_data = "name=Alice;age=30;city=Beijing";

    println!("原始数据: {}", raw_data);
    println!("\n--- 解析键值对 ---");

    let pairs: Vec<&str> = raw_data.split(';').collect();
    for pair in pairs {
        let parts: Vec<&str> = pair.split('=').collect();
        if parts.len() == 2 {
            let key = parts[0].trim();
            let value = parts[1].trim();
            println!("{} => {}", key, value);
        }
    }

    println!("\n--- 构建新字符串 ---");
    let name = "Alice";
    let age = 30;
    let city = "Beijing";
    let summary = format!("{}，{} 岁，来自 {}", name, age, city);
    println!("摘要: {}", summary);

    let mut report = String::from("人员报告\n");
    report.push_str(&format!("姓名: {}\n", name));
    report.push_str(&format!("年龄: {}\n", age));
    report.push_str(&format!("城市: {}\n", city));
    report.push_str("--- 结束 ---");
    println!("\n{}", report);

    let csv_line = ["Alice", "30", "Beijing"].join(",");
    println!("\nCSV 格式: {}", csv_line);
}

原始数据: name=Alice;age=30;city=Beijing

--- 解析键值对 ---
name => Alice
age => 30
city => Beijing

--- 构建新字符串 ---
摘要: Alice，30 岁，来自 Beijing

人员报告
姓名: Alice
年龄: 30
城市: Beijing
--- 结束 ---

CSV 格式: Alice,30,Beijing