小鼠的博客

使用Linux的软路由实战02：基础网络配置

小鼠 — Fri, 22 May 2026 00:00:00 +0000

前言🔗

上一章我们已经在 Hyper-V 中搭建好了实验环境——Router VM 和 Client VM 各就各位，但网络还处于各自为政的状态。这一章我们要进入 Router VM，手动配置网络，让它真正扮演路由器的角色。

本章的目标很简单：让 Router VM 能够为 Client VM 提供 DHCP 分配地址、转发流量访问外网（NAT）。

登录 Router VM🔗

打开 Hyper-V 管理器，右键 Router 虚拟机 → 连接，用你在安装时设置的 root 密码登录。

首先确认网卡状态：

ip link show

你应该能看到两块网卡，命名类似 enpXsY 的形式（在 Fedora 中，eth0/eth1 这类传统命名已被 enpXsY 取代）。为了表述方便，下文统称为 WAN 口（连接 Default Switch 的那块）和 LAN 口（连接内部交换机的那块）。

如果不确定哪块对应哪个交换机，可以用以下命令查看：

ip addr show

WAN 口此时应该已经通过 DHCP 从 Default Switch 拿到了一个 IP（通常是 172.x.x.x 或 192.168.x.x 网段），而 LAN 口还没有 IP 地址。

为 LAN 口配置静态 IP🔗

Router VM 需要为内网（LAN）提供一个固定的网关地址，同时也作为 DHCP 和 DNS 服务的地址。我们给 LAN 口分配一个静态 IP：

nmcli con show

这条命令会列出 NetworkManager 管理的连接。找到对应 LAN 口的连接名称（通常是 Wired 或 enpXsY），然后执行：

# 假设 LAN 口的连接名称为 enpXsY，请替换为实际名称
nmcli con mod "enpXsY" ipv4.addresses 192.168.10.1/24
nmcli con mod "enpXsY" ipv4.method manual
nmcli con up "enpXsY"

192.168.10.1/24 是内网网段，你可以换成自己习惯的网段，比如 192.168.1.1/24，只要后续配置保持一致即可。

验证 LAN 口是否已配置成功：

ip addr show enpXsY

输出中应该能看到 192.168.10.1/24 这个地址。

开启 IP 转发🔗

Linux 默认不会转发数据包——也就是说，从 WAN 口进来的包不会自动走到 LAN 口，反之亦然。要让它成为路由器，必须开启 IP 转发：

# 即时生效
sysctl -w net.ipv4.ip_forward=1

# 写入 sysctl 配置，使重启后依然生效
echo "net.ipv4.ip_forward = 1" >> /etc/sysctl.d/90-router.conf

如果未来需要支持 IPv6，同样需要开启 net.ipv6.conf.all.forwarding = 1。

配置 NAT 和防火墙（firewalld）🔗

开启 IP 转发后，Router VM 可以在不同网口之间转发包，但 WAN 口的数据包无法直接到达内网的 Client VM（它们是私有 IP）。这就需要 NAT（网络地址转换）——将内网 IP 转换为 WAN 口的 IP 访问外网。

Fedora Server 默认使用 firewalld 管理防火墙。我们通过 firewall-cmd 配置：

配置 firewalld 区域🔗

firewalld 通过「区域」（zone）来管理不同网络的信任级别。我们需要：

将 WAN 口 放到 external 区域（开启 masquerade）
将 LAN 口 放到 internal 区域（允许内网设备互访）

先查看当前网络接口所属的区域：

firewall-cmd --get-active-zones

下面我们通过 NetworkManager 将接口分配到正确的区域。

先找到两块网卡对应的连接名称：

nmcli con show

记下 WAN 口和 LAN 口对应的连接名称（如 enp1s0、enp2s0），然后设置区域：

# 将 WAN 口的连接设为 external 区域（开启 masquerade）
nmcli con mod "enp1s0" connection.zone external

# 将 LAN 口的连接设为 internal 区域（允许内网互访）
nmcli con mod "enp2s0" connection.zone internal

# 重新加载连接使生效
nmcli con up "enp1s0"
nmcli con up "enp2s0"

用 nmcli 设置 connection.zone 后，NetworkManager 会负责将区域信息同步给 firewalld，两者互不冲突。重启后配置依然保留。 ⚠️ 反过来，此时通过 firewall-cmd --add-interface 配置区域，NetworkManager 下次重连时会直接覆盖掉。所以区域相关的配置统一走 nmcli。

验证 NAT 是否生效🔗

输入指令查看完整的区域规则：

firewall-cmd --zone=external --list-all

💡 external 区域默认已开启 masquerade，不需要手动执行 --add-masquerade。如果确认一下：
firewall-cmd --zone=external --add-masquerade --permanent
firewall-cmd --reload

内网区域放行必要服务🔗

internal 区域默认放行 SSH 等服务，但我们还需要确保 DHCP 和 DNS 请求能通过防火墙：

firewall-cmd --zone=internal --add-service=dhcp --add-service=dns --permanent
firewall-cmd --reload

允许内网流量转发到外网🔗

配了 zone 和 masquerade 后，firewalld 默认还是不会转发来自 internal 的流量到 external。需要显式添加一条转发策略：

firewall-cmd --permanent --new-policy internal2external
firewall-cmd --permanent --policy internal2external --add-ingress-zone internal
firewall-cmd --permanent --policy internal2external --add-egress-zone external
firewall-cmd --permanent --policy internal2external --set-target ACCEPT
firewall-cmd --reload

internal2external 含义很直白：来自 internal 区域、去向 external 区域的流量，一律放行。

验证最终配置：

firewall-cmd --list-all-zones

配置 DHCP 服务（dnsmasq）🔗

内网的 Client VM 需要自动获取 IP，我们安装 dnsmasq 作为 NetworkManager 的 DNS 和 DHCP 后端，由 NetworkManager 代为管理 dnsmasq 进程。

# 安装 dnsmasq
dnf install -y dnsmasq

启用 dnsmasq 插件🔗

在 /etc/NetworkManager/conf.d/ 下创建一个配置文件，告诉 NetworkManager 使用 dnsmasq 作为 DNS 后端：

cat > /etc/NetworkManager/conf.d/00-use-dnsmasq.conf << 'EOF'
[main]
dns=dnsmasq
EOF

用 conf.d 下的独立文件来配置，比直接改 NetworkManager.conf 更干净，系统更新时不会被覆盖。

配置 dnsmasq🔗

配置文件不放在 /etc/dnsmasq.conf，而是放到 NetworkManager 的 dnsmasq 专用目录：

cat > /etc/NetworkManager/dnsmasq.d/router.conf << 'EOF'
# 监听 LAN 口，不暴露到 WAN 侧
interface=enpXsY
bind-interfaces

# DHCP 地址池：从 192.168.10.100 到 192.168.10.200，租期 24h
dhcp-range=192.168.10.100,192.168.10.200,24h

# 网关（路由器自身）
dhcp-option=3,192.168.10.1

# DNS 服务器（直接用114了）
dhcp-option=6,114.114.114.114

# 域名
local=/lan/
EOF

配置项说明：

dhcp-range 定义分配的 IP 范围

dhcp-option=3 是网关地址

dhcp-option=6 是 DNS 服务器地址

重启 NetworkManager 使以上配置生效：

systemctl restart NetworkManager

验证 Client VM 的网络🔗

回到 Client VM 的 Hyper-V 连接窗口，重启网络或直接重启虚拟机：

# 在 Client VM 中执行
ip addr show

正常情况下，Client VM 应该从 Router VM 的 dnsmasq 获得一个 192.168.10.x 网段的 IP。ping 一下网关和外部地址来验证：

ping -c 3 192.168.10.1          # 网关（Router VM LAN 口）
ping -c 3 8.8.8.8               # 外网（Google DNS）

如果能 ping 通外网，说明 NAT 配置成功。再测试一下 DNS 解析：

ping -c 3 baidu.com

如果域名也能解析，那么 DHCP + DNS + NAT 全套链路就都通了！

总结🔗

到这一步，我们完成了以下工作：

项目	内容
✅ LAN 口静态 IP	`192.168.10.1/24`
✅ IP 转发	`net.ipv4.ip_forward=1`
✅ NAT (firewalld)	`masquerade` 伪装
✅ DHCP 服务 (dnsmasq)	地址池 `192.168.10.100-200`
✅ Client VM 上网	DHCP 分配 + NAT 出网

Router VM 现在是一台功能完整的家用路由器了！下一章我们将在此基础上引入容器化技术，用 Podman 来运行各种软件，进一步扩展路由器的功能。

使用Linux的软路由实战01：搭建实验环境

小鼠 — Sat, 16 May 2026 00:00:00 +0000

前言🔗

相信很多玩网络的朋友都听说过「软路由」这个词。相比于市面上各种硬路由（如 TP-Link、华硕、小米等），软路由的好处不言而喻：性能强大、功能灵活、可定制性极高。市面上比较流行的方案有 OpenWrt、iStoreOS、爱快、RouterOS 等，它们各有千秋，但本质都是基于 Linux 系统的路由发行版。

那么，能不能直接用原生的 Linux 来当路由器呢？

本系列文章将带你从零开始，基于 Fedora + 容器技术，一步步搭建一套完整的家用软路由系统。整个系列计划分为以下几篇：

搭建实验环境（本篇）—— 使用虚拟机模拟家庭网络拓扑
基础网络配置 —— 更改防火墙配置实现路由功能，包括DHCP服务等
容器化技术 —— 使用Podman

花点时间看完这个系列，你会发现：路由器不过也是一台 Linux 电脑而已。

为什么选择原生 Linux 而非 OpenWrt？🔗

OpenWrt 固然优秀，但它毕竟是一个面向嵌入式设备的精简发行版，包管理、内核版本、文件系统等都和主流的发行版有一定差异。如果你已经熟悉 Linux，直接在 Fedora 上搭建路由非常简单——你只是多配了几个网络参数而已。

包管理：dnf 生态远比 opkg 丰富，安装软件更方便
内核更新：及时跟进主线内核，支持更新的网卡驱动和协议
故障排查：标准的 Linux 网络调试手段全部适用
通用性：这台机器本质上还是一台正常的 Linux 主机

实验环境概览🔗

这一篇我们会用 Hyper-V 搭建如下拓扑：

graph TD subgraph HOST [宿主机 Windows] subgraph INTERNAL [内部网络 Internal Network] ROUTER[Router VM Fedora
eth1: 内部网桥] CLIENT[Client VM
验证 DHCP + DNS + NAT] end ROUTER -- eth1 连接 --> CLIENT end INTERNET((外网 Internet)) ROUTER -- eth0: NAT 连接 --> INTERNET style HOST fill:#E2F0D9,stroke:#70AD47,stroke-width:2px style INTERNAL fill:#D9E1F2,stroke:#4472C4,stroke-width:2px,stroke-dasharray: 5 5 style ROUTER fill:#FFF2CC,stroke:#BF8F00 style CLIENT fill:#FFF2CC,stroke:#BF8F00 style INTERNET fill:#F8CBAD,stroke:#ED7D31

我们会在 Router VM 上配置两个网络接口：

eth0：以 NAT 方式连接宿主机网络，模拟 WAN 口（外网）
eth1：连接到一个内部虚拟交换机，模拟 LAN 口（内网）

Client VM 则只需一个网卡，连接到同一个 Internal Network，用来验证路由器提供的 DHCP、DNS、NAT 等是否正常工作。

所需软件🔗

在开始之前，请确保你的宿主机上已安装以下软件：

软件	用途
Hyper-V	虚拟机管理平台
Fedora Server ISO	操作系统镜像

本系列均以 Fedora Server 44 为例。如果你用的是其他发行版，大部分命令同样适用，只需注意包名和网络配置文件的差异。

正式操作🔗

启用 Hyper-V🔗

如果你用的是 Windows 10/11 专业版或企业版，Hyper-V 默认已安装但可能未启用。检查方式如下：

打开 控制面板 → 程序和功能 → 启用或关闭 Windows 功能
找到 Hyper-V，确保其下的 Hyper-V 管理工具 和 Hyper-V 平台 均已勾选
若未勾选，勾选后点击确定，重启电脑

重启后在开始菜单搜索 Hyper-V 管理器 并打开。

创建虚拟交换机🔗

我们需要两个虚拟交换机：一个连接外网（WAN），一个连接内网（LAN）。

Hyper-V 管理器 默认启用的 Default Switch 会以 NAT 的形式为连接上的虚拟机提供网络，我们使用这个交换机当做外部网络。下面我们创建内部的交换机。

点击右侧的 虚拟交换机管理器，选择创建内部交换机
名称填 LAN，点击确定

💡 三种虚拟交换机的区别：

类型虚拟机 ↔ 虚拟机虚拟机 ↔ 宿主机虚拟机 ↔ 外网

外部 (External) ✅ ✅ ✅

内部 (Internal) ✅ ✅ ❌

专用 (Private) ✅ ❌ ❌

类型	虚拟机 ↔ 虚拟机	虚拟机 ↔ 宿主机	虚拟机 ↔ 外网
外部 (External)	✅	✅	✅
内部 (Internal)	✅	✅	❌
专用 (Private)	✅	❌	❌

完成后的虚拟交换机列表：

名称	类型
Default Switch	NAT
LAN	内部

创建 Router VM🔗

在 Hyper-V 管理器右侧点击 新建 → 虚拟机
名称：Router
代数：选择第二代（支持 UEFI 引导）
内存：分配 1024 MB，取消勾选 动态内存
网络：先选择 未连接（后续配置双网卡）
虚拟硬盘：创建新虚拟硬盘，大小 20 GB
安装选项：选择 从可引导的 CD/DVD-ROM 安装操作系统，点击浏览选中 Fedora Server ISO
点击完成

配置双网卡🔗

右键 Router 虚拟机 → 设置：

左侧选择 添加硬件 → 网络适配器 → 添加
第一个网卡（对应 eth0 / WAN）：虚拟交换机选择 Default Switch
再添加第二个网卡（对应 eth1 / LAN）：虚拟交换机选择 LAN
点击确定

网卡的添加顺序决定了 Linux 内核中的接口命名顺序，先添加的是 eth0，后添加的是 eth1。

安装系统🔗

右键 Router 虚拟机 → 连接 → 启动
从 ISO 引导后，选择 Install Fedora Server 44
选择语言（推荐 English，避免终端路径乱码）
Installation Destination：直接使用自动分区
Network & Host Name：
- 主机名改为 router.lan
- 暂时无需配置 IP，安装完成后手动配置
设置 Root Password 和创建一个管理员用户
点击 Begin Installation，等待完成
完成后 Reboot

创建 Client VM🔗

名称：Client
代数：第二代
内存：2048 MB
网络：直接选择 LAN（只需要一个网卡）
虚拟硬盘：20 GB
安装选项：同样使用 Fedora Server ISO

安装时注意：

主机名设为 client.lan
网络配置保持 自动（DHCP），后续由 Router VM 分配 IP

两台虚拟机安装完成后，分别启动并登录。此时 Client VM 因为还没 DHCP 服务，暂时获取不到 IP，属于正常现象。下一节我们将进入 Router VM，配置完整的网络服务。

你好，世界

小鼠 — Tue, 05 May 2026 00:00:00 +0000

折腾了几天，终于把博客搭起来了。

为什么写博客🔗

其实想法很简单——需要一个属于自己的地方，不用管字数限制、不用考虑算法推荐，想写什么就写什么。

技术选型🔗

选了 Zola，一个用 Rust 写的静态站点生成器。体积极小、构建飞快，没有 Node.js 那堆依赖。

会写些什么🔗

计划写三类内容：

技术笔记 — 踩坑记录、工具推荐、代码片段
生活碎片 — 日常、阅读、随感
现实思考 — 对技术、工作、成长的一些想法

最后🔗

很高兴你来到这里。

我们下一篇文章见。

Rust线程

小鼠 — Tue, 20 May 2025 00:00:00 +0000

并发编程（Concurrent programming）代表程序不同部分相互独立地执行，而并行（parallel programming）代表程序不同部分同时执行。

Rust提供了多种工具以符合实际情况和需求来为问题建模。

大部分现代操作系统中，已执行程序的代码在一个进程（process）中运行，操作系统会负责管理多个进程。在程序内部可以拥有多个同时运行的独立部分，称作线程（threads）。将程序拆分进多个线程可以改善性能，不过会增加复杂性。因为程序是同时运行的，所以无法保证不同线程中代码的执行顺序，这会导致以下问题：

竞态条件（Race condition），当多个线程以不一致的顺序访问数据或资源
死锁（Deadlock），当两个或多个线程相互等待对方释放资源
只会发生在特定情况且难以稳定重现和修复的bug。

Rust标准库使用1:1线程实现，每个语言级线程使用一个系统线程。

使用spawn创建新线程🔗

为了创建一个新线程，需要调用thread::spawn函数，这个函数会获取一个闭包（closure）作为参数，这个闭包会在新线程中执行：

use std::thread;
use std::time::Duration;

