30 天拿下 Rust 之语法大全

概述

Rust 作为一种系统编程语言，近年来在开发者社区中逐渐崭露头角。其独特的所有权系统和内存安全特性，使得 Rust 在高性能、并发编程领域具有显著优势。本文将深入介绍 Rust 的一些基础语法，帮助大家快速掌握这门高效、安全的编程语言。

基本数据类型

Rust 中的基本数据类型分为：标量类型和复合类型。

标量类型包括下面几种：

1、整数类型。有符号整数：i8、i16、i32、i64、i128，以及平台相关的 isize（根据目标机器是 32 位还是 64 位系统，其大小分别为 32 位或 64 位）。无符号整数：u8、u16、u32、u64、u128，以及平台相关的 usize（同样依赖于目标平台的字长）。

2、浮点数类型。单精度浮点数：f32。双精度浮点数：f64。

3、布尔类型。表示真假值：bool，仅有两个可能的值：true 和 false。

4、字符类型。Unicode 码点：char，在 Rust 中每个字符占用四个字节。

复合类型包括下面几种：

1、元组（Tuples）：元组可以容纳多个不同类型的值，比如：(i32, f64, bool)。

2、数组：固定长度的同类型元素集合，比如：[i32; 5]表示一个包含 5 个 i32 类型元素的数组。

3、结构体：用户自定义的数据类型，用于将多个字段组合成一个新的类型。可参考下面的 Point 结构体。

struct Point {    x: i32,    y: i32,}

另外，Rust 还提供了枚举、引用、切片、智能指针等更复杂的复合类型。同时，字符串类型（String）虽然不是基本类型，但在实际编程中经常使用，它是一个可变的、拥有 UTF-8 编码文本的动态数组。

变量

变量通过 let 关键字声明，并且可以在声明时初始化。变量的声明方式如下：

let variable_name: type = value;

其中，variable_name 是变量的名称，type 是变量的类型，value 是变量的初始值。由于 Rust 支持自动类型推导，这意味着在某些情况下，编译器可以根据变量的初始化表达式来确定其类型，而不用显式地声明类型 type。

let a = 66;let b: i32 = 99;

Rust 中的变量默认是不可变（immutable）的，即一旦被赋值，后续不能更改其值。

let a = 66;// 会出现编译错误：cannot assign twice to immutable variablea = 99;

如果需要使变量可变，需要使用 mut 关键字来进行声明。

let mut a = 66;a = 99;

常量

常量在 Rust 中使用 const 关键字进行声明，其值在编译时就必须确定，且在整个程序的生命周期中都不能改变。常量的声明方式如下：

const constant_name: type = value;

其中，constant_name 是常量的名称，type 是常量的类型，value 是常量的值。与变量类似，由于 Rust 支持自动类型推导，type 可以省略。注意：常量只能被设置为常量表达式，而不能是函数调用的结果，或其他任何只能在运行时计算出的值。

const MATH_PI: f64 = 3.1415926;

条件判断

Rust 使用 if、else if、else 关键字来进行条件判断，这些关键字允许你根据条件表达式的值来执行不同的代码块。注意：else if 和 else 块是可选的，并且可以根据需要添加任意数量的 else if 块。

条件表达式的结果必须是一个布尔值，也就是为 true 或 false。如果条件为真，则执行 if 块中的代码。如果条件为假，并且存在 else 块，则执行 else 块中的代码。如果存在 else if 块，则继续检查下一个条件，直到找到一个为真的条件或者遍历完所有条件。

另外，Rust 的条件语句必须使用大括号{}来定义代码块，即使代码块只包含一行也是如此。这是 Rust 语法的一个特点，有助于清晰地标识代码块的开始和结束。

let score = 85;if score > 90 {    println!("Excellent");} else if score > 75 {    println!("Good");} else if score > 50 {    println!("Pass");} else {    println!("Fail");}

循环语句

在 Rust 中，循环语句主要有以下三种形式：for 循环、while 循环、loop 循环。下面分别进行介绍。

1、for 循环：用于遍历任何实现了 IntoIterator 特性的集合，比如：数组、切片、元组、迭代器等。

