关键字

关键字	说明
let	声明不可变变量
let mut	声明可变变量
const	声明常量
fn	声明函数
struct	声明结构体
enum	声明枚举
impl	声明实现
trait	声明trait
->	返回值
;	语句结束
:	类型注解
,	分隔符
=	赋值
if	条件判断
else	其他
loop	循环
while	条件循环
for	循环
match	匹配
break	跳出循环
continue	继续循环
return	返回
?	可选错误
async	异步
await	等待

注释

Rust 支持两种风格的注释：单行注释和文档注释。

单行注释以 // 开头。

文档注释以 /// 开头，生成的文档会包含注释中的内容。

数据类型

标量类型

标量类型代表一个单独的值，整型、浮点型、布尔类型和字符类型。

1. 整型，默认是 i32

   整型是没有小数部分的数字，可以是正数、负数或零。

   | 长度 | 有符号 | 有符号区间 | 无符号 | 无符号区间 | |------|-------|------------------------------------------------------------------------------------|-------|---------------------------------------------| | 8 | i8 | -128 ~ 127 | u8 | 0 ~ 255 | | 16 | i16 | -32768 ~ 32767 | u16 | 0 ~ 65535 | | 32 | i32 | -2147483648 ~ 2147483647 | u32 | 0 ~ 4294967295 | | 64 | i64 | -9223372036854775808 ~ 9223372036854775807 | u64 | 0 ~ 18446744073709551615 | | 128 | i128 | -170141183460469231731687303715884105728 ~ 170141183460469231731687303715884105727 | u128 | 0 ~ 340282366920938463463374607431768211455 | | 架构相关 | isize | 64 位架构上它们是 64 位的，32 位架构上它们是 32 位的 | usize | 64 位架构上它们是 64 位的，32 位架构上它们是 32 位的 |

2. 浮点型，默认是 f64

   浮点型是带小数部分的数字，Rust 的浮点数类型是 f32 和 f64，分别占 32 位和 64 位。默认类型是 f64，因为在现代 CPU 中，它与 f32 速度几乎一样，不过精度更高。所有的浮点型都是有符号的。

3. 布尔类型bool，默认是 false

   布尔类型表示真或假，只有两个可能的值：true 和 false。

4. 字符类型char

   字符类型表示一个字符，用单引号括起来，例如 'a'，而字符串字面值使用的是双引号。

复合类型

复合类型可以把多个值组合成一个类型，元组和数组。

1. 元组

   元组是一个固定长度的集合，可以包含不同类型的值。

   元组用圆括号括起来，例如 (1, 2.0, 'a')。

   元组的每个元素都有一个索引，从0开始。

   元组的长度在编译时是已知的。

2. 数组

   数组是一个固定长度的集合，可以包含相同类型的值。

   数组用方括号括起来，例如 [1, 2, 3]。

   数组的每个元素都有一个索引，从0开始。

   数组的长度在编译时是已知的。

变量和可变性

不可变变量（声明关键字 let）

在 Rust 中，变量默认是不可变的。这意味着一旦变量被赋值，它的值就不能被改变。

fn main() {
    let x = 5;
    println!("{}", x);
    // x = 6; // 这行代码会报错，因为 x 是不可变的
}

可变变量（声明关键字 let mut）

在 Rust 中，变量默认是不可变的。这意味着一旦变量被赋值，它的值就不能被改变。

fn main() {
    let mut x = 5;
    println!("{}", x);
    x = 6; // 这行代码不会报错，因为 x 是可变的
}

常量

声明常量（关键字 const）

在 Rust 中，常量是不可变的，这意味着一旦常量被赋值，它的值就不能被改变。

fn main() {
    const X: i32 = 5;
    println!("{}", X);
    // X = 6; // 这行代码会报错，因为 X 是不可变的
}

遮蔽

在 Rust 中，遮蔽（shadowing）是指在相同作用域内，后声明的变量可以覆盖先声明的变量。

fn main() {
    let x = 5;
    println!("{}", x);
    {
        let x = 6;
        println!("{}", x);
    }
}

函数

声明函数（关键字 fn）

在 Rust 中，函数是 First-Class 公民，这意味着它们可以像其他值一样被传递和返回。

函数可以返回值，返回值的类型在 -> 后面指定。

