📚 第2章：环境搭建与工具

本章目标

通过本章学习，你将掌握： - Rust开发环境的安装和配置 - Cargo包管理器的使用 - 常用开发工具和IDE配置 - Rust工具链的管理 - 创建和管理Rust项目

2.1 安装Rust

使用Rustup安装（推荐）

Rustup是Rust的官方工具链管理器，可以轻松安装和管理Rust版本。

Windows安装

# 下载并运行rustup-init.exe
# 或者使用PowerShell
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

macOS/Linux安装

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

加载环境

. "$HOME/.cargo/env"

验证安装

# 检查Rust版本
rustc --version

# 检查Cargo版本
cargo --version

# 检查Rustup版本
rustup --version

安装验证程序

fn main() {
    println!("🦀 Rust安装验证");
    println!("==================");
    
    // 检查编译器版本
    println!("✅ Rust编译器工作正常！");
    
    // 检查标准库
    let version = std::env!("CARGO_PKG_VERSION");
    println!("📦 标准库版本: {}", version);
    
    // 检查基本功能
    let numbers = vec![1, 2, 3, 4, 5];
    let sum: i32 = numbers.iter().sum();
    println!("🔢 基本计算: 1+2+3+4+5 = {}", sum);
    
    // 检查字符串处理
    let greeting = "Hello, Rust!";
    println!("📝 字符串处理: {}", greeting.to_uppercase());
    
    println!("🎉 恭喜！Rust环境安装成功！");
}

export CARGO_PKG_VERSION="1.90.0"
rustc installation_check.rs && ./installation_check

2.2 Rustup工具链管理

基本命令

# 更新Rust到最新稳定版
rustup update

# 查看已安装的工具链
rustup toolchain list

# 安装特定版本
rustup toolchain install 1.70.0

# 设置默认工具链
rustup default stable

# 查看当前工具链
rustup show

# 设置黎明版
rustup default nightly
#确保项目使用的是这个最新的 nightly 版本
rustup override set nightly
#更新依赖项
cargo update

工具链管理示例

fn main() {
    println!("🔧 Rust工具链信息");
    println!("==================");
    
    // 编译器信息
    println!("编译器版本: {}", env!("RUSTC_VERSION"));
    
    // 目标平台
    println!("目标平台: {}", std::env::consts::ARCH);
    println!("操作系统: {}", std::env::consts::OS);
    
    // 编译配置
    #[cfg(debug_assertions)]
    println!("构建模式: Debug");
    
    #[cfg(not(debug_assertions))]
    println!("构建模式: Release");
    
    println!("指针大小: {} bytes", std::mem::size_of::<usize>());
}

export RUSTC_VERSION="1.90.0"
rustc toolchain_info.rs && ./toolchain_info

组件管理

# 安装组件
rustup component add rustfmt      # 代码格式化工具
rustup component add clippy       # 代码检查工具
rustup component add rust-docs    # 离线文档
rustup component add rust-src     # 源代码（用于IDE）

# 查看可用组件
rustup component list

# 查看已安装组件
rustup component list --installed

2.3 Cargo包管理器

Cargo简介

Cargo是Rust的构建系统和包管理器，提供以下功能： - 项目创建和管理 - 依赖管理 - 编译和构建 - 测试运行 - 文档生成 - 包发布

创建新项目

# 创建二进制项目
cargo new hello_cargo
cd hello_cargo

# 创建库项目
cargo new my_library --lib

# 在现有目录初始化项目
cargo init

项目结构

use std::fs;

fn main() {
    println!("📁 Rust项目结构");
    println!("==================");
    
    let structure = r#"
my_project/
├── Cargo.toml          # 项目配置文件
├── Cargo.lock          # 依赖锁定文件
├── src/                # 源代码目录
│   ├── main.rs         # 主程序入口
│   ├── lib.rs          # 库入口（库项目）
│   └── bin/            # 额外的二进制文件
├── tests/              # 集成测试
├── examples/           # 示例代码
├── benches/            # 性能测试
└── target/             # 编译输出目录
    ├── debug/          # Debug构建
    └── release/        # Release构建
"#;
    
    println!("{}", structure);
}

rustc project_structure.rs && ./project_structure

Cargo.toml配置文件

