Rust 教程：入门与实践

Rust 是一门系统编程语言，专注于安全、速度和并发性。它旨在提供一种更安全、更高效的方式来编写高性能的应用程序，而无需像 C 和 C++ 那样面临内存安全和并发安全方面的常见问题。本教程将引导你从 Rust 的基本概念开始，逐步深入到更高级的主题，并通过实践示例帮助你掌握这门强大的语言。

第一部分：入门 Rust

1.1 安装 Rust

首先，你需要安装 Rust 编译器 rustc 和包管理器 Cargo。访问 https://www.rust-lang.org/tools/install 并按照说明进行安装。安装完成后，在终端中运行 rustc --version 和 cargo --version 来验证安装是否成功。

1.2 Hello, World!

让我们从经典的 “Hello, World!” 程序开始：

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

将这段代码保存为 main.rs 文件。然后，在终端中使用以下命令编译并运行它：

bash
rustc main.rs
./main

你将在控制台上看到 “Hello, World!”。

1.3 Cargo 的使用

Cargo 是 Rust 的包管理器和构建工具。使用 Cargo 可以轻松地创建、构建和管理 Rust 项目。

1.3.1 创建新项目

使用以下命令创建一个新的 Cargo 项目：

bash
cargo new hello_cargo
cd hello_cargo

这将创建一个名为 hello_cargo 的目录，其中包含一个 src 目录和一个 Cargo.toml 文件。

1.3.2 Cargo.toml 文件

Cargo.toml 是项目的清单文件，包含项目的元数据、依赖项和其他配置信息。打开 Cargo.toml 文件，你将看到类似以下的内容：

“`toml
[package]
name = “hello_cargo”
version = “0.1.0”
edition = “2021”

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

[dependencies]
“`

[package] 部分包含项目的名称、版本和 Rust 版本。[dependencies] 部分用于指定项目依赖的外部库。

1.3.3 构建和运行项目

在 src/main.rs 文件中编写以下代码：

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

然后，使用以下命令构建并运行项目：

bash
cargo build
cargo run

cargo build 命令编译项目并将可执行文件存储在 target/debug 目录中。cargo run 命令编译并运行项目。

1.4 基本语法和数据类型

• 变量声明: 使用 let 关键字声明变量。默认情况下，变量是不可变的。使用 mut 关键字声明可变变量。

  rust
let x = 5; // 不可变变量
let mut y = 10; // 可变变量
y = 20;

• 数据类型: Rust 是一种静态类型语言，需要在编译时确定变量的类型。常见的 Rust 数据类型包括：

  • 整数: i8, i16, i32, i64, i128, u8, u16, u32, u64, u128, isize, usize
  • 浮点数: f32, f64
  • 布尔值: bool (true, false)
  • 字符: char (Unicode 标量值)
  • 字符串: String, &str (字符串切片)
  • 元组: (i32, f64, char) (固定大小的异构元素集合)
  • 数组: [i32; 5] (固定大小的同构元素集合)
  • 切片: &[i32] (数组的一部分视图)

• 函数: 使用 fn 关键字定义函数。

  “`rust
  fn add(x: i32, y: i32) -> i32 {
  x + y
  }

  let sum = add(5, 3); // sum = 8
  “`

• 控制流: Rust 提供了 if, else if, else, loop, while 和 for 等控制流语句。

  “`rust
  let number = 7;

  if number < 5 {
  println!(“condition was true”);
  } else {
  println!(“condition was false”);
  }

  for i in 1..5 { // 1, 2, 3, 4
  println!(“{}”, i);
  }
  “`

第二部分：Rust 的核心概念

2.1 所有权 (Ownership)

Rust 的所有权系统是其最重要的特性之一，它在编译时强制执行内存安全，而无需垃圾回收。

• 每个值都有一个所有者 (Owner)。
• 一次只能有一个所有者。
• 当所有者离开作用域时，值将被丢弃。

“`rust
fn main() {
let s = String::from(“hello”); // s 是 “hello” 字符串的所有者

// 所有权转移到 s2
let s2 = s;
// println!("{}", s); // 错误！s 的所有权已经转移

println!("{}", s2);

// 克隆字符串 (深度复制)
let s3 = String::from("world");
let s4 = s3.clone();

println!("{}", s3); // 没问题，s3 仍然是所有者
println!("{}", s4);

}
“`

2.2 借用 (Borrowing)

借用允许你访问数据而无需转移所有权。有两种类型的借用：可变借用和不可变借用。

• 一次可以有多个不可变借用。
• 一次只能有一个可变借用。
• 不能同时存在可变借用和不可变借用。

