学习Rust的第一步：入门 – wiki基地

作者： /

学习 Rust 的第一步：入门

欢迎来到 Rust 的世界！

Rust 是一门令人兴奋的语言。它以其惊人的性能、可靠的内存安全（没有垃圾回收器！）以及强大的并发支持而闻名。Rust 正在快速成为构建高性能、可靠软件的首选语言，从操作系统、嵌入式系统、WebAssembly 应用到命令行工具、网络服务，甚至是游戏引擎的部分。

然而，Rust 也因其陡峭的学习曲线而闻名，特别是对于那些习惯了带有垃圾回收器语言（如 Python, Java, Go, C#）或拥有宽松内存管理的语言（如 C, C++）的开发者来说。Rust 的核心概念——所有权（Ownership）、借用（Borrowing）和生命周期（Lifetimes）——是其安全和高性能的基石，但也需要一些时间来理解和掌握。

但是，别担心！每一个 Rust 开发者都曾是新手。学习任何新事物都需要时间和耐心。这篇指南的目标是帮助你迈出学习 Rust 的第一步：搭建环境，运行你的第一个程序，并熟悉最基本的工具和语法。我们不会一开始就深入探讨所有权这样复杂的概念，而是先让你跑起来，感受 Rust 的开发流程。

让我们开始这段激动人心的旅程吧！

为什么选择 Rust？（简单介绍，增强信心）

在你投入学习之前，先了解一下 Rust 的吸引力可能有助于你保持动力：

  1. 内存安全，没有 GC： Rust 在编译时强制执行内存安全规则，这意味着你不会遇到空指针解引用、数据竞争（在并发代码中）等问题，同时又无需垃圾回收器带来的运行时开销。这使得 Rust 既安全又高效。
  2. 高性能： Rust 的抽象机制（零成本抽象）在编译后几乎没有运行时开销，它的性能可以与 C/C++ 相媲美。
  3. 可靠性： Rust 强大的类型系统和所有权模型能在编译期捕获大量错误，让你在程序运行前就能发现并修复问题。
  4. 优秀的工具链： Rust 拥有一个非常成熟且易用的工具链，包括包管理器和构建系统 Cargo、格式化工具 rustfmt、静态分析工具 clippy 等。
  5. 活跃的社区： Rust 拥有一个热情且乐于助人的社区，这使得学习和寻求帮助变得更加容易。

这些特性使得 Rust 成为构建底层系统、高性能服务以及需要高可靠性应用的绝佳选择。

前提准备：你需要知道什么？

开始学习 Rust 并不需要你是编程大师。如果你具备以下基础知识，将会有所帮助：

  • 了解基本的编程概念：变量、数据类型、函数、控制流程（if/else, 循环）等。
  • 对命令行终端（Terminal 或 Command Prompt）有基本的使用经验。

即便你对这些概念不太熟悉，也可以边学边查，Rust 的入门过程会逐步引入这些概念。

第一步：安装 Rust

Rust 的官方推荐安装方法是通过一个叫做 rustup 的工具链管理器。rustup 负责安装和管理 Rust 的编译器 (rustc)、构建工具 (cargo) 以及其他相关工具，并且可以轻松切换 Rust 的版本（稳定版 stable、测试版 beta、夜间版 nightly）以及针对不同平台（target）进行交叉编译。

对于类 Unix 系统（Linux, macOS）：

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

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

这个命令会下载并运行一个脚本。脚本会提示你进行安装。通常选择默认安装（选项 1）即可，它会安装最新稳定版的 Rust。安装过程中，它会提示修改你的 shell 配置文件（如 .bashrc, .zshrc, .profile 等），将 Cargo 的 bin 目录添加到你的 PATH 环境变量中。这一步非常重要！ 完成后，按照提示执行 source 命令（或关闭再重新打开终端）使环境变量生效。

示例安装过程输出（部分）：

“`
info: downloading installer
Welcome to Rust!

This will download and install the official compiler for the Rust programming language, and its package manager, Cargo.

It will add the Cargo installation directory to your PATH environment variable.

3) Customize installation
4) Cancel installation

1) Proceed with installation (default)
?1

… (下载安装过程) …

Rust is installed now. Great!

To get started you may need to restart your current shell.
This would reload your PATH environment variable to include
Cargo’s bin directory.

To configure your current shell, run:
source $HOME/.cargo/env
“`

