原文：https://course.rs/basic/compound-type/string-slice.html
#![allow(unused_variables)] 编译器忽略未使用变量的警告unimplemented!() 指明函数没有实现
切片
对于字符串而言，切片就是对 String 类型中某一部分的引用，String类型的切片就是&str
let s = String::from("hello");
let slice: &str = &s[0..2];
let slice: &str = &s[..2];
在对字符串使用切片语法时需要格外小心，切片的索引必须落在字符之间的边界位置，也就是 UTF-8 字符的边界，例如中文在 UTF-8 中占用三个字节，下面的代码就会崩溃：
let s = "中国人";
let a = &s[0..2];
println!("{}",a);
👇 错误，在获得了不可变借用后，使用可变借用，然后又打印先前的不可变借用产生错误，两者不能共存。
fn main() {
let mut s = String::from("hello world");
let word = first_word(&s); // 获得不可用借用
s.clear(); // error! // 获得可变借用
println!("the first word is: {}", word); // 打印不可变借用
}
fn first_word(s: &String) -> &str {
&s[..1]
}
修复上面的代码👇
fn main() {
let mut s = String::from("hello world");
// 这里, &s 是 `&String` 类型，但是 `first_word` 函数需要的是 `&str` 类型。
// 尽管两个类型不一样，但是代码仍然可以工作，原因是 `&String` 会被隐式地转换成 `&str` 类型，如果大家想要知道更多，可以看看 Deref 章节: https://course.rs/advance/smart-pointer/deref.html
let word = first_word(&s);
println!("the first word is: {}", word);
// 关键是调整了word的使用位置
s.clear();
}
fn first_word(s: &str) -> &str {
&s[..1]
}
其他切片
#![allow(unused)]
fn main() {
let a = [1, 2, 3, 4, 5];
let copy = a; // 复制，地址与a不同let slice1 = &a[..];
let slice2 = &a[..2];
println!("{:p}, {:p}, {:p}, {:p}", &a, ©, slice1, slice2)
// 0x7ffee4da2cf0, 0x7ffee4da2d04, 0x7ffee4da2cf0, 0x7ffee4da2cf0
}
一个切片引用占用了2个字大小的内存空间( 从现在开始，为了简洁性考虑，如无特殊原因，我们统一使用切片来特指切片引用 )。 该切片的第一个字是指向数据的指针，第二个字是切片的长度。字的大小取决于处理器架构，例如在 x86-64 上，字的大小是 64 位也就是 8 个字节，那么一个切片引用就是 16 个字节大小。
- 切片签名
&[T]
- 数组签名
[T; length]
fn main() {
let arr: [char; 3] = ['中', '国', '人'];
let slice = &arr[..2];
// 修改数字 `8` 让代码工作
// 小提示: 切片和数组不一样，它是引用。如果是数组的话，那下面的 `assert!` 将会通过： '中'和'国'是char类型，char类型是Unicode编码，大小固定为4字节，两个字符为8字节。
assert!(std::mem::size_of_val(&slice) == 16);
}
字符串
⭐️ 字符串字面量 是 切片
虽然 String 的底层是 Vec<u8> 也就是字节数组的形式存储的，但是它是基于 UTF-8 编码的字符序列。String 分配在堆上、可增长且不是以 null 结尾。
而 &str 是切片引用类型( &[u8] )，指向一个合法的 UTF-8 字符序列，总之，&str 和 String 的关系类似于 &[T] 和 Vec<T> 。
let s = "Hello, world!";
// ->let s: &str = "Hello, world!";
// s是不可变引用
str 类型是硬编码进可执行文件，也无法被修改，但是 String 则是一个可增长、可改变且具有所有权的 UTF-8 编码字符串，当 Rust 用户提到字符串时，往往指的就是 String 类型和 &str 字符串切片类型，这两个类型都是 UTF-8 编码。
String 与 &str 的转换
&str to String
String::from("hello,world")"hello,world".to_string()
String to &str:
- 取引用（切片）
let slice1 = &s;
let slice1: &str = s.as_str();
fn main() {
let s = String::from("hello,world!");
say_hello(&s);
say_hello(&s[..]);
say_hello(s.as_str());
}
fn say_hello(s: &str) {
println!("{}",s);
}
⭐️ Rust 不允许索引字符串
👇 报错
#![allow(unused)]
fn main() {
let s1 = String::from("hello");
let h = s1[0];
}
对字符串切片是危险的
操作字符串
追加（String可用）
push(char)/push_str(&str)
插入（String可用）
insert(idx: usize, char)/insert_str(idx: usize, &str)
替换（String/&str可用）
replace(needle: &str, haystack: &str)/replacen(needle: &str, haystack: &str, n)
替换范围（String可用）
replace_range(range, &str)
fn main() {
let mut string_replace_range = String::from("I like rust!");
string_replace_range.replace_range(7..8, "R");
dbg!(string_replace_range);
}
删除（String可用）
pop – 删除并返回字符串的最后一个字符。其返回值是一个 Option 类型，如果字符串为空，则返回 None。remove —— 删除并返回字符串中指定位置的字符，remove() 方法是按照字节来处理字符串的，如果参数所给的位置不是合法的字符边界，则会发生错误。
fn main() {
let mut string_remove = String::from("测试remove方法");
println!(
"string_remove 占 {} 个字节",
std::mem::size_of_val(string_remove.as_str())
);
// 删除第一个汉字
string_remove.remove(0);
// 下面代码会发生错误
// string_remove.remove(1);
// 直接删除第二个汉字
// string_remove.remove(3);
dbg!(string_remove);
}
truncate —— 删除字符串中从指定位置开始到结尾的全部字符，无返回值clear —— 清空字符串，相当于truncate(0)
连接字符串
- 用
+ 或 +=: s = s1 + &s2 （s, s1, s2都是 String，&s2自动解引用为 &str 类型）
fn main() {
let string_append = String::from("hello ");
let string_rust = String::from("rust");
// &string_rust会自动解引用为&str
let result = string_append + &string_rust;
let mut result = result + "!";
result += "!!!";
println!("连接字符串 + -> {}", result);
}
⚠️ 注意，之所以可以使用 + 连接字符串是因为，调用了 std::string 标准库中的 add() 方法，这里 add() 方法的第二个参数是一个引用的类型。因此我们在使用 +， 必须传递切片引用类型。不能直接传递 String 类型。+ 和 += 都是返回一个新的字符串。所以变量声明可以不需要 mut 关键字修饰。
⚠️ add() 定义
fn add(self, s: &str) -> 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);
}
fn main() {
let s1 = "hello";
let s2 = String::from("rust");
let s = format!("{} {}!", s1, s2);
println!("{}", s);
}
转义
使用 \
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);
}
禁止转义 r"..."，包含双引号 r#"..."#
fn main() {
println!("{}", "hello \\x52\\x75\\x73\\x74");
let raw_str = r"Escapes don't work here: \x3F \u{211D}";
println!("{}", raw_str);
// 如果字符串包含双引号，可以在开头和结尾加 #
let quotes = r#"And then I said: "There is no escape!""#;
println!("{}", quotes);
// 如果还是有歧义，可以继续增加，没有限制
let longer_delimiter = r###"A string with "# in it. And even "##!"###;
println!("{}", longer_delimiter);
}
操作UTF-8字符串
遍历 char
for c in "中国人".chars() {
println!("{}", c);
}
遍历 byte(字节)
for b in "中国人".bytes() {
println!("{}", b);
}
取子字符串：utf8_slice。
习题
如果要使用 str 类型，只能配合 Box。 & 可以用来将 Box 转换为 &str 类型
fn main() {
let s: Box<str> = "hello, world".into();
greetings(s)
}
fn greetings(s: Box<str>) {
println!("{}", &s)
}
或
fn main() {
let s: Box<&str> = "hello, world".into();
greetings(*s)
}
fn greetings(s: &str) {
println!("{}", s);
}
字节字符串 （Byte String）
use std::str;
fn main() {
// 注意，这并不是 `&str` 类型了！
let bytestring: &[u8; 21] = b"this is a byte string";
// 字节数组没有实现 `Display` 特征，因此只能使用 `Debug` 的方式去打印
println!("A byte string: {:?}", bytestring);
// 字节数组也可以使用转义
let escaped = b"\x52\x75\x73\x74 as bytes";
// ...但是不支持 unicode 转义
// let escaped = b"\u{211D} is not allowed";
println!("Some escaped bytes: {:?}", escaped);
// raw string
let raw_bytestring = br"\u{211D} is not escaped here";
println!("{:?}", raw_bytestring);
// 将字节数组转成 `str` 类型可能会失败
if let Ok(my_str) = str::from_utf8(raw_bytestring) {
println!("And the same as text: '{}'", my_str);
}
let _quotes = br#"You can also use "fancier" formatting, \
like with normal raw strings"#;
// 字节数组可以不是 UTF-8 格式
let shift_jis = b"\x82\xe6\x82\xa8\x82\xb1\x82\xbb"; // "ようこそ" in SHIFT-JIS
// 但是它们未必能转换成 `str` 类型
match str::from_utf8(shift_jis) {
Ok(my_str) => println!("Conversion successful: '{}'", my_str),
Err(e) => println!("Conversion failed: {:?}", e),
};
}
练习：
// 填空
fn main() {
let mut s = String::new();
__;
let v = vec![104, 101, 108, 108, 111];
// 将字节数组转换成 String
let s1 = __;
assert_eq!(s, s1);
println!("Success!")
}
答案
// FILL in the blanks
fn main() {
let mut s = String::new();
s.push_str("hello");
// some bytes, in a vector
let v = vec![104, 101, 108, 108, 111];
// Turn a bytes vector into a String
// We know these bytes are valid, so we'll use `unwrap()`.
let s1 = String::from_utf8(v).unwrap();
assert_eq!(s, s1);
println!("Success!")
}
utf8_slice
use utf8_slice;
fn main() {
let s = "The 🚀 goes to the 🌑!";
let rocket = utf8_slice::slice(s, 4, 5);
// 结果是 "🚀"
}
参考
https://doc.rust-lang.org/std/string/struct.String.html
