什么是 Rust？

Rust 是一门系统编程语言，专注于安全、并发和性能。它由 Mozilla 研究院开发，于 2010 年首次发布，2021 年成为 Linux 内核官方支持的第二种语言。

Rust 的核心特性

  1. 内存安全：通过所有权（Ownership）系统在编译时保证内存安全

  2. 零成本抽象：高级抽象不会带来运行时开销

  3. 并发安全：编译器阻止数据竞争

  4. 性能高效：与 C++ 相当的性能

  5. 工具链完善：包管理器（Cargo）、构建工具、格式化工具等

Rust 的应用场景

  • 系统编程

  • WebAssembly

  • 网络服务

  • 嵌入式开发

  • 命令行工具

  • 区块链

安装 Rust

使用 rustup 安装（推荐）

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

安装完成后，重新加载环境变量：

source $HOME/.cargo/env

验证安装

rustc --version
cargo --version

第一个 Rust 程序

创建项目

cargo new hello_rust
cd hello_rust

这会创建以下项目结构：

hello_rust/
├── Cargo.toml    # 项目配置文件
└── src/
    └── main.rs   # 主程序文件

编写代码

打开 src/main.rs，你会看到：

fn main() {
    println!("Hello, world!");
}

运行程序

cargo run

输出：

Hello, world!

Rust 基础语法

变量与可变性

fn main() {
    // 不可变变量（默认）
    let x = 5;
    println!("x 的值是: {}", x);
    
    // 可变变量
    let mut y = 10;
    println!("y 的值是: {}", y);
    y = 20;
    println!("y 的新值是: {}", y);
    
    // 常量
    const MAX_POINTS: u32 = 100_000;
    println!("最大点数: {}", MAX_POINTS);
    
    // 遮蔽（Shadowing）
    let x = x + 1;
    println!("x 加 1 后: {}", x);
    
    let x = "hello";
    println!("x 现在是: {}", x);
}

数据类型

fn main() {
    // 标量类型
    
    // 整数
    let small: i8 = 127;
    let medium: i32 = 5000;
    let large: i64 = 1_000_000;
    let unsigned: u32 = 100;
    
    // 浮点数
    let float1: f32 = 3.14;
    let float2: f64 = 2.718281828;
    
    // 布尔值
    let is_active: bool = true;
    let is_greater: bool = 10 > 5;
    
    // 字符类型
    let c: char = 'z';
    let emoji: char = '😊';
    
    // 复合类型
    
    // 元组
    let tup: (i32, f64, u8) = (500, 6.4, 1);
    let (x, y, z) = tup;  // 解构
    let first = tup.0;    // 通过索引访问
    
    // 数组
    let arr = [1, 2, 3, 4, 5];
    let first = arr[0];
    let second = arr[1];
}

函数

fn main() {
    println!("调用 greet 函数:");
    greet();
    
    let sum = add(5, 10);
    println!("5 + 10 = {}", sum);
    
    let result = multiply(3, 4);
    println!("3 * 4 = {}", result);
    
    // 表达式与语句
    let y = {
        let x = 3;
        x + 1  // 注意：没有分号，这是一个表达式
    };
    println!("y 的值是: {}", y);
}

// 无参数无返回值
fn greet() {
    println!("Hello, Rust!");
}

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

// 带返回值的函数
fn multiply(a: i32, b: i32) -> i32 {
    return a * b;  // 早期返回需要 return 关键字
}

注释

fn main() {
    // 单行注释
    
    /*
     * 多行注释
     * 可以跨越多行
     */
    
    /// 文档注释（用于函数、结构体等）
    /// 这是一个计算平方的函数
    /// 
    /// # 参数
    /// 
    /// * `x` - 要计算平方的数字
    /// 
    /// # 返回值
    /// 
    /// 返回 x 的平方
    fn square(x: i32) -> i32 {
        x * x
    }
    
    let result = square(5);
    println!("5 的平方是: {}", result);
}

控制流初步

if 表达式

fn main() {
    let number = 6;
    
    if number < 5 {
        println!("条件为真");
    } else {
        println!("条件为假");
    }
    
    // if 表达式可以赋值
    let condition = true;
    let number = if condition { 5 } else { 6 };
    
    println!("number 的值是: {}", number);
}

循环

fn main() {
    // loop 无限循环
    let mut count = 0;
    loop {
        println!("count = {}", count);
        count += 1;
        if count == 5 {
            break;  // 跳出循环
        }
    }
    
    // while 循环
    let mut number = 3;
    while number != 0 {
        println!("{}!", number);
        number -= 1;
    }
    println!("LIFTOFF!!!");
    
    // for 循环
    let a = [10, 20, 30, 40, 50];
    for element in a.iter() {
        println!("值是: {}", element);
    }
    
    // 使用范围
    for number in (1..4).rev() {
        println!("{}!", number);
    }
    println!("LIFTOFF!!!");
}

Cargo 工具

常用命令

# 创建新项目
cargo new project_name

# 构建项目（发布版本）
cargo build --release

# 运行项目
cargo run

# 检查代码（不生成二进制文件）
cargo check

# 更新依赖
cargo update

# 运行测试
cargo test

# 生成文档
cargo doc --open

# 运行 Clippy（代码检查工具）
cargo clippy

# 格式化代码
cargo fmt

Cargo.toml 配置

[package]
name = "my_project"
version = "0.1.0"
edition = "2021"
authors = ["Your Name <your.email@example.com>"]

[dependencies]
# 添加依赖
serde = "1.0"
rand = "0.8"

[dev-dependencies]
# 开发依赖
test-case = "2.0"

[profile.release]
opt-level = 3  # 优化级别

总结

本教程介绍了 Rust 的基本概念和基础语法：

  1. Rust 是一门安全、高效的系统编程语言

  2. 使用 rustup 安装 Rust 工具链

  3. cargo 是 Rust 的包管理和构建工具

  4. Rust 的变量默认不可变，通过 mut 关键字声明可变变量

  5. Rust 丰富的类型系统：整型、浮点型、布尔型、字符型、元组、数组

  6. 使用 fn 关键字定义函数

  7. 控制流：if 表达式、loop、while、for 循环

下一步

在下一教程中，我们将深入学习 Rust 的数据类型和更复杂的控制流结构，包括：

  • match 表达式

  • 结构体

  • 枚举

  • Option 和 Result 类型

继续学习 Rust，探索这门强大语言的更多特性！