Rust圣经 阅读 Rust基本概念

Rust 基础语法

// Rust 程序入口函数，跟其它语言一样，都是 main，该函数目前无返回值
fn main() {
    // 使用let来声明变量，进行绑定，a是不可变的
    // 此处没有指定a的类型，编译器会默认根据a的值为a推断类型：i32，有符号32位整数
    // 语句的末尾必须以分号结尾
    let a = 10;
    // 主动指定b的类型为i32
    let b: i32 = 20;
    // 这里有两点值得注意：
    // 1. 可以在数值中带上类型:30i32表示数值是30，类型是i32
    // 2. c是可变的，mut是mutable的缩写
    let mut c = 30i32;
    // 还能在数值和类型中间添加一个下划线，让可读性更好
    let d = 30_i32;
    // 跟其它语言一样，可以使用一个函数的返回值来作为另一个函数的参数
    let e = add(add(a, b), add(c, d));

    // println!是宏调用，看起来像是函数但是它返回的是宏定义的代码块
    // 该函数将指定的格式化字符串输出到标准输出中(控制台)
    // {}是占位符，在具体执行过程中，会把e的值代入进来
    println!("( a + b ) + ( c + d ) = {}", e);
}

// 定义一个函数，输入两个i32类型的32位有符号整数，返回它们的和
fn add(i: i32, j: i32) -> i32 {
    // 返回相加值，这里可以省略return
    i + j
}

注意，在上面的 add 函数中，不要为 i+j添加 ;，会改变语法导致函数返回 () 而不是 i32。

字符串使用双引号，而不是单引号。单引号是留给单个字符类型使用。
Rust 使用 {} 来作为格式化输出占位符，无需手动指定具体的类型，println!会自动推导出类型 。

变量绑定和解构

Rust 将赋值的过程称为变量绑定。因为绑定的含义更明确，对于Rust的所有权机制来说。将一个对象绑定给一个变量，表示将该对象的所有权交给该变量。
该对象之前的主人将丧失对该对象的所有权。

变量可变性

Rust的变量在默认情况下是不可变的。但也可以通过 mut 关键 让变量成为可变的，让设计更灵活。

使用下划线开头忽略未使用的变量

fn main(){
	let _x = 5;
	let y = 6;
}

如果创建 一个变量却从未使用，Rust将会给出一个警告，因为它可能是一个错误。
但是有时创建一个不会被使用的变量是有用的，比如你正在设计原型或刚刚开始一个项目。

变量解构

fn main() {
    let (a, mut b): (bool,bool) = (true, false);
    // a = true,不可变; b = false，可变
    println!("a = {:?}, b = {:?}", a, b);

    b = true;
    assert_eq!(a, b);
}

let (a, mut b): (bool,bool) = (true, false); 元组解构，将元组的成员分别绑定给多个变量。let (a, mut b): (bool,bool) 定义了两个变量，并显式地指定了两个变量的类型是 bool。

解构式赋值

在 Rust 1.59 版本后，可以在赋值语句的左式中使用元组、切片和结构体模式。

struct Struct {
    e: i32
}

fn main() {
    let (a, b, c, d, e);

    (a, b) = (1, 2);
    // _ 代表匹配一个值，但是我们不关心具体的值是什么，因此没有使用一个变量名而是使用了 _
    [c, .., d, _] = [1, 2, 3, 4, 5];
    Struct { e, .. } = Struct { e: 5 };

    assert_eq!([1, 2, 1, 4, 5], [a, b, c, d, e]);
}

这样的形式不会进行重新绑定，而是仅仅对之间绑定的变量进行再赋值。

常量与变量之间的差异

常量不仅默认不可以变，而且自始至终不可变。
常量使用 const 关键字，而不是 let 关键字，并且值的类型必须标注。

变量遮蔽（shadowing）
Rust允许声明相同的变量名，在后面声明的变量会遮蔽掉前面声明的。

fn main() {
    let x = 5;
    // 在main函数的作用域内对之前的x进行遮蔽
    let x = x + 1;

    {
        // 在当前的花括号作用域内，对之前的x进行遮蔽
        let x = x * 2;
        println!("The value of x in the inner scope is: {}", x);
    }

    println!("The value of x is: {}", x);
}
```![请添加图片描述](https://img-blog.csdnimg.cn/direct/dd8126399f6442bbbabc6c501b23d54c.png)