Rust

# perf record的默认采样频率是1000, 输出的perf.data文件很大, 通过修改命令行参数来降低频率.
# 99是perf record常用的经验值.
cargo flamegraph --cmd 'record --freq=99 --call-graph dwarf'

kernel.perf_event_paranoid=-1
kernel.kptr_restrict=0

async fn do_foo_and_bar() {
    foo().await;
    bar().await;
}

async fn do_foo_and_bar_at_same_time() {
    let future1 = foo();
    let future2 = bar();
    join!(future1, future2);
}

#[tokio::main]
async fn main() {
    ...
}

• registry服务不仅需要操作Git仓库, 还需要向外暴露Git仓库.
  这为实施替代品增添了很多不必要的麻烦, 并且引入了很多决策问题.
• cargo为了下载软件包, 需要克隆Git仓库, 而不是简单查询服务器获得结果.

• extern crate
• #[macro_use]

# 启动ssh-agent, 并执行ssh-agent的返回值:
# SSH_AUTH_SOCK=/tmp/ssh-xxxxx/agent.xxxxxx
# 作用是将sock地址赋值给环境变量SSH_AUTH_SOCK, 以供其他程序访问.
eval `ssh-agent`
# 加载本地的ssh凭证
ssh-add

let mut v = Vec::new();
let v = v;
// 反之亦然
let v = Vec::new();
let mut v = v;

• &String 会转换为 &str
• &Vec<i32> 会转换为 &[i32]
• &Box<Chessboard> 会转换为 &Chessboard.

• true
• false

let love = 'c';
let c1 = '\n';
let c2 = '\x7f';
let c3 = '\u{7FFF}';

let var1: i32 = 32;
let var2: i32 = 0xFF;
let var3: i32 = 0o55;
let var4: i32 = 0b1001;
let var5 = 0x_1234_ABCD; // 任意添加_以增强可读性
let var6 = 123usize; // 指定字面量类型
let var7 = 32; // 默认为i32类型
9_i32.pow(3); // 直接在字面量上调用函数

let f1 = 123.0f64;
let f2 = 0.1f64;
let f3 = 0.1f32;
let f4 = 12E+99_f64;
let f5: f64 = 2;

struct Color(i32, i32, i32);
struct Color {
    0: i32,
    1: i32,
    2: i32,
}
// 用来创造独立的类型
fn main() {
    struct Inches(i32);
    fn f(value: Inches) {}
    let v: i32 = 0;
    f(v); // 编译不通过, 因为Inches和i32不是一个类型, 且Rust不允许隐式类型转换
}

enum Json {
    Null,
    Boolean(bool),
    Number(f64),
    String(String),
    Array(Vec<Json>),
    Object(Box<HashMap<String, Json>>)
}

enum BinaryTree<T> {
    Empty,
    NonEmpty(Box<TreeNode<T>>)
}
struct TreeNode<T> {
    element: T,
    left: BinaryTree<T>,
    right: BinaryTree<T>
}

enum Result<T, E> {
    Ok(T),
    Err(E)
}
enum Option<T> {
    None,
    Some(T),
}

let xs: [i32; 5] = [1, 2, 3, 4, 5];
let xs: [i32; 500] = [0; 500]; // 批量初始化
let xs: [i32; 0] = []; // 空数组
// 多维数组 
let xs: [[i32; 2]; 3] = [[0, 0], [0, 0], [0, 0]];

for (index, value) in v.iter().enumerate() {
    ...
}

let s: &str = "Hello"
// 由于字符串使用了utf-8变长编码, 字符所处的内存位置不能直接得到.
// Rust里按索引取字符需要这样写':
s.chars().nth(n);
// 原始字符串
// r之后可以添加任意数量的井号(#), 字符串末端需要以相同数量的井号结束, 从而允许在原始字符串里输入双引号(").
let path = r"C:\Program Files\Rust"; 
// 字符串连接
let new_str = &str + &str; // 反直觉的是, 这在Rust里会报错.
// 解决方案: 创建一个String作为新字符串的容器
let mut new_string = String::new();
new_string.push_str(s);
new_string.push_str(s);
let new_str = new_string.as_str(); // 转换为&str

let mut s: String = String::from("Hello");
s.push(' ');
s.push_str("World.");
s.as_str(); // 转换为&str类型