按照提示运行 source $HOME/.cargo/env（如果你的 shell 是 bash 或 zsh，通常这个文件是 $HOME/.cargo/env）。

对于 Windows 系统：

  1. 访问 Rust 官方安装页面：https://www.rust-lang.org/tools/install
  2. 下载 rustup-init.exe 安装程序。
  3. 运行下载的 rustup-init.exe 文件。
  4. 安装程序会打开一个命令行窗口，并提示你进行安装。同样，推荐选择默认安装（选项 1）。
  5. 在 Windows 上，Rust 需要 C++ 构建工具。安装程序可能会检查你的系统是否已安装 Visual Studio 的构建工具。如果没有，它可能会提示你安装 Visual Studio Build Tools 2019 或更高版本，并确保安装了 C++ 工作负载。如果你尚未安装，最好先去微软官网下载并安装 Visual Studio Build Tools（Community 版本即可，选择安装“使用 C++ 的桌面开发”工作负载）。
  6. 安装完成后，rustup 会自动将 Cargo 的 bin 目录添加到你的 PATH 环境变量中。你可能需要重启命令行窗口或电脑才能使环境变量生效。

验证安装：

无论你在什么系统上，安装完成后，打开一个新的终端或命令行窗口，运行以下命令来验证 Rust 和 Cargo 是否安装成功：

bash
rustc --version
cargo --version

如果一切正常，你应该能看到类似以下的输出（版本号可能不同）：

rustc 1.xx.y (aabbccdd 20yy-mm-dd)
cargo 1.xx.y (aabbccdd 20yy-mm-dd)

这表明 Rust 编译器 (rustc) 和构建工具 (cargo) 已经成功安装并可以通过命令行访问了。

第二步：你的第一个 Rust 程序——Hello, World!

现在你已经拥有了 Rust 开发环境，是时候写你的第一个 Rust 程序了！按照编程界的传统，我们从 “Hello, World!” 开始。

创建一个新目录用于存放你的 Rust 代码，例如 ~/rust_projects/hello_world。

进入这个目录：

bash
cd ~/rust_projects/hello_world # 或者根据你的实际路径

使用任何文本编辑器（VS Code, Sublime Text, Vim, Nano 等）创建一个名为 main.rs 的文件。 Rust 源代码文件的扩展名总是 .rs。

将以下代码复制到 main.rs 文件中：

rust
// 这是一个注释，Rust 编译器会忽略它
// main 函数是所有 Rust 可执行程序的入口点
fn main() {
// println! 是一个 Rust 宏，用于将文本打印到控制台
// 宏的调用以 '!' 结尾
println!("Hello, World!");
}

保存文件。

现在，我们将使用 rustc 编译器编译这个文件。在终端中，确保你在 hello_world 目录内，然后运行：

bash
rustc main.rs

如果代码没有语法错误，rustc 将会编译你的源代码，并在当前目录下生成一个可执行文件：
* 在类 Unix 系统上，生成的文件名为 main。
* 在 Windows 系统上，生成的文件名为 main.exe。

现在，运行这个可执行文件：

  • 在类 Unix 系统上：
    bash
    ./main
  • 在 Windows 系统上：
    bash
    .\main.exe

你应该能在终端中看到输出：

Hello, World!

恭喜！你已经成功编写、编译并运行了你的第一个 Rust 程序。

代码解析：

  • fn main()：
    • fn 关键字用于声明一个函数。
    • main 是函数名。在可执行程序中，main 函数是程序执行的起点。
    • () 表示这个函数没有参数。
    • 函数体被包含在 {} 花括号中。
  • println!("Hello, World!");：
    • println! 是一个宏（macro），而不是一个常规函数。在 Rust 中，宏提供了一些元编程的能力，例如这里的 println! 可以在编译时展开代码，实现方便的格式化输出。宏调用以 ! 结尾，这是识别宏的一个标志。
    • "Hello, World!" 是一个字符串字面量。
    • ! 后面的括号 () 或花括号 {} 包围着宏的参数。
    • 语句以 ; 分号结束。在 Rust 中，大多数语句都需要以分号结束。

第三步：拥抱 Cargo——Rust 的构建工具和包管理器

虽然使用 rustc 直接编译单个文件对于简单的例子来说没问题，但在实际的 Rust 项目开发中，我们几乎总是使用 Cargo。

