study/ZiuChen.github.io
1
0
Fork 0
mirror of https://github.com/ZiuChen/ZiuChen.github.io.git synced 2025-08-17 23:19:55 +08:00
Code Issues Packages Projects Releases Wiki Activity

docs: Rust docs

Browse Source
This commit is contained in:
ZiuChen 2024-04-06 17:36:23 +08:00
parent a89c4a8d31
commit a606ebce69
6 changed files with 1228 additions and 9 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.npmrc Normal file
View File

@ -0,0 +1 @@
registry=https://registry.npmmirror.com

11
docs/.vitepress/config.ts
View File

@ -9,7 +9,11 @@ export default defineConfig({
lastUpdated: true,
head: [['link', { rel: 'icon', href: '/logo.png' }]],
markdown: {
lineNumbers: true
lineNumbers: true,
math: true,
image: {
lazyLoading: true
}
},
themeConfig: {
logo: '/logo.png',
@ -46,11 +50,6 @@ export default defineConfig({
text: '文章归档',
collapsed: true,
items: [...indexArticleSidebar()]
},
{
text: '学习笔记',
collapsed: true,
items: notes
}
],
socialLinks: [

3
docs/.vitepress/const/links.ts
View File

@ -20,5 +20,6 @@ export const notes = [
{ text: 'React Hooks', link: '/note/React Hooks' },
{ text: 'Redux', link: '/note/Redux' },
{ text: 'React Router', link: '/note/React Router' },
{ text: 'MySQL', link: '/note/MySQL' }
{ text: 'MySQL', link: '/note/MySQL' },
{ text: 'Rust', link: '/note/Rust' }
]

907
docs/note/Rust.md Normal file
View File

@ -0,0 +1,907 @@
# Rust
## Rust 环境搭建
`rustup` 是一个用于管理 Rust 版本和相关工具的命令行工具。
Unix 系统:
```sh
$ curl --proto '=https' --tlsv1.2 https://sh.rustup.rs -sSf | sh
```
Windows 系统:
下载并安装 [rustup-init.exe](https://static.rust-lang.org/rustup/dist/i686-pc-windows-gnu/rustup-init.exe).
安装完毕后，在命令行执行：
```sh
rustc --version
```
可以看到输出的版本号信息，则 rust 已安装完毕。
## Hello, Rust!
```sh
mkdir hello_rust
```
创建并编辑第一个 Rust 程序：
```rs
// main.rs
fn main() {
println!("Hello, Rust!");
}
```
执行 `rustc ./hello_rust/main.rs`
可以看到在代码同目录下输出了二进制文件 `main`，在命令行中执行：
```sh
./main
```
可以看到输出：
```sh
> Hello, Rust!
```
下面我们分析一下这个程序：
在 Rust 中，函数名为 `main` 的函数是一个特殊的函数，它总是会被最先执行：
```rs
fn main() {
}
```
在函数体中的代码：
```rs
println!("Hello, Rust!")
```
`println!` 是一个 Rust 宏（macro），它与函数调用的区别是它以 `!` 结尾。
`"Hello, Rust!"` 是一个字符串，传递给了 `println!` 宏。
**Rust 程序的编译和运行是独立进行的，这意味着你可以将编译产物直接发送给别人，别人不需要安装 Rust 也可以运行**
这与 Ruby Python JavaScript 这类动态语言不同，Rust 是一门**预编译静态语言**（ahead-of-time compiled）
简单项目可以使用 rustc，但随着项目复杂度增长，我们可以使用 cargo 来管理项目中的三方依赖、管理真实世界中 Rust 程序开发的方方面面。
## Cargo
```sh
# 初始化一个 Cargo 项目
cargo new hello_cargo
```
执行 `cargo new` 后会自动帮你初始化一个 Git 仓库，如果你是在一个现存的 Git 仓库中执行的初始化，那么就不会执行此操作。
除了帮你创建了一个 HelloWorld 代码，`cargo` 还创建了一个 `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]`、`[dependencies]` 分别代表是一个片段：
- 其中 `[package]` 下的字段 `name`、`version` 和 `edition` 表示项目的名称、项目的版本和使用的 Rust 版本。
- `[dependenciese]` 中记录着项目的第三方依赖，这些依赖被称为 *crates*
Cargo 期望所有的源代码都存放在 `src/` 目录下，项目根目录中保存如 README、LICENSE 这类的文件。
### 在 Cargo 中构建和运行项目
执行 `cargo build` 可以构建项目：
```sh
cargo build
```
构建产物将输出在 `target/debug/` 目录下，这是因为 `cargo build` 是调试构建（debug build）
执行：
```sh
cargo run
```
即可运行刚刚 build 输出的产物。如果你在 `cargo run` 之前未构建或修改了代码，`cargo` 会自动帮你完成 re-build 并执行代码。
```sh
cargo check
```
这个命令可以帮你完成代码的静态检查且不输出任何文件，由于它不需要准备输出构建产物，所以它比 `cargo build` 要快得多。
### 发布构建
与调试构建不同，可以执行：
```sh
cargo build --release
```
来构建一个用于生产环境的产物，这会在 `target/release/` 下输出产物而不是 `target/debug/` 下。
发布构建的产物往往有针对生产的更多优化，同时构建需要花费的时间也更长，这也是为什么要有调试构建与发布构建的区分：调试构建用于开发时更快的看到最终效果，需要经常快速地执行构建，而发布构建则是为了最终用户使用时构建的。
## Gussing Game
写一个猜数游戏：
使用 `use` 标识符来从标准库中引入 `io` 库，之后就可以在当前作用域中通过 `io:stdin()` 读取到用户输入：
```rs
use std::io;
fn main() {
println!("Guess the number!");
println!("Please input your guess.");
let mut guess = String::new();
io::stdin()
.read_line(&mut guess)
.expect("Failed to read line");
println!("You guessed: {guess}");
}
```
执行 `cargo run` 后测试一下：
```sh
Guess the number!
Please input your guess.
6
You guessed: 6
```
### 使用变量保存数据
在 Rust 中，使用 `let` 与 `const` 声明的变量默认都是不可变的，通过给 `let` 声明的变量加上 `mut` 标记，来让 guess 这个变量可变（mutatiable）
`::new` 中的 `::` 表明：`new` 是 `String` 类型的一个关联函数，在一些语言中它被称之为静态方法（static function）
总的来说，`let mut guess = String::new();` 这一行创建了一个可变变量，当前它绑定到一个新的 `String` 空实例上。
### 读取用户输入
如果在程序开头我们没有使用 `use` 来引入 `io` 库，在代码中我们也可以这样写：
```rs
std::io::stdin()
```
来动态地引入 `io` 库，通过 `read_line` 来从标准输入句柄获取用户输入。
将 `&mut guess` 传递给 `read_line`，其中 `&` 表明传递的是一个变量的引用，同时由于变量是不可变的，`&mut` 表示这个引用可以修改。
### 使用 Result 类型处理潜在错误
前文中我们说 `read_line` 会持续地将用户输入附加到传递给它的字符串中，它也会返回一个 `Result` 类型的值。
`Result` 类型是一个枚举类型，包含两种成员类型：
- `Ok`: 表示操作成功，内部包含成功时产生的值；
- `Err`: 表示操作失败，包含失败的前因后果。
这些 `Result` 类型的作用是处理错误信息，`Result` 的实例具有 `expect` 方法，如果 `io:Result` 实例的值是 `Err`，`expect` 会导致程序崩溃，并显示错误信息。
如果 `read_line` 返回 `Err`，则可能是来源于底层操作系统错误的结果。如果 `Result` 实例的值是 `Ok`，`expect` 会获取 `Ok` 中的值并原样返回。
在此例子中，这个值是用户输入到标准输入中的字节数。
### 使用 println! 占位符打印值
下面这两种 `println!` 是等价的，他们都可以将变量打印到指定位置：
```rs
println!("You guessed: {guess}");
println!("You guessed: {}", guess);
```
### 生成一个随机数
在 Rust 标准库中不包含随机数功能，我们可以使用 rand crate：
```sh
cargo add rand
```
安装后，我们到 Cargo.toml 中可以看到：
```toml
[dependencies]
rand = "0.8.5"
```
这里的 `"0.8.5"` 实际上是 `"^0.8.5"` 的简写，它表示至少是 `0.8.5` 但小于 `0.9.0` 的版本。
具体可以参看[语义化版本（Semantic Versioning）](https://semver.org/)
Cargo 通过 Cargo.lock 文件来保证每一次构建都是可以被重现的，任何人在任何时候重新构建代码都会产生相同的结果，Cargo 只会使用你指定的依赖版本。
> 如果 rand 库下周发布了 `0.8.6` 版本，新版本中修复了一个 BUG 但存在破坏性变更，如果你没有显式地在 Cargo.toml 中升级 rand 库，那 Cargo 会按照上一次构建成功时生成的 Cargo.lock 记录的第三方库版本来构建。
如果你确实要升级 crate，可以使用：
```sh
cargo update
```
来忽略 Cargo.lock 文件，并计算所有符合 Cargo.toml 声明的最新版本。
安装完了 rand crate，我们下面来生成一个随机数：
```rs
use std::io;
use rand::Rng;
fn main() {
println!("Guess the number!");
let secret_number = rand::thread_rng().gen_range(1..=100);
println!("The secret number is: {secret_number}");
println!("Please input your guess.");
let mut guess = String::new();
io::stdin()
.read_line(&mut guess)
.expect("Failed to read line");
println!("You guessed: {guess}");
}
```
`use rand:Rng;` 其中，`Rng` 是一个 trait，它定义了随机数生成器实现的方法的话，此 trait 必须在作用域中。
我们调用 `rand::thread_rng` 函数提供实际使用的**随机数生成器**：它位于当前执行线程的本地环境中，从操作系统获取 seed。
随后调用随机数生成器的 `gen_range` 方法，它由 `Rng` trait 定义，获取一个范围表达式（Range expression）作为参数，并生成一个在此范围之间的随机数。
范围表达式使用 `start..=end` 这样的形式，如 `1..=100` 就代表 1 到 100 之间。
::: info
你不可能凭空知道应当 use 哪个 trait，以及应当从 crate 中调用哪个方法，因此每个 crate 都有说明文档。
通过调用 `cargo doc --open` 来构建所有本地依赖提供的文档并在浏览器中打开。
:::
### 对比两个数字
```rs
// 此代码不可运行
use rand::Rng;
use std::cmp::Ordering;
use std::io;
fn main() {
// --snip--
println!("You guessed: {guess}");
match guess.cmp(&secret_number) {
Ordering::Less => println!("Too small!"),
Ordering::Greater => println!("Too big!"),
Ordering::Equal => println!("You win!"),
}
}
```
我们引入 `std::cmp::Ordering` 到作用域中。`Ordering` 也是一个枚举，其成员包含 `Less`、`Greater` 和 `Equal`，这是在两个值进行比较时可能出现的三种结果。
`cmp` 方法用于比较两个值，并且**可以在任何可比较的值上调用**。它获取一个被比较值的引用：将 `guess` 与 `secret_number` 作比较。然后返回一个通过 `use` 引入作用域的 `Ordering` 枚举的成员。
使用 `match` 表达式，根据对 `guess` 和 `secret_number` 调用 `cmp` 返回的 `Ordering` 成员，来决定下一步应该要做什么。
`match` 表达式由众多的分支（arms）构成，每个分支都包含一个 pattern 以及 pattern 被匹配时要执行的代码。
尝试执行此代码，编译器会抛出错误：不匹配的类型（mismatched types）。Rust 有一个静态强类型系统，同时也有类型推断。
当我们写出 `let guess = String::new();` 时，Rust 会帮我们推断出 `guess` 变量应当是 `String` 类型。
而 `secret_number` 是 1 - 100 之间的数字类型，而符合这个要求（1~100之间）的数字，在 Rust 中有下面几种：
- `i32` 32位数字；
- `u32` 32位无符号数字；
- `i64` 64位数字
- 等等 ...
Rust 默认使用 `i32`，所以 Rust 默认为 `secret_number` 推断出的类型是 `i32`，导致了字符串与数字作对比的情况。
要将 `String` 转化为数字类型才能与 `secret_number` 作比较：
```rs
let guess: u32 = guess.trim().parse().expect("Please type a number!");
```
上面的代码将重新声明 `guess` 变量，这个特性叫隐藏（Shadowing），通过 `guess.trim()` 去除字符串头尾的空白字符（如用户输入 5 并按下空格后，在 Unix 系统中 `guess` 的值为 `5\n`，在 Windows 系统中 `guess` 的值为 `5\r\n`）
`guess.parse()` 方法会将字符串转换为其他类型，通过给 `guess` 显式指定类型来告诉 `guess` 方法转化的目标类型，这里的目标类型是 `u32`。
同时，为了防止字符串中包含特殊字符等原因导致 `parse` 执行失败，这里用 `expect` 来对转化是否成功进行提示：
- 如果 `parse` 不能从字符串生成一个数字，返回一个 `Result` 的 `Err` 成员时，`expect` 方法会使程序结束并打印附加的信息。
- 如果 `parse` 成功执行，那么它会返回 `Result` 的 `Ok` 成员，然后 `expect` 会返回 `Ok` 值中的数字。
### 使用循环来允许多次猜测
可以使用 `loop` 关键字来创建一个无限循环，给用户更多机会来猜数。
```rs
println!("The secret number is: {secret_number}");
loop {
println!("Please input your guess.");
// --snip--
match guess.cmp(&secret_number) {
Ordering::Less => println!("Too small!"),
Ordering::Greater => println!("Too big!"),
Ordering::Equal => {
println!("You win!");
break;
},
}
}
```
当用户成功猜对后，会执行 `break;` 退出程序。
### 忽略非数字的猜测并继续游戏
目前的代码如果用户输入了非数字，会导致 `parse` 失败，进而导致程序退出，因此我们需要改写这部分的逻辑，将 `expect` 调用 改为 `match`：
```rs
// --snip--
io::stdin()
.read_line(&mut guess)
.expect("Failed to read line");
let guess: u32 = match guess.trim().parse() {
Ok(num) => num,
Err(_) => continue,
};
println!("You guessed: {guess}");
// --snip--
```
这样当遇到错误时程序不再崩溃，而是进入到 `match` 的错误分支中处理错误：调用 `continue;` 继续循环。
### 总结
这一章里我们学习了使用 `let` 声明变量、变量隐藏、类型转化、`match` 处理多分支任务、`loop` 循环。
还学习了外部 crate 的使用、如何指定数据类型等
## 常见编程概念
### 变量和可变性
变量默认是不可变的（Immutable），这是 Rust 提供的众多特性之一：
下面的代码由于修改了 `x` 导致编译不通过：
```rs
fn main() {
let x = 5;
println!("x is {}", x);
x = 6;
println!("x is {}", x);
}
```
编译器抛出的错误信息：cannot assign twice to immutable variable `x`
要让 `x` 变得可变，可以在声明 `let` 后添加 `mut`：
```rs
let mut x = 5;
```
这样就可以修改 `x` 的值了。
除了 `let`，还可以通过 `const` 声明一个常量：
- 常量总是不可变，且不允许对常量使用 `mut`
- 必须在声明时注明值的类型
- 常量只能被设置为常量表达式，而不是任何只能在运行时计算出的值
```rs
const THREE_HOURS_IN_SECONDS: u32 = 60 * 60 * 3;
```
这里的 `60 * 60 * 3` 会在编译器编译时执行运算，这使我们可以选择更容易理解和验证的方式来写出这个值，而不是直接将常量设置为 `10,800`。
在前文中我们介绍了变量隐藏，后声明的同名变量将会屏蔽掉之前声明的变量，直到新的变量也被隐藏或作用域结束：
```rs
fn main() {
let x = 5; // 5
let x = x + 1; // 6
{
let x = x * 2;
println!("x is {}", x); // 12
}
println!("x is {}", x); // 6
}
```
需要注意的是，隐藏与将变量标记为 `mut` 是有区别的，当对变量进行重新赋值时，如果没有使用 `mut` 那么会导致编译时错误。通过变量隐藏，我们可以用新的变量进行一些计算，但计算完之后变量依然是不可变的。
`mut` 与隐藏的另一个区别是：当再次使用 `let` 声明变量时，隐藏实际上创建了一个新的变量，我们可以改变值的类型，只不过复用这个名字：
如果没有变量隐藏，代码可能会像这样：
```rs
let spaces_str = " ";
let spaces_num = spaces_str.len();
```
利用变量隐藏，我们可以简单地复用相同变量名：
```rs
let spaces = " "; // 文本之间的空格数量
let spaces = spaces.len(); // 多少个空格
```
然而，如果使用 `mut`，他不允许修改变量的类型：
```rs
let spaces = " ";
spaces = spaces.len(); // 错误：不能改变变量的类型
```
### 数据类型
在 Rust 中，每一个值都属于某一种数据类型（data type），这告诉 Rust 它被指定为何种数据。
Rust 是静态类型（statically typed）语言编译时必须知道所有变量的类型，当多种类型均有可能时，例如使用 `parse` 将 `String` 转换为数字时，必须增加类型注解，像这样：
```rs
let guess: u32 = "42".parse().expect("Not a number!")
```
在 Rust 中有两种数据类型子集：标量和复合
#### 标量类型（scalar）
##### 整型
整型是一个没有小数部分的数字，例如 `u32` 代表一个占据 32 bit 的无符号整数。其中**有符号**和**无符号**代表数字能否为负值。
| 长度 | 有符号 | 无符号 |
|-------|------|------|
| 8-bit | i8 | u8 |
| 16-bit | i16 | u16 |
| 32-bit | i32 | u32 |
| 64-bit | i64 | u64 |
| 128-bit| i128 | u128 |
| arch | isize| usize|
有符号的整型可以存储从 $-(2^{n-1})$ 到 $2^{n-1}-1$ 在内的数字，这里的 $n$ 代表位数。
例如 `i8` 可以存储 $-(2^7)$ 到 $2^7-1$ 在内的数字，也就是从 -128 到 127。
无符号的整型可以存储从 $0$ 到 $2^n-1$的数字。
所以 `u8` 可以存储 $0$ 到 $2^8-1$ 的数字，也就是 0 到 255。
另外，`isize` 与 `usize` 类型依赖运行程序的计算机架构：在 64 位架构上，它们是 64 位的，在 32 位架构上，它们是 32 位的。分别等价于 `i64` `i32` 与 `u64` 和 `u32`。
除了通过类型指定变量的整型类型，还可以以后缀形式使用类型，例如 `let x = 57u8;`。还可以通过数字字面值来指定类型：
`1000` 与 `1_000` 等价，但后者更易读。
| 数字字面值 | 例子 |
|------------------------|------------|
| Decimal (十进制) | 98_222 |
| Hex (十六进制) | 0xff |
| Octal (八进制) | 0o77 |
| Binary (二进制) | 0b1111_0000 |
| Byte (单字节字符)(仅限于u8) | b'A' |
##### 浮点型
在 Rust 中有两个原生浮点数类型：
- `f32` 单精度浮点数，占 32 位
- `f64` 双精度浮点数，占 64 位，现代 CPU 中，它与 `f32` 速度几乎一样，不过精度更高
浮点数都是有符号的。
```rs
fn main() {
let x = 2.0; // f64
let y: f32 = 3.0; // f32
}
```
Rust 中的所有数字类型都支持基本数学运算：加法、减法、乘法、除法和取余。整数除法会向零舍入到最接近的整数：
```rs
fn main() {
// addition
let sum = 5 + 10;
// subtraction
let difference = 95.5 - 4.3;
// multiplication
let product = 4 * 30;
// division
let quotient = 56.7 / 32.2;
let truncated = -5 / 3; // 结果为 -1
// remainder
let remainder = 43 % 5;
}
```
##### 布尔型
```rs
let t = true;
let f: bool = false;
```
##### 字符类型
Rust 的 `char` 类型是语言最原生的字母类型，大小为四个字节：
```rs
fn main() {
let c = 'z';
let z: char = 'ℤ'; // 显式类型声明
let heart_eye_cat = '😻';
}
```
#### 复合类型（compound）
复合类型（Compound types）可以将多个值组合成一个类型。Rust 有两个原生的复合类型：元组（tuple）和数组（array）。
##### 元组类型
元组是一个将多个其他类型的值组合进一个复合类型的主要方式。元组长度固定：一旦声明，其长度不会增大或缩小。
```rs
fn main() {
let tup: (i32, f64, u8) = (500, 6.4, 1);
}
```
可以使用模式匹配（pattern matching）来解构（destructure）元组值：
```rs
fn main() {
let tup = (500, 6.4, 1);
let (x, y, z) = tup;
println!("{}", y); // 6.4
}
```
也可以直接用 `.` 跟随值的索引来访问元组中的元素：
```rs
fn main() {
let tup = (500, 6.4, 1);
let x = tup.0;
let y = tup.1;
let z = tup.2;
println!("{}", x); // 500
}
```
不带任何值的元组有个特殊的名称，叫做 单元（unit） 元组。这种值以及对应的类型都写作 `()`，表示**空值或空的返回类型**。如果表达式不返回任何其他值，则会隐式返回单元值。
##### 数组类型
与元组不同，数组中每个元素的类型必须相同。
**Rust 中的数组长度是固定的。**
```rs
fn main() {
let a = [1, 2, 3, 4, 5];
}
```
当你想要在栈（stack）而不是在堆（heap）上为数据分配空间（第四章将讨论栈与堆的更多内容），或者是想要确保总是有固定数量的元素时，数组非常有用。
但是数组并不如 `vector` 类型灵活。
`vector` 类型是标准库提供的一个 允许 增长和缩小长度的类似数组的集合类型。当不确定是应该使用数组还是 vector 的时候，那么很可能应该使用 `vector`。
然而，当你**确定元素个数不会改变时，数组会更有用**。
例如，当你在一个程序中使用月份名字时，你更应趋向于使用数组而不是 `vector`，因为你确定只会有 12 个元素。
```rs
let months = ["January", "February", "March", "April", "May", "June", "July",
"August", "September", "October", "November", "December"];
```
声明数组时，可以像这样编写数组的类型，既能约束数组中元素的类型，还能限制数组的长度：
```rs
let a: [i32; 5] = [1, 2, 3, 4, 5];
```
这里的 `i32` 代表每个元素的类型，分号之后的 `5` 代表数组的长度为 5，包含五个元素。
还可以在类型声明中指定初始值：
```rs
let b: [3, 5];
```
这样变量 `b` 就是一个长度为 5，初始值全为 3 的数组。
数组是可以在栈 (stack) 上分配的已知固定大小的单个内存块。可以使用索引来访问数组的元素，像这样：
```rs
let c = [1, 2, 3, 4, 5];
let x = c[0]; // 1
let y = c[1]; // 2
```
通过索引从数组中取值的操作如果是在运行时进行的，那么代码可以顺利通过编译，但在运行时会出错：
下面这段代码可以正常通过编译，当你输入 0 1 2 3 4 访问数组时工作正常，但一旦输入了超过数组长度的索引如 10，就会抛出错误。
```rs
use std::io;
fn main() {
let a = [1, 2, 3, 4, 5];
println!("Please enter an array index.");
let mut index = String::new();
io::stdin()
.read_line(&mut index)
.expect("Failed to read line");
let index: usize = index
.trim()
.parse()
.expect("Index entered was not a number");
let element = a[index];
println!("The value of the element at index {index} is: {element}");
}
```
```sh
thread 'main' panicked at 'index out of bounds: the len is 5 but the index is 10', src/main.rs:19:19
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
```
### 函数
- 必须显式指定参数的类型
- 通过 `->` 指定返回值的类型
- 函数结尾不包含分号时，隐式返回表达式
```rs
fn main() {
print_labeled_measurement(188, 's');
let f: i32 = five();
println!("five: {}", f);
}
fn print_labeled_measurement(value: i32, unit_label: char) {
println!("The measurement is: {value}{unit_label}");
}
fn five() -> i32 {
// 结尾不包含分号 隐式返回表达式
5
}
```
### 控制流
#### if-else & else-if
- 可以省略 if 与条件之间的空格
- 不允许隐式转换
```rs
fn main() {
let number = 3;
if number < 5 {
println!("Yes.");
} else {
println!("No.");
}
}
```
```rs
// 不允许隐式转换 条件表达式必须返回一个布尔值
if number {
println!("Yes.");
}
if number != 0 {
println!("Yes.");
}
```
`if` 可以返回一个值，因此可以在 `let` 语句中使用 `if`：
```rs
fn main() {
let condition = true;
// if 与 else 分支的结果都为 i32
let number = if condition { 5 } else { 6 };
println!("number: {}", number);
}
```
由于类型必须在编译时被确定，编译器会自动识别出不符合这一原则的 if-in-let 声明：
```rs
fn main() {
// 编译报错 因为 if 与 else 分支的结果类型不同
let number = if condition { 5 } else { "six" }
}
```
#### 循环
- `break;` 用于中止循环
- `continue;` 用于跳过当次循环
- `break;` 可以从循环返回表达式
```rs
fn main() {
let mut count = 0;
let result = loop {
count += 1;
if (count == 10) {
break count * 2;
}
}
println!("result: {}", result); // 20
}
```
循环标签：在多个循环之间消除歧义
如果你存在一个嵌套的循环，而 `break;` 与 `continue;` 只会应用于此时最内层的循环，可以通过循环标签来让这些关键字应用于已标记的循环：
```rs
fn main() {
let mut count = 0;
'counting_up: loop {
println!("count = {count}");
let mut remaining = 10;
loop {
println!("remaining = {remaining}");
if remaining == 9 {
break;
}
if count == 2 {
break 'counting_up;
}
remaining -= 1;
}
count += 1;
}
println!("End count = {count}");
}
```
上面的代码中，第一个 `break;` 语句只会退出内层循环，而 `break 'counting_up';` 语句将直接退出外层循环。
除了 `loop`，Rust 还支持通过 `while` 来控制循环：
```rs
fn main() {
let mut number = 3;
while number != 0 {
println!("{number}!");
number -= 1;
}
println!("LIFTOFF!!!");
}
```
当我们要实现遍历集合中的元素时，用 `for` 会更方便：
```rs
fn main() {
let a = [10, 20, 30, 40, 50];
for element in a {
println!("value is {}", a);
}
}
```
`for` 亦可用于计时：
这段代码中用到了 `.rev()` 方法来将 range 反转
```rs
fn main() {
for number in (1..4).rev() {
println!("{number}!");
}
println!("LIFTOFF!!!");
}
```
## 所有权
### 什么是所有权
### 引用与借用
### Slice 类型
## 结构体
### 结构体的定义与初始化
### 示例
### 方法语法
## 枚举和模式匹配
### 枚举的定义
### match 控制流结构
### if let 简洁控制流

1
package.json
View File

@ -9,6 +9,7 @@
"@types/node": "^20.12.2",
"@vitejs/plugin-vue-jsx": "^3.1.0",
"ant-design-vue": "^4.1.2",
"markdown-it-mathjax3": "^4.3.2",
"vite": "^5.2.7",
"vue": "^3.4.21"
},

314
pnpm-lock.yaml generated
View File

@ -13,7 +13,7 @@ dependencies:
version: 11.1.0
vitepress:
specifier: 1.0.2
version: 1.0.2(@algolia/client-search@4.23.2)(@types/node@20.12.2)(search-insights@2.13.0)
version: 1.0.2(@algolia/client-search@4.23.2)(@types/node@20.12.2)(markdown-it-mathjax3@4.3.2)(search-insights@2.13.0)
devDependencies:
'@types/node':
@ -25,6 +25,9 @@ devDependencies:
ant-design-vue:
specifier: ^4.1.2
version: 4.1.2(vue@3.4.21)
markdown-it-mathjax3:
specifier: ^4.3.2
version: 4.3.2
vite:
specifier: ^5.2.7
version: 5.2.7(@types/node@20.12.2)
@ -569,138 +572,184 @@ packages:
/@esbuild/aix-ppc64@0.20.2:
resolution: {integrity: sha512-D+EBOJHXdNZcLJRBkhENNG8Wji2kgc9AZ9KiPr1JuZjsNtyHzrsfLRrY0tk2H2aoFu6RANO1y1iPPUCDYWkb5g==}
engines: {node: '>=12'}
cpu: [ppc64]
os: [aix]
requiresBuild: true
optional: true
/@esbuild/android-arm64@0.20.2:
resolution: {integrity: sha512-mRzjLacRtl/tWU0SvD8lUEwb61yP9cqQo6noDZP/O8VkwafSYwZ4yWy24kan8jE/IMERpYncRt2dw438LP3Xmg==}
engines: {node: '>=12'}
cpu: [arm64]
os: [android]
requiresBuild: true
optional: true
/@esbuild/android-arm@0.20.2:
resolution: {integrity: sha512-t98Ra6pw2VaDhqNWO2Oph2LXbz/EJcnLmKLGBJwEwXX/JAN83Fym1rU8l0JUWK6HkIbWONCSSatf4sf2NBRx/w==}
engines: {node: '>=12'}
cpu: [arm]
os: [android]
requiresBuild: true
optional: true
/@esbuild/android-x64@0.20.2:
resolution: {integrity: sha512-btzExgV+/lMGDDa194CcUQm53ncxzeBrWJcncOBxuC6ndBkKxnHdFJn86mCIgTELsooUmwUm9FkhSp5HYu00Rg==}
engines: {node: '>=12'}
cpu: [x64]
os: [android]
requiresBuild: true
optional: true
/@esbuild/darwin-arm64@0.20.2:
resolution: {integrity: sha512-4J6IRT+10J3aJH3l1yzEg9y3wkTDgDk7TSDFX+wKFiWjqWp/iCfLIYzGyasx9l0SAFPT1HwSCR+0w/h1ES/MjA==}
engines: {node: '>=12'}
cpu: [arm64]
os: [darwin]
requiresBuild: true
optional: true
/@esbuild/darwin-x64@0.20.2:
resolution: {integrity: sha512-tBcXp9KNphnNH0dfhv8KYkZhjc+H3XBkF5DKtswJblV7KlT9EI2+jeA8DgBjp908WEuYll6pF+UStUCfEpdysA==}
engines: {node: '>=12'}
cpu: [x64]
os: [darwin]
requiresBuild: true
optional: true
/@esbuild/freebsd-arm64@0.20.2:
resolution: {integrity: sha512-d3qI41G4SuLiCGCFGUrKsSeTXyWG6yem1KcGZVS+3FYlYhtNoNgYrWcvkOoaqMhwXSMrZRl69ArHsGJ9mYdbbw==}
engines: {node: '>=12'}
cpu: [arm64]
os: [freebsd]
requiresBuild: true
optional: true
/@esbuild/freebsd-x64@0.20.2:
resolution: {integrity: sha512-d+DipyvHRuqEeM5zDivKV1KuXn9WeRX6vqSqIDgwIfPQtwMP4jaDsQsDncjTDDsExT4lR/91OLjRo8bmC1e+Cw==}
engines: {node: '>=12'}
cpu: [x64]
os: [freebsd]
requiresBuild: true
optional: true
/@esbuild/linux-arm64@0.20.2:
resolution: {integrity: sha512-9pb6rBjGvTFNira2FLIWqDk/uaf42sSyLE8j1rnUpuzsODBq7FvpwHYZxQ/It/8b+QOS1RYfqgGFNLRI+qlq2A==}
engines: {node: '>=12'}
cpu: [arm64]
os: [linux]
requiresBuild: true
optional: true
/@esbuild/linux-arm@0.20.2:
resolution: {integrity: sha512-VhLPeR8HTMPccbuWWcEUD1Az68TqaTYyj6nfE4QByZIQEQVWBB8vup8PpR7y1QHL3CpcF6xd5WVBU/+SBEvGTg==}
engines: {node: '>=12'}
cpu: [arm]
os: [linux]
requiresBuild: true
optional: true
/@esbuild/linux-ia32@0.20.2:
resolution: {integrity: sha512-o10utieEkNPFDZFQm9CoP7Tvb33UutoJqg3qKf1PWVeeJhJw0Q347PxMvBgVVFgouYLGIhFYG0UGdBumROyiig==}
engines: {node: '>=12'}
cpu: [ia32]
os: [linux]
requiresBuild: true
optional: true
/@esbuild/linux-loong64@0.20.2:
resolution: {integrity: sha512-PR7sp6R/UC4CFVomVINKJ80pMFlfDfMQMYynX7t1tNTeivQ6XdX5r2XovMmha/VjR1YN/HgHWsVcTRIMkymrgQ==}
engines: {node: '>=12'}
cpu: [loong64]
os: [linux]
requiresBuild: true
optional: true
/@esbuild/linux-mips64el@0.20.2:
resolution: {integrity: sha512-4BlTqeutE/KnOiTG5Y6Sb/Hw6hsBOZapOVF6njAESHInhlQAghVVZL1ZpIctBOoTFbQyGW+LsVYZ8lSSB3wkjA==}
engines: {node: '>=12'}
cpu: [mips64el]
os: [linux]
requiresBuild: true
optional: true
/@esbuild/linux-ppc64@0.20.2:
resolution: {integrity: sha512-rD3KsaDprDcfajSKdn25ooz5J5/fWBylaaXkuotBDGnMnDP1Uv5DLAN/45qfnf3JDYyJv/ytGHQaziHUdyzaAg==}
engines: {node: '>=12'}
cpu: [ppc64]
os: [linux]
requiresBuild: true
optional: true
/@esbuild/linux-riscv64@0.20.2:
resolution: {integrity: sha512-snwmBKacKmwTMmhLlz/3aH1Q9T8v45bKYGE3j26TsaOVtjIag4wLfWSiZykXzXuE1kbCE+zJRmwp+ZbIHinnVg==}
engines: {node: '>=12'}
cpu: [riscv64]
os: [linux]
requiresBuild: true
optional: true
/@esbuild/linux-s390x@0.20.2:
resolution: {integrity: sha512-wcWISOobRWNm3cezm5HOZcYz1sKoHLd8VL1dl309DiixxVFoFe/o8HnwuIwn6sXre88Nwj+VwZUvJf4AFxkyrQ==}
engines: {node: '>=12'}
cpu: [s390x]
os: [linux]
requiresBuild: true
optional: true
/@esbuild/linux-x64@0.20.2:
resolution: {integrity: sha512-1MdwI6OOTsfQfek8sLwgyjOXAu+wKhLEoaOLTjbijk6E2WONYpH9ZU2mNtR+lZ2B4uwr+usqGuVfFT9tMtGvGw==}
engines: {node: '>=12'}
cpu: [x64]
os: [linux]
requiresBuild: true
optional: true
/@esbuild/netbsd-x64@0.20.2:
resolution: {integrity: sha512-K8/DhBxcVQkzYc43yJXDSyjlFeHQJBiowJ0uVL6Tor3jGQfSGHNNJcWxNbOI8v5k82prYqzPuwkzHt3J1T1iZQ==}
engines: {node: '>=12'}
cpu: [x64]
os: [netbsd]
requiresBuild: true
optional: true
/@esbuild/openbsd-x64@0.20.2:
resolution: {integrity: sha512-eMpKlV0SThJmmJgiVyN9jTPJ2VBPquf6Kt/nAoo6DgHAoN57K15ZghiHaMvqjCye/uU4X5u3YSMgVBI1h3vKrQ==}
engines: {node: '>=12'}
cpu: [x64]
os: [openbsd]
requiresBuild: true
optional: true
/@esbuild/sunos-x64@0.20.2:
resolution: {integrity: sha512-2UyFtRC6cXLyejf/YEld4Hajo7UHILetzE1vsRcGL3earZEW77JxrFjH4Ez2qaTiEfMgAXxfAZCm1fvM/G/o8w==}
engines: {node: '>=12'}
cpu: [x64]
os: [sunos]
requiresBuild: true
optional: true
/@esbuild/win32-arm64@0.20.2:
resolution: {integrity: sha512-GRibxoawM9ZCnDxnP3usoUDO9vUkpAxIIZ6GQI+IlVmr5kP3zUq+l17xELTHMWTWzjxa2guPNyrpq1GWmPvcGQ==}
engines: {node: '>=12'}
cpu: [arm64]
os: [win32]
requiresBuild: true
optional: true
/@esbuild/win32-ia32@0.20.2:
resolution: {integrity: sha512-HfLOfn9YWmkSKRQqovpnITazdtquEW8/SoHW7pWpuEeguaZI4QnCRW6b+oZTztdBnZOS2hqJ6im/D5cPzBTTlQ==}
engines: {node: '>=12'}
cpu: [ia32]
os: [win32]
requiresBuild: true
optional: true
/@esbuild/win32-x64@0.20.2:
resolution: {integrity: sha512-N49X4lJX27+l9jbLKSqZ6bKNjzQvHaT8IIFUy+YIqmXQdjYCToGWwOItDrfby14c78aDd5NHQl29xingXfCdLQ==}
engines: {node: '>=12'}
cpu: [x64]
os: [win32]
requiresBuild: true
optional: true
@ -735,76 +784,113 @@ packages:
/@rollup/rollup-android-arm-eabi@4.13.2:
resolution: {integrity: sha512-3XFIDKWMFZrMnao1mJhnOT1h2g0169Os848NhhmGweEcfJ4rCi+3yMCOLG4zA61rbJdkcrM/DjVZm9Hg5p5w7g==}
cpu: [arm]
os: [android]
requiresBuild: true
optional: true
/@rollup/rollup-android-arm64@4.13.2:
resolution: {integrity: sha512-GdxxXbAuM7Y/YQM9/TwwP+L0omeE/lJAR1J+olu36c3LqqZEBdsIWeQ91KBe6nxwOnb06Xh7JS2U5ooWU5/LgQ==}
cpu: [arm64]
os: [android]
requiresBuild: true
optional: true
/@rollup/rollup-darwin-arm64@4.13.2:
resolution: {integrity: sha512-mCMlpzlBgOTdaFs83I4XRr8wNPveJiJX1RLfv4hggyIVhfB5mJfN4P8Z6yKh+oE4Luz+qq1P3kVdWrCKcMYrrA==}
cpu: [arm64]
os: [darwin]
requiresBuild: true
optional: true
/@rollup/rollup-darwin-x64@4.13.2:
resolution: {integrity: sha512-yUoEvnH0FBef/NbB1u6d3HNGyruAKnN74LrPAfDQL3O32e3k3OSfLrPgSJmgb3PJrBZWfPyt6m4ZhAFa2nZp2A==}
cpu: [x64]
os: [darwin]
requiresBuild: true
optional: true
/@rollup/rollup-linux-arm-gnueabihf@4.13.2:
resolution: {integrity: sha512-GYbLs5ErswU/Xs7aGXqzc3RrdEjKdmoCrgzhJWyFL0r5fL3qd1NPcDKDowDnmcoSiGJeU68/Vy+OMUluRxPiLQ==}
cpu: [arm]
os: [linux]
requiresBuild: true
optional: true
/@rollup/rollup-linux-arm64-gnu@4.13.2:
resolution: {integrity: sha512-L1+D8/wqGnKQIlh4Zre9i4R4b4noxzH5DDciyahX4oOz62CphY7WDWqJoQ66zNR4oScLNOqQJfNSIAe/6TPUmQ==}
cpu: [arm64]
os: [linux]
libc: [glibc]
requiresBuild: true
optional: true
/@rollup/rollup-linux-arm64-musl@4.13.2:
resolution: {integrity: sha512-tK5eoKFkXdz6vjfkSTCupUzCo40xueTOiOO6PeEIadlNBkadH1wNOH8ILCPIl8by/Gmb5AGAeQOFeLev7iZDOA==}
cpu: [arm64]
os: [linux]
libc: [musl]
requiresBuild: true
optional: true
/@rollup/rollup-linux-powerpc64le-gnu@4.13.2:
resolution: {integrity: sha512-zvXvAUGGEYi6tYhcDmb9wlOckVbuD+7z3mzInCSTACJ4DQrdSLPNUeDIcAQW39M3q6PDquqLWu7pnO39uSMRzQ==}
cpu: [ppc64le]
os: [linux]
libc: [glibc]
requiresBuild: true
optional: true
/@rollup/rollup-linux-riscv64-gnu@4.13.2:
resolution: {integrity: sha512-C3GSKvMtdudHCN5HdmAMSRYR2kkhgdOfye4w0xzyii7lebVr4riCgmM6lRiSCnJn2w1Xz7ZZzHKuLrjx5620kw==}
cpu: [riscv64]
os: [linux]
libc: [glibc]
requiresBuild: true
optional: true
/@rollup/rollup-linux-s390x-gnu@4.13.2:
resolution: {integrity: sha512-l4U0KDFwzD36j7HdfJ5/TveEQ1fUTjFFQP5qIt9gBqBgu1G8/kCaq5Ok05kd5TG9F8Lltf3MoYsUMw3rNlJ0Yg==}
cpu: [s390x]
os: [linux]
libc: [glibc]
requiresBuild: true
optional: true
/@rollup/rollup-linux-x64-gnu@4.13.2:
resolution: {integrity: sha512-xXMLUAMzrtsvh3cZ448vbXqlUa7ZL8z0MwHp63K2IIID2+DeP5iWIT6g1SN7hg1VxPzqx0xZdiDM9l4n9LRU1A==}
cpu: [x64]
os: [linux]
libc: [glibc]
requiresBuild: true
optional: true
/@rollup/rollup-linux-x64-musl@4.13.2:
resolution: {integrity: sha512-M/JYAWickafUijWPai4ehrjzVPKRCyDb1SLuO+ZyPfoXgeCEAlgPkNXewFZx0zcnoIe3ay4UjXIMdXQXOZXWqA==}
cpu: [x64]
os: [linux]
libc: [musl]
requiresBuild: true
optional: true
/@rollup/rollup-win32-arm64-msvc@4.13.2:
resolution: {integrity: sha512-2YWwoVg9KRkIKaXSh0mz3NmfurpmYoBBTAXA9qt7VXk0Xy12PoOP40EFuau+ajgALbbhi4uTj3tSG3tVseCjuA==}
cpu: [arm64]
os: [win32]
requiresBuild: true
optional: true
/@rollup/rollup-win32-ia32-msvc@4.13.2:
resolution: {integrity: sha512-2FSsE9aQ6OWD20E498NYKEQLneShWes0NGMPQwxWOdws35qQXH+FplabOSP5zEe1pVjurSDOGEVCE2agFwSEsw==}
cpu: [ia32]
os: [win32]
requiresBuild: true
optional: true
/@rollup/rollup-win32-x64-msvc@4.13.2:
resolution: {integrity: sha512-7h7J2nokcdPePdKykd8wtc8QqqkqxIrUz7MHj6aNr8waBRU//NLDVnNjQnqQO6fqtjrtCdftpbTuOKAyrAQETQ==}
cpu: [x64]
os: [win32]
requiresBuild: true
optional: true
@ -1106,6 +1192,10 @@ packages:
'@algolia/transporter': 4.23.2
dev: false
/ansi-colors@4.1.3:
resolution: {integrity: sha512-/6w/C21Pm1A7aZitlI5Ni/2J6FFQN8i1Cvz3kHABAAbw93v/NlvKdVOqz7CCWz/3iv/JplRSEEZ83XION15ovw==}
engines: {node: '>=6'}
/ansi-styles@3.2.1:
resolution: {integrity: sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==}
engines: {node: '>=4'}
@ -1152,6 +1242,9 @@ packages:
resolution: {integrity: sha512-7HhHjtERjqlNbZtqNqy2rckN/SpOOlmDliet+lP7k+eKZEjPk3DgyeU9lIXLdeLz0uBbbVp+9Qdow9wJWgwwfg==}
dev: true
/boolbase@1.0.0:
resolution: {integrity: sha512-JZOSA7Mo9sNGB8+UjSgzdLtokWAky1zbztM3WRLCbZ70/3cTANmQmOdR7y2g+J0e2WXywy1yS468tY+IruqEww==}
/browserslist@4.23.0:
resolution: {integrity: sha512-QW8HiM1shhT2GuzkvklfjcKDiWFXHOeFCIA/huJPwHsslwcydgk7X+z2zXpEijP98UCY7HbubZt5J2Zgvf0CaQ==}
engines: {node: ^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7}
@ -1181,6 +1274,27 @@ packages:
supports-color: 5.5.0
dev: true
/cheerio-select@1.6.0:
resolution: {integrity: sha512-eq0GdBvxVFbqWgmCm7M3XGs1I8oLy/nExUnh6oLqmBditPO9AqQJrkslDpMun/hZ0yyTs8L0m85OHp4ho6Qm9g==}
dependencies:
css-select: 4.3.0
css-what: 6.1.0
domelementtype: 2.3.0
domhandler: 4.3.1
domutils: 2.8.0
/cheerio@1.0.0-rc.10:
resolution: {integrity: sha512-g0J0q/O6mW8z5zxQ3A8E8J1hUgp4SMOvEoW/x84OwyHKe/Zccz83PVT4y5Crcr530FV6NgmKI1qvGTKVl9XXVw==}
engines: {node: '>= 6'}
dependencies:
cheerio-select: 1.6.0
dom-serializer: 1.4.1
domhandler: 4.3.1
htmlparser2: 6.1.0
parse5: 6.0.1
parse5-htmlparser2-tree-adapter: 6.0.1
tslib: 2.6.2
/color-convert@1.9.3:
resolution: {integrity: sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==}
dependencies:
@ -1191,6 +1305,14 @@ packages:
resolution: {integrity: sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==}
dev: true
/commander@6.2.1:
resolution: {integrity: sha512-U7VdrJFnJgo4xjrHpTzu0yrHPGImdsmD95ZlgYSEajAn2JKzDhDTPG9kBTefmObL2w/ngeZnilk+OV9CG3d7UA==}
engines: {node: '>= 6'}
/commander@9.2.0:
resolution: {integrity: sha512-e2i4wANQiSXgnrBlIatyHtP1odfUp0BbV5Y5nEGbxtIrStkEOAAzCUirvLBNXHLr7kwLvJl6V+4V3XV9x7Wd9w==}
engines: {node: ^12.20.0 || >=14}
/compute-scroll-into-view@1.0.20:
resolution: {integrity: sha512-UCB0ioiyj8CRjtrvaceBLqqhZCVP+1B8+NWQhmdsm0VXOJtobBCf1dBQmebCCo34qZmUwZfIH2MZLqNHazrfjg==}
dev: true
@ -1204,6 +1326,19 @@ packages:
requiresBuild: true
dev: true
/css-select@4.3.0:
resolution: {integrity: sha512-wPpOYtnsVontu2mODhA19JrqWxNsfdatRKd64kmpRbQgh1KtItko5sTnEpPdpSaJszTOhEMlF/RPz28qj4HqhQ==}
dependencies:
boolbase: 1.0.0
css-what: 6.1.0
domhandler: 4.3.1
domutils: 2.8.0
nth-check: 2.1.1
/css-what@6.1.0:
resolution: {integrity: sha512-HTUrgRJ7r4dsZKU6GjmpfRK1O76h97Z8MfS1G0FozR+oF2kG6Vfe8JE6zwrkbxigziPHinCJ+gCPjA9EaBDtRw==}
engines: {node: '>= 6'}
/csstype@3.1.3:
resolution: {integrity: sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw==}
@ -1231,10 +1366,42 @@ packages:
resolution: {integrity: sha512-bvVTQe1lfaUr1oFzZX80ce9KLDlZ3iU+XGNE/bz9HnGdklTieqsbmsLHe+rT2XWqopvL0PckkYqN7ksmm5pe3w==}
dev: true
/dom-serializer@1.4.1:
resolution: {integrity: sha512-VHwB3KfrcOOkelEG2ZOfxqLZdfkil8PtJi4P8N2MMXucZq2yLp75ClViUlOVwyoHEDjYU433Aq+5zWP61+RGag==}
dependencies:
domelementtype: 2.3.0
domhandler: 4.3.1
entities: 2.2.0
/domelementtype@2.3.0:
resolution: {integrity: sha512-OLETBj6w0OsagBwdXnPdN0cnMfF9opN69co+7ZrbfPGrdpPVNBUj02spi6B1N7wChLQiPn4CSH/zJvXw56gmHw==}
/domhandler@3.3.0:
resolution: {integrity: sha512-J1C5rIANUbuYK+FuFL98650rihynUOEzRLxW+90bKZRWB6A1X1Tf82GxR1qAWLyfNPRvjqfip3Q5tdYlmAa9lA==}
engines: {node: '>= 4'}
dependencies:
domelementtype: 2.3.0
/domhandler@4.3.1:
resolution: {integrity: sha512-GrwoxYN+uWlzO8uhUXRl0P+kHE4GtVPfYzVLcUxPL7KNdHKj66vvlhiweIHqYYXWlw+T8iLMp42Lm67ghw4WMQ==}
engines: {node: '>= 4'}
dependencies:
domelementtype: 2.3.0
/domutils@2.8.0:
resolution: {integrity: sha512-w96Cjofp72M5IIhpjgobBimYEfoPjx1Vx0BSX9P30WBdZW2WIKU0T1Bd0kz2eNZ9ikjKgHbEyKx8BB6H1L3h3A==}
dependencies:
dom-serializer: 1.4.1
domelementtype: 2.3.0
domhandler: 4.3.1
/electron-to-chromium@1.4.723:
resolution: {integrity: sha512-rxFVtrMGMFROr4qqU6n95rUi9IlfIm+lIAt+hOToy/9r6CDv0XiEcQdC3VP71y1pE5CFTzKV0RvxOGYCPWWHPw==}
dev: true
/entities@2.2.0:
resolution: {integrity: sha512-p92if5Nz619I0w+akJrLZH0MX0Pb5DX39XOwQTtXSdQQOaYH03S1uIQp4mhOZtAXrxq4ViO67YTiLBo2638o9A==}
/entities@4.5.0:
resolution: {integrity: sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw==}
engines: {node: '>=0.12'}
@ -1274,11 +1441,19 @@ packages:
engines: {node: '>=6'}
dev: true
/escape-goat@3.0.0:
resolution: {integrity: sha512-w3PwNZJwRxlp47QGzhuEBldEqVHHhh8/tIPcl6ecf2Bou99cdAt0knihBV0Ecc7CGxYduXVBDheH1K2oADRlvw==}
engines: {node: '>=10'}
/escape-string-regexp@1.0.5:
resolution: {integrity: sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==}
engines: {node: '>=0.8.0'}
dev: true
/esm@3.2.25:
resolution: {integrity: sha512-U1suiZ2oDVWv4zPO56S0NcR5QriEahGtdN2OR6FiOG4WJvcjBVFB0qI4+eKoWFH483PKGuLuu6V8Z4T5g63UVA==}
engines: {node: '>=6'}
/estree-walker@2.0.2:
resolution: {integrity: sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==}
@ -1291,6 +1466,7 @@ packages:
/fsevents@2.3.3:
resolution: {integrity: sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==}
engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0}
os: [darwin]
requiresBuild: true
optional: true
@ -1318,6 +1494,22 @@ packages:
engines: {node: '>=8'}
dev: true
/htmlparser2@5.0.1:
resolution: {integrity: sha512-vKZZra6CSe9qsJzh0BjBGXo8dvzNsq/oGvsjfRdOrrryfeD9UOBEEQdeoqCRmKZchF5h2zOBMQ6YuQ0uRUmdbQ==}
dependencies:
domelementtype: 2.3.0
domhandler: 3.3.0
domutils: 2.8.0
entities: 2.2.0
/htmlparser2@6.1.0:
resolution: {integrity: sha512-gyyPk6rgonLFEDGoeRgQNaEUvdJ4ktTmmUh/h2t7s+M8oPpIPxgNACWa+6ESR57kXstwqPiCut0V8NRpcwgU7A==}
dependencies:
domelementtype: 2.3.0
domhandler: 4.3.1
domutils: 2.8.0
entities: 2.2.0
/is-plain-object@3.0.1:
resolution: {integrity: sha512-Xnpx182SBMrr/aBik8y+GuR4U1L9FqMSojwDQwPMmxyC6bvEqly9UBCxhauBF5vNh2gwWJNX6oDV7O+OM4z34g==}
engines: {node: '>=0.10.0'}
@ -1339,6 +1531,19 @@ packages:
hasBin: true
dev: true
/juice@8.1.0:
resolution: {integrity: sha512-FLzurJrx5Iv1e7CfBSZH68dC04EEvXvvVvPYB7Vx1WAuhCp1ZPIMtqxc+WTWxVkpTIC2Ach/GAv0rQbtGf6YMA==}
engines: {node: '>=10.0.0'}
hasBin: true
dependencies:
cheerio: 1.0.0-rc.10
commander: 6.2.1
mensch: 0.3.4
slick: 1.12.2
web-resource-inliner: 6.0.1
transitivePeerDependencies:
- encoding
/lodash-es@4.17.21:
resolution: {integrity: sha512-mKnC+QJ9pWVzv+C4/U3rRsHapFfHvQFoFB92e52xeyGMcX6/OlIl78je1u8vePzYZSkkogMPJ2yjxxsb89cxyw==}
dev: true
@ -1370,10 +1575,37 @@ packages:
resolution: {integrity: sha512-1I+1qpDt4idfgLQG+BNWmrqku+7/2bi5nLf4YwF8y8zXvmfiTBY3PV3ZibfrjBueCByROpuBjLLFCajqkgYoLQ==}
dev: false
/markdown-it-mathjax3@4.3.2:
resolution: {integrity: sha512-TX3GW5NjmupgFtMJGRauioMbbkGsOXAAt1DZ/rzzYmTHqzkO1rNAdiMD4NiruurToPApn2kYy76x02QN26qr2w==}
dependencies:
juice: 8.1.0
mathjax-full: 3.2.2
transitivePeerDependencies:
- encoding
/mathjax-full@3.2.2:
resolution: {integrity: sha512-+LfG9Fik+OuI8SLwsiR02IVdjcnRCy5MufYLi0C3TdMT56L/pjB0alMVGgoWJF8pN9Rc7FESycZB9BMNWIid5w==}
dependencies:
esm: 3.2.25
mhchemparser: 4.2.1
mj-context-menu: 0.6.1
speech-rule-engine: 4.0.7
/medium-zoom@1.1.0:
resolution: {integrity: sha512-ewyDsp7k4InCUp3jRmwHBRFGyjBimKps/AJLjRSox+2q/2H4p/PNpQf+pwONWlJiOudkBXtbdmVbFjqyybfTmQ==}
dev: false
/mensch@0.3.4:
resolution: {integrity: sha512-IAeFvcOnV9V0Yk+bFhYR07O3yNina9ANIN5MoXBKYJ/RLYPurd2d0yw14MDhpr9/momp0WofT1bPUh3hkzdi/g==}
/mhchemparser@4.2.1:
resolution: {integrity: sha512-kYmyrCirqJf3zZ9t/0wGgRZ4/ZJw//VwaRVGA75C4nhE60vtnIzhl9J9ndkX/h6hxSN7pjg/cE0VxbnNM+bnDQ==}
/mime@2.6.0:
resolution: {integrity: sha512-USPkMeET31rOMiarsBNIHZKLGgvKc/LrjofAnBlOttf5ajRvqiRA8QsenbcooctK6d6Ts6aqZXBA+XbkKthiQg==}
engines: {node: '>=4.0.0'}
hasBin: true
/minisearch@6.3.0:
resolution: {integrity: sha512-ihFnidEeU8iXzcVHy74dhkxh/dn8Dc08ERl0xwoMMGqp4+LvRSCgicb+zGqWthVokQKvCSxITlh3P08OzdTYCQ==}
dev: false
@ -1382,6 +1614,9 @@ packages:
resolution: {integrity: sha512-vKivATfr97l2/QBCYAkXYDbrIWPM2IIKEl7YPhjCvKlG3kE2gm+uBo6nEXK3M5/Ffh/FLpKExzOQ3JJoJGFKBw==}
dev: false
/mj-context-menu@0.6.1:
resolution: {integrity: sha512-7NO5s6n10TIV96d4g2uDpG7ZDpIhMh0QNfGdJw/W47JswFcosz457wqz/b5sAKvl12sxINGFCn80NZHKwxQEXA==}
/ms@2.1.2:
resolution: {integrity: sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==}
dev: true
@ -1395,10 +1630,34 @@ packages:
resolution: {integrity: sha512-NzOgmMQ+elxxHeIha+OG/Pv3Oc3p4RU2aBhwWwAqDpXrdTbtRylbRLQztLy8dMMwfl6pclznBdfUhccEn9ZIzw==}
dev: true
/node-fetch@2.7.0:
resolution: {integrity: sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A==}
engines: {node: 4.x || >=6.0.0}
peerDependencies:
encoding: ^0.1.0
peerDependenciesMeta:
encoding:
optional: true
dependencies:
whatwg-url: 5.0.0
/node-releases@2.0.14:
resolution: {integrity: sha512-y10wOWt8yZpqXmOgRo77WaHEmhYQYGNA6y421PKsKYWEK8aW+cqAphborZDhqfyKrbZEN92CN1X2KbafY2s7Yw==}
dev: true
/nth-check@2.1.1:
resolution: {integrity: sha512-lqjrjmaOoAnWfMmBPL+XNnynZh2+swxiX3WUE0s4yEHI6m+AwrK2UZOimIRl3X/4QctVqS8AiZjFqyOGrMXb/w==}
dependencies:
boolbase: 1.0.0
/parse5-htmlparser2-tree-adapter@6.0.1:
resolution: {integrity: sha512-qPuWvbLgvDGilKc5BoicRovlT4MtYT6JfJyBOMDsKoiT+GiuP5qyrPCnR9HcPECIJJmZh5jRndyNThnhhb/vlA==}
dependencies:
parse5: 6.0.1
/parse5@6.0.1:
resolution: {integrity: sha512-Ofn/CTFzRGTTxwpNEs9PP93gXShHcTq255nzRYSKe8AkVpZY7e1fpmTfOyoIvjP5HG7Z2ZM7VS9PPhQGW2pOpw==}
/perfect-debounce@1.0.0:
resolution: {integrity: sha512-xCy9V055GLEqoFaHoC1SoLIaLmWctgCUaBaWxDZ7/Zx4CTyX7cJQLJOok/orfjZAh9kEYpjJa4d0KcJmCbctZA==}
dev: false
@ -1479,6 +1738,9 @@ packages:
'@shikijs/core': 1.2.3
dev: false
/slick@1.12.2:
resolution: {integrity: sha512-4qdtOGcBjral6YIBCWJ0ljFSKNLz9KkhbWtuGvUyRowl1kxfuE1x/Z/aJcaiilpb3do9bl5K7/1h9XC5wWpY/A==}
/source-map-js@1.2.0:
resolution: {integrity: sha512-itJW8lvSA0TXEphiRoawsCksnlf8SyvmFzIhltqAHluXd88pkCd+cXJVHTDwdCr0IzwptSm035IHQktUu1QUMg==}
engines: {node: '>=0.10.0'}
@ -1488,6 +1750,14 @@ packages:
engines: {node: '>=0.10.0'}
dev: false
/speech-rule-engine@4.0.7:
resolution: {integrity: sha512-sJrL3/wHzNwJRLBdf6CjJWIlxC04iYKkyXvYSVsWVOiC2DSkHmxsqOhEeMsBA9XK+CHuNcsdkbFDnoUfAsmp9g==}
hasBin: true
dependencies:
commander: 9.2.0
wicked-good-xpath: 1.3.0
xmldom-sre: 0.1.31
/stylis@4.3.1:
resolution: {integrity: sha512-EQepAV+wMsIaGVGX1RECzgrcqRRU/0sYOHkeLsZ3fzHaHXZy4DaOOX0vOlGQdlsjkh3mFHAIlVimpwAs4dslyQ==}
dev: true
@ -1521,6 +1791,12 @@ packages:
resolution: {integrity: sha512-/OaKK0xYrs3DmxRYqL/yDc+FxFUVYhDlXMhRmv3z915w2HF1tnN1omB354j8VUGO/hbRzyD6Y3sA7v7GS/ceog==}
engines: {node: '>=4'}
/tr46@0.0.3:
resolution: {integrity: sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==}
/tslib@2.6.2:
resolution: {integrity: sha512-AEYxH93jGFPn/a2iVAwW87VuUIkR1FVUKB77NwMF7nBTDkDrrT/Hpt/IrCJ0QXhW27jTBDcf5ZY7w6RiqTMw2Q==}
/undici-types@5.26.5:
resolution: {integrity: sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==}
@ -1535,6 +1811,10 @@ packages:
picocolors: 1.0.0
dev: true
/valid-data-url@3.0.1:
resolution: {integrity: sha512-jOWVmzVceKlVVdwjNSenT4PbGghU0SBIizAev8ofZVgivk/TVHXSbNL8LP6M3spZvkR9/QolkyJavGSX5Cs0UA==}
engines: {node: '>=10'}
/vite@5.2.7(@types/node@20.12.2):
resolution: {integrity: sha512-k14PWOKLI6pMaSzAuGtT+Cf0YmIx12z9YGon39onaJNy8DLBfBJrzg9FQEmkAM5lpHBZs9wksWAsyF/HkpEwJA==}
engines: {node: ^18.0.0 || >=20.0.0}
@ -1570,7 +1850,7 @@ packages:
optionalDependencies:
fsevents: 2.3.3
/vitepress@1.0.2(@algolia/client-search@4.23.2)(@types/node@20.12.2)(search-insights@2.13.0):
/vitepress@1.0.2(@algolia/client-search@4.23.2)(@types/node@20.12.2)(markdown-it-mathjax3@4.3.2)(search-insights@2.13.0):
resolution: {integrity: sha512-bEj9yTEdWyewJFOhEREZF+mXuAgOq27etuJZT6DZSp+J3XpQstXMJc5piSVwhZBtuj8OfA0iXy+jdP1c71KMYQ==}
hasBin: true
peerDependencies:
@ -1593,6 +1873,7 @@ packages:
'@vueuse/integrations': 10.9.0(focus-trap@7.5.4)(vue@3.4.21)
focus-trap: 7.5.4
mark.js: 8.11.1
markdown-it-mathjax3: 4.3.2
minisearch: 6.3.0
shiki: 1.2.3
vite: 5.2.7(@types/node@20.12.2)
@ -1670,6 +1951,35 @@ packages:
loose-envify: 1.4.0
dev: true
/web-resource-inliner@6.0.1:
resolution: {integrity: sha512-kfqDxt5dTB1JhqsCUQVFDj0rmY+4HLwGQIsLPbyrsN9y9WV/1oFDSx3BQ4GfCv9X+jVeQ7rouTqwK53rA/7t8A==}
engines: {node: '>=10.0.0'}
dependencies:
ansi-colors: 4.1.3
escape-goat: 3.0.0
htmlparser2: 5.0.1
mime: 2.6.0
node-fetch: 2.7.0
valid-data-url: 3.0.1
transitivePeerDependencies:
- encoding
/webidl-conversions@3.0.1:
resolution: {integrity: sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==}
/whatwg-url@5.0.0:
resolution: {integrity: sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==}
dependencies:
tr46: 0.0.3
webidl-conversions: 3.0.1
/wicked-good-xpath@1.3.0:
resolution: {integrity: sha512-Gd9+TUn5nXdwj/hFsPVx5cuHHiF5Bwuc30jZ4+ronF1qHK5O7HD0sgmXWSEgwKquT3ClLoKPVbO6qGwVwLzvAw==}
/xmldom-sre@0.1.31:
resolution: {integrity: sha512-f9s+fUkX04BxQf+7mMWAp5zk61pciie+fFLC9hX9UVvCeJQfNHRHXpeo5MPcR0EUf57PYLdt+ZO4f3Ipk2oZUw==}
engines: {node: '>=0.1'}
/yallist@3.1.1:
resolution: {integrity: sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==}
dev: true