fn main() {
    println!("📋 Cargo.toml配置示例");
    println!("========================");
    
    let toml_example = r#"
[package]
name = "my_awesome_project"     # 项目名称
version = "0.1.0"               # 版本号
edition = "2021"                # Rust版本
authors = ["Your Name <email@example.com>"]
license = "MIT"                 # 许可证
description = "一个很棒的Rust项目"
homepage = "https://github.com/user/repo"
repository = "https://github.com/user/repo"
readme = "README.md"
keywords = ["cli", "tool"]
categories = ["command-line-utilities"]

[dependencies]
serde = "1.0"                   # 序列化库
tokio = { version = "1.0", features = ["full"] }
clap = "4.0"                    # 命令行解析

[dev-dependencies]
proptest = "1.0"               # 属性测试

[build-dependencies]
cc = "1.0"                      # C编译器绑定

[[bin]]
name = "my_tool"
path = "src/bin/tool.rs"
"#;
    
    println!("{}", toml_example);
}

rustc cargo_toml_example.rs && ./cargo_toml_example

常用Cargo命令

# 构建项目
cargo build                    # Debug构建
cargo build --release          # Release构建

# 运行项目
cargo run                      # 运行主程序
cargo run --bin my_tool        # 运行指定二进制
cargo run --example demo       # 运行示例

# 检查代码
cargo check                    # 快速检查（不生成可执行文件）
cargo clippy                   # 代码检查和建议
cargo fmt                      # 代码格式化

# 测试
cargo test                     # 运行所有测试
cargo test unit_tests          # 运行特定测试
cargo bench                    # 运行性能测试

# 文档
cargo doc                      # 生成文档
cargo doc --open               # 生成并打开文档

# 清理
cargo clean                    # 清理构建文件

# 发布
cargo publish                  # 发布到crates.io

安装目标平台Linux

rustup target add x86_64-unknown-linux-gnu
#windows
rustup target add  x86_64-pc-windows-msvc
rustup target list --installed

#指定编译目标
cargo build --target x86_64-unknown-linux-gnu

#设置默认目标
rustup default stable-x86_64-unknown-linux-gnu

Cargo工作空间

fn main() {
    println!("🏢 Cargo工作空间示例");
    println!("=====================");
    
    let workspace_structure = r#"
my_workspace/
├── Cargo.toml              # 工作空间配置
├── frontend/               # 前端项目
│   ├── Cargo.toml
│   └── src/
├── backend/                # 后端项目
│   ├── Cargo.toml
│   └── src/
├── shared/                 # 共享库
│   ├── Cargo.toml
│   └── src/
└── target/                 # 共享构建目录
"#;
    
    println!("{}", workspace_structure);
    
    let workspace_toml = r#"
# 根目录的Cargo.toml
[workspace]
members = [
    "frontend",
    "backend",
    "shared",
]

[workspace.dependencies]
serde = "1.0"
tokio = "1.0"
"#;
    
    println!("\n📄 工作空间配置:");
    println!("{}", workspace_toml);
}

rustc workspace_example.rs && ./workspace_example

2.4 开发工具

Rustfmt - 代码格式化

# 格式化当前项目
cargo fmt

# 检查格式但不修改
cargo fmt -- --check

# 格式化特定文件
rustfmt src/main.rs

配置rustfmt

fn main() {
    println!("🎨 Rustfmt配置示例");
    println!("==================");
    
    let config_example = r#"
# rustfmt.toml
max_width = 100                 # 最大行宽
tab_spaces = 4                  # 缩进空格数
newline_style = "Unix"          # 换行符风格
use_small_heuristics = "Default" # 启发式格式化
reorder_imports = true          # 重排导入
reorder_modules = true          # 重排模块
remove_nested_parens = true     # 移除嵌套括号
"#;
    
    println!("{}", config_example);
}

rustc rustfmt_config.rs && ./rustfmt_config

Clippy - 代码检查

# 运行Clippy检查
cargo clippy

# 将警告视为错误
cargo clippy -- -D warnings

# 修复可自动修复的问题
cargo clippy --fix

Clippy示例

#![warn(clippy::all)]

fn main() {
    println!("🔍 Clippy代码检查示例");
    println!("=====================");
    
    // Clippy会建议改进的代码
    let mut vec = Vec::new();
    vec.push(1);
    vec.push(2);
    vec.push(3);
    // Clippy建议: 使用 vec![1, 2, 3]
    
    // 字符串比较
    let name = "Rust";
    if name == "Rust" {
        println!("这是Rust!");
    }
    
    // 循环优化
    let numbers = vec![1, 2, 3, 4, 5];
    for i in 0..numbers.len() {
        println!("{}", numbers[i]);
    }
    // Clippy建议: 使用 for number in &numbers
    
    println!("运行 'cargo clippy' 查看建议！");
}

