快速上手 Rust Cargo：你的第一个Rust项目 – wiki基地

作者： /

快速上手 Rust Cargo：你的第一个 Rust 项目

前言：踏入 Rust 世界的大门

恭喜你决定探索 Rust 这门令人兴奋的系统级编程语言！Rust 以其强大的性能、可靠的安全性和出色的并发支持而闻名，但很多初学者可能会觉得它的学习曲线有些陡峭。别担心，好的工具能够事半功倍。在 Rust 的生态系统中，有一个无处不在的伙伴——Cargo。

Cargo 是 Rust 的构建系统和包管理器，它是 Rust 开发工作流程的核心。从创建新项目、管理依赖、构建代码、运行测试，到生成文档和发布库，Cargo 几乎包办了你在 Rust 开发中需要处理的所有基础事务。掌握 Cargo，就等于抓住了学习 Rust 的关键钥匙。

本文将带你从零开始，详细讲解如何利用 Cargo 创建你的第一个 Rust 项目，并深入了解 Cargo 的基本用法和项目结构。读完本文，你将能够：

  1. 成功安装 Rust 和 Cargo。
  2. 使用 Cargo 创建一个全新的 Rust 项目。
  3. 理解 Rust 项目的基本文件结构。
  4. 认识并编辑项目的核心配置文件 Cargo.toml。
  5. 使用 Cargo 构建、运行和检查你的代码。
  6. 学习如何添加和使用外部库（依赖）。
  7. 了解 Cargo 的其他一些常用功能。

准备好了吗？让我们开始你的 Rust 冒险之旅吧！

第一步：安装 Rust 和 Cargo

Rust 的安装非常简单，官方推荐使用 rustup 工具链安装器。rustup 可以帮助你安装、管理和更新 Rust 的编译器（rustc）和 Cargo，以及其他相关的工具。

对于 Linux 或 macOS 用户：

打开终端，输入以下命令并按回车：

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

这个命令会下载并运行一个脚本，该脚本会安装 rustup，然后通过 rustup 安装 Rust 的最新稳定版本。脚本会引导你完成安装过程，通常选择默认安装即可。安装完成后，脚本会提示你需要将 Cargo 的 bin 目录（通常是 $HOME/.cargo/bin）添加到系统的 PATH 环境变量中。通常情况下，脚本会为你自动完成这一步，但如果遇到问题，你可能需要手动配置。按照脚本的指示进行即可。

对于 Windows 用户：

访问 Rust 官方安装页面：https://www.rust-lang.org/tools/install。下载 rustup-init.exe 安装程序并运行。运行安装程序后，同样选择默认安装即可。安装程序会自动配置 PATH 环境变量。

验证安装：

安装完成后，关闭并重新打开你的终端或命令行窗口（这是为了确保 PATH 环境变量生效）。输入以下命令来验证 Rust 和 Cargo 是否安装成功：

bash
rustc --version
cargo --version

如果看到类似如下的输出（版本号可能不同），说明你已经成功安装了 Rust 和 Cargo：

rustc x.y.z (abcde 2023-xx-yy)
cargo x.y.z (abcde 2023-xx-yy)

现在，你已经拥有了 Rust 开发环境，包括强大的 Cargo！

第二步：什么是 Cargo？为什么使用 Cargo？

在开始创建项目之前，花点时间了解一下 Cargo 是什么以及它为什么如此重要。

什么是 Cargo？

Cargo 是 Rust 的官方包管理器和构建工具。在其他语言中，你可能见过类似工具，比如 Node.js 的 npm/yarn、Python 的 pip、Ruby 的 Bundler、Java 的 Maven/Gradle 等。Cargo 在 Rust 生态系统中的地位与这些工具类似，但它不仅仅是一个包管理器，它还负责：

  • 创建新项目： 快速生成标准化的项目骨架。
  • 管理依赖： 声明项目依赖的第三方库（称为 “crates”），Cargo 会负责下载、构建和更新它们。
  • 构建代码： 编译你的 Rust 源代码。
  • 运行程序： 编译并执行你的项目。
  • 运行测试： 发现并执行项目中的测试函数。
  • 生成文档： 从代码中的注释生成 HTML 文档。
  • 检查代码： 快速检查代码是否存在编译错误，而无需生成可执行文件。
  • 发布库： 将你的 Rust 库发布到官方 crate 注册中心 crates.io，供其他人使用。

