《Rust快速入门》2. 基础语法

January 18, 2025

在本节中，我们将深入探讨 Rust 的基础语法，包括变量与常量的声明与使用、数据类型的分类与特点，以及函数的定义与调用。通过完整的代码示例和详尽的指导，帮助您夯实 Rust 编程的基础。

1. 变量与常量

在 Rust 中，变量和常量是存储值的基本单元。理解它们的特性和用法对于编写高效、安全的代码至关重要。

1.1 变量绑定

在 Rust 中，使用 let 关键字声明变量。默认情况下，变量是不可变的，即一旦赋值后，其值不能被更改。

1
2
3
4
5


fn main() {
    let x = 5;
    println!("x 的值是: {}", x);
    // x = 6; // 这行代码会导致编译错误，因为 x 是不可变的
}

如果需要声明可变变量，可以使用 mut 关键字：

1
2
3
4
5
6


fn main() {
    let mut y = 10;
    println!("y 的初始值是: {}", y);
    y = 15;
    println!("y 的新值是: {}", y);
}

在上述示例中，y 被声明为可变的，因此我们可以修改其值。

1.2 常量

常量使用 const 关键字声明，必须显式指定类型，并且在程序运行期间始终保持不变。常量的命名通常使用全大写字母和下划线分隔，例如：

1

const MAX_POINTS: u32 = 100_000;

需要注意的是，常量与使用 let 声明的变量不同，常量在任何作用域中都有效，并且在编译时确定其值。

2. 数据类型

Rust 是强类型语言，每个值都有一个明确的类型。主要的数据类型包括：

2.1 标量类型

标量类型表示一个单一的值，主要包括：

整数类型：包括有符号和无符号整数，长度从 8 位到 128 位不等。例如：

1
2


let a: i32 = -10; // 有符号 32 位整数
let b: u64 = 100; // 无符号 64 位整数

浮点类型：主要有 f32（32 位）和 f64（64 位），默认是 f64。

1
2


let x = 2.5; // 默认是 f64
let y: f32 = 3.14; // 显式指定为 f32

布尔类型：表示真或假，取值为 true 或 false。
1

let is_active: bool = true;
字符类型：表示单个 Unicode 字符，使用单引号括起来。
1 2

let letter = 'A'; let emoji = '😊';

2.2 复合类型

复合类型可以将多个值组合在一起，主要包括：

元组（Tuple）：将不同类型的多个值组合在一起。

1
2
3


let tup: (i32, f64, u8) = (500, 6.4, 1);
let (x, y, z) = tup; // 解构赋值
println!("y 的值是: {}", y);

数组（Array）：存储相同类型的多个值，长度固定。

1
2
3


let arr = [1, 2, 3, 4, 5];
let first = arr[0];
println!("第一个元素是: {}", first);

3. 函数

函数是组织代码的基本单元，在 Rust 中使用 fn 关键字定义函数。

3.1 定义和调用函数

以下是一个简单的函数定义和调用的示例：

1
2
3
4
5
6
7


fn main() {
    greet();
}

fn greet() {
    println!("Hello, Rust!");
}

在上述代码中，greet 函数被定义为输出一行问候语，并在 main 函数中被调用。

3.2 带参数的函数

函数可以接受参数，参数需要指定类型：

1
2
3
4
5
6
7
8


fn main() {
    let name = "Alice";
    greet(name);
}

fn greet(name: &str) {
    println!("Hello, {}!", name);
}

这里，greet 函数接受一个字符串切片类型的参数 name，并在输出中使用。

3.3 有返回值的函数

函数可以返回一个值，返回类型在箭头 -> 之后指定：

1
2
3
4
5
6
7
8


fn main() {
    let result = add(5, 3);
    println!("结果是: {}", result);
}

fn add(a: i32, b: i32) -> i32 {
    a + b // 表达式的值作为返回值
}

