Rust语言学习：基础语法 - 好暖好温暖的博客

1678 字

8 分钟

Rust语言学习：基础语法

2025-07-29

rust

/

基础语法

/

变量

/

控制流

1. 变量与可变性#

Rust 中的变量默认是 不可变 的。可以使用 mut 关键字使变量变为可变的。

1.1 可变变量#

通过 mut 关键字，可以声明一个可变变量，其值在后续可以被修改。

1
// 可变变量
2
let mut x = 5;
3
println!("The value of x is: {}", x);
4
x = 10;
5
println!("The value of x is: {}", x);

1.2 常量#

常量在绑定值后任何时候都不能更改。

声明: 使用 const 关键字，且必须显式标注值的类型。
命名: Rust 常量的命名约定是使用全大写字母，并用下划线分隔单词。
赋值: 只能被设置为常量表达式，不能是函数调用的结果或任何其他在运行时才能确定的值。

1
// 常量 不可用mut，必须标注类型，仅可以用常量表达式赋值
2
const SPECAL_NUMBER: i32 = 3;
3
println!("The value of SPECAL_NUMBER is: {}", SPECAL_NUMBER);

1.3 变量遮蔽 (Shadowing)#

Rust 允许声明一个与之前变量同名的新变量，这个过程称为遮蔽 (Shadowing)。新变量会“遮蔽”掉旧的变量。

它通过再次使用 let 关键字来创建了一个全新的变量。
这允许我们改变值的类型，同时保持名称不变。
在离开作用域后，被遮蔽的变量会恢复。

1
// 变量遮蔽
2
let my_number = 5;
3
// 这里的my_number是一个新的变量，遮蔽了原来的 5
4
let my_number = my_number + 1;
5

6
{
7
    // 在这个内部作用域，my_number又被一次遮蔽
8
    let my_number = my_number * 2;
9
    println!("The value of my_number in the inner scope is: {}", my_number); // 输出 12
10
}
11

12
println!("The value of my_number is: {}", my_number); // 输出 6

2. 数据类型#

Rust 是一种静态类型语言，它在编译时就必须知道所有变量的类型。数据类型可以分为两大类：标量类型和复合类型。

2.1 标量类型 (Scalar Types)#

标量类型表示一个单一的值。Rust 有四种主要的标量类型：

类型	说明	示例
整数	有符号 (`i8` 到 `i128`, `isize`) 和无符号 (`u8` 到 `u128`, `usize`)	`let int1 = 98_222;`
浮点数	`f32` (单精度) 和 `f64` (双精度)	`const PI: f64 = 3.14159;`
布尔值	`bool`，值为 `true` 或 `false`	`let is_rust_fun = true;`
字符	`char`，表示一个 Unicode 标量值，用单引号括起来	`let char1 = 'z';` `let char2 = '😻';`

整数的字面量表示:

1
let int1 = 98_222;       // 十进制，下划线可用于提高可读性
2
let int2 = 0xff;         // 十六进制
3
let int3 = 0o77;         // 八进制
4
let int4 = 0b1111_0000;   // 二进制
5
let int5 = b'A';         // 字节 (u8)

2.2 复合类型 (Compound Types)#

复合类型可以将多个值组合成一个类型。Rust 有两种原生的复合类型：

元组 (Tuple)#

将多个不同类型的值组合进一个复合类型中。
长度固定：一旦声明，其大小不能伸缩。
可以通过模式匹配进行 解构 (Destructuring)，或使用点号 . 加索引来访问元素。

1
// 元组 不同数据类型的组合
2
let my_tuple: (i32, f64, u8) = (500, 6.4, 1);
3

4
// 解构元组
5
let (x, y, z) = my_tuple;
6
println!("The value of y is: {}", y);
7

8
// 通过索引访问
9
let five_hundred = my_tuple.0;
10
println!("The first value is: {}", five_hundred);

数组 (Array)#

将多个 相同类型 的值组合在一起。
长度固定。
数据存储在栈上。

1
let a = [10, 20, 30, 40, 50];
2
let first = a[0]; // 访问数组元素

3. 函数#

使用 fn 关键字定义函数。Rust 代码使用蛇形命名法 (snake case) 作为函数和变量名称的规范。

