Rust 基础语法综合教程

Rust 是一种现代化、安全、并发的系统级编程语言，具有强大的功能和丰富的特性。本教程将深入探讨 Rust 的基础语法，包括变量与数据类型、函数、模式匹配、所有权与借用、Trait 和泛型以及错误处理等内容，并提供实际示例帮助您更好地理解。

变量与数据类型

在 Rust 中，您可以使用 let 关键字声明变量，而数据类型通常由编译器进行推断，但也可以显式指定。

fn main() {
    let num = 10; // 整数变量
    let message = "Hello, Rust!"; // 字符串变量
    let float_num: f64 = 3.14; // 显式指定数据类型

    println!("Number: {}", num);
    println!("Message: {}", message);
    println!("Floating Point Number: {}", float_num);
}

函数

函数是 Rust 程序的基本构建块之一，您可以使用 fn 关键字定义函数。

// 定义一个简单的函数，用于计算两个数的和
fn add(a: i32, b: i32) -> i32 {
    a + b // 返回值是最后一个表达式的结果，不需要使用 return 关键字
}

fn main() {
    let result = add(5, 3);
    println!("Result: {}", result); // 输出：Result: 8
}

控制流

Rust 支持常见的控制流结构，如条件表达式和循环。

fn main() {
    let num = 10;

    // 使用 if-else 表达式进行条件判断
    if num > 0 {
        println!("Positive");
    } else if num < 0 {
        println!("Negative");
    } else {
        println!("Zero");
    }

    // 使用循环打印数字
    for i in 1..=5 {
        println!("{}", i);
    }

    // 使用 match 表达式匹配值
    match num {
        1 => println!("One"),
        2 => println!("Two"),
        _ => println!("Other"),
    }
}

模式匹配

模式匹配是 Rust 中非常强大的特性，它允许您根据数据的结构进行分支处理。

fn main() {
    let num = 5;

    match num {
        1 => println!("One"),
        2 | 3 | 5 => println!("Prime"),
        4..=7 => println!("Between 4 and 7"),
        _ => println!("Other"),
    }
}

所有权与借用

Rust 中的所有权系统确保了内存安全，它通过所有权、借用和生命周期来管理内存。

fn main() {
    let mut vec = vec![1, 2, 3];

    // 使用引用进行借用
    let first = &vec[0];
    println!("First element: {}", first);

    // 修改可变引用
    vec.push(4);

    // 再次使用引用
    println!("First element: {}", first); // 这里仍然可以访问 first
}

Trait 和泛型

Trait 是 Rust 中用于共享方法签名的一种机制，而泛型允许您编写更加灵活的函数和数据结构。

// 定义一个 trait
trait Printable {
    fn print(&self);
}

// 实现 trait
impl Printable for i32 {
    fn print(&self) {
        println!("Value: {}", self);
    }
}

fn print_all<T: Printable>(items: Vec<T>) {
    for item in items {
        item.print();
    }
}

fn main() {
    let nums = vec![1, 2, 3];
    print_all(nums);
}

错误处理

Rust 提供了 Result 枚举类型来处理可能发生错误的情况，以及简便的 ? 运算符来处理错误。

use std::fs::File;
use std::io::{self, Read};

fn read_file() -> Result<String, io::Error> {
    let mut file = File::open("example.txt")?;
    let mut content = String::new();
    file.read_to_string(&mut content)?;
    Ok(content)
}

fn main() {
    match read_file() {
        Ok(content) => println!("File content: {}", content),
        Err(error) => println!("Error reading file: {}", error),
    }
}

结论

通过本教程，您深入了解了 Rust 的基础语法，包括变量与数据类型、函数、控制流、模式匹配、所有权与借用、Trait 和泛型以及错误处理等内容。这些是您学习 Rust 编程语言的第一步。接下来，您可以继续学习 Rust 的更多高级特性和用法，探索其丰富的生态系统。

希望这个教程对您有所帮助，祝您学习愉快，编程顺利！