在 add 函数中，最后一行是一个表达式，返回两个参数的和。需要注意的是，Rust 中的表达式末尾没有分号。

4. 可运行的完整示例

综合以上内容，以下是一个完整的示例程序，演示变量、常量、数据类型和函数。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52


// 定义常量
const MAX_POINTS: u32 = 100_000;

fn main() {
    // 变量绑定
    let x = 5; // 不可变变量
    let mut y = 10; // 可变变量

    // 打印变量值
    println!("x 的值是: {}", x);
    println!("y 的值是: {}", y);

    // 修改可变变量的值
    y = 15;
    println!("y 的新值是: {}", y);

    // 数据类型示例
    let integer: i32 = 42; // 有符号整数
    let unsigned_integer: u64 = 100; // 无符号整数
    let float: f64 = 3.14; // 浮点数
    let is_active: bool = true; // 布尔值
    let letter: char = 'A'; // 字符

    // 打印数据类型的值
    println!("整数: {}", integer);
    println!("无符号整数: {}", unsigned_integer);
    println!("浮点数: {}", float);
    println!("布尔值: {}", is_active);
    println!("字符: {}", letter);

    // 调用函数
    let sum = add(x, y);
    println!("x 和 y 的和是: {}", sum);

    // 使用元组
    let tup: (i32, f64, char) = (500, 6.4, 'z');
    let (a, b, c) = tup; // 解构元组
    println!("元组的值是: ({}, {}, {})", a, b, c);

    // 使用数组
    let arr = [1, 2, 3, 4, 5];
    let first = arr[0];
    println!("数组的第一个元素是: {}", first);

    // 使用常量
    println!("最大点数是: {}", MAX_POINTS);
}

// 定义函数
fn add(a: i32, b: i32) -> i32 {
    a + b // 返回 a 和 b 的和
}

代码说明：

4.1 常量定义：

1

const MAX_POINTS: u32 = 100_000;

使用 const 关键字定义常量 MAX_POINTS，类型为 u32，值为 100,000。常量在程序运行期间始终保持不变。

4.2 变量绑定：

1
2


let x = 5; // 不可变变量
let mut y = 10; // 可变变量

x 是不可变变量，y 是可变变量，使用 mut 关键字声明。

4.3 数据类型示例：

1
2
3
4
5


let integer: i32 = 42; // 有符号整数
let unsigned_integer: u64 = 100; // 无符号整数
let float: f64 = 3.14; // 浮点数
let is_active: bool = true; // 布尔值
let letter: char = 'A'; // 字符

演示了 Rust 中常见的数据类型，包括有符号整数、无符号整数、浮点数、布尔值和字符。

4.4 函数定义与调用：

1
2
3


fn add(a: i32, b: i32) -> i32 {
    a + b // 返回 a 和 b 的和
}

定义了一个名为 add 的函数，接受两个 i32 类型的参数，返回它们的和。

4.5 元组使用：

1
2


let tup: (i32, f64, char) = (500, 6.4, 'z');
let (a, b, c) = tup; // 解构元组

创建了一个包含不同类型元素的元组，并通过解构将其值赋给变量 a、b 和 c。

4.6 数组使用：

1
2


let arr = [1, 2, 3, 4, 5];
let first = arr[0];

定义了一个包含五个整数的数组，并访问其第一个元素。

4.7 常量使用：

1

println!("最大点数是: {}", MAX_POINTS);

在程序中使用常量 MAX_POINTS。

运行结果：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


x 的值是: 5
y 的值是: 10
y 的新值是: 15
整数: 42
无符号整数: 100
浮点数: 3.14
布尔值: true
字符: A
x 和 y 的和是: 20
元组的值是: (500, 6.4, z)
数组的第一个元素是: 1
最大点数是: 100000

通过上述示例，您可以看到 Rust 中变量、常量、数据类型和函数的基本用法。

在实际编程中，理解这些基础概念对于编写高效、安全的代码至关重要。