• String 是一种类似于 Vec 的动态字符串类型, 位于堆, 可以从中得到切片视图 &str.
• &str 是一个指向内存中数据的指针/切片视图(C语言的 char*).
  指向的地方可以是 string.as_str() (指向堆),
  可以是在创建时就知道其长度的字面量 &str (指向栈),
  也可以是 &'static str (指向程序的静态存储, 静态存储在程序运行时加载进内存).

let x: i32 = if condition { 1 } else { 2 };

enum Direction {
    East, West, South, North
}
fn print(x: Direction) {
    match x {
        Direction::East => { ... }
        Direction::West => { ... }
        Direction::South => { ... }
        Direction::North => { ... }
    }
}

match x {
    i if i > 5 => ...,
    i if i <= 5 => ...,
    _ => unreachable!(), // 由于编译器不懂得数学运算, 因此需要手动提示编译器
}

match x {
    '0' ... '9' => read_number(),
    'a' ... 'z' => read_word(),
    ' ' | '\t' | '\n' => read_whitespace(),
    _ => skip()
}

match x {
    ref r => ..., // 用ref关键字表示匹配的是引用而不是值, 从而避免所有权转移
}

enum OptionalInt {
    Value(i32),
    Missing,
}
let x = OptionalInt::Value(5);
match x {
    // 通过if表达式强化变体的条件匹配
    OptionalInt::Value(i) if i > 5 => ...,
    // `..`表示不在乎内容是什么
    OptionalInt::Value(..) => ...,
    OptionalInt::Missing => ...,
}

// 原始代码
match self.get_selection() {
    Shape::Rect(top_left, bottom_right) =>
        optimized_paint(&Shape::Rect(top_left, bottom_right)),
    _ => // ...
}
// 用@模式简写
match self.get_selection() {
    rect @ Shape::Rect(..) =>
        optimized_paint(&rect),
    _ => // ...
}

loop {
    continue;
    break;
}
// 带有label的循环
'a: loop {
    'b: loop {
        break 'a;
        continue 'a;
    }
}

while condition {
    ...
}
while let Some(x) = optVal {
}

let array = &[1, 2, 3, 4, 5]; // 一个可迭代对象
for i in array {
    println!("The number is {}", i);
}
// 用语法题生成一个Range, Range是可迭代的
for i in 1..10 {
    println!("The nubmer is {}", i);
}

• 通过 &T 暗示函数不需要相关参数的所有权, 从而避免传参时需要复制所造成的成本.
• 通过 T 暗示函数需要相关参数的所有权.

• 数字
• 字符
• bool

• &T 转换为具有所有权的 T
• &[T] 转换为具有所有权的 Vec<T>

• 需要确保不会发生复制语义.
• 需要将数据存放在堆而不是栈上.
  除非必要(例如栈的大小不够用, 或需要超越栈的生命周期), 否则一般不会将数据移动到堆, 因为栈和堆有很大的性能差异:
  栈非常频繁地被使用, 一般会被映射到CPU缓存上, 因此堆的性能会远不如栈的性能.

• Cell
• RefCell

• Mutex
• RwLock
• Atomic*

// 函数
fn select<'a>(arg1: &'a i32, arg2: &'a i32) -> &'a i32 {
    if *arg1 > *arg2 { arg1 } else { arg2 }
}
// 类型
struct Test<'a> {
    member: &'a str
}
impl<'t> Test<'t> {
    fn test<'a>(&self, s: &'a str) {}
}

// Debug是可选的, 用于提供人类可读的错误描述
#[derive(Debug)]
enum GenError {
    Io(io::Error),
    Parse(num::ParseIntError),
}
type GenResult<T> = Result<T, GenError>;

impl From<io::Error> for GenError {
    fn from(err: io::Error) -> {
        GenError::Io(err)
    }
}
impl From<num::ParseIntError> for GenError {
    fn from(err: num::ParseIntError) -> GenError {
        GenError::Parse(err)
    }
}

// 所有标准库里的错误类型都可以隐式转换为Box<std::error::Error>, 利用这一点, 可以将它作为通用错误类型使用
type GenError = Box<dyn std::error::Error>;
// 一种使用GenError的新型Result
type GenResult<T> = Result<T, GenError>;
// 当遇到GenError时, 处理程序可以通过downcast_ref转换为具体错误:
if let Some(err) = gen_err.downcast_ref::<MyError>() {
    // ...
}