为什么强烈推荐使用 Cargo？

  • 标准化： Cargo 定义了 Rust 项目的标准布局和构建流程，使得 Rust 项目易于理解和协作。
  • 依赖管理： 自动处理库的下载、版本冲突和编译，极大地简化了使用第三方库的过程。
  • 构建自动化： 屏蔽了复杂的编译器参数和构建命令，只需简单的 cargo build 或 cargo run。
  • 社区生态： Cargo 与官方 crate 注册中心 crates.io 紧密集成，让你轻松访问和利用数万个高质量的 Rust 库。
  • 提高效率： 快速创建项目、便捷管理依赖、自动化构建流程，都大大提高了开发效率。

简而言之，开发 Rust 项目，始终 使用 Cargo 是最佳实践。

第三步：你的第一个 Rust 项目 – 使用 Cargo 创建

现在，让我们使用 Cargo 创建你的第一个 Rust 项目。打开你的终端或命令行窗口，导航到你想要创建项目的目录。然后输入以下命令：

bash
cargo new my-first-project

按下回车后，你应该会看到类似如下的输出：

Created binary (application) `my-first-project` package

这条消息告诉你，Cargo 已经成功创建了一个名为 my-first-project 的新的二进制（application）项目。

项目类型：

  • cargo new <project_name> 默认创建一个二进制项目（可执行程序）。
  • 如果你想创建一个库项目（供其他项目使用的代码库），可以使用 cargo new <library_name> --lib。

在本篇文章中，我们专注于二进制项目，因为它更直观，可以直接运行。

第四步：探索项目结构

Cargo 创建的项目遵循一个标准的目录布局。进入刚刚创建的 my-first-project 目录：

bash
cd my-first-project

然后查看目录内容（在 Linux/macOS 上使用 ls -la，在 Windows 上使用 dir）：

my-first-project/
├── .git/ (可选，如果你的系统配置了 Git)
├── .gitignore
├── Cargo.toml
└── src/
└── main.rs

让我们逐一了解这些文件和目录的含义：

  • .git/: 如果你的系统安装并配置了 Git，Cargo 会默认初始化一个新的 Git 仓库。这是一个好习惯，建议保留。
  • .gitignore: 一个 Git 配置文件，告诉 Git 哪些文件和目录应该被忽略，不添加到版本控制中。Cargo 默认生成一个.gitignore 文件，通常包含构建输出目录 target/。
  • Cargo.toml: 这是项目的清单文件。它是 Cargo 理解你的项目、如何构建它以及它依赖哪些库的核心文件。这是我们稍后将重点探索的文件。
  • src/: 这个目录是存放项目源代码的地方。Cargo 约定：
    • 对于二进制项目，入口文件是 src/main.rs。
    • 对于库项目，入口文件是 src/lib.rs。
  • src/main.rs: 这是你的第一个 Rust 程序文件。Cargo 默认为你生成了一个简单的 “Hello, world!” 程序。

第五步：理解 Cargo.toml 文件

打开 my-first-project/Cargo.toml 文件。你可以使用任何文本编辑器打开它，例如 VS Code、Sublime Text、Notepad++，或者在终端中使用 cat Cargo.toml 或 less Cargo.toml 查看。

文件的内容应该类似于这样：

“`toml
[package]
name = “my-first-project”
version = “0.1.0”
edition = “2021” # 或者其他年份，取决于你安装的 Rust 版本

See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]
“`

这是一个 TOML (Tom’s Obvious, Minimal Language) 格式的文件。TOML 是一种易于阅读的配置文件格式，Cargo 使用它来管理项目配置。

让我们分解一下这个文件：

  • [package]: 这是一个 section header，表示下面的配置项都属于当前项目包。
    • name = "my-first-project": 这是项目的名称。当你创建项目时，Cargo 使用这个名字作为默认名称。在发布到 crates.io 时，这个名字必须是唯一的。
    • version = "0.1.0": 这是项目的当前版本号。遵循 Semantic Versioning (SemVer) 标准是一种推荐的做法。
    • edition = "2021": 这是项目使用的 Rust 版本（edition）。Rust 会定期发布新的 edition，每个 edition 可能包含一些语言层面的微小改动或新特性，但不同 edition 的代码通常可以互相调用。rustup 默认安装的 Rust 版本会使用最新的 edition。
    • # See more keys...: 这是一个注释行，提供了指向 Cargo 官方文档中关于 Cargo.toml 更多配置项的链接。你可以添加作者信息 (authors = ["Your Name <[email protected]>"])、项目描述 (description = "A simple Rust project")、许可证信息 (license = "MIT") 等。
  • [dependencies]: 这是另一个 section header，用于声明项目依赖的外部库（crates）。项目所需的所有第三方库都将在这里列出。最初创建项目时，这个部分是空的，因为你的项目还没有依赖任何外部库。

