前情回顾: Rust—复合数据类型之字符串（1）

字符串操作

删除 (Delete)

删除方法仅适用于 String 类型，分别是： pop()，remove()，truncate()，clear()，此外还有drain() 方法。

• pop 方法：pop() 方法返回一个 Option<char> 类型，如果字符串非空，则返回 Some(c)其中 c 是被移除的字符；如果字符串为空，则返回 None。最后打印出被移除的字符和剩余的字符串。

let mut s = String::from("hello");
let last_char = s.pop();

match last_char {
    Some(c) => println!("The last character of the string is: {}", c),
    None => println!("The string is empty."),
}

println!("Remaining string after pop: {}", s);

输出：

The last character of the string is: o
Remaining string after pop: hell

• remove 方法：remove() 方法用于从字符串中删除指定位置的字符，并返回被删除的字符。该方法接受一个 char 类型的索引作为参数，表示要删除的字符的位置。删除后，原字符串将被修改。remove() 方法是按照字节来处理字符串的，如果参数所给的位置不是合法的字符边界，则会发生错误。

let mut s = String::from("hello");
let c = s.remove(1); // 删除索引为 1 的字符 'e'
println!("{}", s); // 输出 "hllo"

• truncate 方法：truncate() 方法用于将字符串截断至指定长度，超出指定长度的部分将被删除。该方法接受一个 usize 类型的参数，表示字符串截断后的长度。该方法 truncate() 方法是按照字节来处理字符串的，如果参数所给的位置不是合法的字符边界，则会发生错误。

let mut s = String::from("hello");
s.truncate(2); // 截断字符串至长度 2
println!("{}", s); // 输出 "he"

• drain 方法：drain() 方法用于删除指定范围内的字符，并返回一个迭代器，通过迭代器可以访问被删除的字符。该方法接受一个 Range 类型的参数，表示要删除的字符范围。

let mut s = String::from("hello");
let removed: String = s.drain(1..3).collect(); // 删除索引为 1 和 2 的字符 'e' 和 'l'
println!("{}", s); // 输出 "hlo"
println!("{}", removed); // 输出 "el"

• clear 方法：相当于 truncate() 方法参数为 0 的时候。

fn main() {
    // 创建一个可变的 String
    let mut my_string = String::from("Hello, World!");

    // 清空字符串内容
    my_string.clear();

    // 输出清空后的字符串
    println!("{}", my_string);  // 输出: 空字符串
}

连接 (Concatenate)

• 使用 + 或者 += 连接字符串，只能将 &str 类型的字符串切片添加到 String 类型上，然后返回一个新的 String 类型。

fn main() {
    let s1 = String::from("hello,");
    let s2 = String::from("world!");
    // 在下句中，s1的所有权被转移走了，因此后面不能再使用s1
    let s3 = s1 + &s2;
    assert_eq!(s3,"hello,world!");
    // 下面的语句如果去掉注释，就会报错
    // println!("{}",s1);
}

• 使用 format! 连接字符串。

fn main() {
    let s1 = "hello";
    let s2 = String::from("rust");
    let s = format!("{} {}!", s1, s2);
    println!("{}", s);//输出hello rust!
}

字符串转义

在 Rust 中，字符串可以使用反斜杠 \进行转义，以表示一些特殊字符或者编码。以下是一些常见的字符串转义序列：

• \n：换行符
• \r：回车符
• \t：制表符
• \\：反斜杠自身
• \"：双引号
• \'：单引号
• \u{NNNN}：Unicode 码点，可以表示任意 Unicode 字符，其中 NNNN 为 Unicode 码点的十六进制表示。
• \ 后跟着一个字符的十六进制表示来转义输出一个字符。
• 使用\忽略换行符。

fn main() {
    // 通过 \ + 字符的十六进制表示，转义输出一个字符
    let byte_escape = "I'm writing \x52\x75\x73\x74!";
    println!("What are you doing\x3F (\\x3F means ?) {}", byte_escape);

    // \u 可以输出一个 unicode 字符
    let unicode_codepoint = "\u{211D}";
    let character_name = "\"DOUBLE-STRUCK CAPITAL R\"";

    println!(
        "Unicode character {} (U+211D) is called {}",
        unicode_codepoint, character_name
    );

    // 换行了也会保持之前的字符串格式
    // 使用\忽略换行符
    let long_string = "String literals
                        can span multiple lines.
                        The linebreak and indentation here ->\
                        <- can be escaped too!";
    println!("{}", long_string);
}

输出：