rustc clippy_example.rs && ./clippy_example

Rust-analyzer - 语言服务器

Rust-analyzer提供IDE功能： - 语法高亮 - 代码补全 - 错误检查 - 重构支持 - 跳转定义

# 安装rust-analyzer
rustup component add rust-analyzer

2.5 IDE和编辑器配置

Visual Studio Code

推荐插件： - rust-analyzer: 官方Rust语言支持 - CodeLLDB: 调试支持 - Better TOML: TOML文件支持 - Error Lens: 内联错误显示

VS Code配置示例

fn main() {
    println!("💻 VS Code配置示例");
    println!("==================");
    
    let settings_json = r#"
// settings.json
{
    "rust-analyzer.checkOnSave.command": "clippy",
    "rust-analyzer.cargo.buildScripts.enable": true,
    "rust-analyzer.procMacro.enable": true,
    "editor.formatOnSave": true,
    "[rust]": {
        "editor.defaultFormatter": "rust-lang.rust-analyzer"
    }
}
"#;
    
    println!("{}", settings_json);
}

rustc vscode_config.rs && ./vscode_config

IntelliJ IDEA / CLion

安装插件： - Rust: JetBrains官方Rust插件

Vim/Neovim

推荐插件： - rust.vim: Rust语法支持 - coc-rust-analyzer: 通过CoC使用rust-analyzer

Emacs

推荐包： - rust-mode: Rust语法支持 - lsp-mode: 语言服务器协议支持

2.6 调试工具

使用GDB调试

# 编译带调试信息的程序
cargo build

# 使用GDB调试
gdb target/debug/my_program

使用LLDB调试

# 使用LLDB调试
lldb target/debug/my_program

调试示例程序

fn main() {
    println!("🐛 调试示例程序");
    println!("===============");
    
    let numbers = vec![1, 2, 3, 4, 5];
    
    for (index, number) in numbers.iter().enumerate() {
        println!("索引 {}: 值 {}", index, number);
        
        // 设置断点的好位置
        if *number == 3 {
            println!("找到数字3！");
        }
    }
    
    let result = calculate_sum(&numbers);
    println!("总和: {}", result);
}

fn calculate_sum(numbers: &[i32]) -> i32 {
    let mut sum = 0;
    for number in numbers {
        sum += number;  // 另一个断点位置
    }
    sum
}

rustc -g debug_example.rs && ./debug_example

2.7 性能分析工具

Cargo Flamegraph

# 安装flamegraph
cargo install flamegraph

# 生成火焰图
cargo flamegraph

Criterion - 性能测试

use std::time::Instant;

fn fibonacci(n: u32) -> u32 {
    match n {
        0 => 0,
        1 => 1,
        _ => fibonacci(n - 1) + fibonacci(n - 2),
    }
}

fn fibonacci_iterative(n: u32) -> u32 {
    if n <= 1 {
        return n;
    }
    
    let mut a = 0;
    let mut b = 1;
    
    for _ in 2..=n {
        let temp = a + b;
        a = b;
        b = temp;
    }
    
    b
}

fn main() {
    println!("⚡ 性能测试示例");
    println!("===============");
    
    let n = 30;
    
    // 测试递归版本
    let start = Instant::now();
    let result1 = fibonacci(n);
    let duration1 = start.elapsed();
    
    // 测试迭代版本
    let start = Instant::now();
    let result2 = fibonacci_iterative(n);
    let duration2 = start.elapsed();
    
    println!("递归版本: fibonacci({}) = {}, 耗时: {:?}", n, result1, duration1);
    println!("迭代版本: fibonacci({}) = {}, 耗时: {:?}", n, result2, duration2);
    
    let speedup = duration1.as_nanos() as f64 / duration2.as_nanos() as f64;
    println!("迭代版本快 {:.2} 倍", speedup);
}

rustc -O benchmark_example.rs && ./benchmark_example

2.8 文档工具

生成文档

# 生成项目文档
cargo doc

# 生成并打开文档
cargo doc --open