fn main() {
    thread::spawn(|| {
        for i in 1..10 {
            println!("hi number {} from the spawned thread!", i);
            thread::sleep(Duration::from_millis(1));
        }
    });

    for i in 1..5 {
        println!("hi number {} from the main thread!", i);
        thread::sleep(Duration::from_millis(1));
    }
}

这段代码在新线程和主线程中打印了一些文本，主线程结束时，新线程也会结束而不管其是否执行完毕。这个程序输出每次可能略有不同，不过大体上看起来像这样：

hi number 1 from the main thread!
hi number 1 from the spawned thread!
hi number 2 from the main thread!
hi number 2 from the spawned thread!
hi number 3 from the main thread!
hi number 3 from the spawned thread!
hi number 4 from the main thread!
hi number 4 from the spawned thread!

thread::sleep调用强制线程停止执行一小段时间，允许其他不同的线程运行，这些线程的运行依赖操作系统的调度。

使用join等待所有线程结束🔗

由于主线程结束，其他线程的代码甚至可能不会被执行，可以通过将thread::spawn的返回值储存在变量中来修复新建线程没有执行的问题。thread::spawn返回的是JoinHandle类型，这个一个拥有所有权的值。JoinHandle的join方法会让主线程等待新线程结束：

use std::thread;
use std::time::Duration;

fn main() {
    let handle = thread::spawn(|| {
        for i in 1..10 {
            println!("hi number {} from the spawned thread!", i);
            thread::sleep(Duration::from_millis(1));
        }
    });
    for i in 1..5 {
        println!("hi number {} from the main thread!", i);
        thread::sleep(Duration::from_millis(1));
    }

    handle.join().unwrap();
}

这段代码调用handle的join方法，这个方法会阻塞（Blocking）当前线程，直到新线程结束。这段代码产生类似下面的输出：

hi number 1 from the main thread!
hi number 1 from the spawned thread!
hi number 2 from the main thread!
hi number 2 from the spawned thread!
hi number 3 from the main thread!
hi number 3 from the spawned thread!
hi number 4 from the main thread!
hi number 4 from the spawned thread!
hi number 5 from the spawned thread!
hi number 6 from the spawned thread!
hi number 7 from the spawned thread!
hi number 8 from the spawned thread!
hi number 9 from the spawned thread!

如果将handle.join().unwrap();放在main中for循环之前，则会先打印出新线程的输出，再打印主线程的输出。

将move闭包与线程一同使用🔗

move关键字经常用于传递给thread::spawn的闭包。move关键字会强制闭包获取其使用的变量的所有权，这意味着这些值的所有权会从一个线程转移到另一个线程。下面是一个在主线程中创建一个vector并用于新建线程的例子：

use std::thread;

fn main() {
    let v = vec![1, 2, 3];

    let handle = thread::spawn(|| {
        println!("Here's a vector: {:?}", v);
    });

    handle.join().unwrap();
}

这里闭包会捕获v，并在新线程中访问v，但是这段代码会报错，因为Rust会尝试对v借用，由于Rust不知道新线程会持续执行多久，所以无法知晓对v的引用是否一致有效。下面是一个例子：

use std::thread;

fn main() {
    let v = vec![1, 2, 3];

    let handle = thread::spawn(|| {
        println!("Here's a vector: {:?}", v);
    });
    
    drop(v);

    handle.join().unwrap();
}

如果这段代码可以运行，新线程可能根本没有机会运行，这里在新线程开始运行后主线程直接丢弃了v。

通过在闭包前增加move关键字，可以强制闭包获取所有权，而不是由Rust推断的借用，下面为修改后的代码：

use std::thread;

fn main() {
    let v = vec![1, 2, 3];

    let handle = thread::spawn(move || {
        println!("Here's a vector: {:?}", v);
    });

    handle.join().unwrap();
}

如果在handle之前调用drop(v)，则这段代码会报错，因为v的所有权已经被移动到了新线程中，主线程无法再访问v。

conda环境部署

小鼠 — Sun, 18 May 2025 00:00:00 +0000

conda是一个跨平台包管理工具。对于每一个python项目，我们可能需要有不同的python版本，不同的包，我们就可以使用conda来创建并管理这些虚拟环境。对于数据分析，有时我们并不需要完全地创建一个项目，而只是在相应地环境里面运行jupyter notebook来完成一些任务，我们就可以使用conda来创建虚拟环境，并进入这些环境来完成任务。在开始部署conda前，我们先介绍一下conda的几个发行版：

Anaconda：这个发行版在基本（base）环境中安装了大量的包，可以直接在其base环境中运行，而假如创建新的虚拟环境，如果本地有缓存，那么就可以直接从缓存中安装包，不需要重新下载，否则就需要重新下载。
Miniconda：这个发行版在基本（base）环境中安装了很少的包，只包含了conda和python的基本包，不包含任何其他的包。
Miniforge：这个发行版和Miniconda类似，并增加了mamba这个conda的替代品，它用C++重写了部分功能，在提供了更好的性能的同时完全兼容conda。Miniforge默认使用社区维护的Conda-Forge仓库作为包的来源，而不是官方的Anaconda仓库，Conda-forge的包通常比官方Anaconda仓库更新得更快，并且完全开源免费，不必在意商业许可证上面的问题。
Micromamba：micromamba是mamba的静态链接版本，它和Miniforge类似，但它的base环境没有python和其他包。

基于它们的区别，我选择使用micromamba，本文的指南将基于micromamba和Miniforge来介绍conda的部署。

安装🔗

Windows平台安装🔗

在Windows平台上安装Miniforge，我们可以下载Miniforge的安装程序，然后运行安装程序安装。

在最新的Windows11系统中我们可以使用winget来安装Miniforge，在power shell中输入以下命令：

winget install CondaForge.Miniforge3

对于Micromamba，官方提供了以下命令：