“`rust
fn main() {
let s = String::from(“hello”);

// 不可变借用
let len = calculate_length(&s);
println!("The length of '{}' is {}.", s, len);

// 可变借用
let mut s2 = String::from("world");
change(&mut s2);
println!("{}", s2); // "world, world"

}

fn calculate_length(s: &String) -> usize {
s.len()
}

fn change(s: &mut String) {
s.push_str(“, world”);
}
“`

2.3 切片 (Slices)

切片允许你引用数据的一部分，而无需复制数据。

“`rust
fn main() {
let s = String::from(“hello world”);

let hello = &s[0..5];
let world = &s[6..11];

println!("{} {}", hello, world);

}
“`

2.4 结构体 (Structs)

结构体允许你将相关数据组合在一起。

“`rust
struct User {
active: bool,
username: String,
email: String,
sign_in_count: u64,
}

fn main() {
let user1 = User {
active: true,
username: String::from(“someusername123”),
email: String::from(“[email protected]”),
sign_in_count: 1,
};

println!("{}", user1.username);

}
“`

2.5 枚举 (Enums)

枚举允许你定义一个类型，它可以是几个不同的值之一。

“`rust
enum Movement {
Up,
Down,
Left,
Right,
}

fn move_avatar(m: Movement) {
match m {
Movement::Up => println!(“Moving up”),
Movement::Down => println!(“Moving down”),
Movement::Left => println!(“Moving left”),
Movement::Right => println!(“Moving right”),
}
}

fn main() {
let avatar_move = Movement::Up;
move_avatar(avatar_move);
}
“`

2.6 错误处理 (Error Handling)

Rust 使用 Result 枚举来处理可能出错的操作。

“`rust
use std::fs::File;
use std::io::ErrorKind;

fn main() {
let f = File::open(“hello.txt”);

let f = match f {
    Ok(file) => file,
    Err(error) => match error.kind() {
        ErrorKind::NotFound => match File::create("hello.txt") {
            Ok(fc) => fc,
            Err(e) => panic!("Problem creating the file: {:?}", e),
        },
        other_error => {
            panic!("Problem opening the file: {:?}", other_error)
        }
    },
};

}
“`

Result<T, E> 表示操作可能成功，返回类型 T 的值，或者可能失败，返回类型 E 的错误。

第三部分：实践项目：简单的命令行工具

让我们创建一个简单的命令行工具，用于从文件中读取文本并统计单词出现的频率。

3.1 项目结构

使用 Cargo 创建一个新项目：

bash
cargo new word_counter
cd word_counter

3.2 添加依赖项

我们需要一个外部库来读取文件。在 Cargo.toml 文件中添加 clap 依赖项：

toml
[dependencies]
clap = { version = "3.0", features = ["derive"] }

3.3 代码实现 (src/main.rs)

“`rust
use std::fs;
use std::collections::HashMap;
use clap::Parser;

[derive(Parser, Debug)]

[clap(author = “Your Name”, version = “1.0”, about = “A simple word counter”, long_about = None)]

struct Args {
/// Path to the input file
#[clap(short, long, value_parser, default_value = “input.txt”)]
file: String,
}

fn main() {
let args = Args::parse();

let contents = fs::read_to_string(args.file)
    .expect("Something went wrong reading the file");

let mut word_counts: HashMap<String, u32> = HashMap::new();

for word in contents.split_whitespace() {
    let count = word_counts.entry(word.to_string()).or_insert(0);
    *count += 1;
}

for (word, count) in &word_counts {
    println!("{}: {}", word, count);
}

}
“`

3.4 运行项目

创建一个名为 input.txt 的文件，并包含一些文本：

This is a test file.
This file contains some words.
Some words are repeated.

然后，运行项目：

bash
cargo run

你应该会看到每个单词及其出现次数的列表。

第四部分：进阶主题

• 泛型 (Generics): 允许你编写适用于多种类型的代码。
• **Trait: ** 类似于接口，允许你定义共享行为。
• 生命周期 (Lifetimes): 用于确保引用有效，防止悬垂指针。
• 并发 (Concurrency): Rust 提供了强大的并发工具，例如线程和通道。
• 宏 (Macros): 允许你编写生成代码的代码。

总结

本教程涵盖了 Rust 的基本概念和一些进阶主题。通过学习和实践，你可以掌握这门强大的语言，并利用它来构建安全、高效的应用程序。记住，学习编程是一个持续的过程，不断尝试和实践才能真正掌握 Rust 的精髓。 Rust 的社区非常活跃，拥有大量的文档、教程和库，可以帮助你解决遇到的问题。祝你学习愉快！