Cargo 是 Rust 的官方构建工具和包管理器。它能为你处理许多任务，包括：

  • 创建新项目骨架。
  • 构建你的项目代码。
  • 下载和管理你的项目依赖库（crates）。
  • 运行你的项目。
  • 运行项目的测试。
  • 生成项目文档。

使用 Cargo 可以让你的开发流程更标准化、更便捷。

创建一个新的 Cargo 项目：

让我们用 Cargo 来创建一个新的 “Hello, World!” 项目。回到你的 rust_projects 目录（或者你喜欢存放项目的任何位置），运行以下命令：

bash
cd ~/rust_projects # 或你的目录
cargo new hello_cargo

cargo new hello_cargo 命令会创建一个名为 hello_cargo 的新目录，并在其中生成一个基本的项目结构：

hello_cargo/
├── Cargo.toml
└── src/
└── main.rs

让我们看看这些生成的文件：

  1. Cargo.toml: 这是 Cargo 的配置文件，使用 TOML (Tom’s Obvious, Minimal Language) 格式。它包含了你的项目信息（名称、版本、作者等）以及项目的依赖库。

    打开 Cargo.toml，你会看到类似这样的内容：

    “`toml
    [package]
    name = “hello_cargo”
    version = “0.1.0”
    edition = “2021” # 或者 “2018”

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

    [dependencies]
    “`

    • [package] 部分包含了项目的元信息。
    • name = "hello_cargo" 是项目名称。
    • version = "0.1.0" 是项目版本号。
    • edition = "2021"（或 2018）指定了项目使用的 Rust 版本（Edition），不同 Edition 可能有细微的语法或语言特性差异，但主要版本是兼容的。对于初学者，使用最新的 Edition 即可。
    • [dependencies] 部分用于列出你的项目所依赖的外部库。目前是空的，后面你添加依赖时会用到这里。

  2. src/main.rs: 这是你的源代码文件。Cargo 默认将可执行程序的入口文件放在 src/main.rs。

    打开 src/main.rs，你会发现 Cargo 已经为你生成了一个基本的 “Hello, World!” 程序：

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

    这和我们手动创建的第一个程序一模一样。Cargo 遵循一个惯例：源代码放在 src 目录中，项目的根目录用于存放 Cargo.toml 文件和其他项目相关的非源代码文件。

使用 Cargo 构建和运行项目：

进入新创建的 hello_cargo 目录：

bash
cd hello_cargo

现在，使用 Cargo 来构建你的项目：

bash
cargo build

运行这个命令后，Cargo 会读取 Cargo.toml 文件，下载所需的依赖（这个项目没有依赖，所以这一步很快），编译你的代码。编译成功后，你会在项目根目录下看到一个新创建的 target 目录。在 target/debug/ 目录下，你会找到编译生成的可执行文件 (hello_cargo 或 hello_cargo.exe)。

首次运行 cargo build 会比较慢，因为它需要下载和编译标准库等。后续再运行会快得多。

Cargo 默认进行 Debug 构建，这种构建包含调试信息，并且没有进行优化，因此编译速度快，适合开发阶段。发布（Release）构建则会进行优化，生成的可执行文件性能更高，文件更小，但编译时间更长。要进行发布构建，可以使用 cargo build --release 命令，生成的可执行文件会在 target/release/ 目录下。

现在，使用 Cargo 来运行你的项目：

bash
cargo run

cargo run 命令实际上做了两件事：首先，它会检查你的代码是否需要重新编译（如果自上次构建后有修改），如果需要则执行 cargo build；然后，它会运行生成的可执行文件。

你应该会看到输出：

Hello, world!

cargo run 是开发过程中最常用的命令，因为它方便地集成了构建和运行步骤。

其他常用的 Cargo 命令：

  • cargo check: 这是一个非常有用的命令。它只检查你的代码是否存在编译错误、语法错误和类型错误，但 不 生成可执行文件。这比 cargo build 要快得多，非常适合在编写代码时频繁运行，快速获得反馈。

    bash
    cargo check

  • cargo clean: 清理项目构建生成的文件，包括 target 目录。

    bash
    cargo clean

通过 Cargo，你已经掌握了创建、构建和运行 Rust 项目的基本工作流程。

第四步：学习 Rust 的基本概念（入门级别）

