2021年2月

“为什么都大三了还不会用google”

双引号内为完全匹配
减号前是空格,减号后没有空格表示不包含
因此搜索指令选项时可以考虑用引号包括:ls "-alh"

* 为通配符
OR 表示或关系
+ 同时匹配多个关键词
~[word] 表示匹配同义词
inurl:[word] 关键词在url中
intitle:[word] 关键词在标题中
intext:[word] 关键词在正文中
site:[url] 搜索指定网站
filetype:[type] 指定文件类型

“妈的,之后看到的语法要随手记下来”

调用库: use std::io;
生成文档:cargo doc --open
match 关键字:

    match guess.cmp(&secret_number) {
        Ordering::Less => println!("Too small!"),
        Ordering::Greater => println!("Too big!"),
        Ordering::Equal => println!("You win!"),
    }

ownership :
- 每个值有一个变量作为owner
- 同时只能有一个owner
- 当owner到scope外时,值会消失

rust 特性:

所有权机制保证的安全性
显示变量类型语言,但支持类型的推导
作用域特性:变量在定义的作用域外会被丢弃
不允许空值(null)
不允许悬挂指针
不允许 race condition(因此同一个变量只能有一个可变引用 多个不可变引用)

! 结尾表示宏展开

通用语法

for 循环:

for x in 0..10 {
    println!("{}", x); // x: i32
}

// enumerate 版本
for (i,j) in (5..10).enumerate() { 
    println!("i = {} and j = {}", i, j);
}

区间: a..b 表示 [a, b),类型 core::ops::Range ,标准库为其实现了 Iterator 的 trait

match 语句:

match v.get(2) {
    Some(third) => println!("The third element is {}", third),
    None => println!("There is no third element."),
}

同时是 Option<&T> 的应用
Option 定义 :

enum Option<T> {
    Some(T),
    None,
}

Result 定义 :

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

结构体定义与结构体函数:

struct Point<T, U> {
    x: T,
    y: U,
}

impl<T, U> Point<T, U> {
    fn mixup<V, W>(self, other: Point<V, W>) -> Point<T, W> {
        Point {
            x: self.x,
            y: other.y,
        }
    }
}

tuple 结构体:

struct Color(i32, i32, i32);
struct Point(i32, i32, i32);

let black = Color(0, 0, 0);
let origin = Point(0, 0, 0);
println!("{} {} {}", black.0, black.1, black.2);

triait 定义与使用:

pub trait Summary {
    fn summarize(&self) -> String;
}
impl Summary for NewsArticle {
    fn summarize(&self) -> String {
        format!("{}, by {} ({})", self.headline, self.author, self.location)
    }
}

trait 参数传入:

pub fn notify(item1: impl Summary, item2: impl Summary) {}
pub fn notify(item: impl Summary + Display) {}
pub fn notify<T: Summary + Display>(item: T) {}

函数 && 泛型: fn largest<T>(list: &[T]) -> T { }

生命周期注解:

&i32        // 引用
&'a i32     // 带有显式生命周期的引用
&'a mut i32 // 带有显式生命周期的可变引用

手动 drop 引用 :
core::mem::drop(inner);

数组:let mut app_start: [usize; MAX_APP_NUM + 1] = [0; MAX_APP_NUM + 1];

具体其他

新建 vector : let v : Vec<i32> = Vec::new();, let v = vec![1, 2, 3]

box : 在堆上分配内存空间。

// 把栈上变量转移到堆上
let val: u8 = 5;
let boxed: Box<u8> = Box::new(val);
// 把变量从堆上转移到栈上
let boxed: Box<u8> = Box::new(5);
let val: u8 = *boxed;

string :

&str : string slices, 定长,不能 mut,是指向 UTF-8 字节串的 reference
let greeting = "Hello there.";
"Hello there." 为 string literal,类型 &static str,编译时分配,lifetime为整个程序
let s = String::from("hello"); 类型 String
let slice = &s[3..]; 类型 &str,为切片, slice.len()
s.as_str() 类型 &str
let s1 = "Hello world!"; 类型 &str,为切片

数组切片 :

let a = [1,2,3,4,5];
let slice = &a[1..3]; 类型 &[i32] 为数组切片

升级概念(?)

普通指针:类型 &&mut 两种

    let mut num = 5;
    let num_ref = &mut num;
    *num_ref = 100;

胖指针:如切片,保存了指针和长度信息,类型 &&mut 两种

    let mut arr = [1, 2, 3, 4];
    let slice = &mut arr[1..4];
    slice[0] = 100;

裸指针:类似 C++ 指针,可能为 null
创建裸指针为safe操作,读写裸指针为unsafe 操作,类型 *mut*const 两种

    let mut num = 1;
    // 将引用转为裸指针
    let num_raw_point = &mut num as *mut i32;
    unsafe {
        *num_raw_point = 100;
        println!("{} {} {:p}", num, *num_raw_point, &num); 
        // Output: 100 100 0x8d8c6ff6bc
    }

访问 *mut 裸指针元素: *a.offset(1) = 1

#[derive(Copy, Clone)] 在类前添加,让编译器自动添加 Copy/Clone trait,使传参时不会发生所有权转移

结构相关

目录下 mod.rs 和与目录同名的 .rs 文件起到导出内部接口作用