Rust字符串处理

Trim移除字符串开始末尾的字符串

fn main() {
    let s = "   Hello Rust!   ";
    // trim移除字符串开始末尾的空格
    // "Hello Rust!"
    println!("{}", s.trim());

    // trim_start移除字符串开始的空格
    // "Hello Rust!   "
    println!("{}", s.trim_start());

    // trim_end移除字符串末尾的空格
    // "   Hello Rust!"
    println!("{}", s.trim_end());

    let s = "abcabcabcHello Rust!abcabcabc";

    // trim_start_matches移除字符串开始匹配的字符串
    // "Hello Rust!abcabcabc"
    println!("{}", s.trim_start_matches("abc"));

    // trim_start_matches移除字符串开始匹配的字符串
    // "abcabcabcHello Rust!"
    println!("{}", s.trim_end_matches("abc"));
}

swap交换两个字符

fn main() {
    // 1. as_mut_vec
    let mut s = "中abc".to_string();
    unsafe {
        // 交换第0个和第1个元素
        s.as_mut_vec().swap(0, 1);
        }
    // 乱码abc
    println!("{}", s);

    // 2. chars
    let s = "中abc".to_string();
    let mut arr: Vec<char> = s.chars().collect();
    // 交换第0个和第1个元素
    arr.swap(0, 1);
    let s: String = arr.into_iter().collect();
    // a中bc
    println!("{}", s);

    // 3. into_bytes
    let s = "abc".to_string();
    let mut arr = s.into_bytes();
    unsafe {
        // 交换第0个和第1个元素
        std::ptr::swap(&mut arr[0], &mut arr[1]);
    }
    let s = String::from_utf8(arr).unwrap();
    // bac
    println!("{}", s);

    // 4. replace_range
    let mut s = "abc".to_string();
    // tmp: &alloc::string::String
    let tmp = &s[0..1].to_string();
    // 交换第0个和第1个元素
    // cannot borrow `s` as mutable because it is also borrowed as immutable
    // s.replace_range(0..1, &s[1..2]);
    s.replace_range(0..1, &s[1..2].to_string());
    s.replace_range(1..2, tmp);
    // bac
    println!("{}", s);
}