一文详解Rust中的字符串
有人可能会说，字符串这么简单还用介绍？但是很多人学习rust受到的第一个暴击就来自这浓眉大眼、看似毫无难度的字符串。
请看下面的例子。
fn main() {
let my_name = "World!";
greet(my_name);
}
fn greet(name: String) {
println!("Hello, {}!", name);
}
这段简单Hello world的代码看起来没什么问题，但是在rust里却编译不了。
error[E0308]: mismatched types
--> src/main.rs:3:11
|
3 | greet(my_name);
| ^^^^^^^
| |
| expected struct `std::string::String`, found `&str`
| help: try using a conversion method: `my_name.to_string()`
error: aborting due to previous error
报错的意思是，greet函数需要一个String类型的参数，但是提供了一个&str类型的实参。
这下不觉得字符串简单了吧？
学习Rust你必须理解&str和String的区别。别急，你还经常会在代码里看到 &'static str、&[u8]、&[u8; N]、Vec<u8> 、OsStr、OsString、CStr和CString。
这张图很好地描绘了学习Rust后再谈到字符串的情形：
本文就介绍一下这些字符串相关的类型。
先来说说&str
&str
str类型也叫字符串切片，是最基本的字符器类型，通常是借用的试出现，也就是&str。
什么是切片？
在rust里，切片是连续序列[T]的动态大小视图 ，切片是内存块的视图，表示为指针和长度。 这样的定义会让人难以理解。其实slice就是一种引用，允许你对一个连续序列中元素进行引用。
fn main() {
let a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
let slice = &a[3..7];
println!("{:#?}", slice);
}
let slice = &a[3..7];这一行我们创建了一个slice。它的内容是：
[
4,
5,
6,
7,
]
slice的中文翻译切片这个词，很容易让人认为是从一个连续序列中切下来一段，很难与引用联想在一起，我认为翻译成片段可能更合适。
理解了slice，&str就好理解了，&str就是字符串的slice。Rust负责保证str是有效的UTF-8。因为通常是以借用引用(&str)的方式出现，因此是不可变的。
在其它语言中常用的字符串操作，如split、find、trim,大小写转换等操作，都是str的方法，并不是由String类型提供。
在这里要注意，在对字符串使用切片语法时需要格外小心。因为字符串的内部是[u8]数组，每个数组的元素是一个u8，所以数组的长度就是字符串的长度，跟你看到的字符串的长度可能是不一样的。
let s = "我是中国人";
println!("{}",s.len());
你以为结果会是5,但是结果是15; 为什么是15，因为这个字符串的字节数是15。
let s = "我是中国人";
println!("{:?}",s.bytes())
结果是：
Bytes(Copied { it: Iter([230, 136, 145, 230, 152, 175, 228, 184, 173, 229, 155, 189, 228, 186, 186]) })
字符串的len()返回的是字节数，不是UTF-8字符数。
let s = "我是中国人";
println!("{}",s.chars().count());
这时输出的才是5。
所以当直接对字符串对切片时，一定要注意切片的索引必须落在字符之间的边界位置。
let s = "我是中国人";
let a = &s[0..2];
println!("{}",a);
这段代码可以编译，但是在运行时会报错
Compiling playground v0.0.1 (/playground)
Finished dev [unoptimized + debuginfo] target(s) in 0.39s
Running `target/debug/playground`
thread 'main' panicked at src/main.rs:4:15:
byte index 2 is not a char boundary; it is inside '我' (bytes 0..3) of `我是中国人`
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
每个汉字占用3个字节，&s[0..2]只取了前两个节点，所以报错信息告诉你，index 2是不是字符的边界。所以对字符串使用切片语法时需要格外谨慎。
注意： Rust里字符串字面量的类型是&'static str，这涉及到静态生命周期，有兴趣同学可以参考生命周期相关的文章。
String
在rust中String不是基本类型，是个复合类型，它包含了一个私有的u8的vec。
pub struct String {
vec: Vec<u8>,
}
因为它的唯一字段vec是私有的，所以只能通过String类型提供的构建函数创建String，因此let my_name = "Rust";这样语句创建出来的不是String类型。
因为它的底层是一个vec，所以String支持改变它自身的一些操作，比如push、pop、clear，可以看出来都是针对vec的操作。
let mut s = String::from("abc");
s.push('1');
s.push('2');
s.push('3');
assert_eq!("abc123", s);
let mut s = String::from("abč");
assert_eq!(s.pop(), Some('č'));
assert_eq!(s.pop(), Some('b'));
assert_eq!(s.pop(), Some('a'));
assert_eq!(s.pop(), None);
let mut s = String::from("foo");
s.clear();
assert!(s.is_empty());
assert_eq!(0, s.len());
assert_eq!(3, s.capacity());
&[u8]
&[u8]是一个切片，指向一段连续的内存区域，其中存储着 u8 类型的值（字节）。它不拥有数据，只是借用了数据的引用。
由于不拥有数据，&[u8] 通常用于不可变的字符串操作。可以从 String 或其他字节数组中创建&[u8] 切片。
let mut my_string = String::from("Hello, world!");
// 获取 &[u8] 切片
let my_bytes: &[u8] = my_string.as_bytes();
// 将 &[u8] 转换为 String (需要确保是有效的 UTF-8 编码)
let new_string = String::from_utf8(my_bytes.to_vec()).unwrap();
&[u8;N]
&[u8; N] 表示一个指向长度为 N 的 u8 类型数组的切片。
与 &[u8]的区别是，&[u8] 是一个指向任意长度u8 类型数组的切片，可以指向不同长度的数组。&[u8; N]是一个指向固定长度为 N 的字节数组的切片，只能指向长度为 N 的数组。
一个特别常用的场景就是网络协议栈的解析，数据包头通常都是固定长度的，非常适合用&[u8; N]来保存。
Vec<u8>
Vec<u8> 是String类型的底层存储，可以通过String::from_utf8这个方法创建一个String。
&u8
&u8只是 &[u8]切片中的一个元素，也不展开介绍。
OsStr和OsString
这两个类型包含在std::ffi这个模块里，ffi 的意思是 Foreign Function Interface ，外部函数接口，用来调用其它语言(如C语言)编写的函数。因为目前主流的操作系统都是用C语言写的，所以ffi可以用来调用系统接口和处理与操作系统相关的操作。
为什么需要OsStr和OsString呢？
因为在不同的操作系统中，字符串的编码是有差异的。
在 Unix 系统上，字符串通常是非零字节的任意序列，通常情况下，这些字符串会被解释为 UTF-8 编码的文本，但并非总是如此。
在 Windows 上，字符串通常是非零 16 位值的任意序列，通常情况下，这些字符串会被解释为 UTF-16 编码的文本，也并非总是如此。
在 Rust 中，字符串始终是有效的 UTF-8 编码，可以包含零。 这意味着 Rust 字符串只能包含有效的 UTF-8 编码的字节序列，但可以包含 0 字节。
因为操作系统原生字符串与Rust字符串的这种差异，因此需要有一种类型能同时表示这两种字符串，并可以在需要时进行相互转换，这种类型就是OsString 和 OsStr。
注意， OsString 和 OsStr 内部不一定以平台原生的形式保存字符串;
use std::env;
use std::ffi::OsString;
fn main() {
// 获取命令行参数
let args: Vec<OsString> = env::args_os().collect();
// 获取第一个参数（文件名）
let filename = &args[1];
// 打印文件名
println!("Filename: {:?}", filename);
}
Path 和PathBuf
Path 结构表示底层文件系统中的文件路径。有两种样式： Path posix::Path ，用于类 UNIX 系统，以及 windows::Path ，用于 Windows。只所以有两种形式，是因为windows和Unix的路径差别很大，比如路径分隔符就不一样，windows用,Unix用/。
prelude.rs会根据当前平台导出相应的特定于平台 Path 的变体。
Path这个类型是一个切片，是不可变的(immutable)，它的owned版本的类型是PathBuf。Path和PathBuf的关系跟str和String的关系相似。
因为Path是与操作系统相关的，因此它内部使用的是OsStr。
pub struct Path {
inner: OsStr,
}
下面是Path的代码示例。
use std::path::Path;
use std::ffi::OsStr;
// 注意: 下面代码不能运行在windows下
let path = Path::new("./foo/bar.txt");
let parent = path.parent();
assert_eq!(parent, Some(Path::new("./foo")));
let file_stem = path.file_stem();
assert_eq!(file_stem, Some(OsStr::new("bar")));
let extension = path.extension();
assert_eq!(extension, Some(OsStr::new("txt")));
PathBuf是 Path的 owned版本，是可变的。
use std::path::PathBuf;
let mut path = PathBuf::new();
path.push(r"C:");
path.push("windows");
path.push("system32");
path.set_extension("dll");
CStr和CString
在C语言中字符串是NUL()为结尾的一维字符数组。
Rust中的CStr表示对以 nul 结尾的字节数组的借用引用,也就是C语言的字符串在Rust中的对应类型。
它可以安全地从 &[u8] 切片构建，也可以不安全地(unsafely)从原始 *const c_char 构建。
因为Rust的字符串必须是UTF-8的，所以CStr要转换为String，需要通过 UTF-8 验证，以保证每个字符都是UTF-8的。
use std::ffi::CStr;
use std::os::raw::c_char;
extern "C" { fn my_string() -> *const c_char; }
unsafe {
let slice = CStr::from_ptr(my_string());
println!("string buffer size without nul terminator: {}", slice.to_bytes().len());
}
总结
在Rust语言中有几种字符串相关的类型，&str和String是Rust字符串最常用的类型，前者是一个slice，是借用引用，后者则是它的owned版本，可变。OsStr和OsString是Rust的字符串和操作系统原生字符串的桥，通过这个桥，Rust的字符串和操作系统原生字符串可以相互转换。Path和PathBuf则是Rust为不同的操作系统提供的统一的路径(Path)类型，在内部使用的是OsStr。而CStr则是C语言中以NUL()为结尾的一维字符数组在Rust语言的一种表示。
本文为原创，未经同意不得转载。本文亦发表于https://www.renhl.com/posts/2024/03/17/rust-string-osstring-cstring/