let numbers = [1, 2, 3, 4, 5];for number in numbers.iter() {    println!("Number: {}", number);}

另外，还可以使用范围（range）来创建一个迭代器进行循环，可参考下面的示例代码。注意：范围 0..5，不包括最后的 5。

for i in 0..5 {    println!("Number: {}", i + 1);}

2、while 循环：会一直执行其循环体内的代码，直到给定的条件变为 false 为止。

let mut number = 0;while number < 5 {    println!("Number: {}", number + 1);    number += 1;}

3、loop 循环：是一个无限循环，它没有预设的退出条件，需要显式地使用 break 关键字来终止循环。

let mut number = 0;loop {    if number > 3 {        break;    }
    println!("Number: {}", number + 1);    number += 1;}

除此之外，Rust 还支持使用标签来控制循环的跳转。标签是一个标识符，后面跟着一个冒号，它可以放在循环之前，然后你可以使用 break 或 continue 语句与标签一起使用，来控制循环的跳转。

'outer: loop {    for i in 1..5 {        if i == 3 {            break 'outer;        }        println!("Number: {}", i);    }}println!("Exited the loop");

在上面的示例代码中，我们有一个外层 loop 循环和一个内层 for 循环。当 i 等于 3 时，break 'outer 语句会执行，从而退出带有标签'outer 的外层循环。

函数

在 Rust 中，函数是程序的基本构建块之一，用于封装和重用代码。Rust 中的函数使用 fn 关键字声明，可以接收参数并返回结果。函数可以有任意数量的参数，并且每个参数都有其类型注解。函数可以返回一个值（通过 -> 后跟返回类型指定），也可以不返回任何值（在这种情况下，函数的返回类型为 ()，表示空元组）。

fn greet(name: &str) -> String {    let msg = format!("Hello, {}!", name);    msg}fn main() {    let msg = greet("World");    println!("{}", msg);}

在上面的示例代码中，greet 函数接收一个字符串引用作为参数，并返回一个格式化后的字符串。main 函数调用了 greet 函数，接受其返回值，并打印了 msg。

注释

注释是用来解释和说明代码功能、用法和设计决策的文字内容，它们不会被编译器编译成程序的一部分。Rust 中的注释分为以下三种类型。

单行注释： 单行注释以两个斜杠（//）开始，直到该行结束为止的所有文本都会被编译器忽略。

// 这是一个单行注释let a = 66; // 这里也可以添加一个单行注释

多行注释： 多行注释使用三个斜杠（///）开头，可以跨越多行。特别的是，当这样的注释出现在模块、函数、结构体、枚举等定义的前面时，它们会被编译器用来生成 API 文档。这种类型的注释遵循 Markdown 格式，可以包含更丰富的文本格式和代码示例。

/// 文档注释示例，用于描述函数功能////// # 示例////// ```/// let result = my_func(42);/// println!("结果: {}", result);/// ```fn my_func(num: i32) -> i32 {    num* 2}

文档注释：可以通过 cargo doc 命令来生成 HTML 格式的 API 文档，这对于开源项目或团队协作非常有用，因为它可以帮助其他开发者快速了解库或项目的接口及其使用方法。

宏

Rust 的宏是一种编译时的代码生成工具，它允许在编写代码时使用宏来自动生成代码，从而提高代码的可读性、可维护性和重用性。Rust 的宏系统是基于 macro_rules!关键字实现的，它提供了两种主要的宏类型：声明性宏和程序宏。

声明式宏：这种宏基于规则匹配，利用简单的语法模式来捕获并替换代码片段。声明式宏是通过 macro_rules!关键字来定义的，它们主要用于处理简单的文本转换，比如：创建简化的日志宏，或构建某些特定模式的函数调用。

macro_rules! add {    ($a:expr,$b:expr)=>{        {            $a + $b        }    }}
fn main() {    let result = add!(66, 99);    println!("{}", result);}

程序宏：程序宏提供了更复杂的代码生成能力，允许在编译时执行任意的 Rust 代码。程序宏分为几种类型，包括：自定义派生宏、属性类宏和函数式宏。这些宏允许更高级的代码生成和转换，但也需要更复杂的定义和实现。