Unicode 与 ASCII 的所有 ASCII 码点都相同（0 ~ 0x7f）。
Unicode 将（0 ~ 0x7f）码点范围称为 Latin-1 编码块（ISO/IEC 8859-1）。
即 Unicode 是 Latin-1 的超集：
Latin-1 转换为 Unicode：
fn latin1_to_char(latin1: u8) -> char {
latin1 as char
}
Unicode 转换为 Latin-1:
fn char_to_latin1(c: char) -> Option<u8> {
if c as u32 <= 0xff {
Some(c as u8)
} else {
None
}
}
String 和 str 类型使用 UTF-8 编码格式表示文本。UTF-8 将字符编码为 1 到 4 个字节序列。char 类型是保存 Unicode 码点的 32 位值。char 类型实现了 Copy 和 Clone，以及比较、散列、格式的所有常用特型。ch.is_numeric()：数值字符，包括 Unicode 普通类别 Number; digit 和 Number; letter，但不包括 Number; other。ch.is_alphabetic()：字母字符，包括 Unicode 的 “Alphabetic” 派生属性。ch.is_alphanumeric()：数值或字母字符，包括上面两个类别。ch.is_whitespace()：空白字符，包括 Unicode 字符属性 “WSpace=Y”。ch.is_control：控制字符，包括 Unicode 的 Other, control 普通类别。ch.to_digit(radix)：决定 ch 是否是基数为 radix 的 ASCII 数字。如果是就返回 Some(num)，其中 num 是 u32。否则，返回 None。radix 的范围是 2~36。如果 radix > 10，那么 ASCII 字母将作为值为 10～35 的数字。std::char::from_digit(num, radix)：把 u32 数值 num 转换为 char。如果 radix > 10，ch 是小写字母。ch.is_digit(radix)：在 ch 是基数为 radix 下的 ASCII 数字时，返回 true。等价于 ch.to_digit(radix) != None。ch.is_lowercase()：判断 ch 是否为小写字母。ch.is_uppercase()：判断 ch 是否为大写字母。ch.to_lowercase()：将 ch 转换为小写字母。ch.to_uppercase()：将 ch 转换为大写字母。as 操作符可以把 char 转换为任何整数类型，高位会被屏蔽。as 操作符可以把任何 u8 值转换为 char。char 类型也实现了 From<u8>。推荐使用 std::char::from_u32，返回 Option<char>。Rust 的 String 和 str 类型只保存格式良好的 UTF-8。
String 类型能创建可伸缩缓冲区，用于保存字符串。本质为 Vec<u8> 的包装类型。
str 类型则就地操作字符串文本。
String 的解引用为 &str。str 上定义的所有方法，都可以在 String 上直接调用。
文本处理的方法按照字节偏移量来索引文本，也按字节来度量长度，并不是按照字符。
Rust 会根据变量的名称，推测其类型，如：
| 变量名 | 推测类型 |
|---|---|
string | String |
slice | &str 或解引用为 &str 的类型，如 String 或 Rc<String> |
ch | char |
n | usize，长度 |
i, j | usize，字节偏移量 |
range | usize 字节偏移量范围，可能是全限定 i..j，部分限定 i.. 或..j，或无限定.. |
pattern | 任意模式类型：char, String, &str, &[char], FnMut(char) -> bool |
String 值String::new()：返回全新的空字符串。没有分配在堆上的缓冲区，后续会根据需要分配。
String::with_capacity(n)：返回全新的空字符串，同时在堆上分配至少容纳 n 字节的缓冲区。
slice.to_string()：常用于通过字符串字面量创建 String。分配一个全新的 String，其内容就是 slice 的副本。
iter.collect()：通过拼接迭代器的所有项（char、&str 或 String 值）来构建 String。如下删除字符串中的空格举例：
let spacey = "man hat tan";
let spaceless: String = spacey.chars().filter(|c| !c.is_whitespcae()).collect();
assert_eq!(spaceless, "manhattan");
slice.to_owned()：将 slice 的副本作为一个全新分配的 String 返回。&str 类型不能实现 Clone，可以通过此方法达到克隆的效果。
slice.len()：返回以字节计算的 slice 的长度。
slice.is_empyt()：在 slice.len() == 0 时返回 true。
slice[range]：返回借用 slice 中指定部分的切片。
不能像 slice[i] 这样的格式取得一个位置索引的字符串切片。而是需要基于切片产生一个 chars 迭代器，让迭代器解析出相应字符串的 UTF-8：
let par = "rust he";
assert_eq!(par[6..].chars().next(), Some('e'));
slice.split_at(i)：返回从 slice 借用的两个共享切片的元组，slice[..i] 和 slice[i..]。
slice.is_char_boundary(i)：在 i 为字符边界上时返回 true。
切片可以比较相等、顺序和散列。
String 追加和插入文本string.push(ch)：把字符 ch 追加到字符串末尾。
string.push_str(slice)：追加 slice 的全部内容。
string.extend(iter)：将迭代器 iter 生成的所有项追加到字符串。迭代器可以生成 char、str 或 String 值。
string.insert(i, ch)：在字节偏移值 i 的位置，向字符串中插入字符 ch。i 之后的所有字符向后移一位。
string.insert_str(i, slice)：在字节偏移值 i 的位置，向字符串中插入 slice 的全部内容。
String 实现了 std::fmt::Write，因此可以使用 write! 和 writeln! 宏，给 String 追加格式化文本。它们的返回值类型是 Result。需要在结尾添加 ? 操作符来处理错误。
use std::fmt::Write;
let mut letter = String::new();
writeln!(letter, "Whose {} these are I think I know", "rustabagas")?;
+ 操作符：在操作数为字符串时，可以用于拼接字符串操作。
string.shrink_to_fit()：在删除字符串内容后，可以用来释放内存。string.clear()：将字符串重置为空字符。string.truncate(n)：丢弃字节偏移值 n 之后的所有字符。string.pop()：从字符串中删除最后一个字符，并以 Option<char> 作为返回值。string.remove(i)：从字符串中删除字节偏移值 i 所在的字符，并返回该字符，后面的字符会向前移动。string.drain(range)：根据戈丁字节索引的返回，返回迭代器，并且在迭代器被清除时删除相应字符。Rust 标准库与搜索和迭代文本相关的函数，遵循下述命名约定：
r 开头的操作从右向左处理，如 rsplit 和 split 的相反操作。n 结尾，就表示会对自己限定匹配的次数。_indices 结尾，表示会产生它们在切片中的字节偏移量，以及通常可迭代的值。模式（pattern）：
std::str::Pattern 特型的任何类型。标准库支持的 4 种主要模式：
char 作为模式用于匹配字符；
String、&str 或 &&str 作为模式，用于匹配等于模式的子字符串。
FnMut(char) -> bool 闭包作为模式，用于匹配闭包返回 true 的一个字符。
&[char] 作为模式，表示 char 值的切片，用于匹配出现在列表中的任一字符。
let code = "\t funcation noodle() { ";
assert_eq!(code.trim_left_matchs(&[' ', 't'] as &[char]),
"function noodle() { ");
as 操作符，可以将字符数组字面量转换为 &[char]；&[char; n] 表示固定大小 n 的数组类型，不是模式类型。&[' ', 't'] as &[char] 也可写作 &\[' ', '\t'][..]。slice.contains(pattern)：在 slice 包含与 pattern 匹配的内容时返回 true。
slice.starts_with(pattern) 和 slice.ends_with(pattern)：在 slice 的初始或最终文本与 pattern 匹配时返回 true。
assert!("2017".starts_with(char::is_numeric));
slice.find(pattern) 和 slice.rfind(pattern)：在 slice 包含匹配 pattern 的内容时，返回 Some(i)。i 是匹配项的字节偏移量。
slice.replace(pattern, replacement)：返回以 replacement 替换所有 pattern 的内容之后得到的新 String。
slice.replacen(pattern, replacement, n)：功能与上同，但是最多替换前 n 个匹配项。
slice.chars()：基于 slice 的字符返回一个迭代器。
slice.char_indices()：基于 slice 的字符及它们的字节偏移量返回一个迭代器。
assert_eq!("elan".char_indices().collect::<Vec<_>>(),
vec![(0, 'e'), (2, 'l'), (3, 'a'), (4, 'n')]);
slice.bytes()：基于 slice 中的个别字节返回一个迭代器，暴露 UTF-8 编码。
assert_eq!("elan".bytes().collect::<Vec<_>>(), vec![b'e', b'l', b'a', b'n']);
slice.lines()：基于 slice 中的文本行，返回一个迭代器。每行的终止符是 \n 或 \r\n。这个迭代器所产生的值是从 slice 借用的 &str。并且，所产生的值不包含终止符。
slice.split(pattern)：基于按照 pattern 分割 slice 得到的部分返回一个迭代器。两个相邻的匹配或者与 slice 开头、结尾的匹配都会返回空字符串。
slice.rsplit(pattern)：功能同上，但是会从后向前扫描和匹配 slice。
slice.split_terminator(pattern) 和 slice.rsplit_terminator(pattern)：功能与上两个方法相同，不过 pattern 被当成终止符，而不是分隔符。如果 pattern 恰好匹配 slice 的两头，那么迭代器不会生成表示匹配与切片两头之间空字符串的空切片。
slice.splitn(n, pattern) 和 slice.rsplitn(n, pattern)：与 split 和 rsplit 类似，但是最多把字符串分割成 n 个切片，从 pattern 的第 1 次匹配到第 n-1 次匹配。
slice.split_whitespace()：基于空白 slice 分隔的部分返回一个迭代器。连续多个空白符作为一个分隔符。末尾的空白会被忽略。此处的空白与 char::is_whitespace 中的描述一致。
slice.matches(pattern) 和 slice.rmatches(pattern)：基于 pattern 在 slice 中找到的匹配项返回一个迭代器。
slice.match_indices(pattern) 和 slice.rmatch_indices(pattern)：与上同。不过产生的值是 (offset, match) 对，其中 offset 是匹配开始位置的字节偏移量，match 是匹配的切片。
slice.trim()：返回 slice 的子切片，不包含切片开头和末尾的空白符。slice.trim_left()：只忽略切片开头的空白符。slice.trim_right()：只忽略切片末尾的空白符。slice.trim_matches(pattern)：返回 slice 的子切片，不包含切片开头和末尾匹配 pattern 的内容。slice.trim_left_match(pattern)：仅对切片开头的内容执行匹配操作。slice.trim_right_match(pattern)：仅对切片末尾的内容执行匹配操作。slice.to_uppercase()：返回新匹配的字符串，其保存着转换为大写之后的 slice 文本。结果的长度不一定与 slice 相同。slice.to_lowercase()：与上面类似，但是转换的是小写之后的 slice 文本。所有常见的类型都实现了 std::str::FromStr 特型，拥有从字符串切片中解析值的标准方法。
pub trait FromStr: Sized {
type Err;
fn from_str(s: &str) -> Result<Self, self::Err>;
}
用于存储 IPv4 或 IPv6 互联网地址的枚举（enum）类型 std::net::IpAddr 也实现了 FromStr。
use std::net::IpAddr;
let address = IpAddr::from_str("fe80::0000:3ea9:f4ff:fe34:7a50")?;
assert_eq!(address, IpAddr::from([0xfe80, 0, 0, 0, 0x3ea9, 0xf4ff, 0xfe34, 0x7a50]));
字符串切片的 parse 方法，可以将切片解析为任何类型。在调用时，需要写出给定的类型。
let address = "fe80::0000:3ea9:f4ff:fe34:7a50".parse::<IpAddr>()?;
实现了 std::fmt::Display 特型的打印类型，可以在 format! 宏中使用 {} 格式说明符。
T 实现了 Display，则 Box<T>、Rc<T> 和 Arc<T> 也会实现：它们所打印出来的形式就是它们引用目标的形式。Vec 和 HashMap 等容器没有实现 Display。如果一个类型实现了 Display，则标准库会自动为其实现 std::str::ToString 特型：
to_string。Display，而不是 ToString。标准库的公共类型都实现了 std::fmt::Debug 特型：
可以接收一个值并将其格式化为字符串形式，用于程序的调试。
Debug 生成的字符串，可以借助 format! 宏的 {:?} 格式说明符打印。
自定义类型也可以实现 Debug，建议使用派生特型：
#[derive(Copy, Clone, Debug)]
struct Complex {
r: f64,
i: f64
}
String 实现了 AsRef<str>、AsRef<[u8]>、AsRef<Path> 和 AsRef<OsStr>：使用这些特型作为自己参数类型的绑定，可以直接将切片或字符串传递给它们，及时这些函数需要的是其他类型。String 也实现了 std::borrow::Borrow<Str> 特型：HashMap 和 BTreeMap 使用 Borrow 让 String 可以作为表中的键。slice.as_bytes()：借用 slice 的字节作为 &[u8]。获取的字节必须是格式良好的 UTF-8。string.into_bytes()：取得 String 的所有权并按值返回这个字符串字节的 Vec<u8>。获取的字节可以不是格式良好的 UTF-8。str::from_utf8(byte_slice)：接收一个 &[u8] 字节切片，返回一个 Result：如果 byte_slice 包含格式良好的 UTF-8，则返回 Ok(&str)，否则返回错误。
String::from_utf8(vec)：基于传入的 Vec<u8> 值构建一个字符串。
如果 vec 保存着格式良好的 UTF-8，from_utf8 就返回 Ok(string)，其中 string 就是取得 vec 所有权，并将其作为缓冲的字符串。
如果字节不是格式良好的 UTF-8，则返回 Err(e)，其中 e 是一个 FromUtf8Error 错误值。此时若调用 e.into_bytes() 则会得到原始的向量 vec，即可实现转换失败而不丢失原值。
let good_utf8: Vec<u8> = vec![0xe9, 0x8c, 0x86];
let bad_utf8: Vec<u8> = vec![0x9f, 0xf0, 0xa6, 0x80];
let result = String::from_utf8(bad_utf8); // 失败
assert!(result.is_err());
assert_eq!(result.unwrap_err().into_bytes(),
vec![0x9f, 0xf0, 0xa6, 0x80]);
String::from_utf8_lossy(byte_slice)：基于字节的共享切片 &[u8] 构建一个 String 或 &str。
String::from_utf8_unchecked：将 Vec<>u8 包装为一个 String 并返回它，要求必须是格式良好的 UTF-8。只能在 unsafe 块中使用。
str::from_utf8_unchecked：接收一个 &[u8]，并将其返回为一个 &str，同样不会检查字节的格式是不是格式良好的 UTF-8。同样只能在 unsafe 块中使用。
fn get_name() -> String {
std::env::var("USER").unwrap_or("whoever you are".to_string())
}
println!("Greetings, {}!", get_name());
上述例子实现了问候用户的程序，在 Unix 上可以实现，但是在 Windows 上用户名用的是 USERNAME 字段，拿不到系统的用户名。
std::env::var 函数返回 String。而 get_name 可能返回所有型的 String，也可能是 &'static str'。
所以，可以使用 std::borrow::Cow（Clone-on-write 写时克隆）类型实现，可以保存所有型数据，也可以保存借用的数据。
use std::borrow::Cow;
fn get_name() -> Cow<'static, str> {
std::env::var("USER")
.map(|v| Cow::Owned(v))
.unwrap_or(Cow::Borrowed("whoever you are"))
}
println!("Greetings, {}!", get_name());
USER 环境变量，则 map 将得到的字符串作为 Cow::Owned 返回。unwrap_or 将其静态的 &str 作为 Cow::Borrowed 返回。T 实现了 std::fmt::Display 特型，那么 Cow<'a, T> 会得到与显示 T 一样的结果。std::borrow::Cow 常用于可能需要，也可能不需要修改借用的某个文本时。
在不需要修改的时候，可以继续借用它；
Cow 的 to_mut 方法，确保 Cow 是 Cow::Owned，必要时会应用值的 ToOwned 实现，然后返回这个值的可修改引用。
fn get_title() -> Option<&'static str> { ... }
let mut name = get_name();
if let Some(title) = get_title() {
name.to_mut().push_str(", ");
name.to_mut().push_str(title);
}
println!("Greetrings, {}!", name);
同时也可以在必要时才会分配内存。
标准库为 Cow<'a, str> 提供了对字符串的特殊支持。如提供了来自 String 和 &str 的 From 和 Into 转换，因此上述 get_name 可以简写为：
fn get_name() -> Cow<'static, str> {
std::env::var("USER")
.map(|v| v.into())
.unwrap_or("whoever you are".into())
}
Cow<'a, str> 也实现了 std::ops::Add 和 std::ops::AddAssign 字符串重载，因此 get_title() 判断可以简写为：
if let Some(title) = get_title() {
name += ", ";
name += title;
}
由于 String 可以作为 write! 宏的目标，因此上述代码也等效于：
use std::fmt::Write;
if let Some(title) = get_title() {
write!(name.to_mut(), ", {}", title).unwrap();
}
不是所有 Cow<..., str> 都必须是'static 生命期，在需要复制之前，可以一直使用 Cow 借用之前计算的文本。
String 实现了std::default::Default 和std::iter::Extend::default
default 返回一个空字符串。extend 可以向一个字符串末尾追加字符、字符串切片或字符串。&str类型也是实现了Default
Default。详见《Rust 程序设计》（吉姆 - 布兰迪、贾森 - 奥伦多夫著，李松峰译）第十七章
原文地址