# 包含私有项目
cargo doc --document-private-items

文档注释示例

/// 计算两个数的最大公约数
/// 
/// # 参数
/// 
/// * `a` - 第一个数
/// * `b` - 第二个数
/// 
/// # 返回值
/// 
/// 返回两个数的最大公约数
/// 
/// # 示例
/// 
/// ```
/// let result = gcd(48, 18);
/// assert_eq!(result, 6);
/// ```
fn gcd(mut a: u32, mut b: u32) -> u32 {
    while b != 0 {
        let temp = b;
        b = a % b;
        a = temp;
    }
    a
}

/// 数学工具模块
/// 
/// 提供常用的数学计算函数
pub mod math_utils {
    /// 计算阶乘
    /// 
    /// # 参数
    /// 
    /// * `n` - 要计算阶乘的数
    /// 
    /// # 示例
    /// 
    /// ```
    /// use documentation_example::math_utils::factorial;
    /// assert_eq!(factorial(5), 120);
    /// ```
    pub fn factorial(n: u32) -> u32 {
        match n {
            0 | 1 => 1,
            _ => n * factorial(n - 1),
        }
    }
}

fn main() {
    println!("📚 文档示例");
    println!("============");
    
    let result = gcd(48, 18);
    println!("gcd(48, 18) = {}", result);
    
    let fact = math_utils::factorial(5);
    println!("5! = {}", fact);
    
    println!("运行 'cargo doc --open' 查看生成的文档！");
}

rustc documentation_example.rs && ./documentation_example

2.9 包管理和发布

搜索包

# 在crates.io搜索包
cargo search serde

# 查看包信息
cargo info serde

发布包

# 登录crates.io
cargo login

# 检查包
cargo package

# 发布包
cargo publish

版本管理

fn main() {
    println!("📦 版本管理示例");
    println!("===============");
    
    let version_examples = r#"
# 依赖版本指定方式

[dependencies]
# 精确版本
serde = "=1.0.136"

# 兼容版本（默认）
tokio = "1.0"          # 等同于 "^1.0"

# 波浪号要求
rand = "~1.0.5"        # >=1.0.5, <1.1.0

# 通配符
log = "0.4.*"          # 0.4.x的任意版本

# 范围
clap = ">= 2.0, < 4.0" # 2.0到4.0之间

# Git依赖
my_crate = { git = "https://github.com/user/repo" }

# 本地依赖
local_crate = { path = "../local_crate" }

# 可选依赖
optional_dep = { version = "1.0", optional = true }
"#;
    
    println!("{}", version_examples);
}

rustc version_management.rs && ./version_management

2.10 环境变量和配置

重要的环境变量

use std::env;

fn main() {
    println!("🌍 Rust环境变量");
    println!("===============");
    
    // 显示重要的Rust环境变量
    let vars = [
        ("RUSTC", "Rust编译器路径"),
        ("CARGO_HOME", "Cargo主目录"),
        ("RUSTUP_HOME", "Rustup主目录"),
        ("RUST_LOG", "日志级别"),
        ("RUST_BACKTRACE", "错误回溯"),
        ("RUSTFLAGS", "编译器标志"),
    ];
    
    for (var, description) in &vars {
        match env::var(var) {
            Ok(value) => println!("{}: {} = {}", var, description, value),
            Err(_) => println!("{}: {} = (未设置)", var, description),
        }
    }
    
    println!("\n💡 有用的设置:");
    println!("export RUST_BACKTRACE=1     # 显示详细错误信息");
    println!("export RUST_LOG=debug       # 启用调试日志");
    println!("export RUSTFLAGS='-C target-cpu=native'  # 优化本机CPU");
}

rustc environment_vars.rs && ./environment_vars

Cargo配置文件

fn main() {
    println!("⚙️ Cargo配置示例");
    println!("=================");
    
    let config_example = r#"
# ~/.cargo/config.toml 或 .cargo/config.toml

[build]
target-dir = "target"           # 构建目录
jobs = 4                        # 并行任务数
rustflags = ["-C", "target-cpu=native"]

[cargo-new]
name = "Your Name"
email = "your.email@example.com"
vcs = "git"                     # 版本控制系统

[registry]
default = "crates-io"

[registries.crates-io]
index = "https://github.com/rust-lang/crates.io-index"

[source.crates-io]
replace-with = "tuna"           # 使用清华镜像

[source.tuna]
registry = "https://mirrors.tuna.tsinghua.edu.cn/git/crates.io-index.git"

[target.x86_64-unknown-linux-gnu]
linker = "clang"
rustflags = ["-C", "link-arg=-fuse-ld=lld"]
"#;
    
    println!("{}", config_example);
}

