前面已经学习了rust的基础知识,今天我们来学习rust强大的系统库,从此coding事半功倍。
集合
数组&可变长数组
在 Rust 中,有两种主要的数组类型:固定长度数组(Fixed-size Arrays)和可变长度数组(Dynamic-size Arrays)。
-
固定长度数组(Fixed-size Arrays):
固定长度数组的长度在编译时就确定,并且长度不可改变。你可以使用以下语法定义一个固定长度数组:
fn main() {
let arr: [i32; 5] = [1, 2, 3, 4, 5];
}
在上面的例子中,我们定义了一个类型为 i32 的固定长度数组 arr
,长度为 5,并初始化了数组的元素。
-
可变长度数组(Dynamic-size Arrays):
Rust 中没有直接支持可变长度数组的语法。但是,你可以使用Vec<T>
类型来创建一个动态增长的数组。Vec<T>
是一个可变长度的动态数组,可以根据需要动态添加和删除元素。以下是一个使用Vec<T>
的示例:
fn main() {
let mut vec: Vec<i32> = Vec::new();
vec.push(1);
vec.push(2);
vec.push(3);
}
在上面的例子中,我们首先创建了一个空的 Vec<i32>
,然后使用 push
方法向数组中添加元素。 Vec<T>
会根据需要自动调整大小。
需要注意的是,可变长度数组( Vec<T>
)和固定长度数组( [T; N]
)是不同的类型,它们具有不同的性质和用途。下面我们再看下Vec的一些基础用法:
创建Vec
在 Rust 中,有几种创建 Vec 的方式:
- 使用 Vec::new() 创建一个空的 Vec:
let mut vec = Vec::new();
这会创建一个长度为 0 的空向量。
- 使用 vec![] 宏创建一个非空的 Vec:
let mut vec = vec![1, 2, 3];
这会创建一个长度为 3、值为 [1, 2, 3] 的可变数组。
- 使用 Vec::with_capacity() 创建一个指定容量的 Vec:
let mut vec = Vec::with_capacity(10);
这会创建一个长度为 0 但预分配了 10 个元素空间的向量。这意味着,在不重新分配内存的情况下,vec 可以增长到 10 个元素。
- 使用 iterator 方法创建一个 Vec:
let mut vec = (1..10).collect::<Vec<i32>>();
这会创建一个长度为 9、值为 [1, 2, 3, 4, 5, 6, 7, 8, 9] 的向量。
这些方法的主要区别在于:
- Vec::new() 和 vec![] 创建的向量初始长度为 0 或指定长度。
- Vec::with_capacity() 创建的向量初始长度为 0,但预分配了指定的容量。这可以提高向量在后续增长时的性能,因为不需要频繁重新分配内存。
- 使用 iterator 方法创建的向量会根据 iterator 的长度创建指定大小的向量。
总的来说,如果你知道向量的大致大小,使用 Vec::with_capacity() 可以获得最好的性能。否则,Vec::new() 和 vec![] 也是不错的选择。这里的区别类似Java。
操作Vec
在 Rust 中, Vec<T>
是一个可变长度的动态数组,用于存储相同类型的多个值。它有以下主要的方法:
- 添加元素 - 使用
push()
方法:
let mut vec = Vec::new();
vec.push(1);
- 删除元素 - 使用
pop()
方法删除最后一个元素:
let mut vec = vec![1, 2, 3];
vec.pop(); // vec = [1, 2]
- 查找元素 - 使用索引(
[]
)访问元素:
let vec = vec![1, 2, 3];
let elem = vec[0]; // elem = 1
- 修改元素 - 也使用索引(
[]
)访问元素,然后对其进行修改:
let mut vec = vec![1, 2, 3];
vec[0] = 5;
// vec = [5, 2, 3]
除此之外, Vec<T>
还有其他方法,比如:
-
len()
- 获取向量长度 -
iter()
- 创建一个迭代器以便于遍历元素 -
iter_mut()
- 创建一个可变迭代器以便于修改元素 -
first()
- 获取第一个元素 -
last()
- 获取最后一个元素 -
get()
- 安全地访问一个元素,返回 Option<&T> -
get_mut()
- 安全地访问一个可变元素,返回 Option<&mut T>
这些方法可以满足你对 Vec<T>
的基本操作需求。
map
在 Rust 中,有几种主要的 map 实现:
- HashMap - 散列表映射,基于哈希表实现。这是 Rust 中最常用的映射类型。
- BTreeMap - 二叉树映射,基于二叉树实现。键值是有序的。
- LinkedHashMap - 链表散列表映射,基于哈希表和双向链表实现。键值保持插入顺序。
- IndexMap - 基于数组的映射。键必须实现
Index
trait。 - FxHashMap - 散列表映射,使用第三方
fxhash
算法实现。性能可能优于标准库的HashMap
这里主要介绍HashMap的用法,其他的大同小异,后续会出一个专门的用法介绍。
在 Rust 中,HashMap 的主要用法如下:
- 创建一个空的 HashMap:
let mut map = HashMap::new();
- 插入键值对:
map.insert(1, "a");
- 获取值:
let a = map.get(&1); // a = Some("a")
- 删除键值对:
map.remove(&1);
- 迭代 HashMap:
for (key, value) in &map {
println!("{}: {}", key, value);
}
- 检查键是否存在:
map.contains_key(&1); // true 或 false
- 获取 HashMap 的长度:
let len = map.len();
- 清空 HashMap:
map.clear();
- 只迭代键或值:
for key in map.keys() {
println!("{}", key);
}
for value in map.values() {
println!("{}", value);
}
这些是 HashMap 在 Rust 中最基本和最常用的方法。HashMap 是一个无序的 map,键类型必须实现 Eq
和 Hash
trait。
Set
- HashSet - 散列表集合,基于哈希表实现。用于存储唯一的键。
- BTreeSet - 二叉树集合,基于二叉树实现。键值是有序的。
这里我们也重点介绍HashSet的用法:
- HashSet基础用法:
let mut set = HashSet::new();
set.insert(1); // 插入元素:
set.remove(&1);// 删除元素:
set.contains(&1); // 检查元素是否存在: true 或 false
let len = set.len();// 获取 HashSet 的长度:
for elem in &set { // 迭代 HashSet:
println!("{}", elem);
}
set.clear(); // 清空 HashSet:
- 取两个 HashSet 的交集、并集、差集:
let set1 = HashSet::from([1, 2, 3]);
let set2 = HashSet::from([2, 3, 4]);
let intersection = set1.intersection(&set2).collect(); // [2, 3]
let union = set1.union(&set2).collect(); // [1, 2, 3, 4]
let difference = set1.difference(&set2).collect(); // [1]
HashSet 是一个无序的集合,元素类型必须实现 Eq
和 Hash
trait。
迭代器&流式编程(Iterator)
在 Rust 中,迭代器(Iterator)是一种用于遍历集合元素的抽象。它提供了一个统一的接口,使你可以对各种不同类型的集合进行迭代。
要使用迭代器,你可以按照以下步骤进行操作:
- 创建一个迭代器:
你可以通过调用集合上的.iter()
或.iter_mut()
方法来创建一个不可变或可变的迭代器。例如:
let vec = vec![1, 2, 3];
let iter = vec.iter(); // 不可变迭代器
let mut_iter = vec.iter_mut(); // 可变迭代器
- 使用迭代器方法:
一旦你创建了迭代器,你可以使用迭代器的方法来处理集合的元素。一些常见的方法包括.next()
、.map()
、.filter()
、.fold()
等。例如:
let vec = vec![1, 2, 3];
let mut iter = vec.iter();
// 使用 .next() 方法逐个获取元素
while let Some(item) = iter.next() {
println!("{}", item);
}
// 使用 .map() 方法对元素进行转换
let vec2: Vec<i32> = vec.iter().map(|x| x * 2).collect();
println!("{:?}", vec2); // 输出 [2, 4, 6]
// 使用 .filter() 方法过滤元素
let vec3: Vec<i32> = vec.iter().filter(|x| *x > 1).cloned().collect();
println!("{:?}", vec3); // 输出 [2, 3]
- 链式调用迭代器方法:
你可以使用链式调用来组合多个迭代器方法,以实现复杂的操作。例如:
let vec = vec![1, 2, 3];
let result: i32 = vec.iter()
.filter(|x| *x > 1)
.map(|x| x * 2)
.sum();
println!("{}", result); // 输出 10
通过这些方法,你可以对集合进行各种操作,如过滤、映射、折叠等。
- 自定义迭代器
在 Rust 中,你可以通过实现 Iterator
trait 来自定义迭代器。 Iterator
trait 有以下定义:
trait Iterator {
type Item;
fn next(&mut self) -> Option<Self::Item>;
// 默认方法
fn size_hint(&self) -> (usize, Option<usize>) { ... }
fn count(self) -> usize { ... }
fn last(self) -> Option<Self::Item> { ... }
fn nth(&mut self, n: usize) -> Option<Self::Item> { ... }
fn step_by(self, step: usize) -> StepBy<Self> { ... }
// 等等
}
要实现这个 trait,你需要:
-
定义
Item
类型,表示迭代器返回的元素类型。 -
实现
next
方法,返回迭代器的下一个元素,如果迭代器结束则返回None
。 -
可选:实现其他默认方法来改善迭代器的行为。
以下是一个自定义迭代器的示例:
struct Counter {
count: u32,
}
impl Iterator for Counter {
type Item = u32;
fn next(&mut self) -> Option<Self::Item> {
if self.count < 5 {
let c = self.count;
self.count += 1;
Some(c)
} else {
None
}
}
}
fn main() {
let mut iter = Counter { count: 0 };
while let Some(i) = iter.next() {
println!("{}", i);
}
}
这个迭代器会返回 0 到 4 的数字,然后结束。我们实现了 next
方法来定义这个行为。
通过实现 Iterator
trait,你可以创建各种自定义的迭代器,以满足不同的需求。希望这能帮助你理解 Rust 中的迭代器和如何自定义迭代器!如果还有其他问题,请随时提问。
并发
多线程处理
下面我们通过一个例子学习: 创建一个线程,并每隔2s输出“hello world”
上代码:
use std::thread;
use std::time::Duration;
fn main() {
thread::spawn(|| {
loop {
println!("hello world");
thread::sleep(Duration::from_secs(2));
}
});
}
这个代码会:
- 使用
thread::spawn
创建一个新线程 - 在线程中有一个无限循环
- 每次循环会打印 “hello world”
- 使用
thread::sleep
使线程睡眠 2 秒 - 所以这个线程会每隔 2 秒打印一次 “hello world”
Duration::from_secs(2)
是创建一个表示 2 秒的 Duration。我们将其传递给 thread::sleep
来使线程睡眠 2 秒。
Ok,我们掌握了线程的基础用法, 再来看一个复杂的例子: 用多线程实现观察者模式
要实现观察者模式,可以使用通道(channel)在线程间通信。例如:
use std::sync::mpsc;
use std::thread;
struct Subject {
observers: Vec<mpsc::Sender<i32>>,
}
impl Subject {
fn new() -> Subject {
Subject { observers: vec![] }
}
fn attach(&mut self, observer: mpsc::Sender<i32>) {
self.observers.push(observer);
}
fn notify(&self) {
for observer in self.observers.iter() {
observer.send(1).unwrap();
}
}
}
fn main() {
let (tx1, rx1) = mpsc::channel();
let (tx2, rx2) = mpsc::channel();
let mut subject = Subject::new();
subject.attach(tx1);
subject.attach(tx2);
thread::spawn(move || {
let msg = rx1.recv().unwrap();
println!("Got: {}", msg);
});
thread::spawn(move || {
let msg = rx2.recv().unwrap();
println!("Got: {}", msg);
});
subject.notify();
}
在这个例子中:
- Subject 结构体充当主题(subject),维护多个观察者(observers)的列表。
- attach 方法用于添加观察者(通道的发送端)。
- notify 方法用于通知所有观察者(通过通道发送消息)。
- 我们创建两个线程作为观察者,通过通道接收主题的通知。
- 当调用 subject.notify() 时,两个观察者线程会接收到通知并打印消息。
线程间通信
在上面的例子中,有一个新的知识点:使用通道(channel)在线程间通信。 那么什么是channel呢?
在 Rust 中,channel 用于在线程之间发送消息和通信。它可以在不同的线程之间安全地传递数据。
channel 的主要作用有:
-
线程间通信:channel 可以在不同的线程之间发送消息,用于线程间的通信和协作。
-
安全地共享数据:channel 可以在线程之间安全地传递数据,避免数据竞争。
-
限制并发:channel 的发送端和接收端各有一个缓存,这可以限制线程之间并发发送和接收消息的数量。
举个例子:
use std::sync::mpsc::channel;
use std::thread;
fn main() {
let (tx, rx) = channel();
thread::spawn(move || {
tx.send(10).unwrap();
});
let received = rx.recv().unwrap();
println!("Got: {}", received);
}
在这个例子中:
- 我们使用
channel()
创建一个 channel,它返回一个发送端tx
和一个接收端rx
。 - 然后我们创建一个线程,在线程中通过
tx
发送消息 10。 - 在主线程中,我们通过
rx
接收该消息,并打印结果。 - 这样,通过 channel 我们就在两个线程之间安全地传递了数据。
channel 在 Rust 的并发编程中非常有用,它可以用于线程池、工作窃取等并发模式中。
再看一个用法: 工作窃取
这里是一个使用 channel 实现工作窃取的例子:
use std::sync::mpsc::channel;
use std::thread;
fn main() {
let (tx, rx) = channel();
let mut threads = vec![];
for i in 0..10 {
let tx = tx.clone();
threads.push(thread::spawn(move || {
let mut work = rx.recv().unwrap();
while let Some(job) = work.recv() {
println!("Worker {} got job {}", i, job);
}
}));
}
for job in 0..10 {
let thread_id = job % threads.len();
threads[thread_id].send(job).unwrap();
}
}
这个例子做了以下工作:
-
创建一个
channel
,得到发送端 tx 和接收端 rx。 -
创建 10 个工作线程,每个线程从 rx 接收工作。
-
将 10 个工作(
job
)发送到不同的工作线程,实现工作窃取。每个工作会被发送到线程 ID 与工作 ID 取余后的线程。 -
每个工作线程接收工作,并打印接收到的工作 ID。
-
主线程将所有工作分发完成后结束。
这个例子展示了如何使用 channel 在线程之间传递工作,实现工作窃取的模式。每个工作线程从 channel 接收工作,而不是固定的工作队列。这使得工作可以在线程之间动态分配,实现工作窃取。
线程池
熟悉java的同学可能会问了,有线程? 那有线程池吗?必须有!!
在 Rust 中,你可以使用 threadpool
crate 来创建一个线程池。以下是一个基本的示例:
use threadpool::ThreadPool;
fn main() {
let pool = ThreadPool::new(4);
for i in 0..10 {
let j = i;
pool.execute(move || {
println!("Hello from thread {}", j);
});
}
}
这会创建一个包含 4 个线程的线程池。然后我们使用 pool.execute()
方法在线程池中执行 10 个闭包。这些闭包会被线程池的线程执行,并打印出执行线程的索引。
threadpool
crate 提供了以下主要功能:
-
ThreadPool::new(size)
:创建一个包含size
个线程的线程池。 -
pool.execute(closure)
:在线程池的某个线程中执行提供的闭包。 -
pool.join()
:等待线程池中的所有线程结束。 -
ThreadPoolBuilder
:可以用来自定义线程池的各种设置,如线程名称、堆栈大小等。
一个更复杂的例子:
use std::sync::mpsc;
use std::sync::Arc;
use std::sync::Mutex;
use threadpool::ThreadPool;
fn main() {
let pool = ThreadPool::new(4);
let (tx, rx) = mpsc::channel();
let tx = Arc::new(Mutex::new(tx));
for i in 0..10 {
let tx = tx.clone();
pool.execute(move || {
let mut tx = tx.lock().unwrap();
tx.send(i).unwrap();
});
}
for _ in 0..10 {
let j = rx.recv().unwrap();
println!("Got: {}", j);
}
pool.join();
}
这里我们使用了 mpsc
库创建一个通道,并使用 Arc<Mutex<T>>
在线程之间共享该通道的发送端。然后我们在 10 个任务中发送数字到通道,并在主线程中接收这些数字。
序列化
在后端开发中,序列化是一个绕不过的话题,前后端交互,后端之间交互都需要对数据做序列化与反序列化。 在 Rust 中,有几种常用的序列化方式:
-
Serde:这是 Rust 中最流行的序列化库。它提供了多种序列化格式的支持,如 JSON、YAML、TOML 等。使用 Serde 可以方便地将 Rust 结构体序列化为这些格式,以及反序列化回 Rust 结构体。
-
Bincode:这是一个用于在 Rust 中进行二进制序列化的库。它可以高效地将 Rust 的基本数据结构编码为二进制,并解码回原数据结构。
-
Ron:这是一个用于 Rust 对象表示法 (RON) 的序列化格式和解析器。RON 是一个人类友好的二进制序列化格式,设计用于在 Rust 中存储和传输数据。
-
CBOR:这是一个实现了约束二进制对象表示法 (CBOR) 的 Rust 库。CBOR 是一种二进制序列化格式,它比 JSON 更紧凑,也更适用于嵌入式系统。
-
MessagePack:这是一个实现 MessagePack 二进制序列化格式的 Rust 库。MessagePack 是一个高效的二进制序列化格式,可以用于在不同语言之间交换数据。
-
Protobuf:这是 Google 开发的一种数据序列化格式,在 Rust 中可以使用
prost
或protobuf
库来实现。Protobuf 是一种语言无关、平台无关的可扩展机制,用于序列化结构化数据。
以上就是 Rust 中常用的几种序列化方式。总的来说,如果你需要一个通用的序列化方式,可以选择 Serde。如果你需要一个高效紧凑的二进制格式,可以选择 Bincode、CBOR 或 MessagePack。如果你需要跨语言支持,可以选择 Protobuf。
这里主要演示下Serde的用法,它提供了一组宏和 trait,用于将 Rust 数据结构转换为各种格式的序列化表示,并将序列化表示转换回 Rust 数据结构。
要使用 Serde,首先需要在 Cargo.toml
文件中添加以下依赖项:
[dependencies]
serde = "1.0"
serde_json = "1.0"
接下来,我们将给出一个使用 Serde 进行 JSON 序列化和反序列化的例子:
use serde::{Serialize, Deserialize};
use serde_json::{Result, Value};
#[derive(Serialize, Deserialize, Debug)]
struct Person {
name: String,
age: u8,
address: String,
}
fn main() -> Result<()> {
// 序列化为 JSON
let person = Person {
name: "Alice".to_string(),
age: 25,
address: "123 ABC Street".to_string(),
};
let serialized = serde_json::to_string(&person)?;
println!("Serialized: {}", serialized);
// 反序列化为 Rust 结构体
let deserialized: Person = serde_json::from_str(&serialized)?;
println!("Deserialized: {:?}", deserialized);
Ok(())
}
在上面的例子中,我们定义了一个 Person
结构体,并使用 #[derive(Serialize, Deserialize)]
宏为其实现了 Serde 的 Serialize
和 Deserialize
trait。这使得我们可以将 Person
结构体序列化为 JSON 字符串,并将 JSON 字符串反序列化为 Person
结构体。
在 main
函数中,我们首先创建一个 Person
实例,然后使用 serde_json::to_string
方法将其序列化为 JSON 字符串,并打印出来。接着,我们使用 serde_json::from_str
方法将 JSON 字符串反序列化为 Person
结构体,并打印出来。
网络请求
请求Http接口
在 Rust 中,你可以使用第三方库来进行 HTTP 请求。最常用的库之一是 reqwest
,它提供了简单且易于使用的 API 来发送 HTTP 请求。
首先,你需要在 Cargo.toml
文件中添加 reqwest
依赖项:
[dependencies]
reqwest = "0.11"
接下来,我们将给出一个使用 reqwest
发送 GET 请求的示例:
use reqwest::Error;
#[tokio::main]
async fn main() -> Result<(), Error> {
let response = reqwest::get("https://api.example.com/users").await?;
let body = response.text().await?;
println!("Response Body: {}", body);
Ok(())
}
在上面的示例中,我们使用 reqwest::get
方法发送一个 GET 请求到 https://api.example.com/users
。然后,我们使用 response.text().await?
来获取响应的文本内容,并打印出来。
需要注意的是,我们使用了 tokio::main
宏来异步运行请求。因此,你需要在 main
函数之前添加 tokio
作为依赖项,并在 main
函数前面使用 #[tokio::main]
注解。文章来源:https://www.toymoban.com/news/detail-649446.html
到目前为止,我们学习了集合、并发、序列化和网络请求,最后再留一个作业: 请求百度首页,并解析出所有的http链接。 结合本文所学哦文章来源地址https://www.toymoban.com/news/detail-649446.html
到了这里,关于20天学会rust(四)常见系统库的使用的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!