工具链与第一个 Cargo 项目

一句话总结

Rust 的工具链由 rustup(版本管理),cargo(构建与依赖),rustc(编译器)三件套构成.
cargo 一个工具就覆盖了 Go 里 go build / go run / go test / go mod 的全部职责.
本篇装好环境,跑通第一个项目,并看懂工程结构.

安装工具链:rustup

Rust 官方推荐用 rustup 安装和管理工具链.它类似 Go 的版本管理器,但更核心--几乎所有 Rust 开发者都用它.一条命令搞定:

# macOS / Linux:官方安装脚本
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# 安装后让环境变量生效(或重开终端)
source "$HOME/.cargo/env"

# 验证三件套
rustc --version   # 编译器
cargo --version   # 构建工具
rustup --version  # 工具链管理器

工具	职责	Go 类比
`rustup`	安装/切换 Rust 版本,管理目标平台与组件	类似 `gvm`,但更官方,更常用
`cargo`	构建,运行,测试,管理依赖,发布	`go` 命令的全部子命令
`rustc`	底层编译器,通常由 cargo 间接调用	`compile`,很少直接碰

两个该一起装的辅助组件

rustup component add clippy rustfmt

Clippy 是 Rust 的官方 lint 工具(比 Go vet 强大得多,会给出地道写法建议),rustfmt 是代码格式化器(对应 gofmt).后面会用到.

第一个项目:cargo new

不要手动创建文件,用 cargo new 生成标准项目骨架:

cargo new hello        # 创建一个二进制(可执行)项目
cd hello
cargo run              # 编译并运行

输出 Hello, world!.cargo new 生成的目录结构:

hello/
  ├── Cargo.toml        ← 项目清单(类似 go.mod)
  ├── Cargo.lock        ← 锁定依赖精确版本(类似 go.sum)
  └── src/
      └── main.rs       ← 程序入口,含 fn main()

入口文件 src/main.rs 内容极简:

fn main() {
    println!("Hello, world!"); // println! 末尾的 ! 表示它是宏,不是函数
}

为什么 println! 带个感叹号

println! 是宏(macro) 而非函数,! 是宏调用的标志.宏在编译期展开,能做函数做不到的事--比如接受任意数量,任意类型的参数并做格式检查.

现在记住"带 ! 的是宏"即可,宏的原理在进阶系列展开.常见的还有 format!,vec!,panic!.

核心 cargo 命令

日常开发就围绕这几条命令,几乎和 go 一一对应:

命令	作用	Go 对应
`cargo run`	编译并运行	`go run`
`cargo build`	仅编译(产物在 `target/debug/`)	`go build`
`cargo build --release`	优化编译(产物在 `target/release/`)	`go build -ldflags` 等
`cargo check`	只做类型检查,不生成可执行文件(快)	`go vet` 偏类型部分
`cargo test`	运行测试	`go test`
`cargo add <crate>`	添加依赖到 Cargo.toml	`go get`
`cargo fmt`	格式化代码	`gofmt`
`cargo clippy`	lint 检查	`go vet` / golangci-lint

最佳实践:开发时多用 cargo check

Rust 编译(尤其生成可执行文件)比 Go 慢.开发中频繁验证代码是否通过编译时,用 cargo check 而非 cargo build--它跳过代码生成,只做类型与借用检查,快得多.

配合编辑器的 rust-analyzer,几乎能即时反馈错误.

读懂 Cargo.toml

Cargo.toml 是项目清单,对应 Go 的 go.mod,但用 TOML 格式,信息更丰富:

[package]
name = "hello"
version = "0.1.0"
edition = "2021"      # Rust 版本纪元,见下方说明

[dependencies]
# 依赖写在这里,例如:
# serde = { version = "1.0", features = ["derive"] }
# tokio = { version = "1", features = ["full"] }

用 cargo add 添加依赖最省心,它会自动写好版本号:

cargo add serde --features derive
# 自动在 [dependencies] 写入 serde = { version = "...", features = ["derive"] }

edition 是什么:不是版本号

edition(纪元,如 2015 / 2018 / 2021 / 2024)容易和 Rust 版本号混淆.它是语言的兼容性档位:同一个编译器能编译不同 edition 的代码,新 edition 引入一些语法改进但不破坏旧代码.新项目用最新的稳定 edition 即可.

Go 没有完全对应的概念,最接近的是 go.mod 里的 go 1.xx 语言版本声明.

crates.io 与生态

Rust 的第三方库叫 crate,中央仓库是 crates.io(类比 Go 的模块生态 + pkg.go.dev).文档站 docs.rs 为每个发布的 crate 自动生成 API 文档--这是查阅库用法的主要去处.

cargo 之于 Rust,就像 go 命令 + npm 的合体:既管编译运行,又管依赖拉取与版本锁定.
比起 Go 把功能分散在多个子命令,Rust 的工程工具更集中统一,上手成本低.

编辑器与 rust-analyzer

强烈建议配置 rust-analyzer(官方语言服务器,LSP).它提供实时错误提示,类型推断显示,自动补全,跳转定义--对 Rust 这种类型系统复杂的语言,几乎是"刚需".VS Code 装同名扩展即可,JetBrains 系用 RustRover.

为什么对 Rust 尤其重要

Rust 的很多类型是推断出来的(let x = ... 不写类型),借用错误也常需要"看到编译器怎么想".

rust-analyzer 能把推断出的类型直接显示在代码里(inlay hints),让写代码时就理解所有权与类型的流动,而不必等编译报错.

快速回顾

三件套:rustup 管版本,cargo 管工程,rustc 是底层编译器.
cargo 一统天下:run / build / check / test / add / fmt / clippy,覆盖 Go 多个子命令的职责.
项目骨架:cargo new 生成 Cargo.toml + Cargo.lock + src/main.rs.
开发提速:频繁验证用 cargo check,比 build 快;配合 rust-analyzer 即时反馈.
edition:语言兼容档位,不是版本号;新项目用最新稳定 edition.
生态:crate 来自 crates.io,文档查 docs.rs;println! 等带 ! 的是宏.

动手练习

安装验证:用 rustup 安装工具链,确认 rustc,cargo 版本,并加装 clippy 与 rustfmt 组件.
创建项目:用 cargo new 建项目,跑通 cargo run,观察 target/ 目录的产生.
类型检查对比:修改 main.rs 故意制造一个类型错误,分别用 cargo check 和 cargo build 体会反馈速度差异.
添加依赖:用 cargo add 添加一个依赖(如 rand),观察 Cargo.toml 与 Cargo.lock 的变化.
Clippy 体验:故意写一段不地道的代码(如多余的 return),运行 cargo clippy,看它给出什么建议.