3.1 函数参数#

必须为每个参数声明其类型。

1
fn another_function(x: i32, y: String) {
2
    println!("The value of x is: {}", x);
3
    println!("The value of y is: {}", y);
4
}

3.2 语句和表达式#

语句 (Statements): 执行某些操作但不返回值的指令。例如 let x = 6;。
表达式 (Expressions): 会计算并产生一个值。例如 5 + 6。
函数体由一系列语句和一个可选的结尾表达式构成。
在 Rust 中，代码块 {} 是一个表达式，它会返回块中最后一个表达式的值。

1
let y = {
2
    let x = 5;
3
    x + 1 // 这个块表达式的返回值是 6，注意末尾没有分号
4
};
5
println!("The value of y is: {}", y); // y 的值为 6

3.3 函数返回值#

在箭头 -> 之后声明返回值的类型。
函数的返回值是其函数体中最后一个表达式的值。
可以使用 return 关键字提前从函数中返回。
没有显式返回值的函数，其返回类型是 ()，称为单元类型 (unit type)。

1
// 含返回值的函数
2
fn five() -> i32 {
3
    5 // 这是一个表达式，其值将作为函数返回值
4
}
5

6
fn plus_one(x: i32) -> i32 {
7
    return x + 1; // 也可以使用 return 显式返回
8
}

4. 控制流#

4.1 `if` 表达式#

if 表达式的条件必须是 bool 类型。
因为 if 是一个表达式，所以可以将其用在 let 语句的右侧来赋值。

1
fn if_function(x: i32) {
2
    if x < 5 {
3
        println!("x is less than 5");
4
    } else if x == 5 {
5
        println!("x is equal to 5");
6
    } else {
7
        println!("x is greater than 5");
8
    }
9

10
    // if表达式可以返回值
11
    let y = if x < 10 { x + 1 } else { x - 1 };
12
    println!("The value of y is: {}", y);
13
}

4.2 循环#

Rust 提供了三种循环：loop、while 和 for。

`loop`#

loop 关键字告诉 Rust 无限次地执行一块代码，直到你显式地告诉它停止。
可以使用 break 关键字退出循环，break 后面可以跟一个表达式，作为 loop 循环的返回值。
可以使用 continue 跳过当前迭代，进入下一次迭代。

1
fn loop_function() -> i32 {
2
    let mut counter = 0;
3
    loop {
4
        counter += 1;
5
        if counter == 10 {
6
            break counter * 2; // 退出循环并返回 20
7
        }
8
    }
9
}

循环标签 (Loop Labels)#

对于嵌套循环，可以使用循环标签来指定 break 或 continue 要作用于哪个循环。

1
fn labeled_loop() {
2
    let mut count = 0;
3
    'counting_up: loop {
4
        println!("count = {count}");
5
        let mut remaining = 10;
6

7
        loop {
8
            println!("remaining = {}", remaining);
9
            if remaining == 9 {
10
                break; // 退出内层循环
11
            }
12
            if count == 2 {
13
                break 'counting_up; // 退出名为 'counting_up 的外层循环
14
            }
15
            remaining -= 1;
16
        }
17
        count += 1;
18
    }
19
    println!("End count = {count}");
20
}

`while` 循环#

当条件为真时，循环就会继续。

1
fn while_function() {
2
    let mut number = 3;
3

4
    while number != 0 {
5
        println!("{}!", number);
6
        number -= 1;
7
    }
8
    println!("LIFTOFF!!!");
9
}

`for` 循环#

用于遍历集合中的每个元素，如数组。for 循环是更安全、更简洁的选择，因为它避免了 while 循环中可能出现的索引越界等错误。

1
fn for_function() {
2
    let a = [10, 20, 30, 40, 50];
3

4
    // 使用 .iter() 方法遍历集合
5
    for element in a.iter() {
6
        println!("The value is: {}", element);
7
    }
8

9
    // 遍历一个范围 (Range)
10
    // .rev() 方法用于反转范围
11
    for number in (1..4).rev() {
12
        println!("{}!", number);
13
    }
14
    println!("LIFTOFF!!!");
15
}