rustc cargo_config.rs && ./cargo_config

2.11 第一个完整项目

让我们创建一个完整的示例项目来验证环境配置：

use std::io;
use std::collections::HashMap;

/// 简单的任务管理器
struct TaskManager {
    tasks: HashMap<u32, String>,
    next_id: u32,
}

impl TaskManager {
    /// 创建新的任务管理器
    fn new() -> Self {
        TaskManager {
            tasks: HashMap::new(),
            next_id: 1,
        }
    }
    
    /// 添加任务
    fn add_task(&mut self, description: String) -> u32 {
        let id = self.next_id;
        self.tasks.insert(id, description);
        self.next_id += 1;
        id
    }
    
    /// 列出所有任务
    fn list_tasks(&self) {
        if self.tasks.is_empty() {
            println!("没有任务");
            return;
        }
        
        println!("任务列表:");
        for (id, description) in &self.tasks {
            println!("{}: {}", id, description);
        }
    }
    
    /// 完成任务
    fn complete_task(&mut self, id: u32) -> bool {
        self.tasks.remove(&id).is_some()
    }
}

fn main() {
    println!("📋 简单任务管理器");
    println!("==================");
    
    let mut task_manager = TaskManager::new();
    
    loop {
        println!("\n选择操作:");
        println!("1. 添加任务");
        println!("2. 列出任务");
        println!("3. 完成任务");
        println!("4. 退出");
        print!("请输入选择 (1-4): ");
        
        let mut input = String::new();
        io::stdin().read_line(&mut input).expect("读取输入失败");
        
        match input.trim() {
            "1" => {
                print!("输入任务描述: ");
                let mut description = String::new();
                io::stdin().read_line(&mut description).expect("读取输入失败");
                let id = task_manager.add_task(description.trim().to_string());
                println!("任务已添加，ID: {}", id);
            }
            "2" => {
                task_manager.list_tasks();
            }
            "3" => {
                print!("输入要完成的任务ID: ");
                let mut id_input = String::new();
                io::stdin().read_line(&mut id_input).expect("读取输入失败");
                
                match id_input.trim().parse::<u32>() {
                    Ok(id) => {
                        if task_manager.complete_task(id) {
                            println!("任务 {} 已完成", id);
                        } else {
                            println!("任务 {} 不存在", id);
                        }
                    }
                    Err(_) => println!("无效的ID"),
                }
            }
            "4" => {
                println!("再见！");
                break;
            }
            _ => {
                println!("无效选择，请重试");
            }
        }
    }
}

rustc first_project.rs && ./first_project

本章小结

通过本章学习，你应该掌握了：

• ✅ Rust安装: 使用Rustup安装和管理Rust工具链
• ✅ Cargo使用: 项目创建、依赖管理、构建和测试
• ✅ Cargo使用: 项目创建、依赖管理、构建和测试
• ✅ 开发工具: rustfmt、clippy、rust-analyzer等工具的使用
• ✅ IDE配置: 各种编辑器和IDE的Rust开发环境配置
• ✅ 调试和性能: 调试工具和性能分析工具的使用
• ✅ 文档生成: 编写文档注释和生成项目文档
• ✅ 环境配置: 环境变量和配置文件的设置

下一章预告

在下一章《基本语法》中，我们将：

• 学习Rust的变量和可变性
• 掌握Rust的数据类型系统
• 了解函数定义和调用
• 学习控制流语句
• 理解Rust的表达式和语句

练习题

练习1：环境验证

创建一个新的Cargo项目，编写程序输出当前Rust版本和编译器信息。

练习2：依赖管理

创建一个项目，添加serde和serde_json依赖，编写程序序列化和反序列化一个简单的结构体。

练习3：工具使用

对你的代码运行cargo fmt、cargo clippy和cargo doc，观察输出结果。

练习4：配置优化

配置你的开发环境，包括IDE插件安装和Cargo配置文件设置。

---

恭喜你完成了环境搭建！ 🎉

现在你已经拥有了一个完整的Rust开发环境，让我们开始学习Rust的基本语法吧！