字符串和切片
切片
切片的作用是允许你引用集合中部分连续的元素序列，而不是引用整个集合。
例如：
let s = String::from("hello world");
let hello = &s[0..5]; // 切片 [0,5) 等效于&s[..5]
let world = &s[6..11]; // 切片 [6,11) 等效于&s[6..]
// 完整的s，&s[..]
注意，方括号中的数字是字节，如果字符是多字节的（如汉字），这时如果切片没有落在两个字符之间，程序就会崩溃（汉字是三个字节，切片0-2就会崩溃）
字符串的切片类型是 &str，i32数组的切片类型是 &[i32]
这样一段代码：let s = "Hello world!";， s 是个切片类型，实际上代码为：let s: &str = "Hello world!"
字符串
Rust中字符是 Unicode 类型。内存占用 从1 - 4 个字节空间。
Rust中常用的字符串类型有 str / String，str硬编码不可变，String可变。
// &str --> String
String::from("Hello world");
"hello world".to_string();
// String --> &str
&s;
操作字符串
let mut s = String::from("Hello ");
// 追加字符串
s.push_str("rust");
// 追加字符
s.push('!');
// 插入字符
s.insert(5, ',');
// 插入字符串
s.insert_str(6, " I like");
// 替换
// replace 适用于 String 和 &str，替换所有，返回一个新字符串，而不是操作原来的字符串
let new_string_replace = string_replace.replace("rust", "RUST");
// replacen 适用于 String 和 &str, 替换指定个数，返回一个新字符串，而不是操作原来的字符串
let new_string_replacen = string_replace.replacen("rust", "RUST", 1);
// replace_range 适用于 String，替换指定范围字符串，操作原来的字符串
string_replace_range.replace_range(7..8, "R");
// 删除
// 均是操作原来的字符串
// pop 删除并返回最后一个字符
let p1 = string_pop.pop();
// remove 删除并返回指定位置字符
string_remove.remove(0);
// truncate 删除指定位置到结尾
string_truncate.truncate(3);
// clear 清空字符串
string_clear.clear();
// 连接
// + += ，右面必须是字符串的切片引用类型，相当于调用std::string add()，返回一个新字符串
let result = string_append + &string_rust;
// format!
let s = format!("{} {}!", s1, s2);
遍历字符串
// 以 unicode 字符方式遍历字符串
for c in "中国人".chars() {
println!("{}", c);
}
元组
元组是由多种类型组合到一起形成的，因此它是复合类型，元组的长度是固定的，元组中元素的顺序也是固定的。
fn main() {
let tup: (i32, f64, u8) = (500, 6.4, 1);
}
使用元组：
fn main() {
let tup = (500, 6.4, 1);
// 模式匹配
let (x, y, z) = tup;
println!("The value of y is: {}", y);
// .
let five_hundred = x.0;
let six_point_four = x.1;
// 函数
let s1 = String::from("hello");
let (s2, len) = calculate_length(s1);
}
fn calculate_length(s: String) -> (String, usize) {
let length = s.len(); // len() 返回字符串的长度
(s, length)
}
结构体
使用
结构体的定义：
struct User {
active: bool,
username: String,
email: String,
sign_in_count: u64,
}
结构体的创建和使用：
// 每个都需要初始化，顺序可以打乱
let mut user1 = User {
email: String::from("someone@example.com"),
username: String::from("someusername123"),
active: true,
sign_in_count: 1,
};
// 访问字段，
// **必须要将结构体实例声明为可变的，才能修改其中的字段，Rust 不支持将某个结构体某个字段标记为可变。**
user1.email = String::from("anotheremail@example.com");
// 简化创建
fn build_user(email: String, username: String) -> User {
User {
email,
username,
active: true,
sign_in_count: 1,
}
}
// 更新
let user2 = User {
email: String::from("another@example.com"),
..user1 // 注意 username 发生了所有权转移，不能再被user1使用
};
内存排列
struct File {
name: String,
data: Vec<u8>,
}
内存结构：
元组结构体
元组结构体的字段没有名称：
struct Color(i32, i32, i32);
struct Point(i32, i32, i32);
let black = Color(0, 0, 0);
let origin = Point(0, 0, 0);
使用的使用可以直接用 x,y,z / r,g,b
单元结构体
单元结构体没有任何字段和属性
struct AlwaysEqual;
let subject = AlwaysEqual;
// 我们不关心 AlwaysEqual 的字段数据，只关心它的行为，因此将它声明为单元结构体，然后再为它实现某个特征
impl SomeTrait for AlwaysEqual {
}
结构体的所有权
如果你想在结构体中使用一个引用，就必须加上生命周期，否则就会报错！
生命周期篇再写。
打印
-
使用 #[derive(Debug)] 来打印结构体信息。
println!("{:?}",struct);dbg!(&struct); -
也可以实现 Display 特征打印信息（类似 toString() 方法）
println!("{}",struct);
枚举
使用：
可以向其他语言一样直接使用，也可以为其关联数据信息
// enum PokerSuit {
// Clubs,
// Spades,
// Diamonds,
// Hearts,
// }
enum PokerCard {
Clubs(u8),
Spades(u8),
Diamonds(u8),
Hearts(u8),
}
fn main() {
let c1 = PokerCard::Spades(5);
let c2 = PokerCard::Diamonds(13);
}
更为复杂的：
enum Message {
Quit,
Move { x: i32, y: i32 },
Write(String),
ChangeColor(i32, i32, i32),
}
fn main() {
let m1 = Message::Quit;
let m2 = Message::Move{x:1,y:1};
let m3 = Message::ChangeColor(255,255,0);
}
使用Option枚举处理空值
在rust中使用Option枚举来处理对象为空的情况（null）：
enum Option<T> {
Some(T),
None,
}
使用的使用将值存入 Some<T> 中，这样在使用变量的时候因为不能直接使用 Option，所以需要将值取出来再用。而取出来的时候需要判断值不是Option::None才能用，相当于变相强制进行了判空操作，放置了空指针异常。
数组
在Rust中有两种数组，一种是长度固定吗，速度快的 array，一种是长度动态，性能较低的 vector。
array存储在栈上，vector存储在堆上。
array
使用：
fn main() {
// 1.定义
// let a: [i32; 5] = [1, 2, 3, 4, 5]; 声明类型
let a = [1, 2, 3, 4, 5];
// 重复：5个3
let a = [3; 5];
// 非基础元素
// let array = [String::from("rust is good!"); 8]; × 不能深拷贝
let array: [String; 8] = std::array::from_fn(|i| String::from("rust is good!"));
// 2.访问
let first = a[0]; // 获取a数组第一个元素
}
数组切片
- 创建切片的代价非常小，因为切片只是针对底层数组的一个引用
- 切片类型[T]拥有不固定的大小，而切片引用类型&[T]则具有固定的大小，因为 Rust 很多时候都需要固定大小数据类型，因此&[T]更有用,
&str字符串切片也同理
let a: [i32; 5] = [1, 2, 3, 4, 5];
let slice: &[i32] = &a[1..3]; // 引用
assert_eq!(slice, &[2, 3]);