有了运行环境和开发工具，接下来就是学习 Rust 的基本语法和核心概念了。在第一步入门阶段，我们只需要了解一些最基本、最常见的元素，足以让你写出一些简单的程序。

1. 变量（Variables）

在 Rust 中，使用 let 关键字声明变量。默认情况下，变量是不可变的（immutable）。这意味着一旦给变量赋值，你就不能再改变它的值。

“`rust
fn main() {
let x = 5; // 声明一个不可变变量 x，并赋值为 5
println!(“x 的值是: {}”, x);

// x = 6; // 这行代码会导致编译错误，因为 x 是不可变的

// 如果需要可变变量，使用 mut 关键字
let mut y = 10; // 声明一个可变变量 y，并赋值为 10
println!("y 的值是: {}", y);

y = 15; // 现在可以修改 y 的值了
println!("y 的新值是: {}", y);

}
“`

  • 不可变性（Immutability）： 默认不可变是 Rust 的一个重要设计选择，它可以帮助你在编译时捕获许多潜在的错误，并使代码更容易理解和并发安全。当你确实需要改变变量时，必须明确地使用 mut。
  • 类型推断（Type Inference）： 在上面的例子中，我们没有明确指定 x 和 y 的类型（如 i32），但 Rust 编译器能够根据赋给变量的值自动推断出它们的类型。你也可以显式地指定类型：let x: i32 = 5;。

2. 数据类型（Data Types）

Rust 是一门静态类型语言，这意味着在编译时会确定所有变量的类型。Rust 有多种基本数据类型：

  • 整型（Integers）： 有符号整数 (i8, i16, i32, i64, i128, isize) 和无符号整数 (u8, u16, u32, u64, u128, usize)。后缀数字表示占用的比特位。isize 和 usize 的大小取决于你程序的架构（32位或64位），通常用于索引集合。默认的整数类型是 i32。
    rust
    let an_integer = 98_222; // 可以使用 '_' 作为数字分隔符，提高可读性
    let a_signed_8_bit_integer: i8 = -10;
    let an_unsigned_64_bit_integer: u64 = 123456789;
    let pointer_size_int: usize = 42;
  • 浮点型（Floating-Point Numbers）： f32（单精度）和 f64（双精度）。默认是 f64。
    rust
    let a_float = 2.0; // f64
    let another_float: f32 = 3.0; // f32
  • 布尔型（Booleans）： bool 类型，只有两个值：true 和 false。
    rust
    let t = true;
    let f: bool = false; // 显式类型标注
  • 字符型（Characters）： char 类型，表示一个 Unicode 字符。字符字面量使用单引号 '。
    rust
    let c = 'z';
    let z = 'ℤ';
    let heart_eyed_cat = '😻';
  • 字符串（Strings）： Rust 有两种主要的字符串类型：字符串字面量（string slices, &str）和可增长的堆分配字符串（String）。在入门阶段，你主要会看到字符串字面量，它们是硬编码到程序二进制文件中的不可变文本序列。
    rust
    let greeting = "Hello"; // 字符串字面量，类型是 &str
    // String 类型稍后会学习，它更复杂，但功能更强大
  • 元组（Tuples）： 元组是将多个不同类型的值组合成一个复合类型的方法。元组的长度是固定的。
    rust
    let tup: (i32, f64, u8) = (500, 6.4, 1);
    // 通过模式匹配解构元组来获取值
    let (x, y, z) = tup;
    println!("元组的 y 值是: {}", y);
    // 也可以使用索引访问元组元素 (索引从 0 开始)
    let five_hundred = tup.0;
    let six_point_four = tup.1;

  • 数组（Arrays）： 数组是一组相同类型的值的集合。数组的长度是固定的。数组元素在栈上分配。
    “`rust
    let a = [1, 2, 3, 4, 5]; // 类型是 [i32; 5]
    let months = [“January”, “February”, “March”, “April”, “May”, “June”, “July”,
    “August”, “September”, “October”, “November”, “December”]; // 类型是 [&str; 12]

    // 访问数组元素 (索引从 0 开始)
    let first_month = months[0];
    println!(“第一个月是: {}”, first_month);
    // 访问越界索引会导致运行时错误 (panic)
    // let twelfth_month = months[12]; // 这会导致运行时崩溃！
    “`

3. 函数（Functions）

使用 fn 关键字定义函数。函数可以有参数，也可以返回一个值。

