《Rust快速入门》2. 基础语法
在本节中，我们将深入探讨 Rust 的基础语法，包括变量与常量的声明与使用、数据类型的分类与特点，以及函数的定义与调用。通过完整的代码示例和详尽的指导，帮助您夯实 Rust 编程的基础。
1. 变量与常量
在 Rust 中，变量和常量是存储值的基本单元。理解它们的特性和用法对于编写高效、安全的代码至关重要。
1.1 变量绑定
在 Rust 中，使用 let 关键字声明变量。默认情况下，变量是不可变的，即一旦赋值后，其值不能被更改。
fn main() {
let x = 5;
println!("x 的值是: {}", x);
// x = 6; // 这行代码会导致编译错误，因为 x 是不可变的
}
如果需要声明可变变量，可以使用 mut 关键字：
fn main() {
let mut y = 10;
println!("y 的初始值是: {}", y);
y = 15;
println!("y 的新值是: {}", y);
}
在上述示例中，y 被声明为可变的，因此我们可以修改其值。
1.2 常量
常量使用 const 关键字声明，必须显式指定类型，并且在程序运行期间始终保持不变。常量的命名通常使用全大写字母和下划线分隔，例如：
const MAX_POINTS: u32 = 100_000;
需要注意的是，常量与使用 let 声明的变量不同，常量在任何作用域中都有效，并且在编译时确定其值。
2. 数据类型
Rust 是强类型语言，每个值都有一个明确的类型。主要的数据类型包括：
2.1 标量类型
标量类型表示一个单一的值，主要包括：
-
整数类型：包括有符号和无符号整数，长度从 8 位到 128 位不等。例如：
let a: i32 = -10; // 有符号 32 位整数 let b: u64 = 100; // 无符号 64 位整数 -
浮点类型：主要有
f32（32 位）和f64（64 位），默认是f64。let x = 2.5; // 默认是 f64 let y: f32 = 3.14; // 显式指定为 f32 -
布尔类型：表示真或假，取值为
true或false。let is_active: bool = true; -
字符类型：表示单个 Unicode 字符，使用单引号括起来。
let letter = 'A'; let emoji = '😊';
2.2 复合类型
复合类型可以将多个值组合在一起，主要包括：
-
元组（Tuple）：将不同类型的多个值组合在一起。
let tup: (i32, f64, u8) = (500, 6.4, 1); let (x, y, z) = tup; // 解构赋值 println!("y 的值是: {}", y); -
数组（Array）：存储相同类型的多个值，长度固定。
let arr = [1, 2, 3, 4, 5]; let first = arr[0]; println!("第一个元素是: {}", first);
3. 函数
函数是组织代码的基本单元，在 Rust 中使用 fn 关键字定义函数。
3.1 定义和调用函数
以下是一个简单的函数定义和调用的示例：
fn main() {
greet();
}
fn greet() {
println!("Hello, Rust!");
}
在上述代码中，greet 函数被定义为输出一行问候语，并在 main 函数中被调用。
3.2 带参数的函数
函数可以接受参数，参数需要指定类型：
fn main() {
let name = "Alice";
greet(name);
}
fn greet(name: &str) {
println!("Hello, {}!", name);
}
这里，greet 函数接受一个字符串切片类型的参数 name，并在输出中使用。
3.3 有返回值的函数
函数可以返回一个值，返回类型在箭头 -> 之后指定：
fn main() {
let result = add(5, 3);
println!("结果是: {}", result);
}
fn add(a: i32, b: i32) -> i32 {
a + b // 表达式的值作为返回值
}
在 add 函数中，最后一行是一个表达式，返回两个参数的和。需要注意的是，Rust 中的表达式末尾没有分号。
4. 可运行的完整示例
综合以上内容，以下是一个完整的示例程序，演示变量、常量、数据类型和函数。
// 定义常量
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 常量定义：
const MAX_POINTS: u32 = 100_000;
使用 const 关键字定义常量 MAX_POINTS，类型为 u32，值为 100,000。常量在程序运行期间始终保持不变。
4.2 变量绑定：
let x = 5; // 不可变变量
let mut y = 10; // 可变变量
x 是不可变变量，y 是可变变量，使用 mut 关键字声明。
4.3 数据类型示例：
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 函数定义与调用：
fn add(a: i32, b: i32) -> i32 {
a + b // 返回 a 和 b 的和
}
定义了一个名为 add 的函数，接受两个 i32 类型的参数，返回它们的和。
4.5 元组使用：
let tup: (i32, f64, char) = (500, 6.4, 'z');
let (a, b, c) = tup; // 解构元组
创建了一个包含不同类型元素的元组，并通过解构将其值赋给变量 a、b 和 c。
4.6 数组使用：
let arr = [1, 2, 3, 4, 5];
let first = arr[0];
定义了一个包含五个整数的数组，并访问其第一个元素。
4.7 常量使用：
println!("最大点数是: {}", MAX_POINTS);
在程序中使用常量 MAX_POINTS。
运行结果：
x 的值是: 5
y 的值是: 10
y 的新值是: 15
整数: 42
无符号整数: 100
浮点数: 3.14
布尔值: true
字符: A
x 和 y 的和是: 20
元组的值是: (500, 6.4, z)
数组的第一个元素是: 1
最大点数是: 100000
通过上述示例，您可以看到 Rust 中变量、常量、数据类型和函数的基本用法。
在实际编程中，理解这些基础概念对于编写高效、安全的代码至关重要。