Invoke-Expression ((Invoke-WebRequest -Uri https://micro.mamba.pm/install.ps1 -UseBasicParsing).Content)

当然如果能使用winget，我们也可以输入以下命令来安装：

winget install mamba.Micromamba

Linux平台安装🔗

在Linux上，可以直接使用官方提供的脚本安装Miniconda：

先下载：

curl -L -O "https://github.com/conda-forge/miniforge/releases/latest/download/Miniforge3-$(uname)-$(uname -m).sh"

然后运行：

bash Miniforge3-$(uname)-$(uname -m).sh

对于Micromamba，官方提供了以下命令：

"${SHELL}" <(curl -L micro.mamba.pm/install.sh)

在完成安装后，我们可以使用mamba --version或micromamba --version来查看版本。

Rust引用循环和内存泄漏

小鼠 — Sat, 17 May 2025 00:00:00 +0000

Rust很难制造内存泄漏（memory leak），但并不是不可能，使用Rc和RefCell创建引用循环会造成内存泄漏，因为每一项的引用计数永远也到不了0，持有的数据也永远不会被释放。

制造引用循环🔗

考虑下面代码：

use crate::List::{Cons, Nil};
use std::cell::RefCell;
use std::rc::Rc;

#[derive(Debug)]
enum List {
    Cons(i32, RefCell<Rc<List>>),
    Nil,
}

impl List {
    fn tail(&self) -> Option<&RefCell<Rc<List>>> {
        match self {
            Cons(_, item) => Some(item),
            Nil => None,
        }
    }
}
fn main() {
    let a = Rc::new(Cons(5, RefCell::new(Rc::new(Nil))));

    println!("a initial rc count = {}", Rc::strong_count(&a));
    println!("a next item = {:?}", a.tail());

    let b = Rc::new(Cons(10, RefCell::new(Rc::clone(&a))));

    println!("a rc count after b creation = {}", Rc::strong_count(&a));
    println!("b initial rc count = {}", Rc::strong_count(&b));
    println!("b next item = {:?}", b.tail());

    if let Some(link) = a.tail() {
        *link.borrow_mut() = Rc::clone(&b);
    }

    println!("b rc count after changing a = {}", Rc::strong_count(&b));
    println!("a rc count after changing a = {}", Rc::strong_count(&a));

    // Uncomment the next line to see that we have a cycle;
    // it will overflow the stack
    // println!("a next item = {:?}", a.tail());
}

这里Cons的第二项是RefCell<Rc<List>>，这里就可以修改Cons指向的List，并且增加了个tail方法来获取Cons的第二项。

在main函数中，我们创建了一个Cons，它的第二项指向了Nil，然后我们创建了一个Cons，它的第二项指向了第一个Cons，后面我们修改了第一个Cons的第二项，使其指向了第二个Cons，这样就形成了一个引用循环。运行结果：

a initial rc count = 1
a next item = Some(RefCell { value: Nil })
a rc count after b creation = 2
b initial rc count = 1
b next item = Some(RefCell { value: Cons(5, RefCell { value: Nil }) })
b rc count after changing a = 2
a rc count after changing a = 2

可以看到在将第一个Cons的第二项指向第二个Cons后，两个列表的引用计数都是2，在最后，Rust丢弃b，这时第二个实例的引用计数减为1，然后Rust丢弃a，这时第一个实例的引用计数减为1，但是由于这两个实例的引用计数不为0，所以第二个实例不会被释放，这样就形成了一个引用循环。

如果我们取消代码后面注释的println!，Rust就会打印a指向b，然后b指向a，这样就会一直循环下去，直到栈溢出。

如果在更为复杂的程序中的循环里分配了很多内存并占有很长时间，这个程序会使用多余它所需要的内存，有可能压垮系统并造成没有内存可供使用。

对于循环引用，除了使用自动化测试、代码评审等使其最小化，也可以重新组织数据结构，让一部分引用有所有权而另一部分没有，这样只有有所有权的才能影响值是否被丢弃。

将Rc变为Weak🔗

考虑以下代码：

use std::cell::RefCell;
use std::rc::Rc;

#[derive(Debug)]
struct Node {
    value: i32,
    children: RefCell<Vec<Rc<Node>>>,
}

fn main() {
    let leaf = Rc::new(Node {
        value: 3,
        children: RefCell::new(vec![]),
    });

    let branch = Rc::new(Node {
        value: 5,
        children: RefCell::new(vec![Rc::clone(&leaf)]),
    });
}

这里定义了一个Node结构体，它有一个值和一个子节点的向量，子节点是Rc<Node>，这样就可以创建一个树，并拥有子节点的所有权，也可以更改子节点。

接下来，我们创建了一个leaf节点和一个branch节点，leaf节点没有子节点，branch节点有一个子节点leaf。

这个时候，我们需要让leaf节点知道branch是他的父节点。

增加子到父的引用🔗

我们需要在Node结构体中增加一个parent字段，这个字段如果是RefCell<Rc<Node>>，就可以存储父节点的引用，但是会形成循环引用。现在换一个思路，如果父节点被丢弃，则子节点也应该被丢弃，如果丢弃子节点，其父节点应该依然存在，这便是弱引用的例子。

我们可以使用Weak<T>来存储父节点的引用，这样就可以避免循环引用：

use std::cell::RefCell;
use std::rc::{Rc, Weak};

#[derive(Debug)]
struct Node {
    value: i32,
    parent: RefCell<Weak<Node>>,
    children: RefCell<Vec<Rc<Node>>>,
}

fn main() {
    let leaf = Rc::new(Node {
        value: 3,
        parent: RefCell::new(Weak::new()),
        children: RefCell::new(vec![]),
    });

    println!("leaf parent = {:?}", leaf.parent.borrow().upgrade());

    let branch = Rc::new(Node {
        value: 5,
        parent: RefCell::new(Weak::new()),
        children: RefCell::new(vec![Rc::clone(&leaf)]),
    });

    *leaf.parent.borrow_mut() = Rc::downgrade(&branch);

    println!("leaf parent = {:?}", leaf.parent.borrow().upgrade());
}

这样子节点就能引用父节点而不拥有父节点，并且使用upgrade方法可以获得包含父节点引用的Option类型。第一个打印时leaf并没有父节点，所以输出为：

leaf parent = None

第二个打印时leaf有父节点，而Weak<Node>会被打印为(Weak)，避免了栈溢出的循环，所以输出为：

leaf parent = Some(Node { value: 5, parent: RefCell { value: (Weak) }, children: RefCell { value: [Node { value: 3, parent: RefCell { value: (Weak) }, children: RefCell { value: [] } }] } })

可视化strong_count和weak_count的改变🔗

考虑下面代码：

use std::cell::RefCell;
use std::rc::{Rc, Weak};

#[derive(Debug)]
struct Node {
    value: i32,
    parent: RefCell<Weak<Node>>,
    children: RefCell<Vec<Rc<Node>>>,
}

fn main() {
    let leaf = Rc::new(Node {
        value: 3,
        parent: RefCell::new(Weak::new()),
        children: RefCell::new(vec![]),
    });

    println!(
        "leaf strong = {}, weak = {}",
        Rc::strong_count(&leaf),
        Rc::weak_count(&leaf),
    );

    {
        let branch = Rc::new(Node {
            value: 5,
            parent: RefCell::new(Weak::new()),
            children: RefCell::new(vec![Rc::clone(&leaf)]),
        });

        *leaf.parent.borrow_mut() = Rc::downgrade(&branch);

        println!(
            "branch strong = {}, weak = {}",
            Rc::strong_count(&branch),
            Rc::weak_count(&branch),
        );

        println!(
            "leaf strong = {}, weak = {}",
            Rc::strong_count(&leaf),
            Rc::weak_count(&leaf),
        );
    }

    println!("leaf parent = {:?}",leaf.parent.borrow().upgrade());
    println!(
        "leaf strong = {}, weak = {}",
        Rc::strong_count(&leaf),
        Rc::weak_count(&leaf),
    );
}

一开始创建了leaf，它的强引用计数为1，弱引用计数为0，后面内部作用域创建branch后，branch的强引用计数为1，弱引用计数为1，leaf的强引用计数为2，弱引用计数为0，后面离开内部作用域，branch的强引用计数为0，被丢弃，leaf的强引用计数为1，弱引用计数为0。

考试结束

小鼠 — Mon, 12 May 2025 00:00:00 +0000

终于考完了数学，✋😭✋

Rust智能指针RefCell

小鼠 — Fri, 02 May 2025 00:00:00 +0000

内部可变性（Interior mutability）是Rust中的一个设计模式，它允许你在有不可变引用时也可以改变数据。这需要在数据结构中使用unsafe代码来模糊Rust的可变性与借用规则。

可以确保代码在运行时会遵守借用规则，可以使用运用内部可变性模式的类型，涉及unsafe代码被封装进安全的API中。外部类型依旧是不可变的。

使用RefCell在运行时检查借用规则🔗

ReCell<T>代表数据的唯一所有权，RefCell允许在运行时检查借用规则而不是编译时。在运行时违反规则程序会panic。

在一些特定的内存安全场景，虽没违反规则，但是在编译时检查却不被允许，RefCell<T>就派上用场了。

类似于Rc<T>，RefCell<T>也只能用于单线程场景，下面是选择Box<T>、Rc<T>还是RefCell<T>的理由：

Rc<T>允许相同数据有多个所有者，RefCell<T>和Box<T>有单一所有者。
Box<T>在编译时执行不可变或可变借用检查，Rc<T>在编译时执行不可变借用检查，RefCell<T>在运行时执行不可变或可变借用检查。
允许在RefCell<T>自身不可变的情况下修改其内部的值。

内部可变性用例：mock对象🔗

有时程序员会用某个类型替代另一个类型，观察其某些行为是否被正确实现。这个占位符类型称为测试替身（test double）。mock对象是特定类型的测试替身。

下面是我们想要测试的场景：编写一个记录某个值与最大值差距的库，并根据差距来发送消息，下面是代码：

pub trait Messenger {
    fn send(&self, msg: &str);
}

pub struct LimitTracker<'a, T: Messenger> {
    messenger: &'a T,
    value: usize,
    max: usize,
}

impl<'a, T> LimitTracker<'a, T>
where
    T: Messenger,
{
    pub fn new(messenger: &T, max: usize) -> LimitTracker<T> {
        LimitTracker {
            messenger,
            value: 0,
            max,
        }
    }

    pub fn set_value(&mut self, value: usize) {
        self.value = value;
        let percentage_of_max = self.value as f64 / self.max as f64;
        if percentage_of_max >= 1.0 {
            self.messenger.send("Error: You are over your quota!");
        } else if percentage_of_max >= 0.9 {
            self.messenger
                .send("Urgent warning: You've used up over 90% of your quota!");
        } else if percentage_of_max >= 0.75 {
            self.messenger
                .send("Warning: You've used up over 75% of your quota!");
        }
    }
}

这些代码有一个Massenger trait，它有一个send方法，该方法接受一个字符串切片作为参数。这个trait是mock对象所要实现的接口库。然后我们要测试LimitTracker的set_value方法。

下面是测试代码：

#[cfg(test)]
mod tests {
    use super::*;
    struct MockMessenger {
        sent_messages: Vec<String>,
    }
    impl MockMessenger {
        fn new() -> MockMessenger {
            MockMessenger {
                sent_messages: vec![],
            }
        }
    }
    impl Messenger for MockMessenger {
        fn send(&self, message: &str) {
            self.sent_messages.push(String::from(message));
        }
    }
    #[test]
    fn it_sends_an_over_75_percent_warning_message() {
        let mock_messenger = MockMessenger::new();
        let mut limit_tracker = LimitTracker::new(&mock_messenger, 100);
        limit_tracker.set_value(80);
        assert_eq!(mock_messenger.sent_messages.len(), 1);
    }
}

这里定义了一个MockMessenger结构体，它有一个sent_messages字段，用于存储发送的消息。然后我们实现了Messenger trait，它有一个send方法，该方法接受一个字符串切片作为参数。这个方法将消息添加到sent_messages字段中。这个将limit_tracker的value设置为80，然后我们断言sent_messages字段中有一个消息。

然而测试有问题，因为send方法获取了self的不可变引用，这是我们使用RefCell<T>来解决这个问题：

#[cfg(test)]
mod tests {
    use super::*;
    use std::cell::RefCell;
    struct MockMessenger {
        sent_messages: RefCell<Vec<String>>,
    }
    impl MockMessenger {
        fn new() -> MockMessenger {
            MockMessenger {
                sent_messages: RefCell::new(vec![]),
            }
        }
    }
    impl Messenger for MockMessenger {
        fn send(&self, message: &str) {
            self.sent_messages.borrow_mut().push(String::from(message));
        }
    }
    #[test]
    fn it_sends_an_over_75_percent_warning_message() {
        let mock_messenger = MockMessenger::new();
        let mut limit_tracker = LimitTracker::new(&mock_messenger, 100);
        limit_tracker.set_value(80);
        assert_eq!(mock_messenger.sent_messages.borrow().len(), 1);
    }
}

这里send_messages的字段类型是RefCell<Vec<String>>而不是Vec<String>。

对于send方法的实现，我们使用了borrow_mut方法来获取sent_messages字段的可变引用。这样我们就可以修改sent_messages字段的值了。

最后在assert_eq!宏中，我们使用了borrow方法来获取sent_messages字段的不可变引用。这样我们就可以断言sent_messages字段的值了。

RefCell在运行时记录借用🔗

创建不可变和可变引用时，对RefCell<T>来说是使用borrow和borrow_mut方法。这两个方法都会返回一个Ref<T>和RefMut<T>，它们分别代表不可变和可变引用。

RefCell<T>会记录当前有多少活动的Ref<T>和RefMut<T>，RefCell<T>允许有多个不可变借用或一个可变借用。

结合Rc和RefCell来拥有多个可变数据所有者🔗

Rc<T>允许对相同数据有多个所有者，不过只能提供不可变访问。一个储存了RefCell<T>的Rc<T>可以得到多个所有者并且可以修改的值。下面是链表的例子：

#[derive(Debug)]
enum List {
    Cons(Rc<RefCell<i32>>, Rc<List>),
    Nil,
}

use List::{Cons, Nil};
use std::cell::RefCell;
use std::rc::Rc;

fn main() {
    let value = Rc::new(RefCell::new(5));
    let a = Rc::new(Cons(Rc::clone(&value), Rc::new(Nil)));
    let b = Cons(Rc::new(RefCell::new(3)), Rc::clone(&a));
    let c = Cons(Rc::new(RefCell::new(4)), Rc::clone(&a));
    *value.borrow_mut() += 10;
    println!("a after = {:?}", a);
    println!("b after = {:?}", b);
    println!("c after = {:?}", c);
}

这里创建的一个Rc<RefCell<i32>>实例储存在变量value中，然后通过它创建了a列表，用到了克隆使a和value都拥有内部RefCell<i32>的所有权。

同样将a克隆到b和c中，然后我们使用borrow_mut方法来获取value的可变引用并将其值增加10(这里使用了自动解引用得到了RefCell<i32>，然后调用borrow_mut方法来获取i32的可变引用，最后解引用后修改其值)。最后打印出a、b和c的值，可以看到它们的值都被修改了。

使用RefCell<T>我们创建了一个表面上不可变但实际可修改数据的数据结构，同时其规则也保护我们免于数据竞争。

🔥 谨慎

RefCell<T>不能用于多线程代码，将在后面讨论Mutex<T>这个线程安全版本的RefCell<T>。

Rust智能指针Rc

小鼠 — Thu, 01 May 2025 00:00:00 +0000

有的时候单个值会有多个所有者，例如图数据结构中，多个边可能指向相同的节点，节点在没有任何边指向它从而没有任何所有者之前，都不应该被清理掉。

启用多所有权需要使用Rc<T>，这是引用计数（reference counting）的缩写，它记录了一个值的引用数量来知晓这个值是否仍在被使用，如果这个值有零个引用，就代表没有任何有效引用并可以被清理。

Rc<T>用于我们希望在堆上面分配一些内存供程序多个部分读取，且无法在编译时确定程序的哪一个部分会最后结束使用它的时候。如果知道哪部分最后一个结束使用，就可以令其成为数据的所有者，正常的所有权规则就可以在编译时生效。

🔥 谨慎

Rc<T>只能用于单线程场景，多线程场景将在后面介绍。

使用Rc共享数据🔗

假如我们想创建一个有共享所有权的列表，尝试使用Box<T>：

enum List {
    Cons(i32, Box<List>),
    Nil,
}

use List::{Cons, Nil};

fn main() {
    let a = Cons(5, Box::new(Cons(10, Box::new(Nil))));
    let b = Cons(3, Box::new(a));
    let c = Cons(4, Box::new(a));
}

这段代码会报错，因为创建b列表时，a的所有权已经被移动，所以尝试使用a创建c时不被允许。

可以改变Cons的定义来存放一个引用，不过需要指定生命周期参数，这样可以使列表中每一个元素都至少与列表本身存在的一样久，然而并不是所有情况都是如此。

下面我们使用Rc<T>来解决这个问题：

emum List {
    Cons(i32, Rc<List>),
    Nil,
}

use crate::List::{Cons, Nil};
use std::rc::Rc;

fn main() {
    let a = Rc::new(Cons(5, Rc::new(Cons(10, Rc::new(Nil)))));
    let b = Cons(3, Rc::clone(&a));
    let c = Cons(4, Rc::clone(&a));
}

这里创建b时，不同于获取a的所有权，而是克隆a所包含的Rc<List>，这会使引用计数从1增加到2并允许b和a共享Rc<List>中的数据的所有权，创建c时也一样。每次调用Rc::clone时，引用计数就会增加1，知道有零个引用之前数据都不会被清理。

这里先使用use语句将Rc<T>引入作用域，先创建a，然后创建b和c，Rc::clone接受一个Rc<T>的引用并返回一个新的Rc<T>。这里也可以调用a.clone()而不是Rc::clone(&a)，不过这里习惯是使用Rc::clone。Rc::clone不像大部分类型的clone那样对所有数据进行深拷贝，而是增加了引用计数。这会节省很多时间。

克隆Rc会增加引用计数🔗

考虑下面代码：

fn main() {
    let a = Rc::new(Cons(5, Rc::new(Cons(10, Rc::new(Nil)))));
    println!("count after creating a = {}", Rc::strong_count(&a));
    let b = Cons(3, Rc::clone(&a));
    println!("count after creating b = {}", Rc::strong_count(&a));
    {
        let c = Cons(4, Rc::clone(&a));
        println!("count after creating c = {}", Rc::strong_count(&a));
    }
    println!("count after c goes out of scope = {}", Rc::strong_count(&a));
}

这段代码可以观察到引用计数的变化，这里通过调用Rc::strong_count函数来获取引用计数。这个函数叫strong_count而不是count是因为Rc<T>也有weak_count这个函数。该代码会打印如下内容：

count after creating a = 1
count after creating b = 2
count after creating c = 3
count after c goes out of scope = 2

可以看到，a中初始的引用计数为1，后面每次调用Rc::clone时，引用计数就会增加1，直到c离开作用域时，引用计数就会减少1。不用像调用Rc<T>一样调用函数来减少计数，因为Rc<T>实现了Drop trait，当Rc<T>离开作用域时，引用计数就会减少1。

在最后，a和b离开作用域时，引用计数会减少到0，同时Rc<T>也会被完全清理。

通过不可变引用，Rc<T>可以允许程序的多个部分只读地共享数据，后面会介绍内部可变性模式和RefCell<T>类型，它可以与Rc<T>结合使用来处理不可变性的限制。

Tauri项目搭建

小鼠 — Tue, 29 Apr 2025 00:00:00 +0000

Tauri是一个用于构建跨平台桌面应用程序的框架，使用Web开发技术来构建前端界面，可以使用多种开发后端逻辑。它支持Windows、macOS和Linux等多个操作系统，提供了丰富的API和工具，方便开发者进行桌面应用程序的开发和部署。

在开始前，首先需要安装系统依赖，还有Rust和Node.js，详细安装见Prerequisites。

创建项目🔗

Tauri几乎可以和所有的前端框架一起使用，create-tauri-app是一个快速创建项目的工具。我们可以使用create-tauri-app来创建一个Tauri项目，也可以手动去创建。

使用create-tauri-app🔗

这里使用cargo来使用create-tauri-app：

cargo install create-tauri-app --locked
cargo create-tauri-app

接着会按照提示选择项目的名称、前端语言、包管理器和前端模板，以及前端框架。

💡 提示

如果不清楚该如何选择，可以从原版模板开始：

前端语言：TypeScript/JavaScript
包管理器：pnpm
UI模板：vanilla
UI风格：TypeScript

启动开发服务器🔗

创建完项目后，可以进入项目目录，然后使用Tauri CLI启动开发服务器：

cd tauri-app
pnpm install
pnpm run tauri dev

手动设置（Tauri CLI）🔗

希望自己设置项目，可以使用Tauri CLI来创建项目。

ℹ️ 注意

下面假定创建新项目，如果已经初始化了前端，则可以跳过第一步。

创建新目录并初始化前端，下面用pnpm作为包管理器：

mkdir tauri-app
cd tauri-app
pnpm create vite .

使用包管理器安装Tauri的CLI工具，如果使用cargo则需要全局安装，这里以cargo为例：

cargo install tauri-cli --version "^2.0.0" --locked

确定前端开发服务器的URL，如果使用的是Vite，则默认为http://localhost:5173。
在项目目录中出实话Tauri：

cargo tauri init

这个时候会询问一些问题。 5. 启动开发服务器：

cargo tauri dev

Rust智能指针Box

小鼠 — Mon, 28 Apr 2025 00:00:00 +0000

智能指针（smart pointers）是一类数据结构，String和Vec就是智能指针的例子。智能指针不同于结构体的地方在于，它实现了Deref trait和Drop trait。Deref trait允许智能指针像引用一样使用，Drop trait允许智能指针在离开作用域时自动执行一些操作。这里不会讲所有的智能指针，而是讲以下三个：

Box<T>，用在堆上分配值
Rc<T>，一个引用计数类型，其数据可以有多个所有者
Ref<T>和RefMut<T>，通过RefCell<T>访问

Box🔗

box是最简单直接的智能指针，它允许你将值放在堆上，而不是栈上，留在栈上的是指向堆数据的指针。

使用Box在堆上储存数据🔗

考虑下面代码：

fn main() {
    let b = Box::new(5);
    println!("b = {}", b);
}

这便是box的用法，这里定义了变量b，其值为5，5被放在了堆上，b是指向堆数据的指针。

Box创建递归类型🔗

递归类型（recursive type）的值可以拥有另一个同类型的值作为其自身的一部分，但是Rust在编译时需要知道类型占用了多少空间，而递归类型可以无限地递归下去，所以不知道需要多少空间。因为box有已知的大小，所以通过在循环类型定义中插入box就可以创建递归类型了。

下面探索一下一个递归类型的例子cons list，这个数据类型有两个参数，一个是值，一个是另一个cons list，最后一项包含一个叫Nil的特殊值，代表列表终止：

enum List {
    Cons(i32, List),
    Nil,
}

use List::{Cons, Nil};
fn main() {
    let list = Cons(1, Cons(2, Cons(3, Nil)));
}

上面的代码还不能编译，因为这个类型没有已知的大小。而使用box就可以解决这个问题，因为box作为一个指针有已知的大小：

enum List {
    Cons(i32, Box<List>),
    Nil,
}

use List::{Cons, Nil};
fn main() {
    let list = Cons(1, Box::new(Cons(2, Box::new(Cons(3, Box::new(Nil))))));
}

使用Deref trait将智能指针当作常规引用处理🔗

实现Deref trait允许我们重载*运算符，使得智能指针可以像引用一样使用。

追踪指针的值🔗

常规引用是一个指针类型：

fn main() {
    let x = 5;
    let y = &x;
    assert_eq!(5, x);
    assert_eq!(5, *y);
}

这里创建了一个变量x，其值为5，然后创建了一个指向x的引用y，使用*y可以获取y指向的值。如果尝试编写assert_eq!(5, y);，会报错，因为不允许比较数字的引用与数字，它们是不同的类型。

像引用一样使用Box🔗

可以使用Box<T>替代引用来重写上面代码：

fn main() {
    let x = 5;
    let y = Box::new(x);
    assert_eq!(5, x);
    assert_eq!(5, *y);
}

这段代码与上面的代码的不同之处在于将y设置为一个指向x值拷贝的Box<T>实例。

自定义智能指针🔗

下面我们创建一个类似于标准库中Box<T>类型的智能指针：

struct MyBox<T>(T);
impl<T> MyBox<T> {
    fn new(x: T) -> MyBox<T> {
        MyBox(x)
    }
}

这段代码定义了一个结构体MyBox<T>，它包含一个泛型类型T，是一个元组，并实现了一个名为new的方法，该方法接受一个类型为T的值，并返回一个MyBox<T>实例。

下面尝试使用MyBox<T>：

fn main() {
    let x = 5;
    let y = MyBox::new(x);
    assert_eq!(5, x);
    assert_eq!(5, *y);
}

这段代码不能编译，因为MyBox<T>不能解引用，为了使用*运算符，需要实现Deref trait。

实现Deref trait🔗

实现Deref trait由标准库提供，要求实现名为deref的方法，该方法借用self返回一个指向内部值的引用：

use std::ops::Deref;
impl<T> Deref for MyBox<T> {
    type Target = T;

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

type Target = T;关联类型，这里先不做解释，deref方法返回一个指向内部值的引用，编译器就可以使用*运算符了，事实上当我们输入*y时，编译器会运行*(y.deref())。

deref返回引用的原因是如果返回值，则所有权会被移出，一般情况下我们不希望获取MyBox<T>内部值的所有权。

函数和方法的隐式Deref强制转换🔗

Deref强制转换（Deref coercions）将实现了Deref trait的类型的引用转换为另一种类型的引用。例如&String转换为&str。当这种特定类型的引用作为实参传递给和形参类型不同的函数或方法时将自动进行。

Deref强制转换使得Rust程序员编写函数和方法调用时无需增加过多显式使用&和*的引用和解引用。

下面是一个例子：

fn hello(name: &str) {
    println!("Hello, {}!", name);
}

fn main() {
    let m = MyBox::new(String::from("Rust"));
    hello(&m);
}

这里&m的类型是&MyBox<String>，而hello函数的形参类型是&str，所以编译器会自动将&m转换为&String，然后再转换为&str。

如果没有实现Deref强制转换，则需要这样写：

fn hello(name: &str) {
    println!("Hello, {}!", name);
}
fn main() {
    let m = MyBox::new(String::from("Rust"));
    hello(&(*m)[..]);
}

这里先使用*运算符获取MyBox<String>的值，然后使用&和[]运算符获取字符串的切片，最后将切片传递给hello函数。

Deref强制转换如何与可变性交互🔗

类似Deref trait，标准库还提供了DerefMut trait，用于在可变引用上进行Deref强制转换。

Rust会在下面三种情况时进行Deref强制转换：

当T: Deref<Target=U>时，从&T到&U
当T: DerefMut<Target=U>时，从&mut T到&mut U
当T: Deref<Target=U>时，从&mut T到&U Rust可以将可变引用转换为不可变引用，但是不能将不可变引用转换为可变引用。

使用Drop trait运行清理代码🔗

对于智能指针第二个重要的trait是Drop trait，它允许我们在值离开作用域时运行一些代码。

Drop trait定义了一个名为drop的方法，该方法接受一个self可变引用，这里为了能看出何时调用drop方法，我们使用println!语句实现drop：

struct CustomSmartPointer {
    data: String,
}

impl Drop for CustomSmartPointer {
    fn drop(&mut self) {
        println!("Dropping CustomSmartPointer with data `{}`!", self.data);
    }
}

fn main() {
    let c = CustomSmartPointer {
        data: String::from("my stuff"),
    };
    let d = CustomSmartPointer {
        data: String::from("other stuff"),
    };
    println!("CustomSmartPointers created.");
}

Drop trait包含在prelude中，所以无需导入，输出如下：

CustomSmartPointers created.
Dropping CustomSmartPointer with data `other stuff`!
Dropping CustomSmartPointer with data `my stuff`!

可以看到，当c和d离开作用域时，drop方法被调用，并且data字段的值也被打印出来。变量以被创建时相反的顺序被丢弃。

通过std::men::drop提前丢弃值🔗

有些时候需要提前清理某个值Rust不允许我们主动调用Drop trait的drop方法，而是可以使用std::men::drop函数，该函数接受一个值并调用其Drop trait的drop方法：

fn main() {
    let c = CustomSmartPointer {
        data: String::from("some data"),
    };
    println!("CustomSmartPointer created.");
    drop(c);
    println!("CustomSmartPointer dropped before the end of main.");
}

输出如下：

CustomSmartPointer created.
Dropping CustomSmartPointer with data `some data`!
CustomSmartPointer dropped before the end of main.

std::men::drop位于prelude中，所以无需导入。

ℹ️ 注意

Rust不允许我们显式调用Drop trait的drop方法，因为Rust会在main结尾对值自动调用drop方法，这会导致一个double free错误，因为Rust会尝试清理相同的值两次。

matplotlib简单入门

小鼠 — Sun, 27 Apr 2025 14:00:00 +0800

Figure组成🔗

Matplotlib是一个Python的绘图库，它在Figure上绘制图像，每个Figure可以包含多个Axes，每个Axes可以理解为一幅图。

Figure🔗

Figure是整个图形的容器，一般使用下面函数之一创建一个Figure：

fig = plt.figure()             # an empty figure with no Axes
fig, ax = plt.subplots()       # a figure with a single Axes
fig, axs = plt.subplots(2, 2)  # a figure with a 2x2 grid of Axes
# a figure with one Axes on the left, and two on the right:
fig, axs = plt.subplot_mosaic([['left', 'right_top'],
                               ['left', 'right_bottom']])

Axes🔗

Axes是一个具有数据空间的图像区域，每个Axes都有一个标题（set_title()）、一个x轴标签（set_xlabel()）和一个y轴标签（set_ylabel()）。Axes是绘图的主要部分。

Axis🔗

Axis设置刻度和限制，并有刻度和刻度标签，刻度位置由Locator确定，刻度标签由Formatter确定。

Artist🔗

在Figure上绘制的所有对象都是Artist，Artist包括Axes、Axis、Line2D等。

绘图函数输入🔗

绘图函数的输入一般来讲是numpy.array或numpy.ma.masked_array，或是其他可以传递给numpy.array的对象。若是像numpy.matrix和pandas的数据对象一般需要先转换为numpy.array：

b = np.matrix([[1, 2], [3, 4]])
b_asarray = np.asarray(b)

大多数方法还能解析可字符串索引的对象，例如dict，structured numpy array或pandas.DataFrame，提供数据的索引作为x和y参数：

np.random.seed(19680801)  # seed the random number generator.
data = {'a': np.arange(50),
        'c': np.random.randint(0, 50, 50),
        'd': np.random.randn(50)}
data['b'] = data['a'] + 10 * np.random.randn(50)
data['d'] = np.abs(data['d']) * 100

fig, ax = plt.subplots(figsize=(5, 2.7), layout='constrained')
ax.scatter('a', 'b', c='c', s='d', data=data)
ax.set_xlabel('entry a')
ax.set_ylabel('entry b')

上面代码先创建了一个叫data的dict，装了a，b，c，d四个数组，然后使用scatter函数绘制散点图，x和y参数分别是a和b，color参数是c，size参数是d。

代码风格🔗

显示接口和隐示接口🔗

有两种使用Matplotlib的方法，一种是显式创建Figures和Axes，然后调用它们的方法（OO风格），例如ax.plot(x, y)，另一种是使用pyplot的隐式接口，例如plt.plot(x, y)，这种方法会自动创建Figures和Axes，然后调用它们的方法（pyplot风格）。

第一种如下：

x = np.linspace(0, 2, 100)  # Sample data.

# Note that even in the OO-style, we use `.pyplot.figure` to create the Figure.
fig, ax = plt.subplots(figsize=(5, 2.7), layout='constrained')
ax.plot(x, x, label='linear')  # Plot some data on the Axes.
ax.plot(x, x**2, label='quadratic')  # Plot more data on the Axes...
ax.plot(x, x**3, label='cubic')  # ... and some more.
ax.set_xlabel('x label')  # Add an x-label to the Axes.
ax.set_ylabel('y label')  # Add a y-label to the Axes.
ax.set_title("Simple Plot")  # Add a title to the Axes.
ax.legend()  # Add a legend.

第二种如下：

x = np.linspace(0, 2, 100)  # Sample data.

plt.figure(figsize=(5, 2.7), layout='constrained')
plt.plot(x, x, label='linear')  # Plot some data on the (implicit) Axes.
plt.plot(x, x**2, label='quadratic')  # etc.
plt.plot(x, x**3, label='cubic')
plt.xlabel('x label')
plt.ylabel('y label')
plt.title("Simple Plot")
plt.legend()

另外还有第三种方法，用于将Matplotlib嵌入GUI应用程序中，但这种方法不常用。

一般来说，在复杂的项目中建议使用OO风格，而在需要快速交互工作时，pyplot风格会很方便。

创建辅助函数🔗

可以写函数来简化我们的操作：

def my_plotter(ax, data1, data2, param_dict):
    """
    A helper function to make a graph.
    """
    out = ax.plot(data1, data2, **param_dict)
    return out

data1, data2, data3, data4 = np.random.randn(4, 100)  # make 4 random data sets
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(5, 2.7))
my_plotter(ax1, data1, data2, {'marker': 'x'})
my_plotter(ax2, data3, data4, {'marker': 'o'})

这里定义了一个函数my_plotter，然后绘制了两个图。

Artists风格🔗

对于Artists的样式选择，可以在绘图时指定，也可以在绘图使用setter指定：

fig, ax = plt.subplots(figsize=(5, 2.7))
x = np.arange(len(data1))
ax.plot(x, np.cumsum(data1), color='blue', linewidth=3, linestyle='--')
l, = ax.plot(x, np.cumsum(data2), color='orange', linewidth=2)
l.set_linestyle(':')

这里第一条线在绘图时指定了linestyle，第二条线在绘图后使用set_linestyle指定了linestyle。

颜色🔗

对于颜色的定义，参照Specifying colors，对于一个scatter，标记边缘和内部可以是不同颜色：

fig, ax = plt.subplots(figsize=(5, 2.7))
ax.scatter(data1, data2, s=50, facecolor='C0', edgecolor='k')

线宽、线型和标记大小🔗

线宽一般是以点为单位，用于有线条的Artists，线型的定义参照Linestyles。

标记的大小取决于绘图的方法，plot大小是一个点，scatter大小与可视区域成比例。标记的样式定义可以参照matplotlib.markers：

fig, ax = plt.subplots(figsize=(5, 2.7))
ax.plot(data1, 'o', label='data1')
ax.plot(data2, 'd', label='data2')
ax.plot(data3, 'v', label='data3')
ax.plot(data4, 's', label='data4')
ax.legend()

标签🔗

Axes标签和文本🔗

用set_xlabel、set_ylabel和set_title在指定位置添加文本，也可以用text添加文本到绘图中（详细见Text in Matplotlib）：

mu, sigma = 115, 15
x = mu + sigma * np.random.randn(10000)
fig, ax = plt.subplots(figsize=(5, 2.7), layout='constrained')
# the histogram of the data
n, bins, patches = ax.hist(x, 50, density=True, facecolor='C0', alpha=0.75)

ax.set_xlabel('Length [cm]')
ax.set_ylabel('Probability')
ax.set_title('Aardvark lengths\n (not really)')
ax.text(75, .025, r'$\mu=115,\ \sigma=15$')
ax.axis([55, 175, 0, 0.03])
ax.grid(True)

所有函数text方法都会返回一个matplotlib.text.Text实例，可以通过传入参数来改变文本样式（详细见Text properties and layout）：

t = ax.set_xlabel('my data', fontsize=14, color='red')

在文本中使用数学表达式🔗

Matplotlib支持TeX数学表达式，使用$来表示数学表达式：

ax.set_title(r'$\sigma_i=15$')

这里的r前缀表示里面内容是原始字符串而不是将反斜杠视为Python转义。Matplotlib内置有TeX表达式解析器和输出引擎，另外也可以使用LaTeX来进行文本渲染（详细见Text rendering with LaTeX）。

附注🔗

注释某个点，通常是用箭头指向该点，然后连接到一处文本：

fig, ax = plt.subplots(figsize=(5, 2.7))

t = np.arange(0.0, 5.0, 0.01)
s = np.cos(2 * np.pi * t)
line, = ax.plot(t, s, lw=2)

ax.annotate('local max', xy=(2, 1), xytext=(3, 1.5),
            arrowprops=dict(facecolor='black', shrink=0.05))

ax.set_ylim(-2, 2)

这个实例，使用annotate方法添加了一个指向(2, 1)的箭头，箭头连接到(3, 1.5)。

图例🔗

一般我们使用legend方法来添加图例（详细见Legend guide）：

fig, ax = plt.subplots(figsize=(5, 2.7))
ax.plot(np.arange(len(data1)), data1, label='data1')
ax.plot(np.arange(len(data2)), data2, label='data2')
ax.plot(np.arange(len(data3)), data3, 'd', label='data3')
ax.legend()

Axis刻度🔗

每个Axes都有两个或三个Axis对象，这些参数控制Axis的缩放、刻度定位和刻度格式。

Scales🔗

除了线性刻度，Matplotlib还提供了非线性刻度（例如对数刻度），有loglog、semilogx、semilogy等众多方法（详见Scales overview）。这里我们手动设置：

fig, axs = plt.subplots(1, 2, figsize=(5, 2.7), layout='constrained')
xdata = np.arange(len(data1))  # make an ordinal for this
data = 10**data1
axs[0].plot(xdata, data)

axs[1].set_yscale('log')
axs[1].plot(xdata, data)

这里将第二幅图的y轴设置为对数刻度。

Tick🔗

每个Axis都有一个刻度定位和格式化工具用于选择刻度线和标签，这里一个简单的接口是set_xticks和set_yticks（详细见Tick locators和Tick formatters）：

fig, axs = plt.subplots(2, 1, layout='constrained')
axs[0].plot(xdata, data1)
axs[0].set_title('Automatic ticks')

axs[1].plot(xdata, data1)
axs[1].set_xticks(np.arange(0, 100, 30), ['zero', '30', 'sixty', '90'])
axs[1].set_yticks([-1.5, 0, 1.5])  # note that we don't need to specify labels
axs[1].set_title('Manual ticks')

这里的第二幅图使用set_xticks和set_yticks手动设置了刻度线位置和标签。

dates and strings🔗

对于日期，可以使用matplotlib.dates模块来处理日期，例如（详细见Date tick labels）：

from matplotlib.dates import ConciseDateFormatter

fig, ax = plt.subplots(figsize=(5, 2.7), layout='constrained')
dates = np.arange(np.datetime64('2021-11-15'), np.datetime64('2021-12-25'),
                  np.timedelta64(1, 'h'))
data = np.cumsum(np.random.randn(len(dates)))
ax.plot(dates, data)
ax.xaxis.set_major_formatter(ConciseDateFormatter(ax.xaxis.get_major_locator()))

这里dates生成了从2021-11-15到2021-12-25每个小时的日期序列，而data是根据dates生成的随机数据。

对于字符串，我们使用分类绘图（详细见Plotting categorical variables）：

fig, ax = plt.subplots(figsize=(5, 2.7), layout='constrained')
categories = ['turnips', 'rutabaga', 'cucumber', 'pumpkins']

ax.bar(categories, np.random.rand(len(categories)))

其他轴对象🔗

有些时候可能还需要额外的轴，这时可以使用twinx和twiny添加一副新图（详细见Plots with different scales），或使用secondary_xaxis和secondary_yaxis（详细见Secondary Axis）添加一个新轴：

fig, (ax1, ax3) = plt.subplots(1, 2, figsize=(7, 2.7), layout='constrained')
l1, = ax1.plot(t, s)
ax2 = ax1.twinx()
l2, = ax2.plot(t, range(len(t)), 'C1')
ax2.legend([l1, l2], ['Sine (left)', 'Straight (right)'])

ax3.plot(t, s)
ax3.set_xlabel('Angle [rad]')
ax4 = ax3.secondary_xaxis('top', (np.rad2deg, np.deg2rad))
ax4.set_xlabel('Angle [°]')

这里的第一幅图使用twiny添加了一个新图，第二幅图使用secondary_xaxis添加了一个新轴。

颜色映射数据🔗

有时希望用颜色来表示第三个维度，在Matplotlib中有很多绘图类型可以做到这一点：

from matplotlib.colors import LogNorm

X, Y = np.meshgrid(np.linspace(-3, 3, 128), np.linspace(-3, 3, 128))
Z = (1 - X/2 + X**5 + Y**3) * np.exp(-X**2 - Y**2)

fig, axs = plt.subplots(2, 2, layout='constrained')
pc = axs[0, 0].pcolormesh(X, Y, Z, vmin=-1, vmax=1, cmap='RdBu_r')
fig.colorbar(pc, ax=axs[0, 0])
axs[0, 0].set_title('pcolormesh()')

co = axs[0, 1].contourf(X, Y, Z, levels=np.linspace(-1.25, 1.25, 11))
fig.colorbar(co, ax=axs[0, 1])
axs[0, 1].set_title('contourf()')

pc = axs[1, 0].imshow(Z**2 * 100, cmap='plasma', norm=LogNorm(vmin=0.01, vmax=100))
fig.colorbar(pc, ax=axs[1, 0], extend='both')
axs[1, 0].set_title('imshow() with LogNorm()')

pc = axs[1, 1].scatter(data1, data2, c=data3, cmap='RdBu_r')
fig.colorbar(pc, ax=axs[1, 1], extend='both')
axs[1, 1].set_title('scatter()')

这里分别使用了pcolormesh、contourf、imshow和scatter四种方法。

Colormaps🔗

这些都是ScalarMappableArtists，都可以将vmin和vmax之间的线性映射设置为cmap指定的Colormaps（Colormaps见Choosing Colormaps in Matplotlib）。

Normalization🔗

有时我们希望数据到颜色图的映射是非线性的，这个时候要提供norm参数而不是vmin和vmax参数（详细见Colormap normalization）。

Colorbar🔗

添加一个Colorbar用于查看颜色与数据的关系，用extend参数控制Colorbar的外观，用shrink和aspect参数控制大小。关于Colorbar的放置位置，见Placing colorbars。

使用多个Figures和Axes🔗

可以多次调用plt.figure()或plt.subplots()来创建多个Figure.

添加多个Axes有很多方法，可以用plt.subplots()，要添加更复杂的可以使用subplot_mosaic（详细见Arranging multiple Axes in a Figure和Complex and semantic figure composition (subplot_mosaic)）：

fig, axd = plt.subplot_mosaic([['upleft', 'right'],
                               ['lowleft', 'right']], layout='constrained')
axd['upleft'].set_title('upleft')
axd['lowleft'].set_title('lowleft')
axd['right'].set_title('right')

Rust性能对比：循环 VS 迭代器

小鼠 — Fri, 25 Apr 2025 00:00:00 +0000

为了决定是否使用循环或迭代器，我们需要了解哪个实现更快。

事实上，迭代器是Rust的零成本抽象（zero-cost abstraction）之一，这意味着，无论我们使用迭代器还是循环，Rust都不会产生任何额外的性能开销。

请放心使用迭代器和闭包！它们使代码看起来更高级，但并不为此引入运行时性能损失。

Rust迭代器

小鼠 — Thu, 24 Apr 2025 00:00:00 +0000

迭代器（iterator）负责遍历序列中的每一项并确定序列何时结束的逻辑。

在Rust中迭代器是惰性的（lazy），这意味着它们不会在创建时执行任何操作。考虑以下代码：

let v1 = vec![1, 2, 3];
let v1_iter = v1.iter();

在上面的代码中，v1.iter()创建了一个迭代器，但它并没有执行任何操作。

下面是的例子中将迭代器和for循环的使用分开：

fn main() {
    let v1 = vec![1, 2, 3];
    let mut v1_iter = v1.iter();
    for val in v1_iter {
        println!("Got: {}", val);
    }
}

一般来说，我们可能会使用一个从0开始的索引变量，使用这个变量索引vector中的值，并循环增加到元素总量。迭代器提供了对多种不同的虚了使用相同逻辑的灵活性，而不只是像vecter这样课索引的数据结构。

Iteratortrait和next方法🔗

迭代器都实现了一个叫Iterator的trait，这个trait定义像是这样的：

pub trait Iterator {
    type Item;
    fn next(&mut self) -> Option<Self::Item>;
}

这里有一个新语法type Item和Self::Item，这是一个关联类型（associated type）。现在只需知道这段代码表明实现了Iteratortrait的类型必须提供一个类型Item，这个类型是迭代器返回的元素类型。

next方法每次返回迭代器中的一个项，封装在Some中，迭代完成时，返回None。下面是next调用的一个例子：

#[test]
fn iterator_demonstration() {
    let v1 = vec![1, 2, 3];
    let mut v1_iter = v1.iter();
    assert_eq!(v1_iter.next(), Some(&1));
    assert_eq!(v1_iter.next(), Some(&2));
    assert_eq!(v1_iter.next(), Some(&3));
    assert_eq!(v1_iter.next(), None);
}

这里要将v1_iter的类型标注为mut，因为next方法需要改变迭代器的内部状态来更总迭代器在序列中的位置。也就是说，代码消费（consume）了，用尽了迭代器。使用for循环时，无需时v1_iter标注为mut，因为for循环会获取v1_iter的所有权并在后台使其可变。

ℹ️ 注意

从next调用中获取的值时对vector中值的不可变引用，iter方法生成了一个不可变引用的迭代器。如果我们需要一个获取v1所有权并返回拥有所有权的迭代器，可以使用into_iter方法，如果希望迭代可变引用，则可以调用iter_mut方法。

消费迭代器的方法🔗

Iteratortrait定义了很多方法，这些方法都可以用于消费迭代器。一些方法在定义中调用了next方法，这就是为何实现Iteratortrait的类型必须提供next方法的。

这些调用next方法的方法被称为消费适配器（consuming adaptors），因为调用它们会消耗迭代器。一个例子是sum方法，这个方法会获取迭代器的所有权并反复调用next方法，因而会消费迭代器。以下是例子：

#[test]
fn iterator_sum() {
    let v1 = vec![1, 2, 3];
    let v1_iter = v1.iter();
    let total: i32 = v1_iter.sum();
    assert_eq!(total, 6);
}

调用sum后便不能再使用v1_iter了。

产生其他迭代器的方法🔗

Iteratortrait定义了另一种方法，被称为迭代器适配器（iterator adaptors），这些方法不消耗当前迭代器，而是通过改变原始迭代器的某些方面来生成不同迭代器。

map便是一个例子，这个办法获取一个闭包对每个元素进行操作，map方法返回一个新的迭代器，该迭代器生产经过修改的元素。例子如下：

let v1: Vec<i32> = vec![1, 2, 3];

v1.iter().map(|x| x + 1);

不过这个代码会产生警告，因为实际上这个闭包并没有被调用。为了避免警告，我们可以使用collect方法将迭代器转换为一个集合：

let v1: Vec<i32> = vec![1, 2, 3];
let v2: Vec<_> = v1.iter().map(|x| x + 1).collect();
assert_eq!(v2, vec![2, 3, 4]);

这里用map方法创建了一个新的迭代器，接着使用collect方法消费迭代器并创建一个vector。因为所有迭代器都是惰性的，所以必须调用消费迭代器的方法，才能从这些迭代器适配器的调用中获取结果。

使用捕获环境的闭包🔗

很多迭代器适配器接受闭包作为参数，而我们通常会指定捕获其环境的闭包作为迭代器适配器参数。

作为例子，我们使用filter方法来获取一个闭包。该闭包从迭代器中获取一项并返回一个bool。如果闭包返回true，其值将会包含在filter提供的新迭代器中。如果返回false，则不会包含在新迭代器中。

下面是代码：

#[derive(PartialEq, Debug)]
struct Shoe {
    size: u32,
    style: String,
}

fn shoes_in_size(shoes: Vec<Shoe>, shoe_size: u32) -> Vec<Shoe> {
    shoes.into_iter().filter(|s| s.size == shoe_size).collect()
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn filters_by_size() {
        let shoes = vec![
            Shoe { size: 10, style: String::from("sneaker") },
            Shoe { size: 13, style: String::from("sandal") },
            Shoe { size: 10, style: String::from("boot") },
        ];

        let in_my_size = shoes_in_size(shoes, 10);

        assert_eq!(
            in_my_size,
            vec![
                Shoe { size: 10, style: String::from("sneaker") },
                Shoe { size: 10, style: String::from("boot") },
            ]
        )
    }
}

shoes_in_size函数体中调用了into_iter来创建一个获取vector所有权的迭代器，然后用filter将这个迭代器适配成一个只含有那些闭包返回true的元素的新迭代器，最后调用collect方法将这个新迭代器转换为vector。

Rust闭包

小鼠 — Wed, 23 Apr 2025 00:00:00 +0000

Rust的闭包（closures）是一种可以保存在变量或作为参数传递的匿名函数，与函数不同的是，它可以捕获调用者作用域中的值：

fn main() {
    let x = 1;
    let sum = |y| x + y;

    assert_eq!(sum(2), 3);
}

在上面的例子中，sum变量被赋值为一个闭包，这个闭包捕获了x变量的值。

闭包捕获的环境🔗

我们通过下面例子来了解这一点。例如，有Red和Blue两种成员的ShirtColor枚举，使用Inventory结构体来表示库存，Inventory结构体有一个类型为Vec<ShirtColor>的字段shirts，表示库存中的衬衫颜色，并定义giveaway方法获得免费衬衫得主喜爱的颜色，并返回颜色，代码如下：

#[derive(Debug, PartialEq, Copy, Clone)]
enum ShirtColor {
    Red,
    Blue,
}

struct Inventory {
    shirts: Vec<ShirtColor>,
}

impl Inventory {
    fn giveaway(&self, user_preference: Option<ShirtColor>) -> ShirtColor {
        user_preference.unwrap_or_else(|| self.most_stocked())
    }

    fn most_stocked(&self) -> ShirtColor {
        let mut num_red = 0;
        let mut num_blue = 0;

        for color in &self.shirts {
            match color {
                ShirtColor::Red => num_red += 1,
                ShirtColor::Blue => num_blue += 1,
            }
        }

        if num_red > num_blue {
            ShirtColor::Red
        } else {
            ShirtColor::Blue
        }
    }
}

fn main() {
    let store = Inventory {
        shirts: vec![ShirtColor::Blue, ShirtColor::Red, ShirtColor::Blue],
    };

    let user_pref1 = Some(ShirtColor::Red);
    let giveaway1 = store.giveaway(user_pref1);
    println!(
        "The user with preference {:?} gets {:?}",
        user_pref1, giveaway1
    );

    let user_pref2 = None;
    let giveaway2 = store.giveaway(user_pref2);
    println!(
        "The user with preference {:?} gets {:?}",
        user_pref2, giveaway2
    );
}

main函数里定义store变量还剩两件蓝衬衫和一件红衬衫，调用giveaway方法分别传入Some(ShirtColor::Red)和None参数，分别表示用户有红衬衫偏好和无衬衫偏好。

在giveaway方法中，使用unwrap_or_else方法来处理用户没有指定衬衫偏好的情况，unwrap_or_else方法接受一个无参闭包作为参数，该闭包返回ShirtColor类型的值。如果用户有衬衫偏好，unwrap_or_else方法会返回用户指定的衬衫颜色，否则会调用most_stocked方法来返回库存中最受欢迎的颜色。

将闭包表达式|| self.most_stocked()作为参数传递给unwrap_or_else方法，这是一个本身不获取参数的闭包（如果闭包有参数，它们会出现在||中间）。闭包体调用了self.most_stocked()方法。这里定义了闭包，而unwrap_or_else方法会在用户没有指定衬衫偏好时调用闭包。

我们传递的闭包会在当前Inventory实例上调用self.most_stocked()方法，闭包捕获了self（Inventory实例）的不可变引用，并将代码传递给unwrap_or_else方法。

闭包类型推断和注解🔗

闭包一般不要求对参数和返回值进行类型注解，因为函数是暴露给用户的显示接口的一部分，严格定义接口对确保所有人对函数使用和返回值的类型达成一致理解非常重要。而闭包不用于此，它们储存在变量中并被使用。

闭包通常较短，且与特定的上下文相关，编译器根据上下文推断参数和返回值类型。

如果添加了类型注解，代码会变得冗长，考虑下面代码：

let expensive_closure = |num: u32| -> u32 {
    println!("calculating slowly...");
    thread::sleep(Duration::from_secs(2));
    num
}

这个语法就更像是函数语法了，下面是闭包与函数语法的纵向对比：

fn  add_one_v1   (x: u32) -> u32 { x + 1 }
let add_one_v2 = |x: u32| -> u32 { x + 1 };
let add_one_v3 = |x|             { x + 1 };
let add_one_v4 = |x|               x + 1  ;

v3和v4需要调用才能编译，因为如果不调用，其类型无法被推断。

对于闭包，编译器会为每个参数和返回值推断一个具体类型，考虑下面代码：

let example_closure = |x| x;
let s = example_closure(String::from("hello"));
let n = example_closure(5);

这里在第一次调用闭包是使用了String类型，编译器会推断x的类型为String，这个类型就锁定进闭包example_closure中，在第二次调用闭包时使用了i32类型，编译器就会报错。

捕获引用或移动所有权🔗

闭包通过三种方式捕获环境的值，对应三种获取参数的方式：不可变借用、可变借用、获取所有权。考虑下面代码：

fn main() {
    let list = vec![1, 2, 3];
    println!("Before defining closure: {:?}", list);

    let only_borrows = || println!("From closure: {:?}", list);
    println!("Before calling closure: {:?}", list);
    only_borrows();
    println!("After calling closure: {:?}", list);
}

这里展示一个变量可以绑定一个闭包，我们可以像函数名一样，使用变量名和括号来调用该闭包。

可以看到在闭包定义之后到调用之后，代码仍然可以访问list，因为打印只需要不可变引用。

考虑下面代码：

fn main() {
    let mut list = vec![1, 2, 3];
    println!("Before defining closure: {:?}", list);
    let mut borrows_mutably = || list.push(7);

    borrows_mutably();
    println!("After calling closure: {:?}", list);
}
在这里闭包定义和调用之间就不能再有`println!`语句了，因为闭包定义时捕获的`list`的可变引用，而在闭包调用后就不再使用，可变借用结束，所以可以使用`println!`语句。

如果希望闭包将至获得所有权，可以在参数列表前使用`move`关键字，在将闭包传递到一个新线程时非常有用，考虑下面代码：
```rust
use std::thread;

fn main() {
    let list = vec![1, 2, 3];
    println!("Before defining closure: {:?}", list);

    thread::spawn(move || println!("From thread: {:?}", list))
        .join()
        .unwrap();
}

我们我们生成了一个新线程，并给它传递一个闭包作为参数。这个例子中我们使用了move关键字来获取list的所有权，如果不这样做，可能在新线程结束之前list的不可变引用就会失效。

将被捕获的值移出闭包🔗

闭包捕获和处理环境中的值的方式会影响闭包实现trait，根据闭包体处理这些值的方式，闭包会自动、渐进地实现Fntrait。

FnOnce：这个trait适用于只能被调用一次的闭包。所有闭包都至少实现了这个trait，因为所有闭包都能被调用。一个会讲捕获的值移出闭包体的闭包只会实现这个trait而不实现其他Fn相关的trait。
FnMut：这个trait适用于不会将捕获的值移出闭包体，但可能会修改捕获值的闭包。这类闭包可以被调用多次。
Fn：这个trait适用于不会将捕获的值移出闭包体，也不会修改捕获值的闭包。这类闭包在会多次并发调用闭包的场景中十分重要。

下面是之前使用的unwarp_or_else方法的定义：

impl<T> Option<T> {
    pub fn unwrap_or_else<F>(self, f: F) -> T
    where
        F: FnOnce() -> T,
    {
        match self {
            Some(x) => x,
            None => f(),
        }
    }
}

unwrap_or_else方法接受一个闭包作为参数，这个闭包必须能被调用一次，没有参数，返回T类型的值。trait bound中使用了FnOnce表示unwrap_or_else方法最多只会调用闭包一次。

ℹ️ 注意

函数可以实现三种Fntrait。

现在我们看定义在slice上的标准库方法sort_by_key，这个这个方法使用FnMuttrait：

#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

fn main() {
    let mut list = [
        Rectangle { width: 10, height: 1 },
        Rectangle { width: 3, height: 5 },
        Rectangle { width: 7, height: 12 },
    ];
    list.sort_by_key(|r| r.width);
    println!("{:#?}", list);
}

sort_by_key方法接受一个FnMut类型的闭包作为参数的原因是它会多次调用这个闭包，而|r| r.width满足trait要求。

下面是只实现了FnOncetrait的闭包的例子：

#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

fn main() {
    let list = [
        Rectangle { width: 10, height: 1 },
        Rectangle { width: 3, height: 5 },
        Rectangle { width: 7, height: 12 },
    ];
    let mut sort_oprations = vec![];
    let value = String::from("closure called");

    list.sort_by_key(|r| {
        sort_oprations.push(value);
        r.width
    });
    println!("{:#?}", list);
}

这里闭包调用push方法时，value变量的所有权已经被移动到sort_oprations中，闭包不能再使用value变量，这个闭包只实现了FnOncetrait，所以会报错。

ℹ️ 注意

感觉有点像泛函。

Rast运行测试

小鼠 — Tue, 22 Apr 2025 00:00:00 +0000

cargo test命令会在测试模式下编译代码并运行生成的测试二进制文件，传递参数给cargo test命令，可以改变测试的行为。一部分参数传递给cargo test，另一部分传递给测试二进制文件。前面的参数是传递给cargo test，后面的参数是传递给测试二进制文件。

并行或连续运行测试🔗

Rust默认在运行多个测试时会并行运行，但有些时候，例如往一个文件中写入数据，并行运行的测试可能互相干扰导致测试失败，一种解决方法是每一个测试都写不同的文件，另一解决方法是一次运行一个测试。

想要控制线程数量，可以传递--test-threads参数，如下：

cargo test -- --test-threads=1

这里指定程序不要使用并行机制。

显示函数输出🔗

默认情况下，测试通过时cargo test不会显示测试函数的输出，想要显示测试函数的输出，可以传递--show-output参数，如下：

cargo test -- --show-output

通过指定名字来运行部分测试🔗

如果只希望运行相关代码有关的测试，可以通过向cargo test传递测试函数的名字来运行部分测试，如下：

pub fn add_two(a: usize) -> usize {
    a + 2
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn add_two_and two() {
        let result = add_two(2);
        assert_eq!(result, 4);
    }

    #[test]
    fn add_three_and_two() {
        let result = add_two(3);
        assert_eq!(5, result);
    }

    #[test]
    fn one_hundred() {
        let result = add_two(100);
        assert_eq!(102, result);
    }
}

运行单个测试🔗

使用cargo test one_hundred只运行one_hundred这一个测试。

运行多个测试🔗

指定部分名称，则包含这部分名称的测试都会被运行。例如使用cargo test add会运行add_two_and_two和add_three_and_two这两个测试。

忽略非特别指定的测试🔗

使用ignore属性可以标记测试的时候排除的测试，如下：

pub fn add(left: usize, right: usize) -> usize {
    left + right
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn it_works() {
        let result = add(2, 2);
        assert_eq!(result, 4);
    }

    #[test]
    #[ignore]
    fn expensive_test() {
        
    }
}

在想要排除的#[test]之后增加#[ignore]行，这样使用cargo test运行测试，就会发现expensive_test这个测试没有被运行。

如果我们只希望运行被忽略的测试，可以使用cargo test -- --ignored命令。

Rust测试组织结构

小鼠 — Tue, 22 Apr 2025 00:00:00 +0000

测试分别为两类，单元测试（unit tests）和集成测试（integration tests）。单元测试倾向于小和集中，集成测试则对于库来说是外部的，只测试公共接口。

单元测试🔗

单元测试的目的是在与其他部分隔离的环境中测试每一个单元的代码，单元测试和要测的代码放在src下相同的文件中，每个文件中创建包含测试函数的tests模块，并使用cfg(test)标注模块。

测试模块和#[cfg(test)]🔗

#[cfg(test)]告诉Rust在执行cargo test命令时才编译和运行测试代码，而在执行cargo build命令时则不编译测试代码。而集成测试由于在另外的文件夹，所以不需要#[cfg(test)]标注。

测试私有函数🔗

Rust的私有性规则允许你测试私有函数，考虑下面的例子：

pub fn add_two(a: usize) -> usize {
    internal_adder(a, 2)
}

fn internal_adder(left: usize, right: usize) -> usize {
    left + right
}

#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn internal() {
        let result = internal_adder(2, 2);
        assert_eq!(4, result);
    }
}

这里internal_adder函数是私有的，但是在tests模块中可以测试它。

集成测试🔗

集成测试完全是外部的，所以只能调用公有API，为了创建集成测试，需要先创建一个tests目录。

tests目录🔗

编写集成测试要在项目根目录创建一个tests目录，Cargo会将tests目录下的所有文件都当作独立的crate来编译。

创建tests/integration_test.rs文件，在其中编写集成测试：

use adder::add_two;

#[test]
fn it_adds_two() {
    let result = add_two(2);
    assert_eq!(4, result);
}

不需要在代码中标注#[cfg(test)]，因为tests目录下的所有文件只有在运行cargo test命令时才会被编译。可以使用cargo test --test integration_test来运行integration_test.rs文件中的测试。

集成测试中的子模块🔗

由于tests目录下的所有文件都是独立的crate，所以tests下文件的行为与src中的不一样。

当有一些在多个集成测试文件都会用到的帮助函数，可以把它们都提取到一个通用的模块中，例如可以创建一个tests/common.rs文件，并创建一个叫setup的函数，如下：

pub fn setup() {
    // code to run before each test
}

这个时候运行cargo test，common会出现在测试结果中。

为了不让common会出现在测试结果中，我们将创建tests/common/mod.rs而不是创建tests/common.rs，这样告诉Rust不要将common当作一个集成测试文件。而这样也可以在其他的集成测试文件中调用这个模块：

use adder::add_two;

mod common;

#[test]
fn it_adds_two() {
    common::setup();
    let result = add_two(2);
    assert_eq!(4, result);
}

二进制crate的集成测试🔗

如果项目是一个二进制crate，只包含一个src/main.rs文件而没有src/lib.rs文件，那么tests目录创建的集成测试就不能导入src/main.rs中的函数，所以许多二进制项目会使用一个简单的src/main.rs文件来调用src/lib.rs中的函数。

Rast编写自动化测试

小鼠 — Mon, 21 Apr 2025 00:00:00 +0000

Rust中的测试函数是用来验证非测试代码是否按照期望方式运行的。一般执行以下三种操作：

设置任何所需的数据或状态
运行所需要测试的代码
断言其结果是我们所期望的

测试函数剖析🔗

新建一个库项目，它的src/lib.rs内容如下：

pub fn add(left: u64, right: u64) -> u64 {
    left + right
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn it_works() {
        let result = add(2, 2);
        assert_eq!(result, 4);
    }
}

我们关注it_works函数，fn行之前的#[test]表明这是一个测试函数。这里使用assert_eq!宏来断言result的值等于4。

使用cargo test命令来运行测试，结果如下：

running 1 test
test tests::it_works ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

   Doc-tests testdd

running 0 tests

test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

可以看见我们通过了测试。

下面我们添加一个测试失败的例子，当测试函数出现panic时测试就失败了。

pub fn add(left: u64, right: u64) -> u64 {
    left + right
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn exploration() {
        let result = add(2, 2);
        assert_eq!(result, 4);
    }

    #[test]
    fn another() {
        panic!("Make this test fail");
    }
}

再次运行cargo test，结果如下：

running 2 tests
test tests::it_works ... ok
test tests::another ... FAILED

failures:

---- tests::another stdout ----

thread 'tests::another' panicked at src/lib.rs:17:9:
Make this test fail
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace


failures:
    tests::another

test result: FAILED. 1 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

error: test failed, to rerun pass `--lib`

这里可以看见一个测试通过，一个测试失败。

使用宏来检查结果🔗

assert!由标准库提供，需要向assert!提供一个布尔值的参数。如果时间为true，就什么都不会做，如果是false，就会调用panic!宏。

assert_eq!和assert_ne!宏会比较两个值是否相等，两个宏都有两个参数，如果两个参数相等时，assert_eq!什么都不会做，assert_ne!会调用panic!宏，如果两个参数不相等时，assert_eq!会调用panic!宏，assert_ne!什么都不会做。
由于assert_eq!和assert_ne!宏底层分别使用了==和!=操作符，所以被比较的值必须实现了PartialEq和Debug这两个trait。

可以向assert!、assert_eq!和assert_ne!提供一个可选的失败信息参数，可以在测试失败时将自定义失败信息打印出来。在这三个函数必要的参数后面添加的参数都会传递给format!宏。

使用should_panic检查panic🔗

对函数增加另一个属性should_panic使这个函数在panic时通过，在没有panic时失败：

pub struct Guess {
    value: i32,
}

impl Guess {
    pub fn new(value: i32) -> Guess {
        if value < 1 || value > 100 {
            panic!("Guess value must be between 1 and 100, got {}.", value);
        }
        Guess { value }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    #[should_panic]
    fn greater_than_100() {
        Guess::new(200);
    }
}

#[should_panic]属性位于#[test]属性的下面之后。

然而，should_panic测试结果也可能含糊不清，在一些不是我们期望的原因而导致的panic时，测试也会通过。为了让测试更清晰，我们可以增加expected参数：

pub struct Guess {
    value: i32,
}
impl Guess {
    pub fn new(value: i32) -> Guess {
        if value < 1  {
            panic!("Guess value must be greater than or equal to 1, got {}.", value);
        } else if value > 100 {
            panic!("Guess value must be less than or equal to 100, got {}.", value);
        }
        Guess { value }
    }
}
#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    #[should_panic(expected = "less than or equal to 100")]
    fn greater_than_100() {
        Guess::new(200);
    }
}

这个测试会通过，因为panic信息包含了less than or equal to 100。

将Result<T,E>用于测试🔗

我们可以用Result<T,E>编写测试，这样在失败时可以返回Err而不是panic：

pub fn add(left: usize, right: usize) -> usize {
    left + right
}
#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn it_works() -> Result<(), String> {
        let result = add(2, 2);
        if result == 4 {
            Ok(())
        } else {
            Err(String::from("two plus two does not equal four"))
        }
    }
}

这个函数体中没有调用assert_eq!宏，而是直接返回一个Result<T,E>。如果测试通过，就返回Ok(())，如果测试失败，就返回Err。

不能对Result<T,E>使用#[should_panic]注解，应该使用assert!宏，像这样：assert!(value.is_err())。

Rust生命周期

小鼠 — Sun, 20 Apr 2025 00:00:00 +0000

生命周期是另一类泛型，不是确保类型有期望的行为，而是确保引用如预期一直有效。大多数时候，生命周期是隐式的，Rust会根据引用的使用方式来推断生命周期，但是一些时候引用的生命周期以一些不同方式相关联，Rust需要我们使用泛型生命周期参数来注明它们的关系。

生命周期避免了悬垂引用🔗

考虑下面的代码：

fn main() {
    let r;
    {
        let x = 5;
        r = &x;
    }
    println!("r: {}", r);
}

这段代码会报错，因为在{}中，x的生命周期结束了，但是r仍然指向x，这就是悬垂引用。

借用检查器🔗

Rust有一个借用检查器（borrow checker），他比较作用域来确保所有借用都是有效的，下面是上面代码带有生命周期的注释：

fn main() {
    let r;                    // ---------+-- 'a
                              //          |
    {                         //          |
        let x = 5;            // -+-- 'b  |
        r = &x;               //  |       |
    }                         // -+       |
    println!("r: {}", r);     //          |
}                             // ---------+

'a是r的生命周期，'b是x的生命周期，编译时，Rust会比较两个生命周期的大小，并发现r拥有生命周期'a，不过它引用了一个拥有生命周期'b的变量，这是不允许的，因为被引用的对象比他的引用者存在时间更短。下面是没有悬垂引用的代码例子：

fn main() {
    let x = 5;                // ----------+-- 'b
                              //           |
    let r = &x;               // --+-- 'a  |
                              //   |       |
    println!("r: {}", r);     //   |       |
                              // --+       |
}                             // ----------+

'a的生命周期比'b的生命周期长，所以这是合法的。

函数中的泛型生命周期🔗

编写一个返回两个字符串slice中长的那个的函数：

fn longest(x: &str, y: &str) -> &str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

这段代码不能编译，因为Rust不知道将要返回的引用是来自x还是y。编译器不知道返回的生命周期是怎么和x和y相关联的，所以它会报错。

为了解决这个问题，我们需要使用泛型生命周期参数。

生命周期注解语法🔗

生命周期注解不改变任何引用的生命周期长短，只是描述多个引用生命周期相互的关系。指定了泛型生命周期后函数也能接受任何生命周期的引用。

生命周期注解参数名称必须以（'）开头，名称通常全为小写，且很短。生命周期参数注解位于引用&之后，并有一个空格来将引用类型和生命周期注解分隔开。下面是一些例子：

&i32          // 引用
&'a i32       // 带有显式生命周期的引用
&'a mut i32   // 带有显式生命周期的可变引用

单个生命周期注解本身没什么意义，因为生命周期注解是告诉Rust多个引用的泛型生命周期参数的联系的。

函数签名中的生命周期注解🔗

在函数签名中使用生命周期注解需要在函数名和参数列表间的尖括号中声明泛型生命周期参数，假如希望两个参数和返回的引用存活得一样久，则代码如下：

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

这里表示函数返回的引用的生命周期和函数参数所引用的值的生命周期的较小值一致。

具体引用被传递给longest时，被'a所替代的具体生命周期是x和y的作用域重叠的那一部分。返回的引用值能保证在x和y的作用域内有效。查看下面例子：

fn main() {
    let string1 = String::from("long string is long");
    {
        let string2 = String::from("xyz");
        let result = longest(string1.as_str(), string2.as_str());
        println!("The longest string is {}", result);
    }
}

这里string1和string2的在内部作用域都有效，所以result也有效。下面看另外的例子。

fn main() {
    let string1 = String::from("long string is long");
    let result;
    {
        let string2 = String::from("xyz");
        result = longest(string1.as_str(), string2.as_str());
    }
    println!("The longest string is {}", result);
}

在外部作用域中，string1是有效的，但是string2是无效的，为了保证println!中的result是有效的，string2也需要在外部作用域有效，所以代码无法编译。

虽然以代码的角度讲，上述例子println!中的result中是string1的引用，但是生命周期参数告诉Rust，result的生命周期不能超过string2的生命周期。

考虑如下代码：

fn longest<'a>(x: &'a str, y: str) -> &'a str {
    x
}

这里为x和返回值指定了生命周期参数'a，但是没有为y指定生命周期，因y的生命周期与x和返回值生命周期无关。

函数返回一个引用，返回值的生命周期参数需要与一个参数的生命周期参数相匹配。如果其返回的引用没有指向任何一个参数，那么唯一的可能就是它指向一个函数内部创建的值，这是一个悬垂引用，因为函数结束时就离开了作用域，不能编译：

fn longest(x: &str, y: &str) -> &'a str {
    let result = String::from("really long string");
    result.as_str()
}

result在函数结尾就被清理，返回的是一个悬垂引用。

结构体中定义的生命周期注解🔗

在定义包含引用的结构体中，需要为结构体定义的每个引用指定生命周期：

struct ImportantExcerpt<'a> {
    part: &'a str,
}

fn main() {
    let novel = String::from("Call me Ishmael. Some years ago...");
    let first_sentence = novel.split('.').next().unwrap();
    let i = ImportantExcerpt {
        part: first_sentence
    };
}

这个结构体有唯一字段part，它存放了字符串slice，是一个引用，必须在结构一名称后面的尖括号中声明泛型生命周期参数。这个注解意味着ImportantExcerpt实例的生命周期不能比part引用的生命周期久。

生命周期省略（Lifetime Elision）🔗

每一个引用都有一个生命周期，然而考虑以下代码：

fn first_word(s: &str) -> &str {
    let bytes = s.as_bytes();

    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }
    &s[..]
}

这段代码的参数和返回值都是引用，虽然没有使用生命周期注解，但是可以编译，因为Rust有一个生命周期省略规则（lifetime elision rule）。编译器通过三条规则来判断引用何时不需要明确的注解，第一条适用于输入生命周期，后面两条适用于输出生命周期：

编译器为每一个引用参数都分配了一个生命周期参数。
如果只有一个输入生命周期参数，那么它被赋予所有输出生命周期参数。
如果方法有多个输入生命周期参数，且其中一个是&self或&mut self，那么self的生命周期被赋予所有输出生命周期参数。

以下是例子：

fn first_word(s: &str) -> &str {}

这里适用第一条规则，所以是下面这样：

fn first_word<'a>(s: &'a str) -> &str {}

然后适用第二条规则：

fn first_word<'a>(s: &'a str) -> &'a str {}

现在编译器就可以编译了。

再看看另一个例子：

fn longest(x: &str, y: &str) -> &str {}

这里适用第一条规则，所以是下面这样：

fn longest<'a, 'b>(x: &'a str, y: &'b str) -> &str {}

然后第二条规则和第三条规则都适用，所以会出错。

ℹ️ 注意

实际上第三条规则真正能够适用的只有方法签名。

方法签名中的生命周期注解🔗

带生命周期的结构体实现方法时，我们在哪里声明和使用生命周期参数取决于它们是与结构体字段相关还是与方法参数和返回值相关。

实现方法时结构体字段的生命周期必须总是在impl关键字之后声明并在结构体名称之后被使用，下面看例子：

struct ImportantExcerpt<'a> {
    part: &'a str,
}
impl<'a> ImportantExcerpt<'a> {
    fn level(&self) -> i32 {
        3
    }
}

这里方法level唯一的参数是self的引用，返回值是i32，impl和类型名后面的生命周期参数是必要的，不过因为第一条生命周期规则我们不用标注self引用的生命周期。

考虑下面代码：

impl<'a> ImportantExcerpt<'a> {
    fn announce_and_return_part(&self, announcement: &str) -> &str {
        println!("Attention please: {}", announcement);
        self.part
    }
}

这里应用第一条规则和第三条规则，所有引用的生命周期都被计算出来了。

静态生命周期🔗

一种特殊的生命周期'static，它表示引用的生命周期与整个程序的运行时间相同。将引用指定为'static要考虑这个引用是否真的需要在整个程序生命周期都有效，而不是只是为了修复一些悬垂引用或可用生命周期不匹配的错误。

结合泛型类型参数、trait bound和生命周期🔗

考虑以下代码：

use std::fmt::Display;
fn longest_with_an_announcement<'a, T>(
    x: &'a str,
    y: &'a str,
    ann: T
) -> &'a str
where
    T: Display,
{
    println!("Announcement! {}", ann);
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

这个例子同时使用了生命周期注解、泛型类型参数和trait bound。

Rust的Trait（定义共同行为）

小鼠 — Sat, 19 Apr 2025 00:00:00 +0000

trait定义了某个类型可能与其他类型共享的功能，用抽象的方式定义共同行为。

定义trait🔗

trait定义是一种将方法签名组合起来的方法，目的是定义一个实现某些目的所必需的行为的合集。

例如，这里有存放了不同类型和属性文本的结构体NewsArticle和Tweet，我们想创建一个aggregator的库用来显示NewsArticle和Tweet的数据摘要，就可以调用summarize方法来请求摘要：

pub trait Summary {
    fn summarize(&self) -> String;
}

这里使用trait关键字来声明一个trait，在大括号里声明实现这个trait的类型所需要的行为的方法签名。

每一个实现这个trait的类型需要提供自定义的方法体。

为类型实现trait🔗

考虑以下代码：

pub struct NewArticle {
    pub headline: String,
    pub location: String,
    pub author: String,
    pub content: String,
}

impl Summary for NewsArticle {
    fn summarize(&self) -> String {
        format!("{}, by {} ({})", self.headline, self.author, self.location)
    }
}

pub struct Tweet {
    pub username: String,
    pub content: String,
    pub reply: bool,
    pub retweet: bool,
}

impl Summary for Tweet {
    fn summarize(&self) -> String {
        format!("{}: {}", self.username, self.content)
    }
}

可见trait的实现是在impl关键字后面跟trait名，然后是for关键字，最后是类型名。现在NewsArticle和Tweet都实现了Summarytrait，我们可以像调用常规方法一样调用summarize方法，区别在于trait需要和类型一起引入作用域：

use aggregator::{Summary, Tweet};

fn main() {
    let tweet = Tweet {
        username: String::from("horse_ebooks"),
        content: String::from("of course, as you probably already know, people"),
        reply: false,
        retweet: false,
    };
    println!("1 new tweet: {}", tweet.summarize());
}

ℹ️ 注意

这里需要注意的是，只有类型或trait至少有一个属于当前crate时，我们才能对类型实现trait。这个限制是被称作相关性（coherence）的程序属性的一部分，或者更具体说是孤儿规则（orphan rule）。这个规则确保其他人编写的代码不会破坏你的代码。

默认实现🔗

为trait中的某些方法提供默认行为而不是每个类型每个实现都定义自己的行为很有用，当某个特定类型实现trait时，可以选择保留或重载每个方法的默认行为。

考虑如下代码：

pub trait Summary {
    fn summarize(&self) -> String {
        String::from("(Read more...)")
    }
}

如果想对NewsArticle使用这个默认实现，可以通过impl Summary for NewsArticle {}指定一个空的impl块。这个时候调用NewsArticle的summarize方法就会返回默认实现的结果。

默认实现允许调用相同trait中的其他方法，只需调用的方法定义了就行。

trait作为参数🔗

考虑下面代码：

pub fn notify(item: &impl Summary) {
    println!("Breaking news! {}", item.summarize());
}

对于item参数，我们指定了impl Summary而不是具体类型，这个参数支持任何实现了Summarytrait的类型。在notify函数中，我们可以调用任何来自Summary的方法。

trait bound语法🔗

impl Trait语法实际上是trait bound语法的语法糖：

pub fn notify<T: Summary>(item: &T) {
    println!("Breaking news! {}", item.summarize());
}

impl Trait用于短小的例子，而trait bound用于更复杂的情况，若是参数为两个实现了Summarytrait的类型，我们可以这样写：

pub fn notify(item1: &impl Summary, item2: &impl Summary) {}

其中item1和item2的类型可以不同，如果需要它们都是相同类型，则需要这样写：

pub fn notify<T: Summary>(item1: &T, item2: &T) {}

这里item1和item2的类型都为T，所以类型必须相同。

指定多个trait bound🔗

如果notify函数需要显示itme的格式化形式，也要使用summarize方法，item就需要实现两个trait：

pub fn notify(item: &(impl Summary + Display)) {}

泛型的trait bound语法可以这样写：

pub fn notify<T: Summary + Display>(item: &T) {}

通过where简化trait bound🔗

泛型参数多的时候，代码难以阅读：

fn some_function<T: Display + Clone, U: Clone + Debug>(t: &T, u: &U) -> i32 {}

可以使用where子句来简化：

fn some_function<T, U>(t: &T, u: &U) -> i32
    where T: Display + Clone,
          U: Clone + Debug,
{}

返回实现trait的类型🔗

考虑下面代码：

fn returns_summarizable() -> impl Summary {
    Tweet {
        username: String::from("horse_ebooks"),
        content: String::from("of course, as you probably already know, people"),
        reply: false,
        retweet: false,
    }
}

通过使用impl Summary作为返回值，我们可以返回任何实现了Summarytrait的类型，这里返回的是Tweet类型。

不过这只适用于返回一种类型，若使返回两种就不行：

fn returns_summarizable(switch: bool) -> impl Summary {
    if switch {
        NewsArticle {
            headline: String::from("Penguins win the Stanley Cup Championship!"),
            location: String::from("Pittsburgh, PA, USA"),
            author: String::from("Iceburgh"),
            content: String::from(
                "The Pittsburgh Penguins once again are the best hockey team in the NHL.",
            )，
        }
    } else {
        Tweet {
            username: String::from("horse_ebooks"),
            content: String::from("of course, as you probably already know, people"),
            reply: false,
            retweet: false,
        }
    }
}

这里尝试返回NewsArticle或Tweet类型，编译器会报错。

使用trait bound有条件地实现方法🔗

使用带有trait bound的impl块可以为实现了特定trait的类型实现方法：

use std::fmt::Display;

struct Pair<T> {
    x: T,
    y: T,
}

impl<T> Pair<T> {
    fn new(x: T, y: T) -> Self {
        Self { x, y }
    }
}

impl<T: Display + PartialOrd> Pair<T> {
    fn cmp_display(&self) {
        if self.x >= self.y {
            println!("The largest member is x = {}", self.x);
        } else {
            println!("The largest member is y = {}", self.y);
        }
    }
}

这里cmp_display方法只对实现了Display和PartialOrdtrait的类型有效。同理也可以对实现了特定trait的类型实现trait，称作blanket implementation，例如：

impl<T: Display> ToString for T {
    // --snip--
}

标准库有这些blanket implementation，我们可以对任何实现了Displaytrait的类型使用ToString里面的方法。

Rust泛型

小鼠 — Fri, 18 Apr 2025 00:00:00 +0000

使用泛型定义函数签名或结构体，枚举，方法等，就可以在不同数据类型中使用，而不需要重复定义。

在函数定义中使用泛型🔗

考虑下面代码：

fn largest_i32(list: &[i32]) -> &i32 {
    let mut largest = &list[0];

    for item in list {
        if item > largest {
            largest = item;
        }
    }

    largest
}

fn largest_char(list: &[char]) -> &char {
    let mut largest = &list[0];

    for item in list {
        if item > largest {
            largest = item;
        }
    }

    largest
}

fn main() {
    let number_list = vec![34, 50, 25, 100, 65];
    let result = largest_i32(&number_list);
    println!("The largest number is {}", result);

    let char_list = vec!['y', 'm', 'a', 'q'];
    let result = largest_char(&char_list);
    println!("The largest char is {}", result);
}

可见上面两个函数的代码几乎一致，只是类型不同，因此可以写一个新函数使用泛型来简化代码。
参数化这个新函数，可以定义一个类型参数，并在函数签名中使用它，在这里使用T，将参数声明在函数名称与参数列表中间的尖括号中，如下：

fn largest<T>(list: &[T]) -> &T {}

这里表示，函数largest有泛型类型T，他的参数list是T的切片，返回值也是T的引用。

考虑下面代码：

fn largest<T>(list: &[T]) -> &T {
    let mut largest = &list[0];

    for item in list {
        if item > largest {
            largest = item;
        }
    }

    largest
}

fn main() {
    let number_list = vec![34, 50, 25, 100, 65];
    let result = largest(&number_list);
    println!("The largest number is {}", result);

    let char_list = vec!['y', 'm', 'a', 'q'];
    let result = largest(&char_list);
    println!("The largest char is {}", result);
}

编译器会根据传入的参数类型，自动推断出T的类型，因此不需要显式地声明T的类型，但是代码目前不能编译，因为>并不能使用于所有可能类型，std::cmp::PartialOrd这个trait定义了>这个方法，因此需要将T限制为实现了PartialOrd这个trait的类型才能编译。

结构体定义中使用泛型🔗

考虑下面代码：

struct Point<T> {
    x: T,
    y: T,
}

fn main() {
    let integer = Point { x: 5, y: 10 };
    let float = Point { x: 1.0, y: 4.0 };
}

这里定义了一个结构体Point，它有两个字段x和y，他们的类型都是T，T是一个泛型类型参数，因此Point可以用于任何类型，如i32，f64，char等。

💡 提示

这里只使用了一个泛型类型，表明x和y的类型相同，如果创建一个x和y类型不同的Point，编译器会报错。

枚举定义中使用泛型🔗

考虑下面代码：

enum Option<T> {
    Some(T),
    None,
}

enum Result<T, E> {
    Ok(T),
    Err(E),
}

这里定义了两个枚举，Option和Result，他们都有一个泛型类型参数，Option的泛型类型参数T表示Some的值，Result的泛型类型参数T表示Ok的值，泛型类型参数E表示Err的值。

方法定义中使用泛型🔗

考虑下面代码：

struct Point<T> {
    x: T,
    y: T,
}

impl<T> Point<T> {
    fn x(&self) -> &T {
        &self.x
    }
}

fn main() {
    let p = Point { x: 5, y: 10 };

    println!("p.x = {}", p.x());
}

这里定义了一个x方法用来返回Point的x字段的引用，这个方法使用了泛型类型参数T，因此它可以用于任何类型的Point，如Point，Point等。

在定义方法时也可以指定限制，如：

impl Point<f32> {
    fn distance_from_origin(&self) -> f32 {
        (self.x.powi(2) + self.y.powi(2)).sqrt()
    }
}

这段代码表示只有Point类型的Point结构体才能调用distance_from_origin方法，而其他类型的实例没有这个方法。

ℹ️ 注意

需要在impl后面加上<T>来指定泛型类型参数T，编译器才能知道尖括号中的类型是泛型而不是具体类型。

泛型并不是总和结构体方法签名中的泛型是同一类型：

struct Point<X1, Y1> {
    x: X1,
    y: Y1,
}

impl<X1, Y1> Point<X1, Y1> {
    fn mixup<X2, Y2>(self, other: Point<X2, Y2>) -> Point<X1, Y2> {
        Point {
            x: self.x,
            y: other.y,
        }
    }
}

fn main() {
    let p1 = Point { x: 5, y: 10.4 };
    let p2 = Point { x: "Hello", y: 'c' };

    let p3 = p1.mixup(p2);

    println!("p3.x = {}, p3.y = {}", p3.x, p3.y);
}

这里定义了一个mixup方法，它接受一个Point类型的参数other，返回一个Point类型的值，可见一些泛型通过impl声明，而一些通过方法声明。

泛型代码的性能🔗

Rust会在编译时进行代码的单态化（monomorphization），将泛型代码转换为针对具体类型的代码，因此泛型代码没有额外的性能开销。

Rust的错误处理

小鼠 — Thu, 17 Apr 2025 00:00:00 +0000

Rust的错误主要分可恢复（recoverable）和不可恢复（unrecoverable）两种，对于可恢复错误，只用报告问题并重试操作，而对于不可恢复错误则需要立即停止程序。可恢复错误通过Result类型来处理，不可恢复错误通过panic!宏来处理。

用panic!处理不可恢复的错误🔗

执行会造成代码panic的操作（越界访问数组）或调用panic!宏，都会造成程序panic，这是panic会打印错误信息，展开并清理栈数据然后退出。通过环境变量可以让Rust在panic时打印调用堆栈（call stack）以便定位panic的原因。

ℹ️ 注意

panic时也可选择直接终止（abort），不清理数据就退出，内存需要由操作系统清理。在Cargo.toml的[profile]添加panic = 'abort'即可，例如要在release模式下panic时直接终止，则：

[profile.release]
panic = 'abort'

直接调用panic!宏：

fn main() {
    panic!("crash and burn");
}

运行结果：

thread 'main' panicked at src/main.rs:2:5:
crash and burn
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

这里可以看到panic的位置，也告诉我们可以使用RUST_BACKTRACE=1环境变量来显示backtrace。

使用panic!宏的backtrace🔗

将RUST_BACKTRACE环境变量设置为任何不是0的值来获取backtrace，输入RUST_BACKTRACE=1 cargo run运行程序。
需要获取带有带有这些信息的backtrace，需要启用debug标识，而在不使用--release标识编译时，debug标识默认是开启的。

用Result处理可恢复的错误🔗

Result类型表示可能成功（Ok）或失败（Err）的操作，Result类型是枚举，定义如下：

enum Result<T, E> {
    Ok(T),
    Err(E),
}

考虑下面代码：

use std::fs::File;

fn main() {
    let f = File::open("hello.txt");
}

File::open的返回值是Result<T, E>，当File::open成功时，greeting_file_result变量的值是Ok，其中Ok的值是File类型的文件句柄；当File::open失败时，greeting_file_result的值是Err，其中Err的值是std::io::Error类型的错误对象。

若要实现文件读取操作，考虑下面代码：

use std::fs::File;

fn main() {
    let greeting_file_result = File::open("hello.txt");

    let greeting_file = match greeting_file_result {
        Ok(file) => file,
        Err(error) => panic!("Problem opening the file: {:?}", error),
    }
}

这里如果File::open成功，则greeting_file的值是File类型的文件句柄，否则程序会panic并打印错误信息，告诉我们哪里出错了。

匹配不同错误🔗

上述代码无论什么错误都会调用panic!宏，但有时我们希望对不同的错误采取不同的处理方式，考虑如下代码：

use std::fs::File;
use std::io::ErrorKind;

fn main() {
    let greeting_file_result = File::open("hello.txt");

    let greeting_file = match greeting_file_result {
        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),
        },
    }
}

这里如果File::open失败，则判断错误类型，如果错误类型是ErrorKind::NotFound，则尝试创建文件，如果创建文件也失败，则调用panic!宏，否则返回创建的文件句柄；如果错误类型不是ErrorKind::NotFound，则调用panic!宏。

ℹ️ 注意

处理Result类型时，除了match语句外，使用闭包（closure）会使代码更加简洁。

失败时panic的简写：unwarp和expect🔗

Result类型定义了unwarp方法，如果Result是Ok，则返回Ok中的值，否则调用panic!宏。expect方法与unwarp方法类似，但expect方法接受一个错误信息参数，当Result是Err时，expect方法会打印错误信息并调用panic!宏。

传播错误🔗

考虑下面代码：

use std::fs::File;
use std::io::Read;

fn read_username_from_file() -> Result<String, io::Error> {
    let username_file_result = File::open("hello.txt")?;
    let mut username_file = match username_file_result {
        Ok(file) => file,
        Err(e) => return Err(e),
    };
    let mut username = String::new();
    match username_file.read_to_string(&mut username) {
        Ok(_) => Ok(username),
        Err(e) => Err(e),
    }
}

这里如果成功，则返回OK中的值，否则返回同样的Err，这就是传播错误。

用?运算符传播错误🔗

考虑下面代码：

use std::fs::File;
use std::io::{self, Read};

fn read_username_from_file() -> Result<String, io::Error> {
    let mut username_file = File::open("hello.txt")?;
    let mut username = String::new();
    username_file.read_to_string(&mut username)?;
    Ok(username)
}

在Result后加上?运算符，如果Result是Ok，则返回Ok中的值，否则返回Err，与上面的match表达式一致。
与match不用的是，?会将错误值传递给from函数，它定义于标准库的From trait中，用于将错误类型从一种转换为另一种，在有自定义的错误类型时可以节省代码。

在?之后使用链式方法调用进一步缩短代码：

use std::fs::File;
use std::io::{self, Read};

fn read_username_from_file() -> Result<String, io::Error> {
    let mut username = String::new();
    File::open("hello.txt")?.read_to_string(&mut username)?;
    Ok(username)
}

可见确实节省了很多代码。

下面还有更为简短的写法：

use std::fs;
use std::io;

fn read_username_from_file() -> Result<String, io::Error> {
    fs::read_to_string("hello.txt")
}

fs::read_to_string函数会打开文件，读取文件内容，然后将内容放入String中，并返回Result类型。

⚠️ 警告

?运算符只能用于返回Result或Option类型的函数，如果函数返回的是其他类型，则不能使用?运算符。
一般main函数返回()，修改后的main函数也可以使用?：

use std::error::Error;
use std::fs::File;

fn main() -> Result<(), Box<dyn Error>> {
    let greeting_file = File::open("hello.txt")?;
    Ok(())
}

总结🔗

本文讲解了Rust的错误处理，介绍了panic!宏和Result类型，并介绍了如何使用?运算符传播错误。

Rust的集合（collections）

小鼠 — Wed, 16 Apr 2025 00:00:00 +0000

Rust的标准库里有一系列数据结构，称作集合（collections）。这里讲解三种被广泛使用的集合：vector、string和hashmap。

Vector🔗

vector是一个动态数组，可以存储多个值，并且值类型相同。vector是可变的，可以添加、删除和修改元素。

创建vector🔗

创建一个空的vector：

let v: Vec<i32> = Vec::new();

这里创建了个叫v的vector，类型是i32，初始为空。

创建一个包含初始值的vector：

let v = vec![1, 2, 3];

这里使用了vec!宏，这个宏会根据提供的类型判断出vector的类型，并创建一个包含初始值的vector。

更新vector🔗

向vector中添加元素：

let mut v = Vec::new();
v.push(5);
v.push(6);
v.push(7);
v.push(8);
...

这里使用了push方法向vector中添加元素。

读取vector中的元素🔗

读取vector中的元素有两种方式：索引和get方法。

let v = vec![1, 2, 3, 4, 5];
let third: &i32 = &v[2];
println!("The third element is {}", third);

let third: Option<&i32> = v.get(2);
match third {
    Some(third) => println!("The third element is {}", third),
    None => println!("There is no third element."),
}

这里分别使用索引和get两种方法来读取vector中的元素，可以看到get方法的返回值是一个Option类型，这是因为索引可能超出vector的范围，所以需要使用Option来处理这种情况。

❗ 重要

注意：使用索引访问vector中的元素时，如果索引超出了vector的范围，会导致panic，而使用get方法访问时，如果索引超出了vector的范围，会返回None。

遍历vector🔗

可以使用for遍历vector中的元素：

let v = vec![1, 2, 3, 4, 5];
for i in &mut v {
    println!("{i}");
}

for i in &mut v {
    *i += 50;
}

这里分别使用了for遍历vector中的元素，以及for遍历vector中的可变引用，并修改了元素。

使用枚举来存储多个类型的值🔗

可以使用枚举来存储多个类型的值，例如：

enum SpreadsheetCell {
    Int(i32),
    Float(f64),
    Text(String),
}

let row = vec![
    SpreadsheetCell::Int(3),
    SpreadsheetCell::Text(String::from("blue")),
    SpreadsheetCell::Float(10.12),
];

这里定义了一个枚举SpreadsheetCell，它有三个变体：Int、Float和Text，分别对应i32、f64和String类型。然后使用vec!宏创建了一个包含SpreadsheetCell类型的vector。

String🔗

String是一个可变的、动态分配的UTF-8编码的字符串，是一个vector的封装，可以存储多个字符。

创建String🔗

创建一个空的String：

let mut s = String::new();

这里创建了一个叫s的String，初始为空。

创建带初始值的字符串：

let s = String::from("initial contents");
let s = "initial contents".to_string();

这里分别使用了String::from和to_string方法创建了一个带初始值的String。

ℹ️ 注意

注意：字符串是UTF-8编码的，所以可以存储任何Unicode字符。

更新String🔗

使用push_str方法添加slice到String中，使用push方法添加单个字符到String中：

let mut s = String::from("foo");
s.push_str("bar");
s.push('l');

这里分别使用了push_str和push方法向String中添加了slice和字符。

使用’+’或format!宏连接字符串🔗

可以使用+连接字符串：

let s1 = String::from("Hello, ");
let s2 = String::from("world!");
let s3 = s1 + &s2; // note s1 has been moved here and can no longer be used

这里使用了+运算符连接了两个String，注意s1被移动了，所以不能再使用s1。s2是一个引用，在这里会转移成&str，所以可以连接，之后也可以继续使用。

在连接多个字符串时，可以使用format!宏：

let s1 = String::from("tic");
let s2 = String::from("tac");
let s3 = String::from("toe");

let s = format!("{}-{}-{}", s1, s2, s3);

这里使用了format!宏连接了三个String，并返回了一个新的String，format!宏和println!宏类似，只不过不是打印而是返回结果。

String索引🔗

Rust中的String不可索引，String是Vec的封装，由于使用UTF-8编码，一个字符可能占用多个字节，所以不能像数组那样使用索引访问字符串中的字符。

ℹ️ 注意

另外：索引操作预期需要常数时间O(1)，但Rust计算一个字符需要遍历整个字符串来确认有效字符。

使用索引创建字符串slice是可行的：

let hello = "Здравствуйте";
let s = &hello[0..4];

这里使用了索引创建了一个字符串slice，s的值是“Зд“，注意索引是从0开始的，所以s的长度是4。（这些字符每个占用2个字节）

🔥 谨慎

如果获取&hello[0..1]，会报错，因为第一个字符是两个字节。

遍历String🔗

遍历String需要明确表示的是字符还是字节，可以使用chars方法遍历字符，使用bytes方法遍历字节：

for c in "Зд".chars() {
    println!("{}", c);
}

for b in "Зд".bytes() {
    println!("{}", b);
}

这里分别使用了chars和bytes方法遍历了字符串中的字符和字节，输出如下内容：

这里使用了chars方法遍历了字符串中的字符，使用bytes方法遍历了字符串中的字节。

HashMap🔗

HashMap<K,V>储存了一个键值对的映射。哈希map用于需要任何类型作为key来寻找数据的情况，这里简单介绍HashMap。

创建HashMap🔗

创建一个空的HashMap：

use std::collections::HashMap;

let mut scores = HashMap::new();

scores.insert(String::from("Blue"), 10);
scores.insert(String::from("Yellow"), 50);

这里使用了HashMap::new方法创建了一个空的HashMap，然后使用insert方法向HashMap中添加了两个键值对。
像vector一样，hashmap的键类型和值类型必须相同，这里使用了String和i32类型。

ℹ️ 注意

注意：要先使用use std::collections::HashMap引入HashMap，由于HashMap相对Vector和String使用频率较低，所以没被prelude自动引用。

访问HashMap中的值🔗

使用get方法访问HashMap中的值：

use std::collections::HashMap;

let mut scores = HashMap::new();

scores.insert(String::from("Blue"), 10);
scores.insert(String::from("Yellow"), 50);

let team_name = String::from("Blue");
let score = scores.get(&team_name).copied().unwrap_or(0);

get方法返回一个Option类型，如果键存在，则返回Some值，否则返回None，这里使用了copied方法获取一个Option而不是Option<&i32>，接着用unwrap_or(0)方法获取值，如果Option是None，则返回0。

遍历HashMap中的值也可以用for：

use std::collections::HashMap;

let mut scores = HashMap::new();

scores.insert(String::from("Blue"), 10);
scores.insert(String::from("Yellow"), 50);

for (key, value) in &scores {
    println!("{}: {}", key, value);
}

这里使用了for遍历了HashMap中的键值对，并打印了键和值，输出如下：

Blue: 10
Yellow: 50

hashmap和所有权🔗

对于实现Copy trait的类型，例如i32，HashMap会将值复制到哈希map中，对于String这样有所有权的值，HashMap会将值的移动并获取所有权：

use std::collections::HashMap;

let field_name = String::from("Favorite color");
let field_value = String::from("Blue");

let mut map = HashMap::new();
map.insert(field_name, field_value);

这里创建了一个String类型的field_name和field_value，然后使用insert方法将它们插入到HashMap中，之后field_name和field_value的所有权被移动到了HashMap中，所以不能再使用它们。
如果将值的引用插入到HashMap中，那么值不会被移动，但是这些引用所指的值必须至少在hashmap有效时有效。

更新HashMap🔗

每一个键只能关联一个值，所以在处理一个键时，需要先检查键是否存在，如果存在则更新值，如果不存在则插入键值对。

let mut scores = HashMap::new();

scores.insert(String::from("Blue"), 10);
scores.insert(String::from("Blue"), 25);

println!("{:?}", scores);

这里先插入了一个键值对，然后又插入了一个键值对，但是键是相同的，所以第二个键值对会覆盖第一个键值对，输出如下：

{"Blue": 25}

使用entry可以更简洁的更新HashMap：

use std::collections::HashMap;

let mut scores = HashMap::new();

scores.insert(String::from("Blue"), 10);

scores.entry(String::from("Yellow")).or_insert(50);
scores.entry(String::from("Blue")).or_insert(50);

println!("{:?}", scores);

entry返回值是一个枚举Entry，代表可能存在也可能不存在的值。使用Entry的or_insert方法在键值存在时返回这个值的可变引用，如果不存在则将参数作为值插入，并返回这个新值的可变引用。这里使用了or_insert方法更新了HashMap中的值，输出如下：

{"Yellow": 50, "Blue": 10}

如果要根据旧值更新一个值，考虑如下代码：

//这里是计数一个字符串中每一单词出现的次数
use std::collections::HashMap;

let text = "hello world wonderful world";

let mut map = HashMap::new();

for word in text.split_whitespace() {
    let count = map.entry(word).or_insert(0);
    *count += 1;
}

println!("{:?}", map);

这里使用了entry方法获取了键的可变引用，然后使用*count += 1更新了值，输出如下：

{"hello": 1, "world": 2, "wonderful": 1}

其中，split_whitespace方法返回一个由空格分割text值子slice的迭代器，or_insert方法返回一个可变引用，所以需要使用*count来更新值。

总结🔗

本文介绍了Rust中的Vector、String和HashMap，Vector是动态数组，String是字符串，HashMap是哈希表，它们都是Rust中常用的集合类型，其中HashMap使用时要用use std::collections::HashMap引入，而Vector和String可以直接使用。

Rust的项目结构

小鼠 — Tue, 15 Apr 2025 00:00:00 +0000

crate是Rust的最小代码单位，有二进制项和库两种形式，二进制项有main函数，库没有main函数。包（package）是提供一系列功能的一个或多个crate，一个包会包含一个Cargo.toml文件，包可以包含一个库crate（library crate）或任意多个二进制crate（binary crate），但至少需要包含一个crate。
用Cargo创建一个新的包，里面会有src文件夹和Cargo.toml文件，src文件夹里面有一个main.rs文件，这是与包同名的二进制crate根，如果有lib.rs文件，则是与包同名的库crate根。

💡 提示

将文件放在src/bin文件夹下，Cargo会自动将其视为一个独立的二进制crate，并生成一个对应的二进制crate的根。

模块应用🔗

模块化是一种非常重要的编程范式，它可以帮助开发者编写更清晰、更易于维护、更易于扩展的代码。

模块声明🔗

编译器从crate根文件（src/main.rs或src/lib.rs）开始寻找需要被编译的代码，如果你在crate根文件中声明一个新模块，例如使用mod my_module;，编译器会在crate根目录下寻找src/my_module.rs文件或src/my_module/mod.rs文件。

子模块声明🔗

如果在src/my_module.rs定义了mod my_submodule;，编译器会在src/my_module目录下寻找my_submodule.rs文件或my_submodule/mod.rs文件。

私有和公有🔗

模块的代码默认对其父模块私有，如果想让模块中的项对父模块外部可见，可以使用pub关键字。

ℹ️ 注意

将结构体定义为pub，则结构体的字段默认为私有，如果想让字段公有，需要使用pub关键字。
若结构体某个字段为私有，则需要提供一个关联函数来构建实例，否则外部无法创建实例。

use关键字🔗

use crate::my_module::my_submodule;，这会导入my_submodule模块，之后就可以直接使用my_submodule，而不需要my_module::my_submodule。

模块树🔗

考虑src/lib.rs中的这样一段代码：

mod front_of_house {
    mod hosting {
        fn add_to_waitlist() {}
        fn seat_at_table() {}
    }
    mod serving {
        fn take_order() {}
        fn serve_order() {}
        fn take_payment() {}
    }
}

这段代码中模块树结构如下：

crate
 └── front_of_house
     ├── hosting
     │   ├── add_to_waitlist
     │   └── seat_at_table
     └── serving
         ├── take_order
         ├── serve_order
         └── take_payment

使用模块管理代码能让代码结构更清晰，更易于维护。

引用模块🔗

要调用模块中的函数，需要用到::操作符，关于路径有绝对路径（absolute path）和相对路径（relative path）两种，绝对路径从crate开始，相对路径从当前模块开始，使用self关键字表示当前模块，super关键字表示父模块。

💡 提示

使用use crate::front_of_house::hosting;，这会导入hosting模块，之后就可以直接使用hosting，而不需要front_of_house::hosting。use语句只适用于其所在作用域。

ℹ️ 注意

一般来讲，一个包同时包含二进制crate和库crate，此时二进制crate中只保留可执行文件的代码，被调用的代码都放在库crate中，模块树也应该定义在src/lib.rs中。

使用pub use关键字可以将模块导入当前作用域后，其他模块也可以倒入，例如：

mod front_of_house {
    pub mod hosting {
        pub fn add_to_waitlist() {}
    }
}
pub use crate::front_of_house::hosting;
pub fn eat_at_restaurant() {
    hosting::add_to_waitlist();
}

若不使用pub use，外部代码需要使用路径 restaurant::front_of_house::hosting::add_to_waitlist()来调用add_to_waitlist函数。现在，外部代码可以使用restaurant::hosting::add_to_waitlist()来调用add_to_waitlist函数。

Nix教程①：简单的开始

小鼠 — Fri, 11 Apr 2025 00:00:00 +0000

Ad hoc shell 环境🔗

使用nix-shell和-p（--packages）来创建一个Nix shell，在Nix shell中就可以使用这些包。输入exit退出这个shell。
如果需要直接运行，可以加--run再加入命令，如：

nix-shell -p python3 --run "python3 --version"

这行命令会创建一个Nix shell，安装python3，然后运行python3 --version命令。

💡 提示

可以在NixOS Search查找程序包。
Nix shell里也可以嵌套使用Nix shell。

可重现环境🔗

直接创建Nix shell可能会使环境不可重现，因为包的版本可能随时间变化。使用以下命令创建一个可重复实现的环境：

nix-shell -p git --run "git --version" --pure -I nixpkgs=https://github.com/NixOS/nixpkgs/tarball/2a601aafdc5605a5133a2ca506a34a3a73377247

-I参数指定了Nixpkgs的源，这里选的是github上一个特定的版本。--pure参数忽略了系统的大多数环境变量，一般在需要隔离时使用。

可重现脚本🔗

假设我们要运行以下脚本：

#! /bin/bash

curl https://github.com/NixOS/nixpkgs/releases.atom | xml2json | jq .

这个脚本获取URL的XML将其转换为JSON，并更改格式以提高可读性。
这个脚本需要curl、xml2json和jq三个包，若系统中没有这些包，脚本会失败。
为了使脚本可重现，我们使用以下脚本：

#!/usr/bin/env nix-shell
#! nix-shell -i bash --pure
#! nix-shell -p bash cacert curl jq python3Packages.xmljson
#! nix-shell -I nixpkgs=https://github.com/NixOS/nixpkgs/archive/2a601aafdc5605a5133a2ca506a34a3a73377247.tar.gz

curl https://github.com/NixOS/nixpkgs/releases.atom | xml2json | jq .

这个脚本使用了nix-shell的shebang，-i指定了bash为其余部分的解释器。-p参数指定了需要的包其中xml2json由python3Packages.xmljson提供，cacert使SSL身份验证正常工作。-I参数指定了Nixpkgs仓库特定的提交，这一步保证了包的版本相同。

ℹ️ 注意

第一行是标准的shebang，指定了脚本的解释器。第二行到第四行是nix-shell脚本的shebang。

声明式shell环境🔗

Ad hoc shell环境在一次性使用时比较方便，如果想要更多的自定义空间，从shell.nix文件创建一个shell环境是更好的选择。

💡 提示

有点像docker里的Dockerfile。

创建一个shell.nix文件，内容如下：

let
  nixpkgs = fetchTarball "https://github.com/NixOS/nixpkgs/tarball/nixos-24.05";
  pkgs = import nixpkgs { config = {}; overlays = []; };
in

pkgs.mkShellNoCC {
  packages = with pkgs; [
    cowsay
    lolcat
  ];

  GREETING = "Hello, Nix!";
  shellHook = ''
    echo $GREETING | cowsay | lolcat
  '';
}

在shell.nix文件同一个目录下运行nix-shell，会根据shell.nix文件创建一个shell环境，这里包含cowsay和lolcat两个包。
具体的Nix语言细节将在之后的章节讲解。

固定Nixpkgs🔗

Nix实例中有类似这样的内容：

{ pkgs ? import (fetchTarball "https://github.com/NixOS/nixpkgs/archive/06278c77b5d162e62df170fec307e83f1812d94b.tar.gz") {}
}:

这里直接从Github获取相应的提交，我们可以在NixOS Status选择提交。

CNN（卷积神经网络）简介

小鼠 — Thu, 20 Mar 2025 00:00:00 +0000

若将一张图像每一个点都输入一个神经元，这非常容易过拟合，参数也太大。一般将每个感受野（receptive field）传入神经元。

卷积（Convolution）过程🔗

考虑RGB三个通道，假设每个感受野的大小为$$3 \times 3$$输入一组神经元，每个感受野的步长（stride）为$$2$$，若超出了，做填充（padding）。
对于不同感受野输入的神经元，可以共享参数，共享参数的神经元叫过滤器（filter），而这个操作就叫卷积（Convolution）。
即使用每个过滤器在图像上进行计算，能得出一张新的图片（通道数为过滤器个数）。

池化（Pooling）过程🔗

池化将图片缩小，目的是通过减小输入减小参数。池化的方法有很多最简单的就是在一个神经元输出中选择一个数作为输出。（现在由于算力的增加，Pooling可以不再使用）

Flatten（变平）过程🔗

使用Flatten函数把输出的矩阵变为向量，然后在经过一层神经网络并归一化（Softmax）。

ℹ️ 注意

一般来说，CNN不能够很好地处理缩放或旋转图片后的问题，这需要我们将训练资料做数据增强（Data Augmentation）。

自注意力机制（Self-attention）简介

小鼠 — Thu, 20 Mar 2025 00:00:00 +0000

在处理输入为一组长短不一的向量时，会用到自注意力机制。

Sequence Labeling 问题🔗

每个输入的向量通过全连接层得到输出即可完成，但是在输入相同内容时会出现问题（例如翻译同一个单词时，意思可能不同）。此时，将输入的向量的前后几个向量（window）也输入，能有更好的效果，但是在解决有些需要联系整个Sequence的问题时效果仍然不佳，此时引入自注意力机制（Self-attention）。
将每个输入的向量先通过自注意力机制生成一个带有Sequence信息的向量，然后再通过全连接层得到输出，能更好地解决这些问题。

自注意力层🔗

对于每一个向量，计算出全部向量和其关联程度（attention score）$$\alpha$$，在将其关联程度与向量做出变换的输出的积相加，得出的向量就会靠近关联程度高的那个，这个向量就是自注意力层的输出，也就是上面所说带有Sequence信息的向量。
具体的说，每个向量$$a_i$$乘上一个矩阵$$W_q$$得到$$q_i$$，乘上一个矩阵$$W_k$$得到$$k_i$$，乘上一个矩阵$$W_v$$得到$$v_i$$，其中$$q_i$$和$$k_j$$相乘得到相关系数$$\alpha_{ij}$$，soft-max后得到$$\alpha_{ij}^{\prime}$$，$$v^j$$与$$\alpha_{ij}^{\prime}$$相乘得到$$a_i$$的输出。
有些时候，有多种相关性，此时就需要多头自注意力机制（Multi-head Self-attention），及上面的$$q_i,k_i,v_i$$再乘上多个矩阵得到$$q_i^n,k_i^n,v_i^n$$，再由$$q_i^n,k_i^n,v_i^n$$来计算输出。

💡 位置信息

有时需要考虑到向量所在的位置信息，采用位置编码（Positional Encoding）。一种简单的方法是给每个位置一个表征位置的向量$$e_i$$，把$$e_i$$加到$$a_i$$就能考虑到位置信息，当然也有很多不同的方法将位置信息考虑进去。

Self-attention for Speech🔗

受运算速度限制，在处理语音问题时，我们往往不用考虑整个Sequence，而是考虑输入附近的向量做自注意力层。

Self-attention for Image🔗

将一张图片的每一个像素看作三维向量，一张图片也可以看作是一个Sequence来处理。
与CNN相比，Self-attention考虑了整张图片的信息，比CNN更广，弹性更大，所以Self-attention需要更多的数据，不然容易出现过拟合问题。
与RNN相比，RNN与离得远的向量的联系会比较低，而Self-attention可以定义相应的联系。另外RNN不能够并行处理，而Self-attention可以并行处理，所以Self-attention速度会更快。

Self-attention for Graph🔗

对一个图，每一个节点看作一个向量，节点与节点之间有边，边可以看作是向量之间的联系，所以也可以用Self-attention来处理图。处理时一般只用计算有相连的节点，不相连的节点关联性设为0，这就是一种GNN模型。

My First Post

小鼠 — Sat, 15 Mar 2025 00:00:00 +0000

The purpose of this post is to test the functionality of the blog.
Actually, it works!
这是我的第一篇博客，用来测试博客的功能是否正常。