_占位符

• 忽略该值或者类型，类似go中的
• 使用下划线开头忽略未使用的变量, 不会产生警告
• _x 仍会将值绑定到变量，会发生所有权转义move，而 _ 则完全不会绑定。

.. 忽略剩余值

struct Point {
    x: i32,
    y: i32,
    z: i32,
}

let origin = Point { x: 0, y: 0, z: 0 };

match origin {
    Point { x, .. } => println!("x is {}", x),
}

流程控制

• 分支控制(if, else, else if )
• 循环控制( for、while 和 loop）
• 跳出(break), break 可以单独使用，也可以带一个返回值，有些类似 return
• 跳过当前当次的循环，开始下次的循环（continue)
• loop 是一个表达式，因此可以返回一个值

fn main() {
    let mut counter = 0;

    let result = loop {
        counter += 1;

        if counter == 10 {
            break counter * 2;
        }
    };

    println!("The result is {}", result);
}

模式匹配

• match，类似switch, 需要穷尽匹配
• if let， 当你只要匹配一个条件，且忽略其他条件时
• matches!，它可以将一个表达式跟模式进行匹配，然后返回匹配的结果 true or false
• 匹配守卫（match guard）是一个位于 match 分支模式之后的额外 if 条件，它能为分支模式提供更进一步的匹配条件

Option

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

• 一个变量要么有值：Some(T), 要么为空：None

方法

• 可以为结构体、枚举和特征(trait)实现方法
• 使用 impl 来定义方法，允许我们为一个结构体定义多个 impl 块
• 方法签名 self

self 表示 所有权转移到该方法中，这种形式用的较少
&self 表示不可变借用
&mut self 表示可变借用

• 允许方法名跟结构体的字段名相同
• 返回 Self，表示对象本身，和返回对象一样的含义
• Rust 中有一个约定俗称的规则，使用 new 来作为构造器的名称
• :: 语法用于关联函数和模块创建的命名空间

泛型（可以使用泛型来编写不重复的代码）

• 函数

fn add<T: std::ops::Add<Output = T>>(a: T, b: T) -> T {
    a + b
}

fn main() {
    println!("add i8: {}", add(2i8, 3i8));
    println!("add i32: {}", add(20, 30));
    println!("add f64: {}", add(1.23, 1.23));
}

• 结构体

#[derive(Debug)]
#[allow(dead_code)]
struct Point<T> {
    x: T,
    y: T,
}

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

impl<T, U> Point2<T, U> {
    fn mixup<V, W>(self, other: Point2<V, W>) -> Point2<T, W> {
        Point2 {
            x: self.x,
            y: other.y,
        }
    }
}
fn main() {
    let integer = Point { x: 5, y: 10 };
    let float = Point { x: 1.0, y: 4.0 };
    println!("{:?}", integer);
    println!("{:?}", float);
    let p1 = Point2 { x: 5, y: 10.4 };
    let p2 = Point2 { x: "Hello", y: 'c' };

    let p3 = p1.mixup(p2);

    println!("p3.x = {}, p3.y = {}", p3.x, p3.y);
}

• 枚举

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

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

• Rust 中泛型是零成本的抽象，意味着你在使用泛型时，完全不用担心性能上的问题
• Rust 是在编译期为泛型对应的多个类型，生成各自的代码，因此损失了编译速度和增大了最终生成文件的大小
• Rust 通过在编译时进行泛型代码的 单态化（monomorphization）来保证效率。单态化是一个通过填充编译时使用的具体类型，将通用代码转换为特定代码的过程。编译器所做的工作正好与我们创建泛型函数的步骤相反，编译器寻找所有泛型代码被调用的位置并针对具体类型生成代码。

特征 Trait

• 类似go中的interface
• 如果不同的类型具有相同的行为，那么我们就可以定义一个特征，然后为这些类型实现该特征

pub trait Summary {
    fn summarize(&self) -> String;
}
pub struct Post {
    pub title: String, // 标题
    pub author: String, // 作者
    pub content: String, // 内容
}
// Post 类型实现 Summary 特征
impl Summary for Post {
    fn summarize(&self) -> String {
        format!("文章{}, 作者是{}", self.title, self.author)
    }
}

pub struct Weibo {
    pub username: String,
    pub content: String
}

impl Summary for Weibo {
    fn summarize(&self) -> String {
        format!("{}发表了微博{}", self.username, self.content)
    }
}

• 默认实现,这样其它类型无需再实现该方法，或者也可以选择重载该方法

pub trait Summary {
    fn summarize(&self) -> String {
        String::from("(Read more...)")
    }
}

• 使用特征作为函数参数 和 返回值

pub fn notify(item: &impl Summary) {
    println!("Breaking news! {}", item.summarize());
}
pub fn notify(item1: &impl Summary, item2: &impl Summary) {}
fn returns_summarizable(switch: bool) -> impl Summary {
    if switch {
        Post {
            title: String::from(
                "Penguins win the Stanley Cup Championship!",
            ),
            author: String::from("Iceburgh"),
            content: String::from(
                "The Pittsburgh Penguins once again are the best \
                 hockey team in the NHL.",
            ),
        }
    } else {
        Weibo {
            username: String::from("horse_ebooks"),
            content: String::from(
                "of course, as you probably already know, people",
            ),
        }
    }
}

• derive 派生特征

[derive(Debug)], 用于{:?}格式化输出结构体

特征 对象

pub trait Draw {
    fn draw(&self);
}


pub struct Button {
    pub width: u32,
    pub height: u32,
    pub label: String,
}

impl Draw for Button {
    fn draw(&self) {
        // 绘制按钮的代码
    }
}

struct SelectBox {
    width: u32,
    height: u32,
    options: Vec<String>,
}

impl Draw for SelectBox {
    fn draw(&self) {
        // 绘制SelectBox的代码
    }
}

Self与self

• self指代当前的实例对象
• Self指代特征或者方法类型的别名

trait Draw {
    fn draw(&self) -> Self;
}

#[derive(Clone)]
struct Button;
impl Draw for Button {
    fn draw(&self) -> Self {
        return self.clone()
    }
}

fn main() {
    let button = Button;
    let newb = button.draw();
}
self指代的就是当前的实例对象，也就是 button.draw() 中的 button 实例，Self 则指代的是 Button 类型

Lint levels（静态代码分析）

lint是静态代码分析工具，其不仅可以检查程序中可移植性问题，还可以检查符合语法规则但可能是出现错误逻辑的代码。

• allow

[allow(dead_code)]

• warn(default)
• force-warn
• deny
• forbid

参考

• https://course.rs/
• https://doc.rust-lang.org/rustc/lints/levels.html
• https://baike.baidu.com/item/lint/2836851?fr=aladdin
• https://blog.csdn.net/Helloguoke/article/details/52116804
• https://course.rs/appendix/derive.html