Cargo.toml 是项目的“心脏”，它告诉 Cargo 项目叫什么、版本是多少、使用哪个 Rust edition，以及最重要的——它依赖于哪些外部功能。

第六步：查看源代码 (src/main.rs)

接下来，打开 src/main.rs 文件。

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

这是一个非常简单的 Rust 程序：

  • fn main() { ... }: 定义了一个名为 main 的函数。在可执行程序中，main 函数是程序的入口点，程序从这里开始执行。
  • println!("Hello, world!");: 调用了一个宏 println!，用于向控制台打印一行文本。注意 Rust 中宏调用的名称后面带有感叹号 !。字符串文字使用双引号 "" 包围，语句以分号 ; 结束。

这个程序的功能就是向标准输出打印 “Hello, world!”。

第七步：使用 Cargo 构建和运行项目

现在，我们已经创建了项目，了解了结构，并看过了代码。是时候让 Cargo 发挥作用了！

确保你仍在 my-first-project 目录下。

构建项目：

使用以下命令构建你的项目：

bash
cargo build

第一次运行 cargo build 时，Cargo 会做几件事：

  1. 它会检查你的 Cargo.toml 文件，查找项目信息和依赖。
  2. 由于这是第一次构建，它会下载和编译项目所依赖的任何库（目前没有）。
  3. 它会编译 src/main.rs 文件。
  4. 它会将编译好的可执行文件放置在 target/debug/ 目录下。

你会看到类似这样的输出：

Compiling my-first-project v0.1.0 (/path/to/my-first-project)
Finished dev [unoptimized + debuginfo] target(s) in X.XXs

  • Compiling my-first-project v0.1.0 ...: 表示 Cargo 正在编译你的项目。
  • Finished dev [unoptimized + debuginfo] target(s) in X.XXs: 表示构建成功完成。dev 表示这是一个开发（debug）构建，它是非优化的但包含调试信息，编译速度快，适合开发阶段。

如果你查看 target/debug/ 目录，你会找到一个名为 my-first-project（在 Windows 上是 my-first-project.exe）的可执行文件。你可以直接运行这个可执行文件：

“`bash

在 Linux/macOS 上

./target/debug/my-first-project

在 Windows 的 Command Prompt 或 PowerShell 上

.\target\debug\my-first-project.exe
“`

输出应该是：

Hello, world!

运行项目：

直接构建并运行程序是一个非常常见的操作。Cargo 提供了一个更便捷的命令来完成这个任务：

bash
cargo run

cargo run 命令会首先检查你的项目是否需要重新构建（如果代码有改动），如果需要，它会先构建；然后它会自动运行生成的那个可执行文件。

第一次运行 cargo run 可能需要构建，之后的运行会非常快（除非你修改了代码）：

bash
Compiling my-first-project v0.1.0 (/path/to/my-first-project)
Finished dev [unoptimized + debuginfo] target(s) in X.XXs
Running `target/debug/my-first-project`
Hello, world!

如果你再次运行 cargo run 而没有修改代码，输出会更简洁，因为它不需要重新编译：

bash
Running `target/debug/my-first-project`
Hello, world!

cargo run 是开发过程中最常用的命令之一。

检查代码（不构建）：

有时候，你只是想快速检查一下代码是否有语法错误或类型错误，而不想等待完整的编译过程（尤其是当项目变大时）。Cargo 提供了 check 命令：

bash
cargo check

cargo check 只会执行编译过程的“检查”步骤，不会生成可执行文件。它的速度通常比 cargo build 快得多。

bash
Checking my-first-project v0.1.0 (/path/to/my-first-project)
Finished dev [unoptimized + debuginfo] target(s) in X.XXs

如果你的代码有错误，cargo check 会立即报告错误，而不需要等到编译完成。这是一个非常有用的命令，可以集成到你的编辑器或 IDE 中，提供实时的错误反馈。

