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 variable
a = 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("CSDN");
    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代码。程序宏分为几种类型，包括：自定义派生宏、属性类宏和函数式宏。这些宏允许更高级的代码生成和转换，但也需要更复杂的定义和实现。