Rust学习笔记-3-基础篇：表达式、语句、控制流、注释

本文链接：https://blog.youkuaiyun.com/uddiqpl/article/details/107976756

前言

承接前文，本文主要对Rust基础概念中关于表达式、语句、控制流、注释、函数的知识点进行梳理。

表达式

Rust is primarily an expression language
Rust的表达式包括字面量表达式、方法调用表达式、数组表达式、索引表达式、单目运算符表达式、双目运算符表达式等。
Rust表达式又可以分为“左值”（lvalue）和“右值”（rvalue）两类。所谓左值，意思是这个表达式可以表达一个内存地址。因此，它们可以放到赋值运算符左边使用。其他的都是右值。
算术运算符包括：加（+）、减（-）、乘（*）、除（/）、求余（%）；比较运算符包括：等于（==）、不等于（!=）、小于（<）、大于（>）、小于等于（<=）、大于等于（>=）；位运算符包括：按位取反（!）、按位与（&）、按位或（|)、按位异或（^)、左移（<<）、右移（>>）；逻辑运算符包括：逻辑取反（!）、逻辑与（&&）、逻辑或（||）。
编译器会禁止此形式的连续比较：a==b==c。连续比较运算符必须加上括号。
逻辑与、逻辑或有短路功能。按位与、按位或不会短路。
比较运算符的两边必须是同类型的，并满足PartialEq约束。比较表达式的类型是bool
赋值表达式：一个左值表达式、赋值运算符（=）和右值表达式，可以构成一个赋值表达式。赋值表达式具有“副作用”：当它执行的时候，会把右边表达式的值“复制或者移动”（copy or move）到左边的表达式中。赋值号左右两边表达式的类型必须一致，否则是编译错误。
赋值表达式也有对应的类型和值。Rust规定，赋值表达式的类型为unit，即空的tuple()。如下例，输出是()。Rust这么设计是有原因的，比如说可以防止连续赋值。
```
#![allow(unused)]
fn main() {    
    let x = 1;    
    let mut y = 2;    
    // 注意这里专门用括号括起来了    
    let z = (y = x);    
    println!("{:?}", z); 
}
```
Rust也支持组合赋值表达式。但不支持++、--运算符，请使用+=1、-=1替代。
语句块表达式：在Rust中，语句块也可以是表达式的一部分。语句和表达式的区分方式是后面带不带分号（；）。如果带了分号，意味着这是一条语句，它的类型是（）；如果不带分号，它的类型就是表达式的类型。所以在函数中，我们也可以利用这样的特点来写返回值。这种写法用在后面讲到的闭包closure中，会方便轻量（无需写return）。
```
// 语句块可以是表达式,注意后面有分号结尾,x的类型是() 
let x : () = { println!("Hello."); };
// Rust将按顺序执行语句块内的语句,并将最后一个表达式类型返回,y的类型是 i32 
let y : i32 = { println!("Hello."); 5 };
```

注：

1，查了下PartialEq，可参考：https://segmentfault.com/a/1190000011929777。简言之：PartialEq定义了部分相等，且这种相等具有对称性(a==b则b==a）、传递性(a==b且b==c，则a==c)。但它没有反身性（即a==a不成立。作为对比，Eq具有反身性）。回想前文的浮点数，NAN!=NAN，所以浮点数只实现了PartialEq。

2，rust的运算符，实现了一些trait。要进行自定义的运算符重载，也是实现这些trait。可参考阅读：https://blog.youkuaiyun.com/u010824081/article/details/78447453

语句

一个表达式总是会产生一个值，因此它必然有类型；语句不产生值，它的类型永远是（）。如果把一个表达式加上分号，那么它就变成了一个语句；如果把语句放到一个语句块中包起来，那么它就可以被当成一个表达式使用。
语句（Statements）是执行一些操作但不返回值的指令。表达式（Expressions）计算并产生一个值。
使用 let 关键字创建变量并绑定一个值是一个语句。函数定义也是语句。
```
//函数定义本身就是一个语句
fn main() {
    let y = 6; //这是一个语句
}
```

语句不返回值。看下面的示例：

fn main() {
    let x = (let y = 6); //编译错误。let y = 6 是语句，并不返回值。
}

函数调用是一个表达式；宏调用是一个表达式；我们用来创建新作用域的大括号（代码块），{}，也是一个表达式。

表达式的结尾没有分号。再看个例子：

fn main() {
    let x = 5;

    let y = {
        let x = 3;
        x + 1 //这是一个表达式。如果在结尾加上分号，它就变成了语句，而语句不会返回值。
    };

    println!("The value of y is: {}", y);
}

控制流

条件分支：if-else、if-else if-...-else。其中else可以省略。

条件必须是bool值。else if 如果比较多，可以考虑用match。以下是个示例：

