复合 类型

字符串和切片

切片

切片的作用是允许你引用集合中部分连续的元素序列，而不是引用整个集合。

例如：

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("[e-mail]"),username: String::from("someusername123"),active: true,sign_in_count: 1,
};// 访问字段，
// **必须要将结构体实例声明为可变的，才能修改其中的字段，Rust 不支持将某个结构体某个字段标记为可变。**
user1.email = String::from("[e-mail]");// 简化创建
fn build_user(email: String, username: String) -> User {User {email,username,active: true,sign_in_count: 1,}
}// 更新
let user2 = User {email: String::from("[e-mail]"),..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个3let 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]);