“`rust
fn main() {
println!(“Hello from main function!”);

// 调用其他函数
another_function();
function_with_parameter(5);
function_with_multiple_parameters(10, 'h');

let result = function_with_return_value(5, 6);
println!("函数的返回值是: {}", result);

}

// 定义一个没有参数和返回值的函数
fn another_function() {
println!(“Hello from another function!”);
}

// 定义一个带参数的函数
fn function_with_parameter(x: i32) { // 参数需要显式指定类型
println!(“传递给函数的参数是: {}”, x);
}

// 定义一个带多个参数的函数
fn function_with_multiple_parameters(value: i32, unit: char) {
println!(“{} {}”, value, unit);
}

// 定义一个带返回值且有参数的函数
fn function_with_return_value(x: i32, y: i32) -> i32 { // 使用 -> 后面跟类型来指定返回值类型
// Rust 函数体由一系列语句和一个可选的表达式构成
// 表达式不会以分号结尾，它的值会作为函数的返回值
x + y // 这是一个表达式，计算 x + y 的结果并作为函数返回值
// 如果这里写 x + y; (加了分号)，它就变成一个语句，函数将没有返回值 (或者说返回一个 unit 类型 ())
}

// 也可以使用 return 关键字显式返回
fn function_with_explicit_return(x: i32) -> i32 {
return x * 2; // 使用 return 关键字
}

“`

  • 参数： 函数参数必须显式指定类型。
  • 返回值： 使用 -> 后面跟返回值的类型来指定函数的返回类型。函数体中的最后一个表达式（没有分号结尾的）会自动作为返回值。你也可以使用 return 关键字提前返回。没有返回值的函数实际上返回一个空元组 ()，可以省略 -> ()。

4. 控制流程（Control Flow）

Rust 提供了常见的控制流程结构：if/else 表达式和循环。

  • If / Else 表达式： Rust 的 if 是一个表达式，它可以返回值。条件不需要用括号括起来，但花括号 {} 是必需的。
    “`rust
    fn main() {
    let number = 7;

    if number < 5 {
    println!("条件为真");
} else {
    println!("条件为假");
}

// if 作为表达式返回值
let condition = true;
let number = if condition { 5 } else { 6 }; // 注意 if 的两个分支返回类型必须一致

println!("if 表达式的结果是: {}", number);

    }
    * **循环：** Rust 提供了 `loop`, `while` 和 `for` 三种循环。
    * **`loop`：** 无限循环，直到遇到 `break` 关键字。`loop` 也可以返回一个值。    rust
    fn main() {
    let mut counter = 0;
    let result = loop { // loop 可以返回一个值
    counter += 1;

            if counter == 10 {
            break counter * 2; // 使用 break 关键字并指定要返回的值
        }
    };
    println!("loop 循环的结果是: {}", result); // 输出 20
}
```
    • while： 条件循环，当条件为真时一直执行循环体。
      rust
      fn main() {
      let mut number = 3;
      while number != 0 {
      println!("{}!", number);
      number -= 1;
      }
      println!("LIFTOFF!!!");
      }
    • for： 遍历集合元素的循环，最常用的循环类型。
      “`rust
      fn main() {
      let a = [10, 20, 30, 40, 50];
      // 遍历数组元素
      for element in a {
      println!(“元素的值是: {}”, element);
      }

      // 遍历范围 (Range)
for number in (1..4).rev() { // (1..4) 表示从 1 到 4 (不包含 4) 的范围，rev() 表示倒序
    println!("{}!", number);
}
println!("LIFTOFF!!!");

      }
      “`

5. 注释（Comments）

Rust 支持两种注释方式：

  • 行注释：以 // 开始，直到行尾。
  • 块注释：以 /* 开始，以 */ 结束。

“`rust
// 这是一个单行注释

/
这是一个
块注释
可以跨越多行
/
fn main() {
println!(“带注释的代码”); // 行尾注释
}
“`

第五步：动手实践——写一些简单的代码

理论知识需要通过实践来巩固。现在，尝试在你的 hello_cargo 项目中修改 src/main.rs 文件，运用上面学到的基本概念：

  1. 修改变量： 创建一个可变变量，然后修改它的值并打印。
  2. 使用不同数据类型： 声明不同类型的变量（整数、浮点数、布尔值、字符），并尝试打印它们。
  3. 定义和调用函数： 写一个带参数并返回值的函数，然后在 main 函数中调用它并打印结果。
  4. 使用 if/else： 写一个简单的 if/else 语句，根据某个条件打印不同的消息。
  5. 使用循环： 使用 for 循环遍历一个数字范围或数组，打印每个元素。