第八步：添加和使用依赖（Crates）

Rust 生态系统的强大之处在于其丰富的第三方库，这些库通常称为 “crates”（箱）。crates.io (https://crates.io/) 是官方的 crate 注册中心，你可以找到并使用成千上万个开源库。

Cargo 使得在项目中使用这些库变得异常简单。让我们来添加一个常用的库，比如 rand，用于生成随机数。

方法一：手动编辑 Cargo.toml

打开 my-first-project/Cargo.toml 文件，找到 [dependencies] 部分，在下面添加一行，指定你要添加的 crate 名称和版本号：

“`toml
[package]
name = “my-first-project”
version = “0.1.0”
edition = “2021”

[dependencies]
rand = “0.8.5” # 添加这一行
“`

这里的 rand = "0.8.5" 表示我们依赖 rand 这个 crate，并且希望使用版本 0.8.5。通常，你可以在 crates.io 上找到某个 crate 的最新版本及其添加方式。

方法二：使用 cargo add 命令 (推荐)

从 Rust 1.62.0 版本开始，Cargo 引入了 cargo add 命令，这是添加依赖更便捷的方式。在项目根目录下运行：

bash
cargo add rand

Cargo 会自动在 crates.io 上查找最新的 rand 版本，并将其添加到 Cargo.toml 的 [dependencies] 部分。

bash
Adding rand v0.8.5 to dependencies

无论你使用哪种方法，保存 Cargo.toml 文件后，当你下次运行 cargo build 或 cargo run 时，Cargo 会检测到新的依赖，然后：

  1. 从 crates.io 下载 rand crate 及其所有依赖。
  2. 编译 rand crate 及其所有依赖。
  3. 编译你的项目，使其能够使用 rand crate。

这个过程可能需要一些时间，特别是在第一次添加依赖时。Cargo 会将下载和编译好的依赖缓存在你的本地系统上，以便未来的项目可以重用，从而加快后续项目的构建速度。

Cargo.lock 文件：

当你添加依赖并运行 cargo build 或 cargo run 后，Cargo 会在项目根目录生成一个 Cargo.lock 文件。

my-first-project/
├── .git/
├── .gitignore
├── Cargo.toml
├── Cargo.lock # 新生成的文件
├── src/
└── main.rs

Cargo.lock 文件记录了项目中所有依赖（包括你直接添加的以及这些依赖所依赖的其他库）的精确版本信息。这是一个非常重要的文件，应该添加到版本控制中（例如 Git）。

为什么需要 Cargo.lock？

  • 保证可重复构建： Cargo.toml 中的版本通常允许一定范围（例如 rand = "0.8.5" 表示兼容 0.8.5 版本，直到 0.9.0 的任何 0.8.x 版本）。如果没有 Cargo.lock，不同开发者或在不同时间构建项目时，可能会因为依赖库的小版本更新而使用不同版本的依赖，这可能导致构建结果不一致甚至引入新的错误。Cargo.lock 锁定了所有依赖的确切版本，确保每次构建使用的都是相同的库版本。
  • 当你执行 cargo update 命令时，Cargo 会根据 Cargo.toml 中的规则检查依赖是否有新版本可用，并更新 Cargo.lock 文件。

使用依赖：

现在，让我们修改 src/main.rs 文件，使用 rand 库来生成一个随机数。

“`rust
// 引入 rand crate 中我们需要的功能
use rand::Rng; // 引入 Rng trait

fn main() {
// 创建一个线程局部的随机数生成器
let mut rng = rand::thread_rng();
// 生成一个 1 到 100 之间的随机整数（包含 1 和 100）
let random_number = rng.gen_range(1..=100);

println!("Hello, world!");
println!("Here is a random number: {}", random_number); // 打印随机数

}
“`

  • use rand::Rng;: 这行代码引入了 rand crate 中的 Rng trait。在 Rust 中，use 关键字用于将路径引入当前作用域，以便你可以直接使用名称（例如 Rng）而无需写完整的路径（例如 rand::Rng）。Trait 类似于其他语言中的接口，它定义了类型可以实现的功能。Rng trait 定义了随机数生成器应具备的方法，例如 gen_range。
  • let mut rng = rand::thread_rng();: 调用 rand crate 中的 thread_rng 函数，它返回一个在当前线程中可用的随机数生成器实例。我们使用 let mut 声明一个可变的变量 rng 来存储这个生成器，因为我们将要调用它的方法来改变其内部状态（生成下一个随机数）。
  • let random_number = rng.gen_range(1..=100);: 调用 rng 生成器的 gen_range 方法，并传入一个范围 1..=100。gen_range 方法会返回一个在这个闭区间（包含 1 和 100）内的随机整数。我们将结果赋值给不可变变量 random_number。
  • println!("Here is a random number: {}", random_number);: 使用 println! 宏打印随机数。{} 是占位符，println! 会将 random_number 的值格式化后放入占位符的位置。

保存 src/main.rs 文件。现在，再次运行：

bash
cargo run

Cargo 会检测到 src/main.rs 和 Cargo.toml（因为添加了依赖）都已修改，它会重新编译你的项目（并可能先编译 rand 库），然后运行：

bash
Compiling rand v0.8.5 ...
Compiling my-first-project v0.1.0 (/path/to/my-first-project)
Finished dev [unoptimized + debuginfo] target(s) in X.XXs
Running `target/debug/my-first-project`
Hello, world!
Here is a random number: XX # XX 是一个随机数

每次运行 cargo run，你应该会看到一个不同的随机数。恭喜！你已经成功地在你的 Rust 项目中添加并使用了外部依赖。

第九步：构建发布版本

到目前为止，我们使用的都是开发（debug）构建。开发构建速度快，包含调试信息，但没有进行性能优化。当你想发布你的程序时，你需要一个优化过的、没有调试信息的版本。这就是发布（release）构建的作用。

使用以下命令构建发布版本：

bash
cargo build --release

第一次进行发布构建通常需要更多时间，因为编译器会执行大量的优化工作。

bash
Compiling rand v0.8.5 ...
Compiling my-first-project v0.1.0 (/path/to/my-first-project)
Finished release [optimized] target(s) in X.XXs

发布构建生成的可执行文件位于 target/release/ 目录下。

“`bash

在 Linux/macOS 上运行发布版本

./target/release/my-first-project

在 Windows 的 Command Prompt 或 PowerShell 上运行发布版本

.\target\release\my-first-project.exe
“`

输出与 debug 版本相同，但这个可执行文件通常更小，运行速度更快。

你也可以直接运行发布版本：

bash
cargo run --release

这个命令会先执行 cargo build --release（如果需要的话），然后运行 target/release/ 中的可执行文件。

第十步：运行测试

Rust 内置了对单元测试和集成测试的支持，而 Cargo 是运行这些测试的工具。

虽然我们的 “Hello, world!” 程序没有太多可以测试的逻辑，但我们可以在 src/main.rs 中添加一个简单的单元测试示例来演示。将以下代码块添加到 src/main.rs 的 末尾：

“`rust
// 添加测试模块

[cfg(test)] // 只有在运行测试时才编译这个模块

mod tests {
// 引入外部函数或宏到测试作用域
#[test] // 标记这是一个测试函数
fn it_works() {
// 一个简单的断言
assert_eq!(2 + 2, 4);
}

#[test]
fn greeting_contains_name() {
    let greeting = "Hello, world!";
    // 检查字符串是否包含某个子串
    assert!(greeting.contains("world"));
}

}
“`

  • #[cfg(test)]: 这是一个条件编译属性。它告诉 Rust 编译器，只有在编译测试代码时（例如，使用 cargo test），才包含下面的 mod tests { ... } 代码块。在普通构建（cargo build 或 cargo run）中，这段代码会被忽略。
  • mod tests { ... }: 定义了一个名为 tests 的内部模块，通常用于组织测试函数。
  • #[test]: 这是一个属性，标记了紧跟其后的函数是一个测试函数。Cargo 在运行测试时会查找并执行所有带有 #[test] 属性的函数。
  • fn it_works() { ... } 和 fn greeting_contains_name() { ... }: 这是两个测试函数。测试函数不需要参数，通常返回 ()（单元类型）。
  • assert_eq!(a, b): 是一个宏，用于断言 a 和 b 是否相等。如果它们不相等，测试将失败。
  • assert!(condition): 是一个宏，用于断言条件是否为真。如果条件为假，测试将失败。

保存 src/main.rs 文件。然后在项目根目录下运行测试：

bash
cargo test

Cargo 会构建你的项目（包括测试代码），然后运行所有的测试函数：

“`bash
Compiling my-first-project v0.1.0 (/path/to/my-first-project)
Finished dev [unoptimized + debuginfo] target(s) in X.XXs
Running target/debug/deps/my_first_project-xxxxxxxxxxxxx

running 2 tests
test tests::greeting_contains_name … ok
test tests::it_works … ok

test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in X.XXs
“`

输出显示 Cargo 发现了两个测试，并且它们都成功通过了（ok）。如果任何测试失败，Cargo 会打印详细的错误信息，帮助你调试。

cargo test 是确保你的代码按照预期工作的重要工具。

第十一章：其他有用的 Cargo 命令 (简述)

Cargo 还有许多其他有用的命令，可以帮助你更好地管理和开发 Rust 项目：

  • cargo fmt: 格式化你的 Rust 代码，使其符合官方的风格指南。运行 cargo fmt 可以让你的代码风格保持一致。
  • cargo clippy: 一个 Rust 的 linting 工具，可以检查出代码中的一些常见错误、潜在问题或不良实践。运行 cargo clippy 可以帮助你写出更健壮、更符合习惯的代码。
  • cargo doc: 生成项目的 HTML 文档。这些文档基于你代码中的特殊注释（称为 Doc Comments）。运行后，在 target/doc/ 目录下找到文档。
  • cargo publish: 如果你的项目是一个库，并且你希望将其分享给其他人使用，可以使用 cargo publish 将其发布到 crates.io（需要注册和配置）。
  • cargo clean: 清理项目构建生成的 target 目录。当你遇到一些奇怪的构建问题时，尝试运行 cargo clean，然后重新构建通常能解决问题。

你可以随时在终端输入 cargo --help 或 cargo <command> --help 来查看 Cargo 命令的详细用法和选项。

总结：Cargo 的力量

通过上面的步骤，你已经成功地使用 Cargo 创建、构建、运行、检查、添加依赖和测试了你的第一个 Rust 项目。你亲身体验了 Cargo 作为 Rust 开发核心工具的便捷性和强大功能。

我们回顾一下 Cargo 为我们做了什么：

  • 标准化项目创建： cargo new 快速生成了符合约定的项目结构。
  • 自动化构建流程： cargo build 和 cargo run 屏蔽了复杂的编译命令。
  • 简化依赖管理： Cargo.toml 清晰地声明了项目依赖，cargo add 或手动编辑然后 cargo build/run 自动处理下载和编译。
  • 保证构建可重复性： Cargo.lock 锁定了依赖的精确版本。
  • 内置测试支持： cargo test 轻松运行代码中的测试。

Cargo 不仅仅是 Rust 的一个工具，它是 Rust 开发体验不可或缺的一部分。它鼓励了模块化开发、代码共享和标准化实践，极大地促进了 Rust 生态系统的繁荣。

下一步做什么？

完成了你的第一个 Rust 项目，你已经迈出了重要的一步！接下来，你可以：

  1. 深入阅读官方 Rust Book： Rust Book 是学习 Rust 语言本身的最佳资源，Cargo 章节 (https://book.rust-lang.org/ch01-03-cargo.html) 会更详细地介绍 Cargo。
  2. 尝试更多 Rust 代码： 在 src/main.rs 中尝试编写更复杂的程序，学习 Rust 的语法、所有权系统、借用、生命周期等核心概念。
  3. 探索 Crates.io： 在 crates.io 上查找你感兴趣的库，尝试将它们添加到你的项目中并使用它们的功能。
  4. 学习模块化： 了解如何在 src 目录下组织更多的文件和模块，以及如何在 Cargo.toml 中配置更复杂的项目（例如工作区 – workspaces）。
  5. 实践！ 最好的学习方法是动手实践。尝试解决一些小问题，实现一些小程序，不断运用你学到的 Rust 和 Cargo 知识。

结语

从一个简单的 “Hello, world!” 到能够管理依赖和运行测试，Cargo 极大地降低了 Rust 项目的门槛，并提供了一个高效、可靠的开发工作流程。现在你已经掌握了 Rust 开发中最基础也是最重要的工具之一——Cargo。继续你的探索，享受使用 Rust 构建高性能、高可靠性软件的乐趣吧！

祝你 Rust 学习之旅顺利！

发表评论

您的邮箱地址不会被公开。 必填项已用 * 标注

滚动至顶部