fn main() {
    let number = 6;

    if number % 4 == 0 {
        println!("number is divisible by 4");
    } else if number % 3 == 0 {
        println!("number is divisible by 3");
    } else if number % 2 == 0 {
        println!("number is divisible by 2");
    } else {
        println!("number is not divisible by 4, 3, or 2");
    }
}

在if语句中，后续的结果语句块要求一定要用大括号包起来，不能省略，以便明确指出该if语句块的作用范围。这个规定是为了避免“悬空 else”导致的bug。
条件表达式并未强制要求用小括号包起来；如果加上小括号，编译器反而会认为这是一个多余的小括号，给出警告。（试了下的确如此）

if-else结构还可以当表达式使用。

fn main() {
    let condition = true;
    let number = if condition {
        5
    } else {
        6
    };

    println!("The value of number is: {}", number);
}

if 分支和 else 分支的结果，其类型必须匹配。

循环：loop、while 和 for

loop是个无限循环。可以用break或者continue跳出。与if结构一样，loop结构也可以作为表达式的一部分。以下是示例：

fn main() {
    let mut counter = 0;

    let result = loop {
        counter += 1;

        if counter == 10 {
            break counter * 2; //跳出时可以返回值
        }
    };

    println!("The result is {}", result); //输出20
}

break语句和continue语句还可以在多重循环中选择跳出到哪一层的循环。我们可以在loop while for循环前面加上“生命周期标识符”。该标识符以单引号开头，在内部的循环中可以使用break语句选择跳出到哪一层。以下是示例。

fn main() {
    // A counter variable    
    let mut m = 1;    
    let n = 1;
    'a: loop {
        if m < 100 {
            m += 1;
        } else {
            'b: loop {
                if m + n > 50 {
                    println!("break");
                    break 'a;
                } else {
                    continue 'a;
                }
            }
        }
    }
}

如果一个loop永远不返回，那么它的类型就是“发散类型”。示例如下：
```
fn main() {
    let v = loop {};
    println!("{}", v);
}
```
while语句中也可以使用continue和break来控制循环流程。
既然有while，为何还要loop？书中这么解释的：“主要原因在于，相比于其他的许多语言，Rust语言要做更多的静态分析。loop和while true语句在运行时没有什么区别，它们主要是会影响编译器内部的静态分析结果”。看如下示例：
```
//编译可以通过
let x; 
loop { x = 1; break; } 
println!("{}", x) 

//编译通过不了。因为编译器会觉得while语句的执行跟条件表达式在运行阶段的值 有关，因此它不确定x是否一定会初始化
let x; 
while true { x = 1; break; } 
println!("{}", x);
```

注：

坦白讲，即使看了这样的解释，还没想明白哪个应用场景非用loop不可。感觉还真有点多余。后面如果有了新的理解，再更新这里。

Rust中的for循环实际上是许多其他语言中的for-each循环。Rust中没有类似C/C++的三段式for循环语句。以下是个示例。
```
fn main() {
    let a = [10, 20, 30, 40, 50];

    for element in a.iter() {
        println!("the value is: {}", element);
    }
}
```
for循环的主要用处是利用迭代器对包含同样类型的多个元素的容器执行遍历，如数组、链表、HashMap、HashSet等。在Rust中，我们可以轻松地定制自己的容器和迭代器，因此也很容易使for循环也支持自定义类型。
for循环内部也可以使用continue和break控制执行流程。

注释

分为代码层面的注释和文档注释。
代码注释的格式：一种是用//开头的，是行注释。一种是/**/，是块注释。
文档注释的格式：///、//！、/**…*/、/*！…*/，
用///开头的文档被视为是给它后面的那个元素做的说明；//！开头的文档被视为是给包含这块文档的元素做的说明。/**…*/和/*！…*/也是类似的。
```
mod foo {
    //! 这块文档是给 `foo` 模块做的说明
    /// 这块文档是给函数 `f` 做的说明    
    fn f() {
        // 这块注释不是文档的一部分
    }
}
```
文档内部支持markdown格式。可以使用#作为一级标题。比如标准库中常用的几种标题：
```
/// # Panics 
/// # Errors 
/// # Safety 
/// # Examples
```
文档中的代码部分要用``符号把它们括起来。代码块应该用```括起来。示例如下。Rust文档里面的代码块，在使用cargo test命令时，也是会被当做测试用例执行的。这个设计可以在很多时候检查出文档和代码不对应的情况。
```
/// ```    
/// let mut vec = Vec::with_capacity(10);
///    
/// // The vector contains no items, even though it has capacity for more    
/// assert_eq!(vec.len(), 0);    
/// ```
```
如果文档太长，也可以写在单独的markdown文件中。如果在单独的文件中写文档，就不需要再用///或者//！开头了，直接写内容就可以。然后再用一个attribute来指定给对应的元素：
```
#![feature(external_doc)]
#[doc(include = "external-doc.md")] 
pub struct MyAwesomeType;
```
注：

利用cargo 创建文档注释的html、文档测试等相关知识点，这里跳过。后面和cargo一起说明。列个TODO项。