函数的参数类型在参数名后面指定，参数和参数之间用逗号分隔。

函数体由一对大括号括起来，大括号内可以包含多个语句，最后一个语句的值作为返回值。

如果函数体只有一行，可以省略大括号，但这行代码必须是返回值。

Rust 代码中的函数名和变量名通常使用 snake case 风格。在 snake case 中，所有字母都使用小写，并用下划线分隔单词。

fn main() {
    println!("{}", add(1, 2));
}
fn add(a: i32, b: i32) -> i32 {
    a + b
}

语句和表达式

在 Rust 中，语句和表达式有重要的区别。

语句是执行某些操作但不返回值的代码块。

表达式计算并返回一个值。

语句以分号结尾，而表达式不以分号结尾。

例如，let x = 5; 是一个语句，因为它以分号结尾，不返回值。

例如，5 + 6 是一个表达式，因为它计算并返回一个值。

fn main() {
    let y = {
        let x = 3;
        x + 1
    };
    println!("The value of y is: {y}");
}

具有返回值的函数

在 Rust 中，函数可以返回值。

函数的返回值类型在 -> 后面指定。

函数的最后一个表达式的结果是返回值，除非最后一个表达式以分号结尾，否则它将作为返回值。

例如，fn add(a: i32, b: i32) -> i32 { a + b } 是一个返回值的函数，a + b 的结果作为返回值。

fn main() {
    println!("{}", add(1, 2));
}
fn add(a: i32, b: i32) -> i32 {
    a + b
}

控制流

条件判断（关键字 if）

在 Rust 中，条件判断使用 if 关键字。

if 关键字后面跟着一个条件，条件为 true 时执行 if 块中的代码，否则执行 else 块中的代码。

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");
    }
}

循环（关键字 loop）

在 Rust 中，循环使用 loop 关键字。

loop 关键字后面跟着一个循环块，循环块中可以包含多个语句，最后一个语句的值作为返回值。

例如，loop { println!("again!") } 是一个无限循环，println!("again!") 的结果作为返回值。

fn main() {
    loop {
        println!("again!");
    }
}

1. 从循环返回值（关键字 break）

在 Rust 中，可以使用 break 关键字从循环中返回值。

break 关键字后面跟着一个可选的返回值，如果省略，则返回 ()。

例如，loop { break 42; } 是一个循环，break 42 从循环中返回值 42。

例如，loop { break; } 是一个循环，break 从循环中返回值 ()。

fn main() {
    let mut counter = 0;

    let result = loop {
        counter += 1;

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

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

2. 循环标签：在多个循环之间消除歧义

   在 Rust 中，可以使用循环标签来消除多个循环之间的歧义。 例如，'outer: loop { loop { break 'outer; } } 是一个循环，break 'outer; 从外层循环中返回值。

循环（关键字 while）

在 Rust 中，循环使用 while 关键字。

while 关键字后面跟着一个条件，条件为 true 时执行循环块中的代码，否则执行 else 块中的代码。

例如，while condition { println!("again!") } 是一个循环，condition 为 true 时执行循环块中的代码，否则执行 else 块中的代码。

fn main() {
    let mut number = 3;
    while number != 0 {
        println!("{number}!");
        number -= 1;
    }
    println!("LIFTOFF!!!");
}

循环（关键字 for）

在 Rust 中，循环使用 for 关键字。

for 关键字后面跟着一个循环块，循环块中可以包含多个语句，最后一个语句的值作为返回值。

例如，for i in 0..3 { println!("again!") } 是一个循环，i 从 0 到 3，println!("again!") 的结果作为返回值。

fn main() {
    for i in 0..3 {
        println!("again!");
    }
}

匹配（关键字 match）

在 Rust 中，匹配使用 match 关键字。

match 关键字后面跟着一个值和多个 arms，每个 arm 由一个模式和一个表达式组成。

例如，match value { pattern1 => expression1, pattern2 => expression2, ... } 是一个匹配，value 与 pattern1 匹配时执行 expression1，与 pattern2 匹配时执行 expression2，依此类推。

fn main() {
    let number = 6;
    match number {
        1 => println!("one"),
        2 => println!("two"),
        3 => println!("three"),
        4 => println!("four"),
        5 => println!("five"),
        _ => println!("something else"),
    }
}