测试
单元测试
测试单一模块，且能够测试私有接口。
创建 tests 模块并使用 #[cfg(test)] 注解。一般测试模块与目标函数放置于同一个文件。
使用 cargo test 运行测试，cargo test name_slice 可运行指定测试
pub fn add(a: i32, b: i32) -> i32 {
a + b
}
// 私有方法也可测试
fn bad_add(a: i32, b: i32) -> i32 {
a - b
}
#[cfg(test)]
mod tests {
// Note this useful idiom: importing names from outer (for mod tests) scope.
use super::*;
#[ignore = "这个属性能用于忽略测试"]
#[test]
fn test_add() {
assert_eq!(add(1, 2), 3);
}
// 测试函数也可以返回 Result
#[test]
fn test_bad_add() -> Result<(), String> {
if 2 == bad_add(1, 1) {
Ok(())
} else {
Err("the function is bad".to_owned())
}
}
#[test]
#[should_panic(expected="should panic")] // 当希望发生 panic 时使用
fn test_should_panic() {
panic!("should panic")
}
}文档测试
文档注解支持commonMarkdown格式，其中的代码块在 cargo test 时也执行。
集成测试
cargo将集成测试放在与src平级的tests目录中，只能使用公开接口。
可以将所有测试都需要的初始设置放入一个函数，再引入test
例如：
// tests/common/mod.rs
pub fn setup() {
// some setup code, like creating required files/directories, starting
// servers, etc.
}// importing common module.
mod common;
#[test]
fn test_add() {
// using common code.
common::setup();
assert_eq!(adder::add(3, 2), 5);
}开发期依赖
引入后只在开始时有效
# standard crate data is left out
[dev-dependencies]
pretty_assertions = "1"Vector
可变长的数组，一个vector对象有3个组成部分：指向数据的指针，长度，容量。
fn main() {
let mut v1: Vec<i32> = (0..10).collect();
let mut v2 = vec!["a", "b", "c"];
println!(
"{} {} {} {}", // 10 10 3 3
v1.len(),
v1.capacity(),
v2.len(),
v2.capacity()
);
for (_i, x) in v1.iter_mut().enumerate() {
*x *= 2;
}
v2.append(&mut vec!["d", "e", "f", "g"]);
println!(
"{} {} {:?}", // 7 7 [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
v2.len(),
v2.capacity(),
v1
);
}字符串
Rust中有两种字符串：String 和 &str。String是存储在堆上的字节vector，是不以null结尾的utf8字符。&str是指向utf8序列的切片，指向String。
std::str 和 std::string 专门用于处理 str 和 string 类型。
fn main() {
let s: &'static str = "this is a string data"; // 字面量分配在常量区，只读
println!("{:p} : {}", s.as_ptr(), s);
for word in s.split_whitespace().rev() {
println!("{:p} : {}", word.as_ptr(), word);
}
let S = String::from("this is a string data");
let ss = s.replace("string", "String");
println!("{:p}", S.as_str());
println!("{:p}", ss.as_str());
}
// print:
// 0x7ff6dbc656e8 : this is a string data
// 0x7ff6dbc656f9 : data
// 0x7ff6dbc656f2 : string
// 0x7ff6dbc656f0 : a
// 0x7ff6dbc656ed : is
// 0x7ff6dbc656e8 : this
// 0x2699c84f380
// 0x2699c8522c0智能指针
Box
类似c++的 unique_ptr
智能指针，rust中对象默认分配栈上。可通过 Box 使其分配到堆上，当Box离开作用域时指针和内部对象都销毁。可以通过 * 操作符解引用，直接获得内部对象。
#[derive(Debug, Clone, Copy)]
struct Point {
x: f64,
y: f64,
}
fn main() {
let p = Point { x: 1.0, y: 2.0 };
let bp = Box::new(p);
println!(
"{} {} {}", // 16 8 16
std::mem::size_of_val(&p),
std::mem::size_of_val(&bp),
std::mem::size_of_val(&*bp)
);
}Rc
Rc（Reference Counting）是对内部对象的引用计数指针，类似c++的 shared_ptr 和 weak_ptr。
内部分为强引用和弱引用，弱引用用于防止循环引用。
fn main() {
let s = "xxx".to_string();
let s1 = Rc::new(s);
println!("{} {}", Rc::strong_count(&s1), Rc::weak_count(&s1)); // 1 0
{
let _s2 = Rc::clone(&s1);
println!("{} {}", Rc::strong_count(&s1), Rc::weak_count(&s1)); // 2 0
}
{
println!("{} {}", Rc::strong_count(&s1), Rc::weak_count(&s1)); // 1 0
let s3 = Rc::downgrade(&s1);
println!("{} {}", Rc::strong_count(&s1), Rc::weak_count(&s1)); // 1 1
let _s4 = s3.upgrade();
println!("{} {}", Rc::strong_count(&s1), Rc::weak_count(&s1)); // 2 1
}
println!("{} {}", Rc::strong_count(&s1), Rc::weak_count(&s1)); // 1 0
}Arc
Arc（Atomically Reference Counted）用于多线程间共享所有权。
use std::{sync::Arc, thread};
fn main() {
let s = Arc::new("string");
let mut join_vec = vec![];
for _ in 0..10 {
let ss = Arc::clone(&s);
let join = thread::spawn(move || {
println!("{:?} {:?} {:p}", ss, Arc::strong_count(&ss), ss.as_ptr());
});
join_vec.push(join);
}
join_vec.into_iter().for_each(|j| {
let _ = j.join();
});
}
// "string" 5 0x7ff7f8e29f38
// "string" 6 0x7ff7f8e29f38
// "string" 9 0x7ff7f8e29f38
// "string" 11 0x7ff7f8e29f38
// "string" 10 0x7ff7f8e29f38
// "string" 10 0x7ff7f8e29f38
// "string" 9 0x7ff7f8e29f38
// "string" 9 0x7ff7f8e29f38
// "string" 8 0x7ff7f8e29f38
// "string" 8 0x7ff7f8e29f38多线程
一个简单 map-reduce 程序
MapReduce
use std::{collections::HashMap, thread};
fn main() {
let data = "86967897737416471853297327050364959
11861322575564723963297542624962850
70856234701860851907960690014725639
38397966707106094172783238747669219
52380795257888236525459303330302837
58495327135744041048897885734297812
69920216438980873548808413720956532
16278424637452589860345374828574668";
let mut join_vec = vec![];
let chunked_data = data.split_whitespace();
for (i, segment) in chunked_data.enumerate() {
join_vec.push(thread::spawn(move || -> HashMap<u32, i32> {
let mut map = HashMap::new();
segment.chars().for_each(|c| {
let num = c.to_digit(10).expect("should be digit");
match map.get_key_value(&num) {
Some((&k, &v)) => {map.insert(k, v + 1);}
None => {map.insert(num, 1);}
}
});
println!("thread {i} get result: {:?}", map);
map
}));
}
let mut final_result = HashMap::new();
join_vec.into_iter().for_each(|res| {
match res.join() {
Ok(map) => {
map.iter().for_each(|(&k, &v)| {
match final_result.get(&k) {
Some(old_result) => {
final_result.insert(k, v + old_result);
},
None => {
final_result.insert(k, v);
},
}
});
},
Err(err) => {
println!("thread fail: {:?}", err);
},
}
});
println!("final result: {:#?}", final_result);
}标准库的 channel 支持多sender，1个receiver。第三方库 crossbeam_channel 支持多个生产者和消费者。
use std::{sync::mpsc, thread};
static THREAD_NUM: i32 = 3;
fn main() {
let (sender, receiver) = mpsc::channel();
let mut join_vec = vec![];
for i in 0..THREAD_NUM {
let sender2 = sender.clone();
let join = thread::spawn(move || {
sender2.send(i).unwrap();
println!("thread {i} send: {i}");
});
join_vec.push(join);
}
for _ in 0..THREAD_NUM {
receiver.recv().map_or_else(
|err| println!("err: {err}"),
|recv| println!("recv: {recv}"),
);
}
for j in join_vec {
j.join().expect("the child thread panic");
}
}IO
*nix 和 windows 内部使用不同的格式保存字符串，所以Path对应的路径表示不是uft8格式字符串，而是依赖平台的 OsStr。Path 依赖 OsStr 创建，是不可变的。PathBuf 是可变的，与 Path 相关的。关系类似String 和 str。Path 转换为字符串可能失败，但一定可转换为 OsStr。
use std::path::Path;
fn main() {
let cur_path = Path::new(".");
let mut new_path = cur_path.join("a").join("b");
new_path.push("c");
new_path.push("file.txt");
println!("{:?} {:?}", cur_path, new_path);
}文件操作：
use std::{
fs::{self, File},
io::{self, Write, BufRead},
path::Path,
};
fn main() -> io::Result<()> {
let file_path = Path::new("D:/tmp.txt");
if file_path.try_exists()? {
fs::remove_file(file_path)?;
}
{
let mut f = File::create(file_path)?;
f.write(b"123456\nabcdef")?;
}
let file = match File::open(file_path) {
// 当 File 对象超出作用域时，自动释放资源
Ok(file) => file,
Err(err) => panic!("open file failed: {}", err),
};
// file.read_buf()
for ele in io::BufReader::new(file).lines() {
if let Ok(line) = ele {
println!("{line}");
}
}
Ok(())
}子进程
use std::{io, process::Command};
fn main() -> io::Result<()> {
let output = Command::new("rustc").args(["--version"]).output()?;
if output.status.success() {
let s = String::from_utf8_lossy(&output.stdout);
println!("successded:\n{}", s);
} else {
let s = String::from_utf8_lossy(&output.stderr);
println!("fail:\n{}", s);
}
Ok(())
}