每次修改代码后，记住在终端中使用 cargo run 来运行你的程序，或者使用 cargo check 快速检查语法错误。

“`rust
// 示例：将上面学到的概念组合起来

fn main() {
// 可变变量和基本类型
let mut count: u32 = 0;
let message = “计数器：”;
let active = true;
let initial = ‘S’;

println!("初始状态: {} {}", message, initial);

// 使用 if 表达式
let start_value = if active {
    println!("计数器已激活");
    1 // if 分支的返回值
} else {
    println!("计数器未激活");
    0 // else 分支的返回值
};

count = start_value;

// 使用 loop 循环和 break
let max_count = 5;
let final_count = loop {
    if count > max_count {
        break count; // 退出循环并返回 count 的当前值
    }
    println!("{} {}", message, count);
    count += 1;
};

println!("最终计数达到: {}", final_count);

// 定义并调用一个带参数和返回值的函数
let num1 = 10;
let num2 = 20;
let sum_result = add_numbers(num1, num2);
println!("{} + {} = {}", num1, num2, sum_result);

// 使用 for 循环遍历数组
let numbers = [1, 2, 3, 4, 5];
println!("遍历数组:");
for num in numbers {
    println!("元素: {}", num);
}

}

// 一个简单的加法函数
fn add_numbers(a: i32, b: i32) -> i32 {
a + b // 最后一个表达式作为返回值
}
“`

尝试运行上面的示例代码，并根据你的理解进行修改和实验。这是熟悉新语言语法的最好方法。

接下来去哪里？

恭喜你！你已经成功迈出了学习 Rust 的第一步：安装了环境，熟悉了基本的工具 Cargo，编写并运行了你的第一个 Rust 程序，并对变量、数据类型、函数和控制流程有了初步了解。

这仅仅是 Rust 旅程的开始。Rust 有更深奥且强大的概念等待你去探索，特别是所有权系统。

强烈建议你将以下资源列入下一步的学习计划：

  1. 《Rust 程序设计语言》（The Rust Programming Language, TRPL）： 这是 Rust 官方的免费在线书籍，被誉为“The Book”。它由 Rust 团队编写，是学习 Rust 最权威、最全面的资源。这本书会详细介绍所有权、借用、生命周期、结构体、枚举、模式匹配、模块系统、错误处理、泛型、特征（Traits）、并发等更高级的概念。从你掌握了这篇入门文章的内容后，就可以开始阅读这本书的第二章或第三章。
  2. Rust By Example： 提供大量带解释的代码示例，通过实践学习 Rust 的概念。
  3. Rustlings： 一个通过完成小型练习来学习 Rust 的交互式课程。当你安装 Rust 后，可以通过 Cargo 安装 Rustlings 并开始练习。
  4. Rust 官方文档： Rust 拥有非常详尽的官方文档，包括标准库 API 文档等。当你遇到不明白的函数、宏或类型时，查阅文档是非常好的习惯。

学习 Rust 需要耐心和毅力，尤其是在理解所有权系统时可能会感到挑战。但请记住，这是 Rust 独有的强大之处，一旦理解了它，你就能写出既安全又高效的代码。不要害怕犯错，编译器会给出非常有帮助的错误信息，引导你修正代码。

总结

在这篇入门指南中，我们完成了以下任务：

  • 了解了 Rust 的一些吸引人之处。
  • 通过 rustup 安装了 Rust 工具链（rustc, cargo 等）。
  • 编写并使用 rustc 编译运行了第一个 “Hello, World!” 程序。
  • 学习了如何使用 Cargo 创建和管理 Rust 项目。
  • 熟悉了 Cargo 的基本命令：cargo new, cargo build, cargo run, cargo check。
  • 初步了解了 Rust 的基本语法元素：变量（可变与不可变）、常见数据类型、函数、控制流程 (if/else, loop, while, for) 和注释。

迈出第一步永远是最重要的。你已经做到了！现在，继续你的 Rust 学习之旅吧，深入探索这门令人着迷的语言的更多精彩之处。

祝你学习愉快！

发表评论

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

滚动至顶部