序言

计算机是20世纪最伟大的科学技术发明之一。从第一台电子计算机ENIAC于1946年在美国宾夕法尼亚大学诞生至今，计算机技术经历了从电子管到晶体管、从集成电路到大规模集成电路、从单机到互联网、从桌面到云端的跨越式发展。如今，计算机的运行速度越来越快，功能越来越强大，形态也越来越丰富——从超级计算机到智能手机，从物联网设备到可穿戴装置，计算机已经渗透到人类社会的每一个角落。

然而，伴随技术进步的是日益增长的复杂性。计算机各个领域的书籍汗牛充栋，新技术层出不穷，更新换代的速度令人目不暇接。面对浩如烟海的知识，“该如何高效地学习计算机知识？“成为摆在每一位学习者面前必须优先思考的重要问题。对于这个问题，每个人都会有自己的回答。而本书给出的回答是：学习计算机底层的原理，以不变应万变。本书将分上、中、下三卷，共七十二篇（美其名曰“七十二变”），以简要、有趣的文字，由浅入深地讲解计算机的核心原理，并辅以Rust语言的实战代码，帮助读者在理解原理的同时掌握实践技能。

内容概要

全书分为三卷，每卷聚焦计算机科学的不同维度，层层递进，环环相扣：

上卷 数据与编码

上卷主要介绍常见的几种重要数据是如何通过编码构建计算机的数字化世界的。从最基本的数字、字符、字节出发，逐步扩展到时间、图片、条码、二维码、音频、视频等复杂数据类型，最终探讨序列化、网络协议和压缩算法等高级主题。上卷共十三章：

• 第一 数字：探索整数、浮点数在计算机中的表示方式，理解精度、溢出等核心概念。
• 第二 字符与编码：从ASCII到Unicode，从UTF-8到UTF-16，梳理字符编码的发展脉络。
• 第三 字节：字节是计算机存储的基本单位，深入理解字节序、字节操作及其应用。
• 第四 时间：时间的表示与存储，时间戳、时区、闰秒等问题的处理。
• 第五 图片：位图与矢量图，常见图像格式的编码原理与Rust中的图像处理。
• 第六 条码：一维条码的编码规则与识别原理。
• 第七 二维码：QR Code的编码机制、纠错能力与实际应用。
• 第八 音频：声音的数字化过程，采样、量化、编码与常见音频格式。
• 第九 视频：视频编码原理，帧、关键帧、压缩与主流视频标准。
• 第十 万物皆可编码：将编码思想推广到更广泛的领域，理解“一切皆可表示为数据“的哲学。
• 第十一 序列化与反序列化：数据持久化与跨系统传输的核心技术。
• 第十二 网络协议：HTTP、TCP/IP等协议的数据封装与解析。
• 第十三 压缩算法：无损与有损压缩，经典算法的原理与Rust实现。

中卷 运算与算法

中卷主要介绍各种数据是如何通过运算与转换，解决现实世界的各种问题的。从基础的算术、关系、逻辑、位运算出发，逐步深入到排序、搜索、哈希等经典算法，再扩展到人工智能、代数、几何、微积分、概率论、神经网络、自然语言处理、计算机视觉、强化学习和生成式AI等前沿领域。中卷共二十七章：

• 第十四 算术运算：加减乘除背后的计算机实现，溢出处理与高精度计算。
• 第十五 关系运算：比较操作的底层原理与优化。
• 第十六 逻辑运算：与、或、非、异或，布尔代数与数字电路的桥梁。
• 第十七 位运算：移位、掩码、标志位，高效编程的利器。
• 第十八 交换/反转/旋转：数据重排的基本操作及其应用。
• 第十九 类型转换：安全与危险的类型转换，Rust的类型系统优势。
• 第二十 哈希：哈希函数、哈希表、一致性哈希与分布式系统。
• 第二十一 打包/拆包 压缩/解压：数据结构的紧凑表示与空间优化。
• 第二十二 查询/检索/搜索：线性搜索、二分搜索、字符串匹配与信息检索。
• 第二十三 排序算法：从冒泡到快排，从比较排序到非比较排序的全景梳理。
• 第二十四 Lambda演算：函数式编程的数学基础，从丘奇到现代编程语言。
• 第二十五 人工智能：AI发展简史，从符号主义到连接主义。
• 第二十六 算法：算法复杂度分析，经典问题与解题范式。
• 第二十七 代数：群、环、域，抽象代数在计算机中的应用。
• 第二十八 几何：计算几何基础，图形学中的数学工具。
• 第二十九 行列式：矩阵的行列式及其在几何与代数中的意义。
• 第三十 矩阵：矩阵运算、线性变换与Rust中的矩阵库。
• 第三十一 向量：向量空间、点积、叉积与机器学习中的向量表示。
• 第三十二 函数：函数的数学定义、高阶函数与闭包。
• 第三十三 微积分：极限、导数、积分，连续世界的离散化计算。
• 第三十四 概率论：随机变量、分布、期望，不确定性世界的建模工具。
• 第三十五 离散数学：图论、组合数学、数理逻辑，计算机科学的数学语言。
• 第三十六 神经网络：从感知机到深度学习，神经网络的原理与Rust实现。
• 第三十七 自然语言处理：文本处理、词向量、Transformer与语言模型。
• 第三十八 计算机视觉：图像识别、目标检测、卷积神经网络。
• 第三十九 强化学习：智能体与环境的交互，奖励机制与策略优化。
• 第四十 生成式AI：GAN、VAE、扩散模型，创造新内容的AI技术。

下卷 秘密与密码

下卷主要介绍如何通过密码技术实现数据的安全存储、传输等一系列问题。从最基本的口令和随机数出发，逐步深入到对称密码、非对称密码、哈希函数等核心密码学 primitives，再扩展到身份认证、授权访问、PKI、TLS、区块链、零知识证明、同态加密、量子密码等高级主题，最后以“无敌密码“和“终极密码“作为全书的哲学升华。下卷共三十二章：

• 第四十一 口令：密码的存储、强度评估与破解防护。
• 第四十二 随机数：真随机与伪随机，密码学安全随机数生成器。
• 第四十三 密钥管理：密钥的生成、分发、存储与生命周期管理。
• 第四十四 对称密码：AES、ChaCha20等对称加密算法的原理与Rust实现。
• 第四十五 非对称密码：RSA、ECC等公钥密码体系的数学基础与应用。
• 第四十六 不可逆密码：哈希函数、HMAC、数字签名与完整性验证。
• 第四十七 身份认证：我是谁？如何证明？认证协议与多因素认证。
• 第四十八 授权访问：权限模型、访问控制列表与OAuth等授权框架。
• 第四十九 PKI：公钥基础设施，证书、CA与信任链。
• 第五十 TLS：传输层安全协议，HTTPS背后的密码学握手。
• 第五十一 区块链：分布式账本、共识机制与加密货币的密码学基础。
• 第五十二 零知识证明：证明者如何在不泄露秘密的情况下证明知晓某事。
• 第五十三 同态加密：在加密数据上直接计算，隐私计算的圣杯。
• 第五十四 量子密码：量子密钥分发与后量子密码学。
• 第五十五至第七十（预留）：为密码学前沿发展预留空间。
• 第七十一 无敌密码：探讨是否存在绝对安全的密码系统。
• 第七十二 终极密码：从密码学上升到信息安全哲学，思考安全的本质。

附录

• 附录一 问题：常见问题解答与疑难解析。
• 附录二 程序员：关于程序员职业发展的思考与建议。
• 附录三 符号表：全书数学符号与术语速查。
• 附录四 百宝箱：常用Rust库、工具与资源汇总。
• 附录五 实战：综合实战项目与案例分析。
• 附录六 游戏：以游戏化的方式巩固所学知识。

全书章节总览

全书共七十八章（含附录），覆盖数据表示、计算理论、密码安全三大核心领域，形成完整的计算机底层知识体系。

标准、规范、协议是计算机、互联网的基石

如果将0、1比作沙子，那么该如何使用这些沙子高效地构建整个计算机、互联网世界的大厦呢？很显然，沙子太小而大厦则相对大得多，直接使用沙子来建设大厦简直是天方夜谭。唯一可行的做法就是：先使用沙子制作砖块、混凝土、玻璃等最基本的材料（实际上需要的材料还有很多，比如钢铁、木材），然后根据施工标准，采用恰当的构建方法，按照一定的步骤一步步构建起最终的大厦。

计算机、互联网世界也是如此。就软件而言，0、1二进制首先构成了各种编程语言的类型系统中的各种类型数据：整数、浮点数、字符串、数组、队列、堆、栈、文件等等。这些类型的各种方法实现了类型的各种计算、转换等逻辑，而我们常说的软件、代码则是使用编程语言（当然编程语言本身也是代码）表达的一定业务逻辑的符号系统。可以看出，在构建整个大厦的过程中，沙子、砖块、混凝土等等都是最基础的材料，然后更为重要的是加工、制造这些材料的方法，以及经过大量实践证明、被大多数人遵循和采用的经验总结，进而上升为各种标准、规范、协议。

从TCP/IP协议栈到HTTP协议，从JPEG图像标准到MP3音频编码，从Unicode字符集到TLS安全协议——这些标准、规范、协议构成了现代数字世界的“交通规则“，让来自不同厂商、不同国家、不同年代的设备和软件能够无缝协作。理解这些标准，就是理解计算机世界的运行法则。

制定标准、规范、协议是实力与话语权的象征

“无规矩不成方圆”，社会生活中，为了规范每个人、各种社会组织、团体的行为，保持社会稳定，我们制定了各种规章制度、法律法规、民俗公约。计算机、互联网世界则是各种标准、规范、协议。从ASCII (American Standard Code for Information Interchange，美国信息交换标准代码)开始，在不到一百年的时间里，计算机世界里出台了成百上千的标准、规范、协议，而且还处在不断新增、完善的过程中。这些极大地促进了计算机的应用和发展。

美国最早发明了计算机、互联网，同时也是众多标准、规范、协议的制定者，体现了其强大的科技创新实力与话语权。“海到无边天作岸，山登绝顶我为峰”，每个希望变得强大且愿意为全人类做贡献的国家、组织，都应该在各个行业、各个领域努力做到最好，推动制定相关领域的标准、规范、协议，共同推动全人类的发展与进步。

在密码学领域，这一趋势尤为明显。从DES到AES，从SHA-1到SHA-3，国际密码学标准的演进反映了全球科研实力的此消彼长。今天，随着中国、欧洲等国家和地区在量子计算、后量子密码等前沿领域的投入，密码学标准制定的格局正在发生深刻变化。掌握标准制定权，就是掌握技术发展的方向。

为什么学习、使用Rust？

对公司而言，使用Rust更省钱、更省心、更省事

性能卓越，更省钱

云计算时代，CPU、内存、网络（流量、带宽）就如城市中的水和电一样，都可以轻易获得，但大规模使用的成本不容忽视。看看各大云服务商的数据中心，仅仅耗电一项就是巨大开支。Rust凭借优异的性能，能够大幅减少CPU运行的时间，同时消耗较少的内存，这就意味着消耗更少的电力——对于老板而言，这意味着做同样的事情花费更少的成本。当前全球经济形势不容乐观，开源节流、降本增效成为大多数公司的一致选择。另一方面，消费降级成为主流，质优价廉的商品更受市场青睐。如何在降低成本的同时提供优质产品和服务，成为企业必须认真思考的问题。

Energy Efficiency across Programming Languages: How Do Energy, Time, and Memory Relate?这篇论文详细比较了各种编程语言的能耗、运行时间、内存消耗。

《Sustainability with Rust》

【Rust生态观察】Rust实现的事件处理引擎tremor-runtime已经在美国最大家具电商公司Wayfair生产环境跑了三年

内存安全，更省心

在数据安全以及隐私越来越受重视的今天，安全漏洞造成的损失和影响都将是巨大的。Java开源库接连爆出重大漏洞，影响极大。Rust通过所有权（Ownership）、借用（Borrowing）和生命周期（Lifetime）机制，在编译期就消除了空指针、数据竞争、缓冲区溢出等内存安全问题，让“Heartbleed“级别的漏洞在Rust代码中几乎不可能发生。

系统健壮，更省事

系统稳定运行意味着后期维护时，再也不用担心服务随时可能宕机了。Rust的健壮性为系统稳定运行奠定了坚实的基础。Rust的“零成本抽象“理念让开发者既能享受高级语言的表达能力，又能获得接近C/C++的运行效率，同时避免了C/C++中常见的未定义行为。

对个人而言，学习Rust是一个十分明智的选择

Rust渐成主流

Java内卷太严重，我要学习Rust。在国内，Java绝对是大部分企业的主力开发语言。Java程序员需求量大，相关的职位也最多。随着高薪的吸引，大量科班、非科班的就业人群涌入IT、互联网行业，Java行业的内卷（竞争）程度也越来越激烈。Golang、Rust等新兴编程语言经过多年的快速发展，在国内也逐渐成为主流。

Rust已经连续多年被Stack Overflow开发者调查评为“最受喜爱的编程语言“。从Linux内核到Windows驱动，从Firefox到Cloudflare，从Discord到Dropbox，Rust正在渗透到底层系统的每一个角落。掌握Rust，就是掌握未来十年系统编程的通行证。

重剑无锋，大巧不工

Rust就好比一柄“锈迹斑斑“的玄铁重剑。Rust拥有令人望而却步的学习曲线，初学者刚开始学习使用时非常吃力。所有权系统、生命周期标注、 trait 系统——这些概念对于习惯了垃圾回收语言的开发者来说确实需要一段时间适应。值得庆幸的是，在人工智能的辅助下，将大大加快学习的速度。开发者一旦掌握了就可以轻松应对各种复杂的编程任务，就能充分利用Rust在效率、稳定性、安全性方面的优势，可以保障系统的稳定运行和数据的安全性。

AI助力，迎刃而解

AI工具的普遍使用，使得学习Rust更加高效、便捷。现代AI编程助手可以帮助开发者快速理解复杂的编译错误信息、生成符合Rust idioms 的代码、解释所有权和生命周期的微妙之处。在AI的辅助下，Rust的学习曲线变得平缓了许多，而掌握Rust后获得的系统级编程能力将成为开发者职业生涯中的核心竞争力。

本书特色

本书力求在以下三个方面做到有机结合：

原理为先：每一章都从底层原理出发，讲解“为什么“而非仅仅是“怎么做“。理解原理才能举一反三，面对新技术时才能快速上手。

代码为体：所有核心概念都配以Rust代码实现。代码不仅是理论的验证，更是实践的起点。读者可以直接运行、修改、扩展这些代码，在动手实践中深化理解。

实战为要：每卷末尾和附录中设有实战项目，将分散的知识点串联成完整的解决方案。从编码一个二维码生成器到实现一个简单的加密通信系统，实战项目让知识真正转化为能力。

阅读建议

适合人群

• 有一定编程基础的开发者：了解至少一门编程语言，希望深入理解计算机底层原理。
• 系统编程爱好者：对操作系统、网络、密码学等领域感兴趣，希望用Rust进行系统级开发。
• 计算机专业学生：作为课堂学习的补充，通过实战代码加深对理论知识的理解。
• 技术管理者：了解技术趋势，评估Rust在团队中的适用场景。

阅读顺序

顺序阅读：对于希望系统学习的读者，建议从上卷开始顺序阅读。三卷之间存在逻辑递进关系——先理解数据如何表示，再学习如何运算处理，最后掌握如何安全保护。

按需查阅：对于有经验的开发者，可以根据兴趣直接跳读到特定章节。每章尽量保持相对独立，交叉引用会标明相关章节的编号。

结合实践：强烈建议读者在阅读时打开Rust开发环境，亲手运行和修改书中的代码示例。本书的代码示例均使用最新稳定版Rust编写，可在Rust Playground或本地环境中直接运行。

预备知识

阅读本书前，建议读者具备以下基础：

• 基本的编程概念（变量、函数、条件、循环）
• 对二进制、十六进制有初步了解
• 高中水平的数学知识（代数、几何基础）

不具备Rust基础的读者也不用担心——本书会在必要时解释Rust特有的语法和概念，但建议同时参考Rust官方文档进行系统学习。

致谢

本书的完成离不开开源社区的支持。感谢Rust核心团队和所有贡献者打造了这样一门卓越的编程语言；感谢crates.io上无数开源库的维护者，他们的工作让Rust生态日益繁荣；感谢Stack Overflow、Rust用户论坛等社区中的热心回答者，他们的经验分享解决了本书写作过程中的诸多技术难题。

感谢所有为计算机科学奠定基础的前辈们——从图灵、香农到里斯特、汤普森，从迪杰斯特拉到科克，正是他们的智慧结晶构成了我们今天所站立的巨人肩膀。

参考资源

• The Rust Programming Language - Rust官方教程
• Rust by Example - 通过示例学习Rust
• Rustlings - Rust小练习
• Crypto101 - 密码学入门
• 3Blue1Brown - 数学可视化
• Computerphile - 计算机科学视频

愿每一位读者都能通过本书，在Rust的世界里习得七十二般变化，在计算机科学的道路上越走越远。

上卷 数据与编码

数据

数据（data）是事实或观察的结果，是对客观事物的逻辑归纳，是用于表示客观事物的未经加工的原始素材。

信息

信息，指音讯、消息、通讯系统传输和处理的对象，泛指人类社会传播的一切内容。人通过获得、识别自然界和社会的不同信息来区别不同事物，得以认识和改造世界。在一切通讯和控制系统中，信息是一种普遍联系的形式。1948年，数学家香农在题为“通讯的数学理论“的论文中指出：“信息是用来消除随机不定性的东西”。创建一切宇宙万物的最基本单位是信息。

信息（百度百科）

数据经过编码等手段加工后得到信息。

上卷概述：为什么从数据与编码开始

在计算机科学的宏大叙事中，数据与编码是最基础、最不可或缺的篇章。正如学习一门自然语言需要从字母和词汇开始，理解计算机世界也需要从数据及其表示方式起步。上卷选择“数据与编码“作为全书的开篇，基于以下考量：

第一，数据是计算的原材料。无论是简单的算术运算还是复杂的人工智能模型，无论是本地文件存储还是分布式网络通信，一切计算活动的起点都是数据。不理解数据的本质，就无法理解计算的本质。

第二，编码是数字世界的通用语言。计算机只能处理0和1，而人类世界充满了丰富多样的信息——文字、图像、声音、视频。编码就是连接这两个世界的桥梁，它将人类可理解的信息转换为计算机可处理的数据，反之亦然。

第三，编码思想贯穿全书。上卷介绍的编码原理不仅适用于数据表示，更是中卷算法设计和下卷密码技术的理论基础。哈希编码、纠错编码、压缩编码——这些思想在后续章节中将反复出现。

数据在计算机中的表示：二进制是一切的基础

1948年，香农发表了《通信的数学理论》，奠定了信息论的基础。在这篇开创性的论文中，香农指出：任何信息都可以被表示为二进制数字序列。这一论断看似简单，却深刻揭示了数字世界的本质。

计算机内部使用二进制（base-2）表示所有数据，原因有三：

1. 物理实现的简便性：电子元件天然具有两种稳定状态（高电平/低电平、有磁/无磁、有光/无光），用0和1表示最为可靠。

2. 运算规则的简洁性：二进制算术运算规则远比十进制简单。例如，二进制加法只需记住四条规则（0+0=0, 0+1=1, 1+0=1, 1+1=10），而十进制加法需要记住45条规则。

3. 逻辑表达的天然契合：布尔代数中的真（True）和假（False）与二进制的1和0完美对应，使得算术运算和逻辑运算可以在同一套硬件上实现。

在Rust中，我们可以直观地看到各种数据类型的二进制表示：

fn main() {
    let n: u8 = 65;
    println!("十进制: {}, 二进制: {:08b}, 十六进制: {:02X}", n, n, n);
    // 输出: 十进制: 65, 二进制: 01000001, 十六进制: 41

    let c: char = 'A';
    println!("字符: {}, Unicode码点: {:04X}", c, c as u32);
    // 输出: 字符: A, Unicode码点: 0041
}

从这段代码可以看出，字符'A'和整数65在底层共享相同的二进制表示01000001。这正是编码的魔力——相同的比特序列，根据不同的解释规则，可以呈现完全不同的含义。

编码的本质：建立映射关系

编码的本质是建立映射关系。具体来说，编码是在两个集合之间建立一一对应（或近似对应）的规则：

• 字符编码：建立“字符“集合与“二进制数“集合之间的映射。ASCII编码将128个字符映射到0-127的二进制数；Unicode则将全球所有书写系统的字符映射到统一的码点空间。

• 图像编码：建立“像素颜色“集合与“二进制数“集合之间的映射。RGB编码将每种颜色表示为三个字节（红、绿、蓝各一个字节）。

• 音频编码：建立“声波振幅“集合与“二进制数“集合之间的映射。PCM编码以固定的时间间隔采样声波的振幅，将连续的模拟信号离散化为数字序列。

• 视频编码：建立“图像序列“集合与“二进制数“集合之间的映射。由于视频数据量巨大，编码通常包含压缩步骤，利用帧间冗余减少存储空间。

理解编码的映射本质，有助于我们把握各种编码方案的共性与差异。好的编码方案应当满足以下特性：

不同的应用场景对这些特性的侧重不同。例如，文本存储优先保证唯一性和可逆性；网络传输强调紧凑性和鲁棒性；实时音视频则更注重编码和解码的高效性。

信息论简介：香农与信息熵

克劳德·香农（Claude Shannon）被誉为“信息论之父“。1948年，他在贝尔实验室发表了《通信的数学理论》，首次用数学方法定量描述了信息的本质。香农提出的核心概念——信息熵（Entropy），成为衡量信息量的基本单位。

信息熵的直观含义是：一个事件所包含的“惊讶程度“。发生概率越小的事件，一旦发生，带来的信息量越大。例如，“太阳从东方升起“是大概率事件，信息量几乎为零；而“太阳从西方升起“是极小概率事件，一旦发生将带来极大的信息量。

信息熵的数学定义为：

$$H(X) = -\sum_{i=1}^{n} p(x_i) \log_2 p(x_i)$$

其中，$p(x_i)$ 是第 $i$ 个事件发生的概率。信息熵的单位是比特（bit）。

信息熵与编码密切相关。香农证明了：编码一个信息源所需的最小平均比特数，等于该信息源的熵。这就是著名的香农第一定理（无噪声编码定理）。

例如，如果一个信息源只产生两种符号：A（概率90%）和B（概率10%），那么它的熵为：

$$H = -(0.9 \times \log_2 0.9 + 0.1 \times \log_2 0.1) \approx 0.469 \text{ bit}$$

这意味着，理论上我们只需要约0.469比特/符号就能编码这个信息源，远小于直接使用1比特/符号的固定长度编码。这种利用概率分布进行优化编码的思想，正是霍夫曼编码（将在第十三章详细介绍）的理论基础。

信息论的思想不仅适用于数据压缩，还深刻影响了密码学（下卷）、机器学习（中卷）等领域。第二十一章“打包/拆包 压缩/解压“将更深入地探讨信息论在数据压缩中的应用。

上卷各章节内容预览

上卷共十三章，从基础数据类型到复杂编码系统，逐步构建完整的“数据与编码“知识体系：

第一至第四章：数据的原子

这四章关注最基本的数据类型，它们是构建一切复杂数据的“原子“：

• 第一 数字：计算机如何表示整数和浮点数？为什么0.1 + 0.2 != 0.3？本章从二进制表示出发，讲解原码、反码、补码、IEEE 754浮点标准，以及Rust中的数值类型系统。

• 第二 字符与编码：从摩斯电码到ASCII，从GB2312到Unicode，从UTF-8到UTF-16。字符编码的发展史是一部人类追求“天下同文“的技术史诗。本章将梳理这段历史，并展示Rust对Unicode的原生支持。

• 第三 字节：字节（Byte）是计算机存储的基本单位。本章讲解字节序（大端/小端）、位操作、字节缓冲区，以及Rust中Vec<u8>、Bytes等类型的使用。

• 第四 时间：时间是人类最古老的概念之一，但在计算机中表示时间却充满挑战。时间戳、时区、闰秒、夏令时、ISO 8601标准——本章将揭示“时间“背后的复杂性，并介绍Rust的chrono库。

第五至第九章：多媒体数据

这五章将编码思想应用于图像、音频、视频等多媒体数据：

• 第五 图片：位图与矢量图有何区别？BMP、PNG、JPEG、GIF各自采用什么编码策略？本章从像素出发，讲解图像的数字化表示和常见格式的编码原理。

• 第六 条码：EAN-13、Code 128、Code 39——一维条码是商品流通的“身份证“。本章讲解条码的编码规则、校验算法，以及如何用Rust生成和识别条码。

• 第七 二维码：QR Code是二维条码的代表。本章深入QR Code的编码机制：数据模式、纠错等级、掩码模式、定位图案，并展示Rust中的二维码生成与解析。

• 第八 音频：声音是连续的模拟信号，如何将其数字化？采样定理、量化、编码——从WAV到MP3，从PCM到AAC，本章探索音频编码的技术演进。

• 第九 视频：视频是图像的时间序列，但视频编码远不止“连续播放图片“那么简单。帧类型（I/P/B帧）、运动补偿、变换编码——本章介绍H.264、H.265等主流视频标准的编码原理。

第十至第十三章：编码的升华

这四章将编码思想提升到更高层次：

• 第十 万物皆可编码：从DNA序列到地理位置，从情绪表情到区块链交易——本章展示编码思想的普适性，理解“一切皆可表示为数据“的数字化哲学。

• 第十一 序列化与反序列化：数据需要在内存中高效访问，也需要在磁盘上持久存储、在网络上传输。序列化就是数据结构到字节流的编码，反序列化则是逆向过程。本章介绍JSON、XML、Protobuf、MessagePack等序列化格式，以及Rust中的serde库。

• 第十二 网络协议：网络协议本质上是通信双方约定的编码规则。从物理层的比特编码到应用层的HTTP报文，本章解析协议栈中各层的数据封装与编码方式。

• 第十三 压缩算法：数据压缩是编码的“优化版“——用更少的比特表示相同的信息。本章介绍游程编码、霍夫曼编码、LZ系列算法、算术编码等经典压缩算法，以及Rust中的压缩库。

上卷知识图谱

上卷十三章的知识可以用以下层次结构来概括：

数据与编码
├── 基础数据表示
│   ├── 数字（二进制、整数、浮点数）
│   ├── 字符与编码（ASCII、Unicode、UTF-8）
│   ├── 字节（字节序、位操作）
│   └── 时间（时间戳、时区、格式）
├── 多媒体编码
│   ├── 图片（位图、矢量图、图像格式）
│   ├── 条码（一维条码、编码规则）
│   ├── 二维码（QR Code、纠错编码）
│   ├── 音频（采样、量化、音频编码）
│   └── 视频（帧、压缩、视频标准）
├── 高级编码技术
│   ├── 万物皆可编码（编码的普适性）
│   ├── 序列化与反序列化（数据交换格式）
│   ├── 网络协议（分层编码体系）
│   └── 压缩算法（信息熵、无损/有损压缩）
└── 理论基础
    └── 信息论（香农、信息熵、编码定理）

这个知识图谱展示了上卷内容的内在逻辑：从基础到应用，从简单到复杂，从具体到抽象。每一层都建立在前一层的基础之上，形成完整的知识体系。

阅读建议

学习路径

路径一：顺序阅读。对于初次接触数据编码的读者，建议按章节顺序阅读。前四章是基础，务必扎实掌握；第五至第九章可按兴趣选择顺序；最后四章需要前面的知识铺垫，建议放在后面阅读。

路径二：问题导向。如果你已经有一定的编程经验，可以带着具体问题来阅读：

• “为什么我的浮点数计算结果不准确？” → 第一 数字
• “如何处理中文乱码问题？” → 第二 字符与编码
• “如何设计一个高效的数据交换格式？” → 第十一 序列化与反序列化
• “如何减小我的数据文件大小？” → 第十三 压缩算法

实践建议

1. 动手实验：每章都包含Rust代码示例，建议读者在本地环境或Rust Playground中运行这些代码，观察输出结果，尝试修改参数。

2. 对比学习：将Rust的实现与其他语言（如Python、C、Java）进行对比，体会Rust在类型安全、性能、表达能力方面的特点。

3. 项目驱动：尝试用Rust实现一个小项目，如：二维码生成器、图片格式转换工具、文本压缩程序等。项目驱动是巩固知识的最好方式。

4. 查阅标准：编码的本质是标准。阅读相关RFC文档（如UTF-8的RFC 3629、PNG的RFC 2083）可以加深对编码原理的理解。

与中卷、下卷的衔接

上卷介绍的编码知识是中卷和下卷的基础：

• 中卷的哈希（第二十）、排序（第二十三）、神经网络（第三十六）等章节，都需要理解数据的二进制表示。
• 下卷的对称密码（第四十四）、非对称密码（第四十五）、哈希函数（第四十六）等章节，本质上是特殊的编码——将明文编码为密文，且编码规则依赖于密钥。

因此，扎实掌握上卷内容，将为后续学习打下坚实基础。

数据是信息的载体，编码是数据的灵魂。当我们理解了数据如何被表示、如何被编码，就掌握了打开数字世界大门的钥匙。让我们从上卷开始，踏上“Rust七十二变“的学习之旅。

第一 数字

计算机正如其名，从诞生之日，就是为了进行快速地数值计算，主要用于炮弹的弹道计算。为了搞清楚计算机的工作原理，我们首先要了解数字（尤其是整数）在计算机中是怎么表示的。本章将从最基础的二进制编码出发，逐步深入进制转换、大数运算、浮点数表示、特殊数以及素数与数论等领域，并结合 Rust 代码进行实践。

1.1 编码方式

1.1.1 二进制与编码概述

我们知道计算机中数据都是以 0、1 组成的二进制进行编码、计算、存储、传输的。二进制编码又分为：原码、反码、补码几种编码方式。

• 原码
• 反码
• 补码
• 掩码

所谓原码就是二进制定点表示法，即最高位为符号位，“0“表示正，“1“表示负，其余位表示数值的大小。

1.1.2 原码、反码、补码

原码（Sign-Magnitude）：最高位表示符号，其余位表示数值的绝对值。对于 $n$ 位有符号整数，原码的表示范围为 $[-(2^{n-1}-1), 2^{n-1}-1]$。

$$[x]_{原} = \begin{cases} x & x \geq 0 \ 2^{n-1} + |x| & x < 0 \end{cases}$$

反码（Ones’ Complement）：正数的反码与其原码相同；负数的反码是对正数逐位取反，符号位保持为 1。

$$[x]_{反} = \begin{cases} x & x \geq 0 \ 2^n - 1 + x & x < 0 \end{cases}$$

补码（Two’s Complement）：正数的补码与其原码相同；负数的补码是在其反码的末位加 1。在计算机系统中，数值一律用补码来表示和存储。

$$[x]_{补} = \begin{cases} x & x \geq 0 \ 2^n + x & x < 0 \end{cases}$$

使用补码的好处在于：可以将符号位和数值域统一处理；同时，加法和减法也可以统一处理（减法转化为加负数的补码）。

1.1.3 编码转换规则

原码 => 反码 => 补码

原码 => 补码

(1) 正整数的补码是其二进制表示，与原码相同。

(2) 求负整数的补码，将其原码除符号位外的所有位取反（0 变 1，1 变 0，符号位为 1 不变）后加 1。

补码 => 原码

(1) 如果补码的符号位为“0“，表示是一个正数，其原码就是补码。

(2) 如果补码的符号位为“1“，表示是一个负数，那么求给定的这个补码的补码就是要求的原码。

简而言之：正整数的原码、反码、补码相同；负整数的补码就是在原码的基础上符号位不变，其他位取反（得到反码），然后加 1。

以 -1 为例（假设类型为 i8），-1 的原码为 10000001，反码为 11111110，补码为 11111111。由此可见反码作为原码和补码相互转换的中间码。

1.1.4 编码方式对比表

1.1.5 Rust 整数类型与进制输出

Rust 提供了丰富的整数类型，下面是各类型的取值范围：

#![allow(unused)]
fn main() {
// 十进制
println!("{}", i8::MIN);
println!("{}", i8::MAX);
println!("{}", i16::MIN);
println!("{}", i16::MAX);
println!("{}", i32::MIN);
println!("{}", i32::MAX);
println!("{}", i64::MIN);
println!("{}", i64::MAX);
println!("{}", u8::MIN);
println!("{}", u8::MAX);
println!("{}", u16::MIN);
println!("{}", u16::MAX);
println!("{}", u32::MIN);
println!("{}", u32::MAX);
println!("{}", u64::MIN);
println!("{}", u64::MAX);
}

Rust 支持多种进制的格式化输出：

#![allow(unused)]
fn main() {
// 二进制 10001
println!("0b{:08b}", 17i8);
// 八进制 21
println!("0o{:08o}", 17i8);
// 十六进制 11
println!("0x{:08x}", 17i8);

println!("0b{:08b}", 0i8);
println!("0b{:08b}", 1i8);
println!("0b{:08b}", -1i8);
println!("0b{:08b}", i8::MAX);

println!("0b{:08b}", -2i8);
println!("0b{:08b}", 17u8);
println!("0o{:08o}", 17u8);
println!("0x{:08x}", 17u8);
}

1.2 进制转换

1.2.1 进制转换概述

进制是计数系统的基础。日常生活中我们使用十进制（基数为 10），而计算机使用二进制（基数为 2）。此外，八进制和十六进制也因便于表示二进制而被广泛使用。不同进制之间的转换是程序员的基本功。

进制转换的核心公式：一个 $b$ 进制数 $(d_n d_{n-1} … d_1 d_0)_b$ 转换为十进制：

$$N = d_n \times b^n + d_{n-1} \times b^{n-1} + … + d_1 \times b^1 + d_0 \times b^0 = \sum_{i=0}^{n} d_i \times b^i$$

1.2.2 Excel 表格列名转换（26 进制）

Excel 表格的列名采用了一种特殊的 26 进制表示：A=1, B=2, …, Z=26, AA=27, AB=28, …。这与普通的 26 进制略有不同，因为没有表示 0 的“数字“。

Go 语言实现：

// ColumnNameToNumber provides a function to convert Excel sheet column name
// (case-insensitive) to int. The function returns an error if column name
// incorrect.
//
// Example:
//
//	excelize.ColumnNameToNumber("AK") // returns 37, nil
func ColumnNameToNumber(name string) (int, error) {
	if len(name) == 0 {
		return -1, newInvalidColumnNameError(name)
	}
	col := 0
	multi := 1
	for i := len(name) - 1; i >= 0; i-- {
		r := name[i]
		if r >= 'A' && r <= 'Z' {
			col += int(r-'A'+1) * multi
		} else if r >= 'a' && r <= 'z' {
			col += int(r-'a'+1) * multi
		} else {
			return -1, newInvalidColumnNameError(name)
		}
		multi *= 26
	}
	if col > MaxColumns {
		return -1, ErrColumnNumber
	}
	return col, nil
}

// ColumnNumberToName provides a function to convert the integer to Excel
// sheet column title.
//
// Example:
//
//	excelize.ColumnNumberToName(37) // returns "AK", nil
func ColumnNumberToName(num int) (string, error) {
	if num < MinColumns || num > MaxColumns {
		return "", ErrColumnNumber
	}
	var col string
	for num > 0 {
		col = string(rune((num-1)%26+65)) + col
		num = (num - 1) / 26
	}
	return col, nil
}

Rust 语言实现：

#![allow(unused)]
fn main() {
const MIN_COLUMNS: usize = 1;
const MAX_COLUMNS: usize = 16384;
/// The column number convert to column name
fn column_number_to_name(num: usize) -> std::string::String {
    if num < MIN_COLUMNS || num > MAX_COLUMNS {
        return "".to_string();
    }
    let mut ret = num;
    let mut col = std::string::String::new();
    while ret > 0 {
        let ch = ((ret - 1) % 26 + 65) as u8;
        ret = (ret - 1) / 26;
        col.insert(0, ch as char);
    }

    col
}

///
/// column name convert to column number
fn column_name_to_number(name: std::string::String) -> usize {
    let len = name.len();
    if len == 0 {
        return 0;
    }
    let mut col = 0;
    let bytes = name.as_bytes();
    let mut i = len - 1;
    let mut multi = 1;
    loop {
        let ch = bytes[i];
        if ch >= b'A' && ch <= b'Z' {
            col += multi * (ch - b'A' + 1) as usize;
        } else if ch >= b'a' && ch <= b'z' {
            col += multi * (ch - b'a' + 1) as usize;
        } else {
            return 0;
        }

        if i < 1 {
            break;
        }
        i -= 1;
        multi *= 26;
    }
    if col > MAX_COLUMNS {
        return 0;
    }

    col
}

println!("{}", column_number_to_name(28));
println!("{}", column_name_to_number("AF".to_string()));
}

1.3 实战应用

1.3.1 力扣实战：十进制整数的反码

1009. 十进制整数的反码

原码通过与掩码进行异或（XOR）运算得到“反码“，注意：这里的“反码“和真正的反码定义是不一样的。

pub fn bitwise_complement(n: i32) -> i32 {
    if n == 0 {
        return 1;
    }
    let mut num = n;
    let mut mark = 1;
    let mut high_bit = 0;
    while num > 0 {
        num >>= 1;
        high_bit += 1;
    }

    //dbg!(high_bit);
    let mark = match (high_bit == 31) {
        true => i32::MAX - 1,
        false => (1 << high_bit) - 1,
    };

    n ^ mark
}

fn main() {
    let n = 911;
    let complement = bitwise_complement(n);
    println!("{:032b}", n);
    println!("{:032b}", complement);
}

1.4 大数运算

1.4.1 大整型概述

数值多大才能称得上天文数字呢？天文数字又有何用呢？在现代密码学、科学计算和数论研究中，大数运算是不可或缺的。Rust 的标准整数类型有固定的位数限制，对于超出范围的计算，需要使用专门的大数库。

1.4.2 古戈尔

1 古戈尔 = $10^{100}$（10 的 100 次方）

目前人类发现的最大素数，是 $2^{136279841} - 1$，这个数字有 41,024,320 位。

葛立恒数 葛立恒数诞生于组合数学领域的拉姆齐理论（Ramsey Theory）。这个理论的核心思想是：在足够大的系统中，完全的无序是不可能的，一定会出现某种有规则的子结构

TREE(3) 如果把葛立恒数比作一个原子的大小，那么 TREE(3) 的大小可能相当于一个已知宇宙的规模。在数学上，TREE(3) 的增长速度已经超越了使用葛立恒数定义过程中所使用的递归方法所能达到的极限。更具体地说，TREE(3) 的增长速度远非葛立恒数可比，它已经触及了 “增长速度超越皮亚诺算术” 的领域。

1.4.3 阶乘与末尾零

问题：100 的阶乘（100!）末尾有多少个零呢？

要计算 $n!$（$n$ 的阶乘）末尾有多少个零，其实就是看这个乘积里因子 10 有多少个。而 $10 = 2 \times 5$，在阶乘中因子 2 的数量远多于因子 5，所以末尾零的个数等于因子 5 的个数。

计算方法（勒让德公式）：

$$Z(n!) = \sum_{k=1}^{\infty} \left\lfloor \frac{n}{5^k} \right\rfloor = \left\lfloor \frac{n}{5} \right\rfloor + \left\lfloor \frac{n}{25} \right\rfloor + \left\lfloor \frac{n}{125} \right\rfloor + \cdots$$

以 $n = 100$ 为例：

$$Z(100!) = \left\lfloor \frac{100}{5} \right\rfloor + \left\lfloor \frac{100}{25} \right\rfloor + \left\lfloor \frac{100}{125} \right\rfloor + \cdots = 20 + 4 + 0 + \cdots = 24$$

答案：100! 的末尾有 24 个零。

1.4.4 Rust 大数运算示例

#![allow(unused)]
fn main() {
use num::bigint::{BigInt, ToBigInt};
/// 计算 x 的阶乘，即 x!
fn factorial(x: i32) -> BigInt {
    if let Some(mut facatorial) = 1.to_bigint() {
        for i in 1..(x + 1) {
            facatorial *= i;
        }
        facatorial
    } else {
        panic!("Failed to calculate factorial!");
    }
}
let result = factorial(100);
println!("{}", result);

use num::BigUint;
let x = BigUint::parse_bytes(b"786fe10f87d8ddfeeeea9a4a49e63388e3b2a9e1b0a794907908f6123dbf6c6a", 16).unwrap();
println!("{}", x);
// SM2 密码算法曲线所使用的质数
let p = BigUint::parse_bytes(b"FFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000FFFFFFFFFFFFFFFF", 16).unwrap();
println!("{}", p);
}

1.5 浮点数

1.5.1 IEEE 754 标准

现代计算机普遍采用 IEEE 754 标准存储浮点数，主要由三部分组成：

$$\text{浮点数} = (-1)^{sign} \times (1 + mantissa) \times 2^{(exponent - bias)}$$

• 符号位（Sign Bit）：表示浮点数的正负，1 位。
• 指数位（Exponent）：表示浮点数的指数部分，单精度 8 位，双精度 11 位。
• 尾数位（Mantissa/Significand）：表示浮点数的小数部分，单精度 23 位，双精度 52 位。
• 偏置（Bias）：指数部分的偏移量，用于表示负数指数。单精度 bias = 127，双精度 bias = 1023。

1.5.2 浮点数的精度问题

fn main() {
    // 默认是 f64
    let a: f64 = 0.1;
    let b: f64 = 0.2;

    // 使用 f32 精度更低
    let c: f32 = 0.1;
    let d: f32 = 0.2;

    println!("f64: {}", a + b);  // 0.30000000000000004
    println!("f32: {}", c + d);  // 0.3

    // 比较浮点数（不推荐直接使用 ==）
    let x: f64 = 0.1 + 0.2;
    let y: f64 = 0.3;
    println!("直接比较: {}", x == y);  // false

    // 使用容差比较
    let eps = 1e-10;
    println!("容差比较: {}", (x - y).abs() < eps);  // true
}

浮点数的精度问题原因：

• 原因 1：二进制无法精确表示某些十进制小数（如 0.1）
• 原因 2：运算顺序影响精度
• 原因 3：舍入误差累积

解决精度问题

• 方案一：rust_decimal — 高性能金融计算首选
• 方案二：bigdecimal — 任意精度的“瑞士军刀”

1.6 特殊数

1.6.1 数的分类概述

数可以按照多种方式进行分类：整数（奇数、偶数）、浮点数、复数、质数、合数、完美数等。本节介绍两种有趣的特殊数——勾股数和的士数。

1.6.2 勾股数

勾股数（Pythagorean triple）是指满足勾股定理的三个正整数 $(a, b, c)$ 的一组解：

$$a^2 + b^2 = c^2$$

例子：

$$3^2 + 4^2 = 5^2$$ $$5^2 + 12^2 = 13^2$$ $$6^2 + 8^2 = 10^2$$ $$8^2 + 15^2 = 17^2$$ $$7^2 + 24^2 = 25^2$$

勾股数有无穷多组，可以通过欧几里得公式生成：对于任意正整数 $m > n$，令

$$a = m^2 - n^2, \quad b = 2mn, \quad c = m^2 + n^2$$

则 $(a, b, c)$ 必为一组勾股数。

1.6.3 的士数

的士数（Taxicab Number，记为 $Ta(n)$）：能写成 $n$ 组两个正整数立方和的最小正整数。

$$N = a_1^3 + b_1^3 = a_2^3 + b_2^3 = … = a_n^3 + b_n^3$$

最著名的的士数是 $1729 = 1^3 + 12^3 = 10^3 + 9^3$。这个数因数学家哈代和拉马努金的一段著名对话而得名。

1.7 素数与数论

1.7.1 素数概述

质数（素数）是数论的核心研究对象。素数在密码学（如 RSA 算法）、哈希函数、随机数生成等领域有着广泛应用。

素数的主要类型包括：

• 孪生素数：相差为 2 的一对素数，如 (3, 5), (11, 13), (17, 19)
• 梅森素数：形如 $2^p - 1$ 的素数，其中 $p$ 本身也是素数
• 费马素数：形如 $2^{2^n} + 1$ 的素数

1.7.2 素数的定义与性质

定义：质数（prime number）又称素数，有无限个。质数定义为在大于 1 的自然数中，除了 1 和它本身以外不再有其他因数的数称为质数。

质数的性质：

• 无穷性：质数有无穷多个（欧几里得证明）。
• 分布规律：随着数字增大，质数会变得越来越稀疏。质数定理描述了这种分布：小于 $n$ 的质数个数约为 $\frac{n}{\ln n}$。
• 唯一分解定理（算术基本定理）：任何一个大于 1 的整数，无论它有多大，都可以被唯一地分解成一组质数的乘积。

$$n = p_1^{a_1} \times p_2^{a_2} \times … \times p_k^{a_k}$$

• 素性检验：判断一个大数是否为质数在计算上非常困难，没有简单的通用公式，这也是许多密码系统安全性的基础。

1.7.3 著名猜想与定理

• 费马小定理：对于质数 $p$ 和任意整数 $a$，有 $a^{p-1} \equiv 1 \pmod{p}$。

• 欧拉定理：对于互质的正整数 $a$ 和 $n$，有 $a^{\varphi(n)} \equiv 1 \pmod{n}$，其中 $\varphi(n)$ 是欧拉函数，表示小于 $n$ 且与 $n$ 互质的正整数的个数。

• 哥德巴赫猜想：任何一个大于 2 的偶数，都可以写成两个质数之和。例如，$4 = 2 + 2$，$10 = 3 + 7$。这个猜想至今未被证明，但已被计算机验证到非常大的数。

• 孪生素数猜想：存在无穷多对相差为 2 的质数。目前，数学家张益唐在该问题上取得了里程碑式的突破。

• 黎曼猜想：这是关于质数分布规律的终极猜想，被认为是数学界最重要的未解难题之一。它试图用黎曼 $\zeta$ 函数来精确描述质数的分布：

$$\zeta(s) = \sum_{n=1}^{\infty} \frac{1}{n^s} = \frac{1}{1^s} + \frac{1}{2^s} + \frac{1}{3^s} + \cdots$$

• 克拉茨猜想：对于任意正整数，如果是偶数则除以 2，如果是奇数则乘 3 加 1，重复此过程，最终都会到达 1。

1.8 总结

本章知识点汇总

Rust 整数类型范围

1.9 练习题

1. 基础题：写出 -5（i8 类型）的原码、反码和补码，并用 Rust 代码验证 println!("0b{:08b}", -5i8) 的输出。

2. 进制转换：编写一个 Rust 函数，将十进制整数转换为任意进制（2-36）的字符串表示。

3. Excel 列名：使用 Rust 实现 column_number_to_name 和 column_name_to_number 函数，并编写测试用例验证 1->A, 26->Z, 27->AA, 702->ZZ, 703->AAA 等边界情况。

4. 阶乘末尾零：编写一个 Rust 函数，输入整数 $n$，计算 $n!$ 末尾零的个数。验证 $n = 100$ 时结果为 24，$n = 1000$ 时结果为 249。

5. 浮点数比较：解释为什么 0.1 + 0.2 != 0.3 在计算机中成立，并编写一个 Rust 函数，使用容差法正确比较两个 f64 浮点数是否相等。

6. 勾股数生成：使用欧几里得公式编写 Rust 代码，生成前 10 组本原勾股数（即 $gcd(a, b, c) = 1$ 的勾股数）。

7. 素数判定：编写一个 Rust 函数，使用试除法判断一个正整数是否为素数，并分析其时间复杂度。尝试优化到只需检查到 $\sqrt{n}$。

8. 思考题：在密码学中，为什么需要使用大素数（数百位甚至上千位）？如果素数很小会有什么安全隐患？

第二 字符与编码

二进制能够表示数字，那能不能表示数字之外的各种文字，如英文、中文、俄语、法语等世界各个国家的文字？答案是肯定的，不仅可以表示各种文字，还能表示各种符号、图形（包括表情包）等。其中就使用到一种古老而又充满活力的技术——编码（coding）技术。

计算机中的编码技术，简单而言就是建立数字与字符之间一一对应的关系。比如用数字0到9分别表示其本身，10表示A，11表示B，12表示C，以此类推，就能解决所有字符的编码问题。很显然实际上存在无数种编码的方式。正所谓“无规矩不成方圆“，没有统一的编码规则是不行的。本章将系统介绍计算机中主流的字符编码方案，从经典的ASCII到现代的Unicode，以及Rust中的字符串处理。

2.1 ASCII编码

美国作为计算机的发明地，最先提出了一套编码方案——ASCII（American Standard Code for Information Interchange，美国信息交换标准代码），即ASCII码。

2.1.1 ASCII编码原理

ASCII码使用7位二进制数（共128个码位）来表示字符，其编码空间为：

$$ 0 \leq \text{ASCII码} \leq 127 \quad (0\text{x}00 \sim 0\text{x}7F) $$

ASCII码是计算机历史上最著名的编码方案之一，它最初是美国国家标准，供不同计算机在相互通信时用作共同遵守的西文字符编码标准，后来它被国际标准化组织（International Organization for Standardization, ISO）定为国际标准，称为ISO 646标准。

2.1.2 ASCII控制字符

ASCII码中，0~31和127为控制字符，用于控制设备的操作：

2.1.3 ASCII可打印字符

32~126为可打印字符，包括数字、英文字母、标点符号等：

ASCII码的局限性也是显而易见的，它仅能表示128个字符，对于数以万计的中国汉字就显得十分无力了。

2.2 ANSI编码——各国方言

ANSI编码并非一个具体的编码标准，而是对不同国家和地区各自制定的多字节字符编码标准的统称。不同的国家和地区制定了不同的标准，由此产生了 GB2312、GBK、GB18030、Big5、Shift_JIS 等各自的编码标准。这些使用多个字节来代表一个字符的各种汉字延伸编码方式，统称为 ANSI 编码。

2.2.1 各国主要编码标准

2.2.2 ANSI编码的局限

ANSI编码的核心问题是：相同的字节序列在不同编码下可能表示不同的字符。例如，在简体中文Windows系统中，字节0xD6 0xD0表示“中“字（GB2312编码）；而在日语系统中，相同的字节序列可能表示完全不同的字符。这种“方言“式的编码体系是产生乱码的根本原因。

2.3 Unicode编码——计算机世界中的“书同文“

秦始皇统一六国后，为了便于管理庞大的帝国，保证政令通畅，于是推行统一的文字和度量衡——“书同文，车同轨“不仅是秦始皇一项重要的历史贡献，也深刻影响和促成中国之后两千多年大一统的政治格局的形成。如今世界那么大，各国的文字、符号的数量是相当惊人的，并且随着社会的发展，新的字符不断涌现。字符的编码也需要与时俱进。Unicode（统一码，也叫万国码、单一码）应运而生，彻底解决全世界所有国家的文字、符号的编码问题。

2.3.1 Unicode编码空间

Unicode编码系统可分为编码方式和实现方式两个层次。Unicode是国际组织制定的可以容纳世界上所有文字和符号的字符编码方案。Unicode用数字0~0x10FFFF来映射这些字符，最多可以容纳1114112个字符，或者说有1114112个码位。码位（Code Point）就是可以分配给字符的数字，通常表示为 U+XXXX 的形式。

Unicode编码空间划分为若干平面（Plane）：

2.3.2 UTF-8编码原理

UTF-8（Unicode Transformation Format - 8-bit）是一种变长编码方案，使用1~4个字节表示一个Unicode字符：

UTF-8的编码规则可以用以下方式理解：

$$ \text{UTF-8字节数} = \begin{cases} 1 & \text{if } 0 \leq U \leq 0\text{x}7F \ 2 & \text{if } 0\text{x}80 \leq U \leq 0\text{x}7FF \ 3 & \text{if } 0\text{x}800 \leq U \leq 0\text{x}FFFF \ 4 & \text{if } 0\text{x}10000 \leq U \leq 0\text{x}10FFFF \end{cases} $$

编码示例：

UTF-8的优势在于：

• 向后兼容ASCII：纯ASCII文本在UTF-8下完全不变
• 无字节序问题：不需要BOM（虽然可以添加）
• 自同步：可以从任意字节位置开始解析

2.3.3 UTF-16编码原理

UTF-16使用2或4个字节表示一个Unicode字符：

• BMP内字符（U+0000 ~ U+FFFF）：直接使用2字节表示
• 辅助平面字符（U+10000 ~ U+10FFFF）：使用4字节（代理对）表示

代理对编码方式：

$$ \text{辅助平面字符编码} = \begin{cases} \text{高位代理} = \frac{U - 0\text{x}10000}{0\text{x}400} + 0\text{x}D800 \ \text{低位代理} = (U - 0\text{x}10000) \bmod 0\text{x}400 + 0\text{x}DC00 \end{cases} $$

其中，高位代理范围：0xD800~0xDBFF，低位代理范围：0xDC00~0xDFFF。

2.3.4 UTF-32编码原理

UTF-32使用固定4个字节表示所有Unicode字符，是最简单的编码方式：

$$ \text{UTF-32编码} = \text{Unicode码位值} $$

虽然UTF-32在字符定位上效率最高（O(1)随机访问），但由于每个字符固定占用4字节，对于以ASCII为主的文本，空间效率较低。

2.3.5 三种UTF编码对比

2.3.6 BOM（字节顺序标记）

BOM（Byte Order Mark）是放在文本文件开头的特殊字符（U+FEFF），用于标识字节序：

访问如下网站查看所有Unicode符号：

• Unicode – The World Standard for Text and Emoji
• emojipedia

2.4 中文编码

中国程序员在职业生涯中，一定会遇到的一个问题就是中文乱码问题。操作系统、数据库、网络传输都有可能出现中文乱码问题，其本质就是使用了不恰当的编码对中文数据进行编码、解码。因此非常有必要了解各种场景下系统正在使用的编码方式。

2.4.1 中文编码标准演进

为了解决汉字的编码问题，中国制定了GB2312、GBK、GB18030等编码标准。

2.4.2 编码转换 iconv

生僻字 GB2312、GBK两种编码基本解决中文常用字符的编码，但中文中还有大量生僻字，需要GB18030才能编码。因此需要视具体情况采用恰当的编码。

# 查看文件编码
file -bi example.txt

# UTF-8转为GBK
iconv -f UTF-8 -t GBK 沁园春·雪.txt > snow.txt

# 忽略无法转换的字符
iconv -c UTF-8 -t GBK 沁园春·雪.txt > snow.txt

# GBK转为UTF-8
iconv -f GBK -t UTF-8 abc.txt > abc_1.txt

# UTF-8转为GB18030
iconv -f UTF-8 -t GB18030 生僻字.txt > gb18030.txt

2.4.3 操作系统的编码

Windows下中文常用支持中文编码有：简体中文(GB2312)、繁体中文(Big5)、UTF-8。

# Windows PowerShell
PS C:\Users\huang> chcp
活动代码页: 936

ISO-8859-1（Latin-1） 是MySQL数据库默认编码，也是网络传输默认编码之一。

2.5 Rust中的字符串处理

Rust中默认使用的是UTF-8编码。这一设计决策与Rust的内存安全和零成本抽象理念高度一致。

2.5.1 Rust中的String、&str与Vec<u8>

Rust中的字符串类型设计体现了所有权和借用的核心概念：

fn main() {
    // String：拥有所有权的UTF-8字符串
    let mut s = String::from("hello");
    s.push_str(" world");
    println!("String: {}", s);

    // &str：字符串切片（借用）
    let slice: &str = &s;
    println!("&str: {}", slice);

    // String 与 &str 的关系
    let owned: String = slice.to_string();  // &str -> String（拷贝）
    let borrowed: &str = &owned;             // String -> &str（借用）

    // `Vec<u8>`：原始字节
    let bytes: Vec<u8> = owned.into_bytes();
    println!("`Vec<u8>`: {:?}", bytes);

    // `Vec<u8>` -> String（需要验证UTF-8）
    let s2 = String::from_utf8(bytes).unwrap();
    println!("String from bytes: {}", s2);
}

2.5.2 Rust中的Unicode操作

fn main() {
    // 从UTF-8字节构造字符串
    let sparkle_heart_vec = vec![240, 159, 146, 150];
    let sparkle_heart = String::from_utf8(sparkle_heart_vec).unwrap();
    assert_eq!("💖", sparkle_heart);

    let bytes = sparkle_heart.into_bytes();
    assert_eq!(bytes, [240, 159, 146, 150]);

    // Unicode转义序列
    println!("\u{65b0}\u{534e}\u{793e}\u{5feb}\u{8baf}\u{ff1a}\u{0033}\u{6708}\u{0032}\u{0036}\u{65e5}\u{ff0c}\u{4e2d}\u{56fd}\u{548c}\u{6d2a}\u{90fd}\u{62c9}\u{65af}\u{5efa}\u{4ea4}\u{3002}");
    println!("\u{5b78}\u{7fd2}\u{5f37}\u{570b} 伟大复兴");

    // 字符转Unicode码位
    println!("{:X} {:X}", '华' as u32, '夏' as u32);

    // Emoji
    println!("Rust常见emoji（表情符号）：\u{1F1E8}\u{1F1F3}🦀💖🚀😂\u{1F980}\u{1F602}");
    println!("常见emoji（国旗）：\u{1F1E8}\u{1F1F3} 🇨🇳 🇺🇸 🇷🇺");

    // ASCII转义
    println!("ASCII常见字符：\u{0020}\u{0040}\u{0021}\u{0041}");

    // 数学符号
    println!("数学符号：∂∆∮\u{2211}\u{2200}\u{2208}\u{2209}\u{222b}");
}

2.5.3 String/&str/Vec<u8>转换关系（与第十九章呼应）

use std::str;

fn main() {
    // &str -> String
    let s: &str = "hello";
    let owned: String = String::from(s);
    let owned2: String = s.to_string();
    assert_eq!(owned, owned2);

    // &str -> &[u8]
    let bytes: &[u8] = s.as_bytes();
    println!("bytes: {:?}", bytes); // [104, 101, 108, 108, 111]

    // String -> &str
    let hello = String::from("hello");
    let slice: &str = &hello;
    let slice2: &str = hello.as_str();
    assert_eq!(slice, slice2);

    // String -> `Vec<u8>`
    let hello = String::from("hello");
    let bytes_vec: Vec<u8> = hello.into_bytes();
    println!("into_bytes: {:?}", bytes_vec);

    // &[u8] -> &str（可能失败）
    let valid: &[u8] = b"hello";
    let s: &str = str::from_utf8(valid).unwrap();
    println!("from_utf8: {}", s);

    let invalid: &[u8] = &[0xff, 0xfe]; // 非UTF-8
    let result = str::from_utf8(invalid);
    println!("invalid utf8: {:?}", result); // Err(Utf8Error)

    // `Vec<u8>` -> String（可能失败）
    let bytes = vec![104, 101, 108, 108, 111]; // "hello"的ASCII
    let s = String::from_utf8(bytes).unwrap();
    println!("from_utf8(Vec): {}", s);
}

2.6 数据库编码

数据库编码是中文乱码问题的另一个重灾区。MySQL数据库的历史遗留问题尤其值得关注。

2.6.1 MySQL字符集设置

-- 查看当前数据库字符集设置
show variables like 'character%';

2.6.2 utf8 vs utf8mb4

MySQL中的utf8实际上是utf8mb3的别名，只使用最多3个字节，无法存储4字节的Unicode字符（如Emoji、部分生僻字）。

-- utf8mb4：支持完整的Unicode，包括Emoji
UPDATE bakeries_db.user SET wx_nickname = 'abc🚀🎵✨' WHERE id = 5;

-- utf8mb3（旧版MySQL默认utf8）
-- Error Code: 1366. Incorrect string value: '\xF0\x9F\x9A\x80\xF0\x9F...' for column 'wx_nickname' at row 1
UPDATE uic.user SET wx_nickname = 'abc🚀🎵✨' WHERE id = 5;

建议：新项目务必使用 utf8mb4，并设置 character_set_server=utf8mb4。

2.7 编码检测与转换

2.7.1 常见编码检测方法

// Rust中使用 encoding_rs 库进行编码检测和转换
use encoding_rs::{GBK, UTF_8};

fn main() {
    // GBK编码的字节
    let gbk_bytes: Vec<u8> = vec![0xD6, 0xD0, 0xCE, 0xC4]; // "中文"的GBK编码

    // GBK -> UTF-8
    let (cow, _, had_errors) = GBK.decode(&gbk_bytes);
    if !had_errors {
        let utf8_string = cow.into_owned();
        println!("转换结果: {}", utf8_string); // 输出: 中文
    }

    // UTF-8 -> GBK
    let utf8_str = "中文";
    let (gbk_result, _, _) = UTF_8.encode(utf8_str);
    println!("GBK字节: {:?}", gbk_result);
}

2.7.2 编码转换注意事项

1. 有损转换：当目标编码无法表示源编码中的某些字符时，转换可能失败或产生替换字符
2. BOM处理：UTF-8文件有时包含BOM，读取时需要注意跳过前3个字节
3. 编码推断：没有绝对可靠的编码自动检测方法，最好明确指定编码

总结

练习题

1. ASCII编码范围：写出字符 ‘A’、‘a’、‘0’ 的ASCII码十进制值，并说明大小写字母ASCII码之间的关系。

2. UTF-8编码计算：手动计算汉字“中“（Unicode码位 U+4E2D）的UTF-8编码字节序列，并与 "中".as_bytes() 的Rust输出进行对比。

3. Rust字符串操作：编写Rust代码，创建一个包含Emoji “🦀”（Unicode U+1F980）的 String，然后将其转换为 Vec<u8>，打印每个字节的十六进制值，并验证其符合UTF-8编码规则。

4. 编码转换陷阱：解释为什么以下Rust代码可能产生非预期结果，并给出修复方案：

   #![allow(unused)]
   fn main() {
   let s = "中文";
   let bytes: Vec<u8> = s.bytes().collect();
   let recovered = String::from_utf8(bytes).unwrap();
   println!("{}", recovered);
   }

5. BOM处理：编写一个Rust函数 read_file_without_bom(path: &str) -> Result<String, std::io::Error>，读取UTF-8文本文件并自动跳过可能存在的BOM头。

6. 编码检测：使用 encoding_rs 库编写程序，读取一个未知编码的文本文件，尝试用GBK和UTF-8分别解码，输出两种解码结果供人工判断。

7. MySQL编码配置：写出创建数据库时指定 utf8mb4 字符集的完整SQL语句，包括数据库、表和连接字符集的设置。

8. String/&str/Vec<u8>关系图：画出Rust中 String、&str、Vec<u8>、&[u8] 之间的转换关系图，标注每个转换方法名称及其可能的失败情况。

第三 字节

字节（Byte）是计算机信息技术用于计量存储容量的基本计量单位，也是计算机编程语言中常用的数据类型。字节是连接硬件存储与软件数据的桥梁——无论是内存中的变量、磁盘上的文件，还是网络中传输的数据包，其底层都是以字节为单位进行组织和处理的。

本章将从字节的计量单位出发，深入探讨字节序、Base64 编码、Hex 编码等核心概念，并结合 Rust 代码展示如何在实际开发中处理字节数据。

3.1 计量单位

3.1.1 位与字节

计算机中所有数据最终都以二进制形式存储和传输。二进制中最小的存储单位是位（bit，Binary Digit），它只能表示 0 或 1 两种状态。8 个二进制位组成一个字节（Byte），字节是计算机处理数据的基本单位。

$$1 \text{ Byte} = 8 \text{ bits}$$

为什么一个字节是 8 位而不是其他数字？这源于历史和技术两方面的因素：

• 历史因素：早期的计算机使用 6 位编码（如 BCD 码）表示字符，但随着 ASCII 标准的普及，需要 7 位来表示 128 个字符。为了容纳扩展 ASCII（256 个字符）并方便处理，8 位成为标准。
• 技术因素：8 是 2 的幂次方（$2^3$），便于计算机硬件设计和寻址。同时，8 位可以表示 $2^8 = 256$ 种状态，足以覆盖绝大多数单字节字符编码需求。

3.1.2 为什么用 1024 而不是 1000

在计算机科学中，存储容量的进位通常采用 1024（$2^{10}$）而非 1000。这是因为计算机基于二进制工作，$2^{10} = 1024$ 是最接近 1000 的 2 的幂次方，便于硬件寻址和计算。

然而，这带来了一个混乱：硬盘厂商通常使用 1000 作为进位（1 GB = $10^9$ 字节），而操作系统使用 1024（1 GiB = $2^{30}$ 字节）。因此，一块标称 500 GB 的硬盘，在操作系统中显示的容量约为 465 GiB。

为了区分这两种计量方式，国际电工委员会（IEC）于 1998 年引入了二进制前缀：

3.1.3 计量单位换算表

我们常见的十进制数字的计量单位有：个、十、百、千、万、亿，比亿还大的单位有：兆、京、垓、秭、穰、沟、涧、正、载、极。 二进制也有自己的计量单位。位（bit，Binary Digits）：存放一位二进制数，即 0 或 1，为最小的存储单位，8 个二进制位为一个字节单位。更大的计量单位有 KB、MB、GB、TB、PB、EB、ZB、YB、BB 等。

3.2 字节序

3.2.1 什么是字节序

当数据需要占用多个字节时（例如一个 32 位整数占 4 个字节），就涉及到一个关键问题：这些字节在内存中应该如何排列？ 这就是**字节序（Endianness）**问题。

假设有一个 16 位整数 0x1234，它由两个字节组成：0x12（高位字节）和 0x34（低位字节）。在内存中存储时，有两种方式：

大端序（Big-Endian）

高位字节存储在低地址，低位字节存储在高地址。类似于人类书写数字的习惯：先写高位。

内存地址:  0x1000   0x1001
          +--------+--------+
          |  0x12  |  0x34  |
          +--------+--------+
           高位字节  低位字节

小端序（Little-Endian）

低位字节存储在低地址，高位字节存储在高地址。

内存地址:  0x1000   0x1001
          +--------+--------+
          |  0x34  |  0x12  |
          +--------+--------+
           低位字节  高位字节

3.2.2 网络字节序

在网络通信中，不同架构的计算机可能使用不同的字节序。为了确保数据能够正确解析，网络协议统一使用大端序作为标准，称为网络字节序（Network Byte Order）。

例如，IP 地址 192.168.1.1 在传输时，会按照大端序将 32 位整数 0xC0A80101 发送出去。TCP/IP 协议栈中的 htonl()（Host to Network Long）和 htons()（Host to Network Short）函数就是用于将主机字节序转换为网络字节序。

3.2.3 Rust 中的字节序处理

Rust 标准库为整数类型提供了便捷的字节序转换方法：

fn main() {
    let num: u32 = 0x12345678;

    // 转换为大端序字节数组
    let be_bytes = num.to_be_bytes();
    println!("大端序: {:02X?}", be_bytes);  // [12, 34, 56, 78]

    // 转换为小端序字节数组
    let le_bytes = num.to_le_bytes();
    println!("小端序: {:02X?}", le_bytes);  // [78, 56, 34, 12]

    // 从字节数组还原
    let restored = u32::from_be_bytes(be_bytes);
    println!("还原: 0x{:08X}", restored);   // 0x12345678
}

3.2.4 检测系统字节序

大多数现代计算机（x86、x86_64、ARM 等）使用小端序，但某些架构（如网络设备、部分嵌入式系统）使用大端序。以下代码可以检测当前系统的字节序：

fn is_little_endian() -> bool {
    let num: u16 = 0x0001;
    let bytes = num.to_ne_bytes();
    bytes[0] == 0x01  // 小端序：低位字节在低地址
}

fn main() {
    if is_little_endian() {
        println!("当前系统使用小端序（Little-Endian）");
    } else {
        println!("当前系统使用大端序（Big-Endian）");
    }
}

3.3 Base64 编码

3.3.1 编码原理

Base64 是一种将二进制数据编码为 ASCII 字符串的方法。它的核心思想是：将每 3 个字节（24 位）的数据拆分为 4 个 6 位的组，每个 6 位组对应一个 Base64 字符。

编码过程如下：

$$\text{3 字节} \rightarrow \text{24 位} \rightarrow \text{4 个 6 位组} \rightarrow \text{4 个 Base64 字符}$$

Base64 字符集包含 64 个字符（$2^6 = 64$）：

• A-Z（26 个）
• a-z（26 个）
• 0-9（10 个）
• + 和 /（2 个）

填充规则：当数据长度不是 3 的倍数时，使用 = 进行填充：

例如，编码字符串 "Man"：

M        a        n
01001101 01100001 01101110
|  6位  ||  6位  ||  6位  ||  6位  |
010011   010110   000101   101110
   T        W        F        u

因此 "Man" 的 Base64 编码为 "TWFu"。

3.3.2 URL 安全变体

标准的 Base64 编码包含 + 和 / 字符，这在 URL 中需要进行转义。因此出现了 URL 安全 Base64（Base64URL），将 + 替换为 -，将 / 替换为 _，并通常省略填充符 =。

3.3.3 Shell 命令示例

任何二进制文件都可以使用 Base64 进行编码，比如 txt 文本、图片。

# 编码文件
openssl enc -base64 -in 生僻字.txt -out 生僻字.base64.txt

# 解码文件
openssl enc -base64 -d -in 生僻字.base64.txt -out 生僻字.demo.txt

# 编码字符串
echo "龙行龘龘（dá dá）前程朤朤（lǎng lǎng）生活䲜䲜（yè yè）健康𣊫𣊫（liù liù）财运𨰻𨰻（bǎo bǎo）🔥" | openssl enc -base64

# 解码字符串
echo "6b6Z6KGM6b6Y6b6Y77yIZMOhIGTDoe+8ieWJjeeoi+acpOacpO+8iGzHjm5nIGzH
jm5n77yJ55Sf5rS75LKc5LKc77yIecOoIHnDqO+8ieWBpeW6t/Cjiqvwo4qr77yI
bGnDuSBsacO577yJ6LSi6L+Q8Kiwu/CosLvvvIhix45vIGLHjm/vvIkK" | openssl enc -base64 -d

3.3.4 Rust 实现

#![allow(unused)]
fn main() {
#[test]
fn base64_demo() {
    let hello = b"hello rustaceans00";
    let encoded = general_purpose::STANDARD.encode(hello);
    let decoded = general_purpose::STANDARD.decode(&encoded).unwrap();

    println!("origin: {}", str::from_utf8(hello).unwrap());
    println!("base64 encoded: {}", encoded);
    println!("back to origin: {}", str::from_utf8(&decoded).unwrap());

    // &[u8;T]/String <= Vec<u8> => Base64 String
    let common_base64_str = general_purpose::STANDARD.encode("中文@123&");
    println!("common base64 string: {}", common_base64_str);
    let common_vecu8 = general_purpose::STANDARD
        .decode(&common_base64_str)
        .unwrap();
    println!("common string: {}", str::from_utf8(&common_vecu8).unwrap());

    println!("道路安全千万条，安全第一条");

    use base64::{
        alphabet,
        engine::{self, general_purpose},
        Engine as _,
    };

    let reform = "商鞅变法、戊戌变法、改革开放";
    let b64 = general_purpose::STANDARD.encode(reform.as_bytes());
    println!("{}", b64);

    const CUSTOM_ENGINE: engine::GeneralPurpose =
        engine::GeneralPurpose::new(&alphabet::URL_SAFE, general_purpose::NO_PAD);

    let b64_url = CUSTOM_ENGINE.encode(b"hello internet~");
    println!("{}", b64_url);

    let url = String::from("忘记过去不但意味着背叛，意味着将来可能还要重来");
    let lesson = general_purpose::URL_SAFE.encode(url.as_bytes());
    println!("{}", lesson);

    // 图片 Base64
    let read_result = fs::read("examples/file/SeaORM_banner.png");
    if let Some(picture_bytes) = read_result.ok() {
        let b64 = general_purpose::STANDARD.encode(&picture_bytes);
        println!(
            "picture_bytes len:{} ,base64 len:{}",
            picture_bytes.len(),
            b64.len()
        );
        // 输出一行字符串
        fs::write("examples/file/SeaORM_banner.base64.txt", b64.as_bytes());

        // 76 个字符添加一个换行符
        // shell: fold -w 76 SeaORM_banner.base64.txt > SeaORM_banner.base64.3.txt
        if let Ok(file) = File::create("examples/file/SeaORM_banner.base64.3.txt") {
            let mut writer = BufWriter::new(file);
            let mut chars = b64.chars();
            for line in &chars.chunks(76usize) {
                // println!("{}",line.collect::<String>());
                // fs::write("examples/file/SeaORM_banner.base64.3.txt",line.collect::<String>());
                let mut bytes = line.collect::<String>();

                bytes.push_str("\n");
                let count = writer.write(bytes.as_bytes());
                //writer.write(b"\n");
            }

            writer.flush();
        }
    }
}
}

3.4 Hex 编码

3.4.1 编码原理

Hex（Hexadecimal，十六进制）编码是将二进制数据转换为十六进制字符串表示的方法。每个字节（8 位）恰好对应两个十六进制字符：

$$\text{1 字节} \rightarrow \text{8 位} \rightarrow \text{2 个十六进制字符}$$

十六进制字符集为 0-9 和 A-F（或 a-f），共 16 个字符。由于 $16 = 2^4$，每个十六进制字符恰好表示 4 位二进制数据。

例如，字节 0x4D（二进制 01001101，即 ASCII 字符 'M'）的 Hex 编码为 "4D"。

Hex 编码的特点：

• 可读性好：比纯二进制更易于人工阅读和调试
• 无歧义：每个字节固定对应 2 个字符，无需填充
• 体积膨胀：编码后数据大小变为原来的 2 倍
• 常用场景：调试输出、哈希值表示、内存转储、颜色代码

3.4.2 Rust 实现

#![allow(unused)]
fn main() {
use data_encoding::{HEXUPPER, DecodeError};

// 编码和解码十六进制
let original = b"The quick brown fox jumps over the lazy dog.";
let expected = "54686520717569636B2062726F776E20666F78206A756D7073206F76\
    657220746865206C617A7920646F672E";

let encoded = HEXUPPER.encode(original);
assert_eq!(encoded, expected);

let decoded = HEXUPPER.decode(&encoded.into_bytes()).unwrap();
assert_eq!(&decoded[..], &original[..]);
println!("{}", str::from_utf8(&decoded).unwrap());

let cn = HEXUPPER.encode("功成不必在我".as_bytes());
println!("{}", cn);
}

3.5 内存映射

3.5.1 什么是内存映射

内存映射（Memory Mapping，MMAP）是一种将文件内容直接映射到进程虚拟地址空间的技术。通过内存映射，程序可以像访问内存一样访问文件内容，避免了传统 I/O 中的多次数据拷贝，实现了**零拷贝（Zero-Copy）**效果。

内存映射的优势：

• 减少数据拷贝：数据直接从磁盘加载到用户空间，无需经过内核缓冲区的额外拷贝
• 延迟加载：只有实际访问的页面才会从磁盘加载，适合处理大文件
• 进程间共享：多个进程可以映射同一个文件，实现高效的进程间通信
• 简化编程：文件操作转化为内存操作，代码更简洁

3.5.2 Rust 中的 MMAP

#![allow(unused)]
fn main() {
#[test]
fn mmap_mut() -> Result<(), Error> {
    use memmap::MmapMut;
    use std::fs::OpenOptions;
    use std::io::Write;
    use std::ops::DerefMut;
    use std::path::PathBuf;

    // let file = File::options().write(true).open("abcd.txt")?;

    let path: PathBuf = PathBuf::from("abcd.txt");
    let file = OpenOptions::new()
        .read(true)
        .write(true)
        .create(true)
        .open(&path)?;
    file.set_len(30)?;

    let mut mmap = unsafe { MmapMut::map_mut(&file)? };

    // mmap.copy_from_slice(b"Hello, world!");
    (&mut mmap[..]).write_all(b"Hello BeiJing! Hello, world!")?;
    mmap.flush()?;

    Ok(())
}
}

• mmap-sync Rust library for concurrent data access, using memory-mapped files, zero-copy deserialization, and wait-free synchronization.

3.6 总结

3.6.1 编码方式对比

3.6.2 关键概念汇总

3.7 练习题

1. 基础题：编写 Rust 程序，将字符串 "Rust" 分别进行 Base64 编码和 Hex 编码，输出编码结果并验证解码后是否还原。

2. 字节序实践：定义一个 u32 变量 0xDEADBEEF，分别输出其大端序和小端序的字节表示，并用 from_be_bytes 和 from_le_bytes 还原验证。

3. 字节序检测：编写一个函数 detect_endianness()，返回当前系统的字节序（大端或小端），并在 main 函数中打印结果。

4. Base64 填充分析：分别对 1 字节、2 字节、3 字节的数据进行 Base64 编码，观察输出结果中 = 填充符的数量，验证填充规则。

5. URL 安全 Base64：使用 base64 crate 的 URL_SAFE 引擎，对一个包含中文的字符串进行编码，验证输出中不含 + 和 / 字符。

6. Hex 编码实现：不使用任何第三方库，手动实现一个函数 fn bytes_to_hex(input: &[u8]) -> String，将字节数组转换为 Hex 字符串。

7. 内存映射读取：使用 memmap crate 编写程序，将一个文本文件映射到内存，读取其内容并输出前 100 个字符。

8. 思考题：为什么网络协议统一使用大端序？如果发送方和接收方使用不同的字节序，会发生什么问题？请结合 TCP/IP 协议栈说明。

第四 时间

时间是什么？不同的人就会有不同的回答。古人根据日月星辰的运行规律，制定了历法。中国的干支纪年，西方的公元纪年。再到近代的格林尼治标准时间（Greenwich Mean Time，GMT），直到现在基于原子钟的世界标准时间（世界协调时 UTC），以及计算机领域著名的UNIX时间。

在计算机系统中，时间是程序运行、数据记录、网络通信的基础。从日志时间戳到定时任务，从缓存过期到分布式一致性，时间的准确性和一致性至关重要。本章将从计算机时间的本质出发，深入剖析时间戳、日期格式化、时区、时间间隔等核心概念，并通过 Rust 代码实现时间的获取、转换和运算。

4.1 计算机时间概述

4.1.1 时间的历史

人类对时间的计量经历了漫长的演变。古代人们使用圭表、日晷、滴漏等工具计时；近代发展出机械钟表；现代则使用原子钟计时，并可以通过无线电波、卫星、互联网等手段进行授时。

• 计算机时间到底是怎么来的？程序员必看的时间知识！

4.1.2 原子钟与 UTC

1967 年，国际计量大会将秒的定义改为：铯-133 原子基态的两个超精细能级之间跃迁所对应的辐射的 9,192,631,770 个周期的持续时间。这一定义基于原子钟，其精度可达每数百万年误差不超过 1 秒。

UTC（Coordinated Universal Time，协调世界时）是目前全球最通用的时间标准。它结合了：

• TAI（International Atomic Time，国际原子时）：基于全球约 400 台原子钟的加权平均，是连续均匀的时间尺度。
• UT1（Universal Time 1）：基于地球自转，与天文观测相关。

UTC 通过在 TAI 基础上插入闰秒来保持与 UT1 的偏差不超过 0.9 秒。

4.1.3 UNIX 时间戳原理

UNIX 时间戳（Unix Timestamp）是计算机系统中最常用的时间表示方式，定义为自 1970-01-01 00:00:00 UTC 起经过的秒数（或毫秒数、微秒数、纳秒数）。

选择 1970 年作为纪元（Epoch）的原因是 UNIX 操作系统诞生于 1969 年，1970-01-01 是 UNIX 的“生日“。

时间戳的核心优势在于：

• 无歧义：不受时区、夏令时、日期格式影响
• 便于计算：两个时间戳的差值即为时间间隔
• 存储高效：一个整数即可表示任意时刻

4.1.4 闰秒问题

由于地球自转速度不均匀（潮汐摩擦等因素导致逐渐变慢），UTC 需要通过插入闰秒来与地球自转保持一致。闰秒的插入规则是：

• 当 UTC 与 UT1 的偏差接近 0.9 秒时，在 6 月 30 日或 12 月 31 日的最后一分钟插入一个额外的第 61 秒
• 闰秒可以正（增加一秒）也可以负（减少一秒），但历史上只出现过正闰秒

闰秒给计算机系统带来了挑战：

• 一分钟可能有 61 秒或 59 秒
• 时间戳在闰秒期间可能出现倒退或重复
• 部分系统采用“闰秒抹平“（Leap Second Smearing）策略，将闰秒分散到多个小时中

时间戳转换工具

4.2 时间戳

4.2.1 时间戳的精度

根据精度不同，时间戳可分为多个级别：

秒级时间戳在 32 位有符号整数中的最大值为 $2^{31} - 1 = 2147483647$，对应 2038-01-19 03:14:07 UTC，这就是著名的 Y2K38 问题（2038 年问题）。使用 64 位整数可以表示到约 2920 亿年后，彻底解决这个问题。

4.2.2 Rust 获取时间戳

use chrono::Utc;

fn main() {
    // 秒级时间戳
    println!("Utc timestamp: {}", Utc::now().timestamp());
    
    // 毫秒级时间戳
    println!("Utc timestamp_millis: {}", Utc::now().timestamp_millis());
    
    // 微秒级时间戳
    println!("Utc timestamp_micros: {}", Utc::now().timestamp_micros());
    
    // 纳秒级时间戳
    println!("Utc timestamp_nanos: {}", Utc::now().timestamp_nanos_opt().unwrap_or(0));
}

4.3 日期格式化

4.3.1 ISO 8601 标准

ISO 8601 是国际标准化组织制定的日期和时间表示标准，旨在消除不同国家和文化之间的日期表示歧义。

基本格式：

$$\text{YYYY-MM-DDTHH:MM:SS±HH:MM}$$

其中：

• YYYY：四位年份
• MM：两位月份（01-12）
• DD：两位日期（01-31）
• T：日期和时间的分隔符
• HH:MM:SS：时:分:秒
• ±HH:MM：与 UTC 的时区偏移

示例：

• 2024-01-15T09:30:00+08:00（北京时间）
• 2024-01-15T01:30:00Z（UTC 时间，Z 表示零时区）

4.3.2 RFC 2822 与 RFC 3339

RFC 2822 是电子邮件中使用的日期格式：

Fri, 28 Nov 2014 12:00:09 +0000

RFC 3339 是互联网协议中广泛使用的日期格式，基于 ISO 8601 但做了一些限制：

2014-11-28T12:00:09+00:00

两者的主要区别：

4.3.3 Rust chrono 格式化字符串

chrono crate 提供了丰富的格式化选项：

4.3.4 日期与字符串相互转换

use chrono::{Utc, NaiveDateTime, TimeZone, NaiveDate};

pub fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 1. DateTime -> &str (格式化输出日期)
    let dt = Utc.with_ymd_and_hms(2014, 11, 28, 12, 0, 9).unwrap();
    assert_eq!(
        dt.format("%Y-%m-%d %H:%M:%S").to_string(),
        "2014-11-28 12:00:09"
    );

    assert_eq!(dt.to_string(), "2014-11-28 12:00:09 UTC");
    assert_eq!(dt.to_rfc2822(), "Fri, 28 Nov 2014 12:00:09 +0000");
    assert_eq!(dt.to_rfc3339(), "2014-11-28T12:00:09+00:00");
    assert_eq!(format!("{:?}", dt), "2014-11-28T12:00:09Z");

    // 2. &str -> DateTime
    let no_timezone = NaiveDateTime::parse_from_str("2015-09-05 23:56:04", "%Y-%m-%d %H:%M:%S");
    println!("{:?}", no_timezone);

    assert_eq!(
        NaiveDateTime::parse_from_str("2014-5-17T12:34:56+09:30", "%Y-%m-%dT%H:%M:%S%z"),
        Ok(NaiveDate::from_ymd_opt(2014, 5, 17).unwrap().and_hms_opt(12, 34, 56).unwrap())
    );
    
    Ok(())
}

4.4 时区

4.4.1 时区概念

地球自转导致不同经度地区看到太阳的位置不同，因此将地球划分为 24 个时区，每个时区跨 15 度经度。时区用 UTC 偏移量表示：

$$\text{本地时间} = \text{UTC} + \text{时区偏移}$$

常见时区：

UTC+5:30   印度新德里时间       （东5.5区时间）
UTC+8      北京时间             （东八区时间）
UTC+9      东京时间             （东九区时间）
UTC-5      东部时间（EST）      （西五区时间）
UTC-8      太平洋标准时区（PST）（西八区时间）

4.4.2 夏令时

夏令时（Daylight Saving Time，DST）是一种为节约能源而人为调整时间的制度。在夏季将时钟拨快一小时，以充分利用日光。

• 并非所有国家/地区都使用夏令时
• 中国自 1991 年起不再实行夏令时
• 美国、欧洲大部分国家仍在使用
• 夏令时的开始和结束日期每年可能不同，给程序处理带来复杂性

4.4.3 Rust 时区处理

use chrono::{Local, DateTime, Utc, FixedOffset, NaiveDate, TimeZone};
use chrono::{Datelike, Timelike};

fn main() {
    // ❌ 旧方法（已弃用）
    // let utc_time = DateTime::<Utc>::from_utc(local_time.naive_utc(), Utc);
    
    // ✅ 新方法：使用 Utc.from_utc_datetime()
    let local_time = Local::now();
    let utc_time = Utc.from_utc_datetime(&local_time.naive_utc());
    
    // 定义时区（注意：FixedOffset::east() 已弃用，使用 east_opt() 或 from_hours()）
    let new_delhi_timezone = FixedOffset::east_opt(5 * 3600 + 1800).unwrap();
    let china_timezone = FixedOffset::east_opt(8 * 3600).unwrap();
    let japan_timezone = FixedOffset::east_opt(9 * 3600).unwrap();
    let rio_timezone = FixedOffset::west_opt(2 * 3600).unwrap();
    let est_timezone = FixedOffset::west_opt(5 * 3600).unwrap();
    let pst_timezone = FixedOffset::west_opt(8 * 3600).unwrap();

    println!("Local time now is {}", local_time);
    println!("UTC time now is {}", utc_time);

    // UTC --> 各时区时间
    println!("Time in Beijing now is {}", utc_time.with_timezone(&china_timezone));
    println!("Time in Tokyo now is {}", utc_time.with_timezone(&japan_timezone));
    println!("Time in Rio de Janeiro now is {}", utc_time.with_timezone(&rio_timezone));
    println!("Time in New Delhi now is {}", utc_time.with_timezone(&new_delhi_timezone));
    println!("Time in EST now is {}", utc_time.with_timezone(&est_timezone));
    println!("Time in PST now is {}", utc_time.with_timezone(&pst_timezone));
    
    // 格式化输出
    let local: DateTime<Local> = Local::now();
    println!("{}", local.format("%Y-%m-%d %H:%M:%S"));
    println!("当前本地时间: {}", local);

    // NaiveDateTime 构建（需要 NaiveDate 类型）
    let local_time_now = Local::now();
    let dt = NaiveDate::from_ymd_opt(
        local_time_now.year(), 
        local_time_now.month(), 
        local_time_now.day()
    )
    .unwrap()
    .and_hms_opt(
        local_time_now.hour(), 
        local_time_now.minute(), 
        local_time_now.second()
    )
    .unwrap();
    
    println!("NaiveDateTime: {}", dt);
}

4.5 时间间隔 Duration

4.5.1 Duration 概念

Duration 表示两个时间点之间的间隔。在 Rust 的 chrono 库中，Duration 可以表示正负的时间长度，支持多种时间单位：

4.5.2 时间运算

use chrono::{Duration, DateTime, Utc, TimeZone, Local};

fn day_earlier(date_time: DateTime<Utc>) -> Option<DateTime<Utc>> {
    date_time.checked_sub_signed(Duration::days(1))
}

fn main() {
    let now = Utc::now();
    
    let almost_three_weeks_from_now = now
        .checked_add_signed(Duration::weeks(2))
        .and_then(|in_2weeks| in_2weeks.checked_add_signed(Duration::weeks(1)))
        .and_then(day_earlier);

    match almost_three_weeks_from_now {
        Some(x) => println!("三周前一天: {}", x),
        None => eprintln!("Almost three weeks from now overflows!"),
    }

    // ✅ 新方法：使用 with_ymd_and_hms()
    let today = Utc::now();
    let now = Local::now();
    let founding_date = Utc.with_ymd_and_hms(1949, 10, 1, 0, 0, 0).unwrap();
    
    let years_passed = now.signed_duration_since(founding_date).num_days() / 365;
    println!("今天{}，建国{}年", now, years_passed);
    
    // 时间运算示例
    let tomorrow = now.checked_add_signed(Duration::days(1)).unwrap();
    let last_week = now.checked_sub_signed(Duration::weeks(1)).unwrap();
    let ten_minutes_later = now.checked_add_signed(Duration::minutes(10)).unwrap();
    
    println!("明天: {}", tomorrow);
    println!("上周: {}", last_week);
    println!("十分钟后: {}", ten_minutes_later);
    
    // 计算两个时间点的间隔
    let start = Utc.with_ymd_and_hms(2024, 1, 1, 0, 0, 0).unwrap();
    let end = Utc.with_ymd_and_hms(2024, 6, 20, 12, 0, 0).unwrap();
    let diff = end.signed_duration_since(start);
    
    println!("从年初到今天的间隔: {} 天", diff.num_days());
    println!("从年初到今天的间隔: {} 小时", diff.num_hours());
    println!("从年初到今天的间隔: {} 秒", diff.num_seconds());
}

更多详细代码

4.6 时间标准

4.6.1 NTP 协议

NTP（Network Time Protocol，网络时间协议）是用于同步计算机系统时钟的协议。它通过分层的时间服务器架构（Stratum 0-15）将时间从原子钟传播到互联网上的各种设备。

• Stratum 0：原子钟、GPS 等高精度时间源
• Stratum 1：直接与 Stratum 0 连接的时间服务器
• Stratum 2：从 Stratum 1 获取时间的服务器
• …

NTP 使用 UDP 端口 123，精度可达毫秒级。SNTP（Simple NTP）是 NTP 的简化版本，适用于对精度要求不高的场景。

4.6.2 日期与时间标准

• 网络时间协议
• ISO 8601 Date and time format
• rfc2822
• rfc3339

4.7 总结

时间相关概念对比

关键公式汇总

4.8 练习题

1. 基础题：使用 chrono 库获取当前时间的秒级、毫秒级和纳秒级时间戳，并输出到控制台。

2. 格式转换：编写一个 Rust 程序，将当前 UTC 时间分别格式化为 ISO 8601、RFC 2822 和 RFC 3339 格式，并输出对比。

3. 时区转换：给定一个 UTC 时间字符串 "2024-06-20T12:00:00Z"，将其转换为北京时间（UTC+8）、东京时间（UTC+9）和纽约时间（UTC-5）的本地时间。

4. 时间运算：计算从 1949 年 10 月 1 日 00:00:00 UTC 到当前时间经过了多少天、多少小时、多少分钟。

5. 闰年判断：编写一个函数判断给定年份是否为闰年。闰年规则：能被 4 整除但不能被 100 整除，或者能被 400 整除。

6. 倒计时程序：编写一个 Rust 程序，计算距离 2038-01-19 03:14:07 UTC（Y2K38 问题发生时刻）还剩多少天、小时、分钟和秒。

7. 时间解析：编写一个函数，解析各种格式的日期字符串（如 "2024-01-15"、"15/01/2024"、"Jan 15, 2024"），统一返回 DateTime<Utc> 类型。

8. 思考题：为什么计算机系统使用时间戳而不是人类可读的日期字符串来存储时间？时间戳有哪些优势和局限性？

第五 图片

随着互联网、社交媒体、电子商务的发展，图片作为一个重要的信息载体，被广泛应用。“一图胜过千言万语”、“有图有真相”、“发个朋友圈”。也催生了美颜、马赛克、PS（Photoshop）等相关技术。

本章将从图片的本质出发，深入剖析像素编码原理、各种图片格式的底层机制，并通过 Rust 代码实现图片的读取、处理、转换等操作。

5.1 图片的本质

5.1.1 像素

图片（Image）本质上是一个二维的像素矩阵。像素（Pixel，Picture Element 的缩写）是构成数字图像的最小单元。每个像素携带颜色信息，所有像素按照行列排列就构成了一幅完整的图像。

一张分辨率为 $W \times H$ 的图片，共有 $W \times H$ 个像素。例如，一张 $1920 \times 1080$ 的 Full HD 图片共有 $2,073,600$ 个像素。

5.1.2 分辨率

分辨率（Resolution）描述了图像中包含的像素数量，通常用“宽 x 高“表示。常见的分辨率标准：

5.1.3 颜色空间

颜色空间（Color Space）定义了如何用数值来表示颜色。不同的颜色空间有不同的应用场景。

RGB 颜色空间

RGB（Red, Green, Blue）是最常用的加色模型，用于显示器、手机屏幕等发光设备。每个通道取值范围为 $[0, 255]$（8位），共可表示 $256^3 = 16,777,216$ 种颜色。

一个像素的 RGB 值可以表示为三元组 $(R, G, B)$，其中：

$$C = R \cdot (1, 0, 0) + G \cdot (0, 1, 0) + B \cdot (0, 0, 1)$$

CMYK 颜色空间

CMYK（Cyan, Magenta, Yellow, Key/Black）是减色模型，用于印刷行业。RGB 和 CMYK 之间的转换关系：

$$K = 1 - \max(R, G, B)$$ $$C = \frac{1 - R - K}{1 - K}$$ $$M = \frac{1 - G - K}{1 - K}$$ $$Y = \frac{1 - B - K}{1 - K}$$

YUV 颜色空间

YUV 将亮度（Y）和色度（U、V）分离，广泛用于视频压缩和传输。人眼对亮度变化更敏感，因此可以对色度分量进行更大的压缩。RGB 到 YUV 的转换（BT.601 标准）：

$$Y = 0.299R + 0.587G + 0.114B$$ $$U = -0.147R - 0.289G + 0.436B$$ $$V = 0.615R - 0.515G - 0.100B$$

HSV 颜色空间

HSV（Hue, Saturation, Value）更符合人类对颜色的直觉感知：

• H（色相）：颜色类型，取值 $[0, 360)$
• S（饱和度）：颜色的纯度，取值 $[0, 1]$
• V（明度）：颜色的明暗，取值 $[0, 1]$

#![allow(unused)]
fn main() {
/// RGB 转 HSV
fn rgb_to_hsv(r: u8, g: u8, b: u8) -> (f64, f64, f64) {
    let r = r as f64 / 255.0;
    let g = g as f64 / 255.0;
    let b = b as f64 / 255.0;

    let max = r.max(g).max(b);
    let min = r.min(g).min(b);
    let delta = max - min;

    // 计算色相 H
    let h = if delta == 0.0 {
        0.0
    } else if max == r {
        60.0 * (((g - b) / delta) % 6.0)
    } else if max == g {
        60.0 * (((b - r) / delta) + 2.0)
    } else {
        60.0 * (((r - g) / delta) + 4.0)
    };

    // 计算饱和度 S
    let s = if max == 0.0 { 0.0 } else { delta / max };

    (h, s, max)
}
}

5.2 像素编码原理

5.2.1 位深

位深（Bit Depth）决定了每个像素可以表示的颜色数量。位深越大，颜色越丰富，但文件也越大。

一张 $1920 \times 1080$ 的图片，在 24 位色深下的原始数据大小为：

$$1920 \times 1080 \times 24 \text{ bits} = 49,766,400 \text{ bits} \approx 5.93 \text{ MB}$$

5.2.2 Alpha 通道

Alpha 通道用于表示像素的透明度，取值范围 $[0, 255]$，其中 0 表示完全透明，255 表示完全不透明。带有 Alpha 通道的图像称为 RGBA 图像。

RGBA 像素在内存中的排列方式通常为：

字节 0: R (红色)
字节 1: G (绿色)
字节 2: B (蓝色)
字节 3: A (透明度)

Alpha 混合公式（将前景色与背景色混合）：

$$C_{out} = \alpha \cdot C_{fg} + (1 - \alpha) \cdot C_{bg}$$

其中 $\alpha$ 为归一化后的透明度值 $[0, 1]$。

5.3 图片格式详解

5.3.1 BMP（Bitmap）

BMP 是 Windows 系统的标准图像格式，采用无压缩方式存储像素数据，文件体积较大但解码简单。

文件结构：

┌─────────────────────┐
│ BMP 文件头 (14字节)   │  ← 文件类型、文件大小、偏移量
├─────────────────────┤
│ DIB 信息头 (40字节)   │  ← 宽度、高度、位深、压缩方式
├─────────────────────┤
│ 调色板 (可选)         │  ← 仅用于低位深图像
├─────────────────────┤
│ 像素数据              │  ← 按行存储，每行4字节对齐
└─────────────────────┘

BMP 的像素数据是从下到上存储的（即图像的最后一行在文件的最前面），且每行数据需要按 4 字节对齐。例如，宽度为 3 的 24 位 BMP 图像，每行需要 $3 \times 3 = 9$ 字节，对齐后为 12 字节（补 3 字节填充）。

5.3.2 JPEG（Joint Photographic Experts Group）

JPEG 是网络上最流行的有损压缩图像格式，在保留较高图像质量的同时拥有很高的压缩比。

压缩流程：

原始图像 → 颜色空间转换(YCbCr) → 分块(8x8) → DCT变换 → 量化 → 熵编码 → JPEG文件

离散余弦变换（DCT）

JPEG 将图像分割为 $8 \times 8$ 的像素块，对每个块进行二维 DCT 变换：

$$F(u,v) = \frac{1}{4}C(u)C(v)\sum_{x=0}^{7}\sum_{y=0}^{7}f(x,y)\cos\frac{(2x+1)u\pi}{16}\cos\frac{(2y+1)v\pi}{16}$$

其中：

$$C(k) = \begin{cases} \frac{1}{\sqrt{2}} & k=0 \ 1 & k>0 \end{cases}$$

DCT 将空间域的像素值转换为频率域的系数，低频系数集中在左上角（代表图像的大致轮廓），高频系数在右下角（代表细节）。

量化

量化是 JPEG 有损压缩的核心步骤。通过量化表将 DCT 系数除以对应的量化步长并取整：

$$F_Q(u,v) = \text{round}\left(\frac{F(u,v)}{Q(u,v)}\right)$$

量化步长越大，压缩比越高，但图像质量损失也越大。JPEG 标准定义了质量参数（1-100），通过缩放默认量化表来控制压缩质量。

熵编码

量化后的系数经过 Zigzag 扫描（将二维系数排列为一维序列，从低频到高频），然后使用 Huffman 编码或算术编码进行压缩。

5.3.3 PNG（Portable Network Graphics）

PNG 是一种无损压缩的位图格式，支持 Alpha 通道，广泛用于网页和图形设计。

压缩算法：LZ77 + Huffman

PNG 使用 DEFLATE 压缩算法，该算法结合了两种技术：

1. LZ77：使用滑动窗口查找重复的字符串模式，用“距离-长度“对替换重复数据
2. Huffman 编码：对出现频率不同的符号使用不同长度的编码，高频符号用短编码

PNG 文件结构：

┌─────────────────────┐
│ PNG 签名 (8字节)      │  固定值: 89 50 4E 47 0D 0A 1A 0A
├─────────────────────┤
│ IHDR 数据块           │  宽度、高度、位深、颜色类型、压缩方法等
├─────────────────────┤
│ 可选数据块             │  PLTE(调色板)、tEXt(文本)、gAMA(伽马)等
├─────────────────────┤
│ IDAT 数据块           │  压缩后的图像数据（可多个）
├─────────────────────┤
│ IEND 数据块           │  文件结束标记
└─────────────────────┘

隔行扫描（Adam7）

PNG 支持 Adam7 隔行扫描，将图像分为 7 个通道（pass），按特定模式逐步加载：

Pass 1: █ . . █ . . █ . .   (每8行每8列)
Pass 2: . █ . . █ . . █ .   (每8行每4列)
Pass 3: █ █ . █ █ . █ █ .   (每4行每4列)
Pass 4: . . █ . . █ . . █   (每4行每2列)
Pass 5: █ . █ █ . █ █ . █   (每2行每2列)
Pass 6: . █ █ . █ █ . █ █   (每2行每1列)
Pass 7: █ █ █ █ █ █ █ █ █   (每1行每1列)

这使得 PNG 在网络传输时可以先显示低分辨率预览，再逐步加载完整图像。

5.3.4 WebP

WebP 是 Google 于 2010 年推出的现代图像格式，旨在替代 JPEG 和 PNG。

特点：

有损 WebP 编码流程：

原始图像 → 预测(帧内预测) → 变换(DCT/WHT) → 量化 → 算术编码 → WebP文件

WebP 有损模式使用 VP8 视频编码的帧内预测技术，支持 4x4 到 16x16 的宏块划分，比 JPEG 的固定 8x8 分块更灵活。

5.3.5 GIF（Graphics Interchange Format）

GIF 由 CompuServe 于 1987 年发布，是互联网早期最流行的图像格式之一。

特点：

• LZW 压缩：使用 Lempel-Ziv-Welch 无损压缩算法
• 256 色限制：每个 GIF 最多包含 256 种颜色（8 位索引色），通过调色板实现
• 支持动画：通过将多帧图像存储在同一个文件中，配合帧延迟时间实现动画效果
• 支持透明：可以指定一种颜色为透明色

GIF 动画原理：

┌─────────────────────┐
│ GIF 文件头            │  GIF87a 或 GIF89a
├─────────────────────┤
│ 逻辑屏幕描述符         │  画布尺寸、全局调色板信息
├─────────────────────┤
│ 全局颜色表 (可选)      │  最多 256 种颜色
├─────────────────────┤
│ 图形控制扩展           │  帧延迟时间、透明色索引
├─────────────────────┤
│ 图像描述符 + 像素数据   │  第 1 帧
├─────────────────────┤
│ 图形控制扩展           │  帧延迟时间
├─────────────────────┤
│ 图像描述符 + 像素数据   │  第 2 帧
├─────────────────────┤
│ ... (更多帧)          │
├─────────────────────┤
│ GIF 结尾标记 (0x3B)    │
└─────────────────────┘

5.3.6 SVG（Scalable Vector Graphics）

SVG 是基于 XML 的矢量图像格式，与位图（BMP、JPEG、PNG 等）有本质区别。

位图 vs 矢量图：

SVG 示例：

<svg xmlns="http://www.w3.org/2000/svg" width="200" height="200">
  <!-- 红色圆形 -->
  <circle cx="100" cy="100" r="80" fill="red" stroke="black" stroke-width="2"/>
  <!-- 蓝色矩形 -->
  <rect x="20" y="20" width="60" height="40" fill="blue" rx="5"/>
  <!-- 文本 -->
  <text x="100" y="190" text-anchor="middle" font-size="16">Rust Logo</text>
</svg>

SVG 支持路径（path）、变换（transform）、渐变（gradient）、滤镜（filter）等丰富的图形功能，可以通过 CSS 和 JavaScript 进行动态控制。

5.4 EXIF 信息

EXIF（Exchangeable Image File Format）是嵌入在 JPEG、TIFF 等图像文件中的元数据标准，最初由日本电子工业发展协会（JEIDA）制定。

EXIF 记录了拍摄时的各种参数：

安全提示：EXIF 中的 GPS 信息可能泄露拍摄地点，在分享照片前应注意清除敏感元数据。

5.5 Rust 图片处理实战

5.5.1 环境准备

在 Cargo.toml 中添加依赖：

[dependencies]
image = "0.25"

image crate 是 Rust 生态中最流行的图像处理库，支持 BMP、JPEG、PNG、GIF、WebP、TIFF、AVIF 等多种格式的编解码。

5.5.2 读取与写入各种格式

use image::{DynamicImage, ImageFormat, io::Reader as ImageReader};
use std::fs::File;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 读取图片（自动识别格式）
    let img = ImageReader::open("input.jpg")?
        .with_guessed_format()?
        .decode()?;

    println!("图片尺寸: {}x{}", img.width(), img.height());
    println!("图片颜色类型: {:?}", img.color());

    // 保存为不同格式
    img.save("output.png")?;                          // 根据扩展名自动选择格式
    img.save_with_format("output.bmp", ImageFormat::Bmp)?;
    img.save_with_format("output.webp", ImageFormat::WebP)?;

    // 手动指定格式写入
    let mut output = File::create("output.jpg")?;
    img.write_to(&mut output, ImageFormat::Jpeg)?;

    Ok(())
}

5.5.3 图片裁剪

#![allow(unused)]
fn main() {
use image::GenericImageView;

fn crop_example() -> Result<(), Box<dyn std::error::Error>> {
    let img = image::open("input.jpg")?;
    let (width, height) = img.dimensions();

    // 裁剪上半部分
    let cropped = img.crop(0, 0, width, height / 2);
    cropped.save("cropped_top.jpg")?;

    // 裁剪中心区域
    let crop_w = width / 2;
    let crop_h = height / 2;
    let cropped_center = img.crop(
        (width - crop_w) / 2,
        (height - crop_h) / 2,
        crop_w,
        crop_h,
    );
    cropped_center.save("cropped_center.jpg")?;

    Ok(())
}
}

5.5.4 图片缩放与缩略图生成

#![allow(unused)]
fn main() {
use image::{imageops::FilterType, GenericImageView};
use std::time::Instant;

fn resize_example() -> Result<(), Box<dyn std::error::Error>> {
    let img = image::open("examples/scaledown/test.jpg")?;

    // 不同的缩放滤波算法对比
    let filters = [
        ("nearest", FilterType::Nearest),     // 最近邻插值（最快，质量最低）
        ("triangle", FilterType::Triangle),     // 三角插值（双线性）
        ("catmullrom", FilterType::CatmullRom),// Catmull-Rom 插值
        ("gaussian", FilterType::Gaussian),     // 高斯插值
        ("lanczos3", FilterType::Lanczos3),    // Lanczos3 插值（质量最高，较慢）
    ];

    for &(name, filter) in &filters {
        let timer = Instant::now();
        let scaled = img.resize(400, 400, filter);
        println!("使用 {} 算法缩放耗时: {:?}", name, timer.elapsed());
        let mut output = File::create(format!("test-{}.png", name))?;
        scaled.write_to(&mut output, ImageFormat::Jpeg)?;
    }

    // 生成缩略图（保持宽高比）
    for &size in &[20_u32, 40, 100, 200, 400] {
        let timer = Instant::now();
        let thumbnail = img.thumbnail(size, size);
        println!("生成 {}x{} 缩略图耗时: {:?}", size, size, timer.elapsed());
        thumbnail.save(format!("test-thumb{}.png", size))?;
    }

    Ok(())
}
}

各滤波算法对比：

5.5.5 像素级操作

灰度化

将彩色图像转换为灰度图像，使用加权平均法（ITU-R BT.601 标准）：

$$Gray = 0.299 \times R + 0.587 \times G + 0.114 \times B$$

#![allow(unused)]
fn main() {
use image::{DynamicImage, Rgba};

fn to_grayscale(img: &DynamicImage) -> DynamicImage {
    let rgba_img = img.to_rgba8();
    let mut output = rgba_img.clone();

    for pixel in output.pixels_mut() {
        let Rgba([r, g, b, a]) = *pixel else { continue };
        let gray = (0.299 * r as f64 + 0.587 * g as f64 + 0.114 * b as f64) as u8;
        *pixel = Rgba([gray, gray, gray, a]);
    }

    DynamicImage::ImageRgba8(output)
}
}

二值化

将灰度图像转换为黑白图像（只有 0 和 255 两个值）：

#![allow(unused)]
fn main() {
use image::{DynamicImage, Rgba, GenericImage};

fn to_binary(img: &DynamicImage, threshold: u8) -> DynamicImage {
    let gray_img = to_grayscale(img);
    let (width, height) = gray_img.dimensions();
    let mut output = image::GrayImage::new(width, height);

    for y in 0..height {
        for x in 0..width {
            let pixel = gray_img.get_pixel(x, y);
            let val = if pixel[0] > threshold { 255 } else { 0 };
            output.put_pixel(x, y, image::Luma([val]));
        }
    }

    DynamicImage::ImageLuma8(output)
}
}

颜色反转（底片效果）

#![allow(unused)]
fn main() {
use image::{DynamicImage, Rgba};

fn invert_colors(img: &DynamicImage) -> DynamicImage {
    let rgba_img = img.to_rgba8();
    let mut output = rgba_img.clone();

    for pixel in output.pixels_mut() {
        let Rgba([r, g, b, a]) = *pixel else { continue };
        *pixel = Rgba([255 - r, 255 - g, 255 - b, a]);
    }

    DynamicImage::ImageRgba8(output)
}
}

亮度与对比度调整

#![allow(unused)]
fn main() {
use image::{DynamicImage, Rgba};

fn adjust_brightness_contrast(
    img: &DynamicImage,
    brightness: i16,  // -255 到 255
    contrast: f32,    // 0.0 到 2.0（1.0 为原始）
) -> DynamicImage {
    let rgba_img = img.to_rgba8();
    let mut output = rgba_img.clone();

    let factor = (259.0 * (contrast + 255.0)) / (255.0 * (259.0 - contrast));

    for pixel in output.pixels_mut() {
        let Rgba([r, g, b, a]) = *pixel else { continue };
        let adjust = |c: u8| -> u8 {
            let val = factor * (c as f32 - 128.0) + 128.0 + brightness as f32;
            val.clamp(0.0, 255.0) as u8
        };
        *pixel = Rgba([adjust(r), adjust(g), adjust(b), a]);
    }

    DynamicImage::ImageRgba8(output)
}
}

5.5.6 格式转换

use image::{io::Reader as ImageReader, ImageFormat};
use std::path::Path;

/// 批量转换图片格式
fn convert_format(input: &Path, output: &Path, format: ImageFormat) -> Result<(), Box<dyn std::error::Error>> {
    let img = ImageReader::open(input)?
        .with_guessed_format()?
        .decode()?;

    let mut file = std::fs::File::create(output)?;
    img.write_to(&mut file, format)?;
    println!("已转换: {} -> {}", input.display(), output.display());
    Ok(())
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // JPEG 转 PNG
    convert_format(
        std::path::Path::new("photo.jpg"),
        std::path::Path::new("photo.png"),
        ImageFormat::Png,
    )?;

    // PNG 转 WebP
    convert_format(
        std::path::Path::new("photo.png"),
        std::path::Path::new("photo.webp"),
        ImageFormat::WebP,
    )?;

    Ok(())
}

5.5.7 图片水印

#![allow(unused)]
fn main() {
use image::{DynamicImage, GenericImage, imageops::overlay};

fn add_watermark(base_img: &DynamicImage, watermark: &DynamicImage, opacity: f32) -> DynamicImage {
    let mut base = base_img.clone();
    let (bw, bh) = base.dimensions();
    let wm = watermark.resize(bw / 4, bh / 4, imageops::FilterType::Lanczos3);
    let (ww, wh) = wm.dimensions();

    // 将水印放在右下角
    let x = bw.saturating_sub(ww + 20);
    let y = bh.saturating_sub(wh + 20);

    overlay(&mut base, &wm, x as i64, y as i64);
    base
}
}

5.6 OCR 光学字符识别

OCR（Optical Character Recognition，光学字符识别）是将图像中的文字转换为可编辑文本的技术。

OCR 的基本流程：

输入图像 → 图像预处理 → 文字区域检测 → 字符分割 → 字符识别 → 后处理 → 输出文本

预处理步骤：

1. 灰度化：减少计算量
2. 二值化：分离文字和背景
3. 去噪：消除干扰
4. 倾斜校正：修正图像角度
5. 归一化：统一文字大小

主流 OCR 引擎：

应用场景：

• 身份证、银行卡、发票识别
• 车牌识别
• 文档数字化
• 手写文字识别
• 街景文字提取

在 Rust 中，可以通过 FFI 调用 Tesseract C 库，或者调用 PaddleOCR 的 HTTP 服务来实现 OCR 功能。

5.7 相关 Rust 库

5.8 总结

图片格式对比

关键公式汇总

5.9 练习题

1. 基础题：使用 image 库读取一张 JPEG 图片，获取其宽度、高度和颜色类型，并输出到控制台。

2. 格式转换：编写一个 Rust 程序，将一个目录下所有 .png 文件批量转换为 .webp 格式。

3. 像素操作：实现一个函数，将图片的红色通道增强 50%（即将每个像素的 R 值乘以 1.5，不超过 255）。

4. 灰度化对比：分别实现平均值法（$Gray = (R+G+B)/3$）和加权平均法（BT.601）的灰度化，对比两种方法的效果差异。

5. 缩略图生成器：编写一个命令行工具，接受一个图片路径和目标尺寸参数，生成指定大小的缩略图，并支持选择不同的缩放滤波算法。

6. EXIF 读取：使用 kamadak-exif 或 rexiv2 crate 读取一张照片的 EXIF 信息，输出拍摄时间、光圈、快门速度和 GPS 坐标。

7. 思考题：为什么 JPEG 不适合存储文字截图？如果需要压缩文字截图，应该选择什么格式？为什么？

第六章 条形码

条形码（Barcode）是一种将数据编码为机器可读图形符号的技术。它通过不同宽度的条（bar）和空（space）的组合来表示信息，广泛应用于零售、物流、图书管理、医疗等领域。本章将深入探讨条形码的编码原理、常见标准，并使用 Rust 实现条形码的生成与校验。

6.1 条形码的定义与历史

6.1.1 什么是条形码

条形码是一种光学机器可读的数据表示形式。它将字符集（通常是数字和字母）转换为一系列具有不同反射率的平行线条或图案。扫描设备通过检测条（暗色，低反射率）和空（亮色，高反射率）的宽度差异来解码信息。

从信息论的角度看，条形码是一种信道编码方案，它将源数据映射到适合光学传输的物理信号。编码过程需要满足以下约束：

• 自同步性：扫描器能够从任意位置开始正确解码
• 检错能力：能够检测常见的读取错误
• 密度与可靠性平衡：在有限空间内存储尽可能多的信息，同时保证扫描成功率

6.1.2 发展历程

条形码的发展可追溯至20世纪中期：

• 1948年：Norman Joseph Woodland 和 Bernard Silver 基于摩尔斯电码发明了最早的条形码概念，使用同心圆图案（牛眼码）
• 1973年：美国统一代码委员会（UCC）采纳了 George Laurer 设计的 UPC（Universal Product Code） 标准，标志着现代条形码时代的开始
• 1977年：欧洲成立了欧洲物品编码协会（EAN），推出了与 UPC 兼容的 EAN 编码体系
• 1994年：日本 Denso Wave 公司发明了 QR Code，将条形码从一维扩展到二维，显著提升了信息容量

如今，条形码已成为全球供应链和零售行业的基础设施，每天被扫描数十亿次。

6.2 常见条形码类型

条形码主要分为一维码（线性条形码）和二维码两大类。它们在信息容量、编码字符集和应用场景上各有侧重。

6.2.1 EAN/UPC 系列

UPC-A 和 EAN-13 是最常见的零售商品条形码。

• UPC-A：12位数字，主要用于美国和加拿大
• EAN-13：13位数字，是国际通用的商品条码标准
• EAN-8：8位数字，用于小型包装

EAN-13 的结构如下：

| 前缀码 (2-3位) | 厂商代码 (4-5位) | 产品代码 (5位) | 校验码 (1位) |

例如，中国的前缀码为 690-699。

6.2.2 Code 128

Code 128 是一种高密度的一维码，可以编码全部 128 个 ASCII 字符。它通过三种不同的字符集（Code A、Code B、Code C）灵活切换，在物流和工业领域广泛应用。

Code 128 的特点：

• 支持数字、字母、标点符号和控制字符
• 编码密度高，相同长度可存储更多字符
• 包含校验码，可靠性好

6.2.3 Code 39

Code 39（又称 Code 3 of 9）是一种较早的条形码标准，每个字符由 9 个元素组成（5 条 + 4 空），其中 3 个是宽元素。

特点：

• 支持 43 个字符：数字 0-9、大写字母 A-Z 和若干符号
• 不需要校验码（但通常添加一位校验字符以增强可靠性）
• 编码密度较低，但实现简单

6.2.4 QR Code

QR Code（Quick Response Code）是一种矩阵式二维码，与一维码有本质区别：

QR Code 通过 Reed-Solomon 纠错码实现了即使部分图案损坏仍可读取的能力。其容量随版本号增加而增大，最高版本（Version 40）可存储约 7,089 个数字或 4,296 个字母数字字符。

6.3 条形码编码原理

6.3.1 条空宽度与二进制的对应

一维条形码本质上是一种**脉冲宽度调制（PWM）**信号。条和空的宽度对应不同的二进制序列。以 EAN-13 为例，每个数字由 7 个模块（module）组成，每个模块宽度相同，条表示二进制的 1，空表示二进制的 0。

每个数字有两种编码模式：

• 左侧奇校验（L-code）：以空开始，以条结束
• 左侧偶校验（G-code）：以空开始，以条结束，但模式与 L-code 不同
• 右侧（R-code）：以条开始，以空结束，是 L-code 的反码

EAN-13 的数字编码表如下：

注意：这里的 1 和 0 分别表示条和空，实际绘制时需要考虑条空交替。

前缀第一位数字决定了左侧 6 位数字使用 L-code 还是 G-code 的组合，这一设计使得扫描器可以自动判断条码方向。

6.3.2 起始符、终止符与中间分隔符

EAN-13 条码还包含以下固定模式：

• 起始符（Guard Bar）：101，位于条码左侧
• 中间分隔符（Center Guard）：01010，位于条码中间
• 终止符（Guard Bar）：101，位于条码右侧

这些守卫条帮助扫描器校准读取位置，确保解码的准确性。

6.3.3 Code 128 的编码结构

Code 128 的每个字符由 11 个模块组成（终止符为 13 个），结构为：

| 起始符 | 数据字符1 | 数据字符2 | ... | 校验字符 | 终止符 |

Code 128 使用三种字符集：

• Code A：ASCII 控制字符和大写字母
• Code B：大写、小写字母和标点
• Code C：仅数字，每两个数字用一个字符编码，密度翻倍

字符集切换通过特殊的切换字符（如 CODE B、CODE C）实现，这类似于数据压缩中的模式切换。

6.4 校验码计算

6.4.1 EAN-13 校验码算法

EAN-13 的最后一位是校验码，用于检测输入或扫描错误。其计算步骤如下：

1. 取前 12 位数字
2. 从右向左，奇数位（第1、3、5…位）数字相加，乘以 3
3. 从右向左，偶数位（第2、4、6…位）数字相加
4. 将两个和相加，取结果的个位数
5. 校验码 = $(10 - \text{个位数}) \bmod 10$

用数学公式表示：

$$ c = \left(10 - \left(\sum_{i=1}^{6} d_{2i-1} \times 3 + \sum_{i=1}^{6} d_{2i}\right) \bmod 10\right) \bmod 10 $$

其中 $d_1, d_2, \ldots, d_{12}$ 为前 12 位数字。

6.4.2 Rust 实现 EAN-13 校验码

fn calculate_ean13_check_digit(digits: &[u8; 12]) -> u8 {
    let mut sum = 0u32;
    for (i, &d) in digits.iter().enumerate() {
        // 从右向左，所以索引 0 对应最右边（奇数位）
        if i % 2 == 0 {
            sum += (d as u32) * 3;
        } else {
            sum += d as u32;
        }
    }
    let remainder = sum % 10;
    ((10 - remainder) % 10) as u8
}

fn validate_ean13(code: &str) -> bool {
    if code.len() != 13 || !code.chars().all(|c| c.is_ascii_digit()) {
        return false;
    }
    let digits: Vec<u8> = code.bytes().map(|b| b - b'0').collect();
    let input_check = digits[12];
    let computed = calculate_ean13_check_digit(
        &digits[..12].try_into().unwrap()
    );
    input_check == computed
}

fn main() {
    let digits = [6, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
    let check = calculate_ean13_check_digit(&digits);
    println!("校验码: {}", check); // 输出: 校验码: 2

    let full_code = "6901234567892";
    println!("{} 校验结果: {}", full_code, validate_ean13(full_code));
}

6.4.3 Code 128 校验码算法

Code 128 的校验码计算采用加权求和模 103 的方式：

1. 起始符有一个数值（Code A = 103, Code B = 104, Code C = 105）
2. 每个数据字符有一个对应的值（0-102）
3. 校验码 = $(\text{起始符值} + \sum_{i=1}^{n} i \times \text{字符}_i\text{的值}) \bmod 103$

#![allow(unused)]
fn main() {
fn calculate_code128_check(start_value: u8, values: &[u8]) -> u8 {
    let mut sum = start_value as u32;
    for (i, &v) in values.iter().enumerate() {
        sum += ((i + 1) as u32) * (v as u32);
    }
    (sum % 103) as u8
}
}

6.5 使用 Rust 生成条形码

6.5.1 使用 barcode-rs 库

barcode crate 是 Rust 生态中成熟的条形码生成库，支持多种一维码格式。

在 Cargo.toml 中添加依赖：

[dependencies]
barcode = "0.1"
image = "0.24"

生成 Code 128 条形码的示例：

use barcode::sym::code128::Code128;
use barcode::generators::image::Image;
use barcode::generators::Generator;

fn main() {
    let data = "RUST-2024";
    let barcode = Code128::new(data).unwrap();
    let generator = Image::png();
    let bytes = generator.generate(&barcode).unwrap();
    std::fs::write("rust2024.png", bytes).unwrap();
    println!("条形码已生成: rust2024.png");
}

6.5.2 手动生成简单 Code 128

为了深入理解编码原理，下面手动实现一个简化的 Code 128 编码器，仅支持 Code B 字符集（ASCII 32-127）。

const CODE128_B_START: u8 = 104;
const CODE128_STOP: u8 = 106;

// Code B 字符值映射：空格(32) -> 0, '!'(33) -> 1, ..., 'Z'(90) -> 58, ...
fn char_to_code128_b(c: char) -> Option<u8> {
    let code = c as u8;
    if (32..=127).contains(&code) {
        Some(code - 32)
    } else {
        None
    }
}

fn code128_checksum(start: u8, values: &[u8]) -> u8 {
    let mut sum = start as u32;
    for (i, &v) in values.iter().enumerate() {
        sum += ((i + 1) as u32) * (v as u32);
    }
    (sum % 103) as u8
}

fn encode_code128_b(text: &str) -> Option<Vec<u8>> {
    let mut values = vec![CODE128_B_START];
    for c in text.chars() {
        values.push(char_to_code128_b(c)?);
    }
    let check = code128_checksum(CODE128_B_START, &values[1..]);
    values.push(check);
    values.push(CODE128_STOP);
    Some(values)
}

fn main() {
    let text = "HELLO";
    match encode_code128_b(text) {
        Some(encoded) => {
            println!("'{}' 的 Code 128 编码值: {:?}", text, encoded);
        }
        None => println!("包含不支持的字符"),
    }
}

6.5.3 将编码值渲染为位图

Code 128 每个字符由 11 个模块组成，条和空的模式由查找表确定。以下是将编码值渲染为简单文本表示的示例：

// Code 128 字符模式表（简化，仅展示部分）
// 每个字符由 11 个模块组成：1 表示条，0 表示空
const CODE128_PATTERNS: [&str; 107] = [
    "11011001100", "11001101100", "11001100110", // 0-2 (空格, !, ")
    // ... 省略中间条目
    "1100011101011", // STOP (106)
];

fn render_code128_bars(values: &[u8]) -> String {
    let mut result = String::new();
    for &v in values {
        let pattern = CODE128_PATTERNS.get(v as usize).unwrap_or(&"");
        result.push_str(pattern);
    }
    result
}

fn bars_to_ascii(bars: &str) -> String {
    bars.chars()
        .map(|c| if c == '1' { '█' } else { ' ' })
        .collect()
}

fn main() {
    let text = "HI";
    if let Some(values) = encode_code128_b(text) {
        let bars = render_code128_bars(&values);
        println!("{}", bars_to_ascii(&bars));
    }
}

实际应用中，应将条空模式渲染为 PNG、SVG 或位图格式，并确保条宽符合打印分辨率要求（通常最小条宽为 0.33mm）。

6.6 条形码的校验与识别

6.6.1 扫描解码流程

条形码扫描器的工作流程如下：

1. 光学采样：激光或 LED 光源照射条码，光电传感器接收反射光
2. 模拟-数字转换：将光强信号转换为电压波形
3. 边缘检测：识别条与空之间的跳变沿
4. 宽度测量：测量每个条和空的宽度（以模块为单位）
5. 字符解码：根据编码表将模块序列映射为字符
6. 校验验证：核对校验码，确认数据完整性

6.6.2 Rust 实现简单的条码校验

在实际系统中，接收到的条码数据应进行格式和校验码验证：

#[derive(Debug)]
enum BarcodeError {
    InvalidLength,
    InvalidCharacter,
    ChecksumMismatch,
}

struct Ean13(String);

impl Ean13 {
    fn new(code: &str) -> Result<Self, BarcodeError> {
        if code.len() != 13 {
            return Err(BarcodeError::InvalidLength);
        }
        if !code.chars().all(|c| c.is_ascii_digit()) {
            return Err(BarcodeError::InvalidCharacter);
        }
        let digits: Vec<u8> = code.bytes().map(|b| b - b'0').collect();
        let mut sum = 0u32;
        for (i, &d) in digits[..12].iter().enumerate() {
            if i % 2 == 0 {
                sum += (d as u32) * 3;
            } else {
                sum += d as u32;
            }
        }
        let check = ((10 - (sum % 10)) % 10) as u8;
        if digits[12] != check {
            return Err(BarcodeError::ChecksumMismatch);
        }
        Ok(Ean13(code.to_string()))
    }

    fn country_prefix(&self) -> &str {
        &self.0[..3]
    }

    fn as_str(&self) -> &str {
        &self.0
    }
}

fn main() {
    match Ean13::new("6901234567892") {
        Ok(ean) => {
            println!("有效的 EAN-13: {}", ean.as_str());
            println!("国家前缀: {}", ean.country_prefix());
        }
        Err(e) => println!("校验失败: {:?}", e),
    }
}

6.6.3 纠错与容错

一维码（如 EAN、Code 128）本身不具备纠错能力，仅能通过校验码检测错误。若校验失败，扫描器通常会要求重新扫描。

相比之下，QR Code 采用 Reed-Solomon 纠错码，可以在以下情况下恢复数据：

Reed-Solomon 码的数学基础是有限域（Galois Field）上的多项式运算。对于 QR Code，数据被分割为若干块，每块附加纠错码，使得即使部分模块损坏或遮挡，仍可通过解线性方程组恢复原始数据。

6.7 总结

本章系统介绍了条形码技术的核心概念与 Rust 实现方法。下表总结了各类条形码的关键特性：

条形码技术虽然看似简单，但其背后蕴含了信号处理、编码理论和纠错算法的深刻原理。从 UPC 到 QR Code，条形码的演进反映了信息存储密度与可靠性之间持续优化的过程。

练习

1. 扩展 Ean13 结构体，添加解析厂商代码和产品代码的方法。
2. 实现完整的 EAN-13 编码器，将 13 位数字转换为条空模块序列，并输出为 SVG 图形。
3. 为 Code 128 实现 Code C 字符集支持，使连续数字对的编码密度提升一倍。
4. 使用 image crate 将条形码模块序列渲染为 PNG 位图，支持配置条宽和高度。
5. 研究 QR Code 的数据掩码（Data Masking）机制，理解其如何避免大面积同色块导致扫描困难。

第七 二维码

二维码源于日本，在中国发扬光大。

二维码相较于条形码，能够存储的信息更多，同时也能快速完成短信息的识别输入。从移动支付到健康码，从商品溯源到电子名片，二维码已经深入到我们生活的方方面面。

7.1 二维码的历史

7.1.1 QR码的诞生

1994年，日本 Denso Wave 公司的工程师原昌宏（Masahiro Hara）发明了 QR Code（Quick Response Code）。当时，丰田汽车旗下的零部件供应商需要一种能够快速扫描并存储大量信息的条码系统来追踪汽车零部件。传统的条形码只能存储少量数字信息，且只能单向扫描，无法满足工业需求。

原昌宏从围棋棋盘的网格结构中获得灵感，设计了这种可以在水平和垂直两个方向同时存储信息的矩阵式二维码。QR Code 的“Quick Response“（快速响应）之名，正是强调了其高速读取的特性。

QR Code 的关键创新：

• 高速读取：通过定位图案实现 360 度任意方向扫描
• 大容量：相比一维条码，信息容量提升数十倍
• 容错能力：即使部分损坏仍可正确读取
• 支持多种数据类型：数字、字母、汉字、二进制数据

7.1.2 在中国的发扬光大

QR Code 在日本发明后，最初主要用于工业领域。然而，真正让二维码“火遍全球“的是中国。

• 2011年：支付宝推出二维码支付，开创了移动支付的先河
• 2014年：微信支付全面接入二维码，“扫码支付“迅速普及
• 2020年：健康码系统使用二维码进行疫情防控，几乎全民使用
• 如今，中国已成为全球二维码应用最广泛的国家，日均扫码量超过百亿次

7.2 QR码原理详解

7.2.1 QR码的结构

一个标准的 QR 码由以下功能区域组成：

┌─────────────────────────────┐
│ ■ ■ ■ ■ ■ ■ ■   ■         │  定位图案（左上）
│ ■       ■         ■         │
│ ■       ■         ■         │  定位图案（右上）
│ ■ ■ ■ ■ ■ ■ ■   ■ ■ ■ ■ ■ ■ ■ ■
│                     ■       │
│ ■ ■ ■ ■ ■ ■ ■     ■       │  定位图案（左下）
│ ■       ■           ■       │
│ ■       ■           ■       │
│ ■ ■ ■ ■ ■ ■ ■   ■         │
│                     ■       │
│   ■   ■   ■   ■   ■   ■   ■  ← 定时图案（水平和垂直）
│                     ■       │
│   [格式信息]  [版本信息]     │
│   [数据和纠错码字]           │
│   [剩余位]                  │
└─────────────────────────────┘

各区域说明：

7.2.2 编码模式

QR 码支持四种编码模式，根据数据内容自动或手动选择最优模式：

数字模式的编码方式：将数字分为 3 位一组，每组转换为 10 位二进制数。例如数字 123456：

$$123 \rightarrow 0001111011_2$$ $$456 \rightarrow 0111001000_2$$

字母数字模式的字符集包含 45 个字符：

0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:

将字符分为 2 个一组，每组转换为 11 位二进制数：

$$\text{value} = c_1 \times 45 + c_2$$

7.2.3 纠错等级

QR 码使用 Reed-Solomon 纠错编码，提供四个纠错等级：

纠错等级越高，可用数据容量越小，但容错能力越强。例如，Version 1 的 QR 码在不同纠错等级下的数据容量：

7.2.4 数据编码流程

QR 码的完整编码流程如下：

┌──────────┐    ┌──────────┐    ┌──────────┐    ┌──────────┐    ┌──────────┐
│ 1.数据分析 │ → │ 2.数据编码 │ → │ 3.纠错编码 │ → │ 4.数据排列 │ → │ 5.掩码处理 │
│          │    │          │    │          │    │          │    │          │
│ 确定编码  │    │ 将数据转换 │    │ 生成Reed- │    │ 将码字放入 │    │ 应用掩码  │
│ 模式和版本│    │ 为位流    │    │ Solomon码 │    │ QR码矩阵  │    │ 优化图案  │
└──────────┘    └──────────┘    └──────────┘    └──────────┘    └──────────┘

步骤详解：

1. 数据分析：确定最优编码模式、版本号和纠错等级
2. 数据编码：添加模式指示符和字符计数指示符，将数据转换为位流，添加终止符和填充位
3. 纠错编码：将数据分为若干块，对每块生成 Reed-Solomon 纠错码字
4. 数据排列：按照蛇形路径将数据码字和纠错码字放入 QR 码矩阵
5. 掩码处理：尝试 8 种掩码图案，选择使评分最优的一种

7.2.5 Reed-Solomon 纠错算法

Reed-Solomon（RS）编码是 QR 码容错能力的核心。它属于分组纠错码，基于有限域（Galois Field, GF）上的多项式运算。

基本原理：

设数据码字为 $d_0, d_1, \ldots, d_{n-1}$，构造数据多项式：

$$D(x) = d_0 + d_1 x + d_2 x^2 + \cdots + d_{n-1} x^{n-1}$$

纠错码字通过对 $D(x)$ 在特定点求值得到：

$$c_i = D(\alpha^i) \mod p(x)$$

其中 $\alpha$ 是有限域 $GF(2^8)$ 的本原元，$p(x)$ 是不可约多项式：

$$p(x) = x^8 + x^4 + x^3 + x^2 + 1$$

解码过程：

当 QR 码部分损坏时，接收端通过求解方程组恢复原始数据。设接收到的码字为 $r_0, r_1, \ldots, r_{n+k-1}$（含 $k$ 个纠错码字），定义错误多项式和伴随式（Syndrome），通过 Berlekamp-Massey 算法或 Euclidean 算法求解错误位置和错误值。

7.2.6 版本与容量

QR 码共有 40 个版本（Version 1 到 Version 40），版本号与模块数的关系为：

$$\text{模块数} = 4 \times \text{版本号} + 17$$

Version 40 的 QR 码最大可存储 7,089 个数字字符或 2,953 个字节（约 2.9 KB）。

7.3 其他二维码标准

除了 QR Code，还有多种二维码标准，各有特色：

7.3.1 Data Matrix

Data Matrix 由 International Data Matrix 于 1994 年开发，广泛应用于工业标记和电子元器件标识。

7.3.2 PDF417

PDF417（Portable Data File 417）由 Symbol Technologies 于 1991 年开发，是一种堆叠式二维码。

7.3.3 Aztec Code

Aztec Code 由 Andrew Longacre 于 1995 年发明，中心有一个定位图案。

7.3.4 二维码标准对比

7.4 QR码安全

7.4.1 恶意二维码

二维码本身不携带恶意代码，但可以被用来引导用户访问恶意网站。常见的攻击方式：

• 钓鱼攻击：将二维码指向伪造的登录页面，窃取用户账号密码
• 恶意软件下载：扫描后自动下载并安装恶意应用
• 中间人攻击：通过二维码劫持通信会话
• 虚假支付：将收款二维码替换为攻击者的收款码

7.4.2 防护建议

1. 扫码前预览：使用支持 URL 预览的扫码工具，查看目标地址后再决定是否访问
2. 使用安全扫码工具：选择带有安全检测功能的扫码应用
3. 注意 URL 来源：确认链接域名是否为官方域名
4. 不要随意扫码：来源不明的二维码不要扫描
5. 开启支付验证：移动支付应设置密码或生物识别验证

7.5 Rust 二维码实战

7.5.1 环境准备

在 Cargo.toml 中添加依赖：

[dependencies]
qrcode = "0.14"
image = "0.25"

7.5.2 生成基本二维码

use qrcode::QrCode;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 生成二维码
    let code = QrCode::new("https://www.rust-lang.org")?;

    // 在终端打印二维码（ASCII 形式）
    println!("{}", code.render::<char>()
        .quiet_zone(false)
        .module_dimensions(2, 1)
        .build());

    // 输出二维码的基本信息
    println!("版本: {}", code.version());
    println!("宽度: {} 模块", code.width());

    Ok(())
}

7.5.3 生成二维码图片

#![allow(unused)]
fn main() {
use image::{GenericImage, ImageBuffer, Rgba};
use qrcode::QrCode;

fn generate_qr_image(data: &str, size: u32) -> ImageBuffer<Rgba<u8>, Vec<u8>> {
    // 1. 编码数据生成二维码
    let code = QrCode::new(data.as_bytes()).unwrap();

    // 2. 设置二维码的模块大小，并添加白色边框
    let border = 4;
    let module_size = (size as f32 / (code.width() as f32 + 2.0 * border as f32)).ceil() as u32;

    // 3. 将二维码渲染为图像
    code.render::<Rgba<u8>>()
        .min_dimensions(size, size) // 设置最小尺寸，确保清晰
        .quiet_zone(true) // 添加静区（白色边框）
        .module_dimensions(module_size, module_size)
        .build()
}
}

7.5.4 自定义颜色的二维码

use image::{ImageBuffer, Rgba, Rgb};
use qrcode::{QrCode, Color};

fn generate_colored_qr(
    data: &str,
    fg_color: [u8; 3],
    bg_color: [u8; 3],
    module_size: u32,
) -> ImageBuffer<Rgba<u8>, Vec<u8>> {
    let code = QrCode::new(data).unwrap();
    let border = 4;
    let width = code.width();
    let img_size = (width + border * 2) as u32 * module_size;

    let mut img = ImageBuffer::from_pixel(
        img_size,
        img_size,
        Rgba([bg_color[0], bg_color[1], bg_color[2], 255]),
    );

    for y in 0..width {
        for x in 0..width {
            let color = if code[(x, y)] == Color::Dark {
                Rgba([fg_color[0], fg_color[1], fg_color[2], 255])
            } else {
                Rgba([bg_color[0], bg_color[1], bg_color[2], 255])
            };

            // 绘制模块
            for dy in 0..module_size {
                for dx in 0..module_size {
                    let px = (x as u32 + border as u32) * module_size + dx;
                    let py = (y as u32 + border as u32) * module_size + dy;
                    img.put_pixel(px, py, color);
                }
            }
        }
    }

    img
}

fn main() {
    // 生成蓝色前景、白色背景的二维码
    let qr = generate_colored_qr(
        "https://www.rust-lang.org",
        [0, 100, 200],   // 蓝色前景
        [255, 255, 255],  // 白色背景
        10,
    );
    qr.save("qr_blue.png").unwrap();

    // 生成红色前景的二维码
    let qr_red = generate_colored_qr(
        "Hello, Rust!",
        [220, 50, 50],   // 红色前景
        [255, 255, 255],  // 白色背景
        10,
    );
    qr_red.save("qr_red.png").unwrap();
}

7.5.5 带Logo的二维码

利用 QR 码的纠错能力，可以在二维码中心放置 Logo 而不影响识别。需要使用较高的纠错等级（H 级，30% 容错）。

use image::{GenericImage, ImageBuffer, Rgba, imageops};
use qrcode::{QrCode, EcLevel};

fn generate_qr_with_logo(
    data: &str,
    logo_path: &str,
    size: u32,
    logo_ratio: f32,  // Logo 占二维码的比例（建议 0.2-0.3）
) -> Result<ImageBuffer<Rgba<u8>, Vec<u8>>, Box<dyn std::error::Error>> {
    // 1. 使用 H 级纠错生成二维码
    let code = QrCode::with_error_correction_level(
        data.as_bytes(),
        EcLevel::H,  // 30% 纠错容量
    )?;

    // 2. 渲染二维码
    let border = 4;
    let module_size = (size as f32 / (code.width() as f32 + 2.0 * border as f32)).ceil() as u32;
    let mut qr_img = code.render::<Rgba<u8>>()
        .min_dimensions(size, size)
        .quiet_zone(true)
        .module_dimensions(module_size, module_size)
        .build();

    // 3. 加载 Logo
    let logo = image::open(logo_path)?.to_rgba8();
    let (qr_w, qr_h) = qr_img.dimensions();

    // 4. 计算 Logo 尺寸和位置（居中）
    let logo_w = (qr_w as f32 * logo_ratio) as u32;
    let logo_h = (qr_h as f32 * logo_ratio) as u32;
    let resized_logo = logo.resize(logo_w, logo_h, imageops::FilterType::Lanczos3);

    // 5. 添加白色背景区域
    let padding = 10;
    let bg_w = logo_w + padding * 2;
    let bg_h = logo_h + padding * 2;
    let mut bg = ImageBuffer::from_pixel(bg_w, bg_h, Rgba([255, 255, 255, 255]));
    bg.copy_from(&resized_logo, padding, padding)?;

    // 6. 将 Logo 放置在二维码中心
    let x = (qr_w - bg_w) / 2;
    let y = (qr_h - bg_h) / 2;
    qr_img.copy_from(&bg, x, y)?;

    Ok(qr_img)
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let qr = generate_qr_with_logo(
        "https://www.rust-lang.org",
        "images/rust-logo-blk.svg",
        600,
        0.25,
    )?;
    qr.save("qr_with_logo.png")?;
    println!("带 Logo 的二维码已生成: qr_with_logo.png");
    Ok(())
}

7.5.6 二维码解码/识别

使用 bardecoder crate 进行二维码解码：

[dependencies]
bardecoder = "0.5"
image = "0.25"

use bardecoder::decode::Decode;
use image::DynamicImage;

fn decode_qr(image_path: &str) -> Result<String, Box<dyn std::error::Error>> {
    let img = image::open(image_path)?;
    let decoder = bardecoder::default_decoder();

    let results = decoder.decode(&img);
    for result in results {
        match result {
            Ok(content) => {
                println!("解码结果: {}", content);
                return Ok(content);
            }
            Err(e) => println!("解码失败: {:?}", e),
        }
    }

    Err("无法解码二维码".into())
}

fn main() {
    match decode_qr("qr_code.png") {
        Ok(content) => println!("二维码内容: {}", content),
        Err(e) => println!("错误: {}", e),
    }
}

7.5.7 批量生成二维码

use image::{GenericImage, ImageBuffer, Rgba};
use qrcode::QrCode;
use std::fs;

/// 批量生成二维码并保存
fn batch_generate_qr_codes(
    data_list: &[(&str, &str)],  // (数据, 输出文件名)
    size: u32,
) -> Result<(), Box<dyn std::error::Error>> {
    for (data, filename) in data_list {
        let code = QrCode::new(data.as_bytes())?;
        let border = 4;
        let module_size = (size as f32 / (code.width() as f32 + 2.0 * border as f32)).ceil() as u32;

        let img = code.render::<Rgba<u8>>()
            .min_dimensions(size, size)
            .quiet_zone(true)
            .module_dimensions(module_size, module_size)
            .build();

        img.save(filename)?;
        println!("已生成: {} -> {}", data, filename);
    }

    Ok(())
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let data_list = &[
        ("https://www.rust-lang.org", "qr_rust.png"),
        ("https://crates.io", "qr_crates.png"),
        ("https://docs.rs", "qr_docs.png"),
        ("https://github.com/rust-lang/rust", "qr_github.png"),
    ];

    // 创建输出目录
    fs::create_dir_all("output_qr")?;

    batch_generate_qr_codes(data_list, 300)?;

    Ok(())
}

7.5.8 合并多个二维码

以下代码将多个二维码横向合并为一张图片：

use image::{GenericImage, ImageBuffer, Rgba};
use qrcode::QrCode;

fn generate_qr_image(data: &str, size: u32) -> ImageBuffer<Rgba<u8>, Vec<u8>> {
    let code = QrCode::new(data.as_bytes()).unwrap();
    let border = 4;
    let module_size = (size as f32 / (code.width() as f32 + 2.0 * border as f32)).ceil() as u32;

    code.render::<Rgba<u8>>()
        .min_dimensions(size, size)
        .quiet_zone(true)
        .module_dimensions(module_size, module_size)
        .build()
}

fn combine_qr_codes_horizontally(
    img1: &ImageBuffer<Rgba<u8>, Vec<u8>>,
    img2: &ImageBuffer<Rgba<u8>, Vec<u8>>,
    gap: u32,
) -> ImageBuffer<Rgba<u8>, Vec<u8>> {
    // 1. 计算新图片的尺寸
    let (w1, h1) = img1.dimensions();
    let (w2, h2) = img2.dimensions();
    let final_width = w1 + gap + w2;
    let final_height = h1.max(h2);

    // 2. 创建新画布，并填充白色背景
    let mut combined =
        ImageBuffer::from_pixel(final_width, final_height, Rgba([255, 255, 255, 255]));

    // 3. 将第一张图复制到左侧 (0, 0) 位置
    combined.copy_from(img1, 0, 0).unwrap();

    // 4. 将第二张图复制到右侧 (w1 + gap, 0) 位置
    combined.copy_from(img2, w1 + gap, 0).unwrap();

    combined
}

fn main() {
    // 1. 生成两个二维码图像，尺寸设为 200x200
    let qr1 = generate_qr_image("https://qr.alipay.com/fkx18203840eqbo648wdo95", 200);
    let qr2 = generate_qr_image("wxp://f2f0QuWokq-0iWOJrBOVHz7vVLoOhrChnMI28COpdSmFzRs", 200);

    // 2. 横向合并，间隔 20 像素
    let combined = combine_qr_codes_horizontally(&qr1, &qr2, 20);

    // 3. 保存最终图片
    combined.save("/tmp/combined_qr_codes.png").unwrap();
}

7.6 二维码的用途

二维码的应用已经渗透到生活的方方面面：

7.7 标准与规范

QR Code 的国际标准为 ISO/IEC 18004，由国际标准化组织（ISO）和国际电工委员会（IEC）联合发布。

• ISO/IEC DIS 18004 - QR Code 国际标准

QR Code 的官方信息：

• QR码 官网
• QR码的成功之路
• qrcode.show - 在线制作二维码

技术原理参考：

• 基础——二维码的生成细节和原理
• 二维码的生成细节和原理

7.8 相关 Rust 库

7.9 总结

QR码核心参数对比

二维码标准对比

关键公式汇总

7.10 练习题

1. 基础题：使用 qrcode crate 生成一个包含你名字的二维码，保存为 PNG 格式。

2. 纠错等级对比：分别使用 L、M、Q、H 四种纠错等级生成相同内容的二维码，对比它们的大小差异，并用图像编辑工具遮挡部分区域后测试是否能正确解码。

3. 带 Logo 二维码：选择一张你喜欢的 Logo 图片，使用 H 级纠错生成带 Logo 的二维码，并验证其可扫描性。

4. 批量生成：编写一个 Rust 程序，读取 CSV 文件中的 URL 列表，为每个 URL 生成一个二维码，文件名为 URL 的哈希值。

5. 编码模式分析：对于字符串 "Hello, World! 123"，分析 QR 码会选择哪种编码模式？为什么？如果字符串是 "1234567890" 呢？

6. 容量计算：Version 10 的 QR 码有多少个模块？在纠错等级 M 下，字节模式最多能存储多少个字节？

7. 思考题：为什么二维码在中国如此普及，而在欧美国家的使用率相对较低？从技术、商业模式、社会习惯等角度分析。

8. 安全实践：编写一个 Rust 程序，生成二维码前先验证 URL 的合法性（检查协议、域名等），拒绝生成指向已知恶意域名的二维码。

第八 音频

声音是人类最古老的信息载体之一。从口头语言到音乐艺术，从电话通信到语音识别，音频技术贯穿了人类文明的发展历程。在数字时代，音频被编码为二进制数据，在计算机中存储、传输和处理。本章将探讨声音的本质、音频数字化原理、常见编码格式，以及如何使用 Rust 进行音频处理。

8.1 声音的本质

8.1.1 声波

声音是一种机械波，由物体振动产生，通过介质（通常是空气）以纵波的形式传播。当声波到达人耳时，引起鼓膜振动，最终被大脑感知为声音。

声波具有三个基本属性：

• 频率（Frequency）：表示声波每秒振动的次数，单位是赫兹（Hz）。频率决定音调的高低。人耳可听范围约为 20 Hz ~ 20,000 Hz。
• 振幅（Amplitude）：表示声波振动的强度，决定声音的响度。振幅越大，声音越响。
• 波形（Waveform）：表示声波的形状，决定声音的音色。不同乐器演奏同一音高时，音色差异源于波形不同。

8.1.2 纯音与复音

纯音是单一频率的正弦波，如音叉发出的声音。复音则由多个不同频率的纯音叠加而成，包含基频和谐波。任何复杂的声音都可以通过傅里叶变换分解为一系列纯音的叠加，这也是音频压缩和合成的基础。

8.2 音频采样与量化

模拟声波是连续的，而计算机只能处理离散的数字信号。将模拟音频转换为数字音频的过程称为模数转换（ADC），包含两个核心步骤：采样和量化。

8.2.1 采样率

采样是在时间轴上对模拟信号进行离散化，每隔固定时间间隔记录一次声波的振幅值。每秒采样的次数称为采样率（Sample Rate）。

根据奈奎斯特-香农采样定理，为了完整还原原始信号，采样率必须至少是信号最高频率的两倍。因此：

• 44.1 kHz：CD 音质标准，可还原最高 22.05 kHz 的频率，覆盖人耳全部可听范围。
• 48 kHz：专业音频和数字视频的标准采样率。
• 96 kHz / 192 kHz：高解析度音频（Hi-Res），用于音乐制作和发烧级播放。

8.2.2 位深度

量化是在振幅轴上对采样值进行离散化，用有限位数的二进制数表示每个采样点的振幅。**位深度（Bit Depth）**决定了每个采样点使用的位数。

位深度越大，量化误差越小，动态范围越广，信噪比越高。

8.2.3 声道与音频数据量

音频可以按声道数分为单声道（Mono）、立体声（Stereo，双声道），以及多声道环绕声（5.1、7.1 等）。

未经压缩的音频数据量计算公式：

数据量（字节/秒）= 采样率 × 位深度 × 声道数 / 8

以 CD 音质（44.1 kHz、16 bit、立体声）为例：

44100 × 16 × 2 / 8 = 176,400 字节/秒 ≈ 172 KB/s
一分钟约 10 MB，一小时约 600 MB

可见未经压缩的音频数据量相当可观，因此音频压缩编码技术至关重要。

8.3 音频编码格式

音频编码格式分为无损压缩、有损压缩和不压缩三大类。

8.3.1 WAV

WAV（Waveform Audio File Format）是微软和 IBM 联合开发的一种音频文件格式。它通常使用 PCM（Pulse Code Modulation，脉冲编码调制）编码，不压缩或仅使用无损压缩，完整保留原始音频数据。

• 优点：音质无损、解码简单、兼容性好、适合音频编辑。
• 缺点：文件体积大。
• 适用场景：专业音频制作、音效素材存储、需要反复编辑的音频文件。

8.3.2 MP3

MP3（MPEG-1 Audio Layer III）是最广为人知的有损压缩音频格式。它利用人耳的听觉掩蔽效应，去除人耳不易察觉的音频信息，实现大幅压缩。

• 压缩比：通常可达 1:10 ~ 1:12（128 kbps 时约为 CD 音质的 1/11）。
• 优点：兼容性好、文件小、普及度极高。
• 缺点：有损压缩，高频细节有所损失。
• 适用场景：音乐播放、网络流媒体、便携设备存储。

8.3.3 AAC

AAC（Advanced Audio Coding）是 MP3 的后继者，在相同码率下通常比 MP3 提供更好的音质。

• 优点：音质优于 MP3、支持多声道、被苹果生态广泛采用。
• 适用场景：Apple Music、YouTube、数字广播、移动设备。

8.3.4 FLAC

FLAC（Free Lossless Audio Codec）是一种开源的无损压缩音频格式，可将音频文件压缩到原大小的 50%~70%，同时完整保留所有音频信息，解码后可 100% 还原为原始 PCM 数据。

• 优点：无损压缩、开源免费、支持元数据标签。
• 缺点：压缩比不如有损格式，文件仍较大。
• 适用场景：音乐收藏、发烧级音频存储、音频归档。

8.4 Rust 音频处理

Rust 生态系统提供了多个优秀的音频处理库，涵盖音频播放、格式解析、WAV 读写等功能。

8.4.1 使用 rodio 播放音频

rodio 是一个纯 Rust 编写的音频播放库，支持 WAV、MP3、Vorbis、FLAC 等格式，使用简单，适合游戏和应用程序中的音频播放需求。

在 Cargo.toml 中添加依赖：

[dependencies]
rodio = "0.17"

播放本地音频文件：

use std::fs::File;
use std::io::BufReader;

fn main() {
    // 1. 获取默认音频输出设备
    let (_stream, stream_handle) = rodio::OutputStream::try_default().unwrap();

    // 2. 打开音频文件
    let file = File::open("music.mp3").unwrap();
    let source = rodio::Decoder::new(BufReader::new(file)).unwrap();

    // 3. 播放音频
    stream_handle.play_raw(source.convert_samples()).unwrap();

    // 4. 等待播放完成（示例中休眠 10 秒）
    std::thread::sleep(std::time::Duration::from_secs(10));
}

rodio 还支持音量控制、播放速度调整、音频混合等高级功能：

use rodio::{Decoder, Source};
use std::fs::File;
use std::io::BufReader;

fn main() {
    let (_stream, stream_handle) = rodio::OutputStream::try_default().unwrap();
    let file = File::open("music.wav").unwrap();
    let source = Decoder::new(BufReader::new(file)).unwrap();

    // 调整音量（0.5 表示一半音量）
    let volume_adjusted = source.amplify(0.5);

    // 调整播放速度（1.5 倍速）
    let speed_adjusted = volume_adjusted.speed(1.5);

    stream_handle.play_raw(speed_adjusted.convert_samples()).unwrap();
    std::thread::sleep(std::time::Duration::from_secs(10));
}

8.4.2 使用 symphonia 解析音频

symphonia 是一个纯 Rust 编写的高性能多媒体格式解析库，支持 MP3、AAC、FLAC、WAV、OGG 等多种格式，设计注重正确性和安全性。

在 Cargo.toml 中添加依赖：

[dependencies]
symphonia = { version = "0.5", features = ["mp3", "flac", "wav"] }

读取音频文件元数据和采样数据：

use symphonia::core::codecs::DecoderOptions;
use symphonia::core::formats::FormatOptions;
use symphonia::core::io::MediaSourceStream;
use symphonia::core::meta::MetadataOptions;
use symphonia::core::probe::Hint;
use std::fs::File;

fn main() {
    // 1. 打开文件
    let file = File::open("music.mp3").unwrap();
    let mss = MediaSourceStream::new(Box::new(file), Default::default());

    // 2. 创建提示和选项
    let hint = Hint::new();
    let format_opts: FormatOptions = Default::default();
    let metadata_opts: MetadataOptions = Default::default();
    let decoder_opts: DecoderOptions = Default::default();

    // 3. 探测格式
    let probed = symphonia::default::get_probe()
        .format(&hint, mss, &format_opts, &metadata_opts)
        .unwrap();

    let mut format = probed.format;

    // 4. 获取音频流信息
    let track = format.default_track().unwrap();
    let codec_params = &track.codec_params;

    println!("采样率: {:?}", codec_params.sample_rate);
    println!("声道数: {:?}", codec_params.channels);

    // 5. 创建解码器并读取采样数据
    let mut decoder = symphonia::default::get_codecs()
        .make(codec_params, &decoder_opts)
        .unwrap();

    while let Ok(packet) = format.next_packet() {
        match decoder.decode(&packet) {
            Ok(decoded) => {
                // 处理解码后的音频采样数据
                let samples = decoded.samples();
                println!("解码得到 {} 个采样点", samples.len());
            }
            Err(_) => break,
        }
    }
}

8.4.3 使用 hound 读写 WAV 文件

hound 是一个轻量级的纯 Rust WAV 文件读写库，无外部依赖，适合需要生成或处理 WAV 音频的场景。

在 Cargo.toml 中添加依赖：

[dependencies]
hound = "3.5"

读取 WAV 文件：

fn main() {
    let reader = hound::WavReader::open("music.wav").unwrap();
    let spec = reader.spec();

    println!("采样率: {}", spec.sample_rate);
    println!("声道数: {}", spec.channels);
    println!("位深度: {}", spec.bits_per_sample);
    println!("样本格式: {:?}", spec.sample_format);

    // 读取所有采样值（假设为 16 位有符号整数）
    let samples: Vec<i16> = reader.into_samples::<i16>()
        .filter_map(|s| s.ok())
        .collect();

    println!("总采样数: {}", samples.len());
}

生成 WAV 文件（生成一个 1 秒的正弦波）：

use std::f32::consts::PI;

fn main() {
    let sample_rate = 44100;
    let frequency = 440.0; // A4 音符
    let duration = 1; // 1 秒
    let amplitude = 0.5;

    let spec = hound::WavSpec {
        channels: 1,
        sample_rate,
        bits_per_sample: 16,
        sample_format: hound::SampleFormat::Int,
    };

    let mut writer = hound::WavWriter::create("sine.wav", spec).unwrap();

    for t in 0..sample_rate * duration {
        let sample = (amplitude * (2.0 * PI * frequency * t as f32 / sample_rate as f32).sin())
            * i16::MAX as f32;
        writer.write_sample(sample as i16).unwrap();
    }

    writer.finalize().unwrap();
    println!("已生成 sine.wav");
}

8.4.4 音频可视化：提取波形数据

结合 hound 库，我们可以提取音频数据用于可视化分析：

#![allow(unused)]
fn main() {
fn analyze_audio(path: &str) {
    let reader = hound::WavReader::open(path).unwrap();
    let spec = reader.spec();

    let samples: Vec<i16> = reader.into_samples::<i16>()
        .filter_map(|s| s.ok())
        .collect();

    // 计算每个声道的采样数
    let samples_per_channel = samples.len() / spec.channels as usize;

    // 计算平均振幅（响度近似值）
    let sum: i64 = samples.iter().map(|&s| s.abs() as i64).sum();
    let avg_amplitude = sum as f64 / samples.len() as f64;

    println!("文件: {}", path);
    println!("总采样数: {}", samples.len());
    println!("每声道采样数: {}", samples_per_channel);
    println!("平均振幅: {:.2}", avg_amplitude);

    // 找出最大振幅
    let max_amplitude = samples.iter().map(|&s| s.abs()).max().unwrap();
    println!("最大振幅: {}", max_amplitude);
}
}

8.5 本章小结

练习建议

1. 使用 hound 库生成不同频率的正弦波，体验频率与音调的关系。
2. 使用 rodio 播放音频文件，并实现一个简单的播放器（支持暂停、继续、音量调节）。
3. 编写程序读取 WAV 文件，计算其 RMS（均方根）响度值。
4. 尝试使用 symphonia 解析 MP3 或 FLAC 文件，提取其元数据（标题、艺术家等）。
5. 对比同一首音乐的不同格式（WAV、FLAC、MP3）的文件大小，理解压缩率的差异。

第九 视频

视频是现代社会最重要的信息媒介之一。从电影电视到短视频直播，从视频会议到监控安防，视频技术深刻改变了人们获取和传播信息的方式。与静态图片不同，视频是随时间连续变化的图像序列，同时伴随音频流。本章将探讨视频的本质、编码原理、主流编码格式，以及如何使用 Rust 进行视频处理。

9.1 视频的本质

视频本质上是一系列静态图像（称为帧）按照一定速率连续播放，利用人眼的视觉暂留效应产生运动的错觉。衡量视频质量的核心参数有三个：帧率、分辨率和码率。

9.1.1 帧率

**帧率（Frame Rate）**表示每秒显示的图像帧数，单位是 FPS（Frames Per Second）。

• 24 FPS：电影标准，画面具有电影感。
• 25 FPS / 30 FPS：传统电视广播标准（PAL / NTSC）。
• 60 FPS：游戏和高清视频常用，运动画面更流畅。
• 120 FPS / 240 FPS：高帧率视频，用于慢动作回放和电竞。

帧率越高，运动画面越流畅，但数据量也越大。对于普通观影，24~30 FPS 已足够；对于快速运动场景（如体育赛事、游戏），60 FPS 能显著提升观感。

9.1.2 分辨率

分辨率表示视频画面的像素尺寸，决定了画面的清晰度。

分辨率越高，画面细节越丰富，但像素数量呈指数增长。4K 的像素数是 1080p 的 4 倍，数据量也相应大幅增加。

9.1.3 码率

**码率（Bitrate）**表示视频每秒传输的数据量，单位通常是 kbps 或 Mbps。码率直接决定视频的画质和文件大小。

• 恒定码率（CBR）：码率保持不变，适合网络流媒体。
• 可变码率（VBR）：根据画面复杂度动态调整码率，相同平均码率下画质更好。

以 1080p 视频为例：

未经压缩的 1080p@60FPS 视频数据量极为惊人：

1920 × 1080 × 3（RGB）× 60 FPS = 373,248,000 字节/秒 ≈ 356 MB/s
一小时约 1.25 TB

这正是视频压缩编码技术存在的根本原因。

9.2 视频编码原理

视频编码的核心目标是在尽可能保持画质的前提下，大幅减少数据量。主要利用两种冗余：空间冗余和时间冗余。

9.2.1 帧内压缩

**帧内压缩（Intra-frame Compression）**利用单帧图像内部的空间冗余。相邻像素通常具有相似的颜色值，通过以下技术实现压缩：

• 色彩空间转换：将 RGB 转换为 YUV（亮度+色度），利用人眼对色度不敏感的特性降低色度采样精度（如 4:2:0）。
• 离散余弦变换（DCT）：将图像块从空间域转换到频率域，能量集中在低频分量。
• 量化：对高频分量进行较大量化，丢弃人眼不敏感的细节。
• 熵编码：使用哈夫曼编码或算术编码进一步压缩数据。

只使用帧内压缩的帧称为 I 帧（Intra-coded Frame），可以独立解码，是视频随机访问的锚点。

9.2.2 帧间压缩

**帧间压缩（Inter-frame Compression）**利用相邻帧之间的时间冗余。视频相邻帧通常非常相似，只需记录变化部分即可。

• P 帧（Predicted Frame）：参考前面的 I 帧或 P 帧，只编码差异部分和运动矢量。
• B 帧（Bidirectional Predicted Frame）：同时参考前后帧，压缩率最高，但解码需要更多计算。

典型的视频帧序列如：I P B B P B B I P B B ...

帧间压缩是视频编码效率的关键。一个 I 帧可能占用数兆字节，而 P 帧和 B 帧通常只有几十到几百 KB。

9.2.3 运动估计与补偿

帧间压缩的核心技术是运动估计。编码器将画面划分为宏块（如 16×16 像素），在参考帧中搜索最佳匹配位置，记录运动矢量（位移偏移量）。解码时根据运动矢量从参考帧“搬运“像素块，再叠加残差数据还原当前帧。

运动估计的计算量巨大，是视频编码中最耗时的环节，也是硬件加速的重点。

9.3 视频编码格式

9.3.1 H.264 / AVC

H.264（又称 AVC，Advanced Video Coding）是目前最广泛使用的视频编码标准，由 ITU-T 和 ISO/IEC 联合制定。

• 发布时间：2003 年。
• 压缩效率：相比前代 MPEG-2，同等画质下码率降低约 50%。
• 特点：兼容性好、专利授权成熟、硬件解码支持最广泛。
• 应用场景：网络视频（YouTube、Bilibili）、蓝光光盘、视频监控、视频会议。
• Profile 等级：
  • Baseline：低复杂度，适合视频通话和移动设备。
  • Main：平衡画质和复杂度，用于标清广播。
  • High：最高画质，用于高清和蓝光。

9.3.2 H.265 / HEVC

H.265（又称 HEVC，High Efficiency Video Coding）是 H.264 的继任者。

• 发布时间：2013 年。
• 压缩效率：同等画质下码率比 H.264 降低约 50%，即 1080p 的码率可看 4K 画质。
• 特点：支持更高分辨率（8K）、更高效的帧间预测、更大的编码单元（CTU 最大 64×64）。
• 缺点：专利授权复杂且昂贵，导致普及速度不及预期。
• 应用场景：4K 蓝光、Apple 设备、部分流媒体平台。

9.3.3 AV1

AV1（AOMedia Video 1）是由开放媒体联盟（AOMedia）主导开发的开源免版税视频编码格式。

• 发布时间：2018 年。
• 压缩效率：同等画质下码率比 H.265 低约 20%~30%，比 H.264 低约 50%。
• 特点：完全开源免版税、由 Google、Mozilla、Netflix 等巨头推动。
• 缺点：编码速度较慢（正在快速改善），硬件解码支持仍在普及中。
• 应用场景：YouTube、Netflix、WebRTC、浏览器视频。

9.4 Rust 视频处理

Rust 在视频处理领域虽然不如 Python 或 C++ 生态成熟，但已有可用的库和绑定，特别是通过 FFI 调用 FFmpeg 这一业界标准工具。

9.4.1 FFmpeg 简介

FFmpeg 是开源多媒体处理的事实标准，支持几乎所有音视频格式的编解码、转码、流媒体处理。它由 C 语言编写，提供了命令行工具和 C 库（libavcodec、libavformat、libavutil 等）。

Rust 社区提供了 FFmpeg 的绑定库 ffmpeg-next，使得在 Rust 中调用 FFmpeg 功能成为可能。

在 Cargo.toml 中添加依赖：

[dependencies]
ffmpeg-next = "6.1"

9.4.2 使用 ffmpeg-next 读取视频信息

use ffmpeg_next as ffmpeg;

fn main() {
    // 初始化 FFmpeg
    ffmpeg::init().unwrap();

    // 打开视频文件
    let mut ictx = ffmpeg::format::input(&"video.mp4").unwrap();

    // 遍历所有流，找到视频流
    for (stream_index, stream) in ictx.streams().enumerate() {
        let codec = stream.codec();
        match codec.medium() {
            ffmpeg::media::Type::Video => {
                let video = codec.decoder().video().unwrap();
                println!("视频流 #{}:", stream_index);
                println!("  编码格式: {:?}", video.id());
                println!("  分辨率: {}x{}", video.width(), video.height());
                println!("  帧率: {}/{}",
                    stream.rate().0, stream.rate().1);
                println!("  总帧数: {}", stream.frames());
            }
            ffmpeg::media::Type::Audio => {
                let audio = codec.decoder().audio().unwrap();
                println!("音频流 #{}:", stream_index);
                println!("  采样率: {}", audio.rate());
                println!("  声道数: {}", audio.channels());
            }
            _ => {}
        }
    }
}

9.4.3 使用 ffmpeg-next 解码视频帧

use ffmpeg_next as ffmpeg;
use ffmpeg::software::scaling::{context::Context, flag::Flags};
use ffmpeg::util::frame::video::Video;

fn main() {
    ffmpeg::init().unwrap();

    let mut ictx = ffmpeg::format::input(&"video.mp4").unwrap();

    // 找到第一个视频流
    let input_stream = ictx.streams()
        .best(ffmpeg::media::Type::Video)
        .expect("未找到视频流");
    let stream_index = input_stream.index();

    // 创建解码器
    let context_decoder = ffmpeg::codec::context::Context::from_parameters(input_stream.parameters()).unwrap();
    let mut decoder = context_decoder.decoder().video().unwrap();

    // 创建缩放器，将帧转换为 RGB24 格式
    let mut scaler = Context::get(
        decoder.format(),
        decoder.width(),
        decoder.height(),
        ffmpeg::format::Pixel::RGB24,
        decoder.width(),
        decoder.height(),
        Flags::BILINEAR,
    ).unwrap();

    // 读取数据包并解码
    for (stream, packet) in ictx.packets() {
        if stream.index() == stream_index {
            decoder.send_packet(&packet).unwrap();

            let mut decoded = Video::empty();
            while decoder.receive_frame(&mut decoded).is_ok() {
                let mut rgb_frame = Video::empty();
                scaler.run(&decoded, &mut rgb_frame).unwrap();

                println!("解码一帧: {}x{}", rgb_frame.width(), rgb_frame.height());

                // 此处可以对 rgb_frame.data(0) 中的 RGB 像素数据进行处理
                // 例如保存为图片、进行图像识别等
            }
        }
    }

    // 刷新解码器
    decoder.send_eof().unwrap();
}

9.4.4 使用 ffmpeg-next 进行视频转码

use ffmpeg_next as ffmpeg;

fn main() {
    ffmpeg::init().unwrap();

    // 打开输入文件
    let mut ictx = ffmpeg::format::input(&"input.mp4").unwrap();

    // 创建输出上下文
    let mut octx = ffmpeg::format::output(&"output.mkv").unwrap();

    // 遍历输入流，在输出中添加对应流
    for (stream_index, istream) in ictx.streams().enumerate() {
        let codec_id = istream.codec().id();
        let mut ostream = octx.add_stream(codec_id).unwrap();
        ostream.set_parameters(istream.parameters()).unwrap();
    }

    octx.write_header().unwrap();

    // 复制数据包
    for (stream, mut packet) in ictx.packets() {
        let istream_index = stream.index();
        let ostream = octx.stream(istream_index).unwrap();

        packet.set_stream(ostream.index());
        packet.rescale_ts(stream.time_base(), ostream.time_base());
        packet.write_interleaved(&mut octx).unwrap();
    }

    octx.write_trailer().unwrap();
    println!("转码完成: input.mp4 -> output.mkv");
}

9.4.5 rav1e：Rust 原生的 AV1 编码器

rav1e 是由 Xiph.Org 基金会开发的 AV1 编码器，使用 Rust 和 Assembly 编写，是 Rust 视频编码领域的重要项目。

// rav1e 基本使用示例（API 可能随版本变化）
use rav1e::config::Config;
use rav1e::encoder::EncoderStatus;

fn main() {
    // 创建编码配置
    let mut cfg = Config::default();
    cfg.enc.width = 1920;
    cfg.enc.height = 1080;
    cfg.enc.bit_depth = 8;
    cfg.enc.time_base = rav1e::data::Rational { num: 1, den: 30 }; // 30 FPS

    // 创建编码器
    let mut ctx = cfg.new_context().unwrap();

    // 发送帧进行编码
    // ctx.send_frame(frame).unwrap();

    // 刷新编码器
    ctx.flush();

    // 接收编码后的数据包
    loop {
        match ctx.receive_packet() {
            Ok(packet) => {
                println!("收到编码包，大小: {} 字节", packet.data.len());
                // 将 packet.data 写入文件或传输
            }
            Err(EncoderStatus::LimitReached) => break,
            Err(EncoderStatus::Encoded) => continue,
            Err(e) => {
                println!("编码错误: {:?}", e);
                break;
            }
        }
    }
}

rav1e 展示了 Rust 在性能敏感型多媒体处理领域的潜力，其内存安全特性对于处理大规模视频数据尤为重要。

9.4.6 相关 Rust 库

9.5 本章小结

练习建议

1. 使用 ffmpeg-next 编写程序，读取一个视频文件的完整元数据（分辨率、帧率、码率、编码格式、时长等）。
2. 使用 ffmpeg-next 提取视频中的每一帧，保存为 PNG 图片序列。
3. 对比同一视频分别用 H.264、H.265、AV1 编码后的文件大小和画质差异。
4. 编写程序计算视频的平均码率和峰值码率。
5. 了解 Rust 的 vpx-encode 或 x264 绑定，尝试进行视频编码。

第十章 万物皆可编码

10.1 概述

“万物皆可编码”——这并非一句夸张的口号，而是计算机科学的基石。从最底层的电信号高低（0和1），到我们日常使用的文字、图片、音频、视频，再到复杂的文档格式、网络协议、数据库结构，无一不是编码的产物。

所谓编码，就是将信息从一种形式转换为另一种形式的过程。在计算机的世界里，一切信息最终都会被转换为二进制序列——由0和1组成的比特流。正如香农（Claude Shannon）在1948年的划时代论文《通信的数学理论》中所揭示的：信息是可以被量化和编码的。

编码的层次可以概括为以下递进关系：

$$ \text{数据} \xrightarrow{\text{类型化}} \text{类型} \xrightarrow{\text{抽象化}} \text{对象} \xrightarrow{\text{持久化}} \text{文件} \xrightarrow{\text{标准化}} \text{协议} $$

• 数据：最原始的比特流，没有语义。
• 类型：赋予数据以语义，如“这是一个整数“或“这是一个字符串“。
• 对象：将类型与行为绑定，形成具有状态和操作的实体。
• 文件：将对象持久化到存储介质中。
• 协议：在文件格式之上建立标准化的交换规则。

本章将从基本类型出发，逐步深入到面向对象编程、唯一标识符、文件系统、文件格式，最终探讨万物编码的哲学意义。

10.2 基本类型与编码

正如之前章节的介绍，通过编码技术，我们可以实现对数字、文字、符号、时间等数据进行编码以便在计算机中进行各种处理。因此才有了整型、浮点型、字符串、数组、切片、哈希表、元组等基本类型，这些构成了编程语言的类型系统。

Rust 基本类型一览

Rust基本类型包括：

类型在内存中的编码方式

整数的编码采用补码（Two’s Complement）表示法。对于 $n$ 位有符号整数，其取值范围为：

$$ [-2^{n-1},\ 2^{n-1} - 1] $$

例如，i8 的取值范围是 $[-128, 127]$，i32 的取值范围是 $[-2^{31},\ 2^{31}-1]$。

浮点数的编码遵循 IEEE 754 标准。以 f32 为例，其 32 位由三部分组成：

$$ \text{float} = (-1)^S \times 2^{E-127} \times (1 + M) $$

其中 $S$ 为符号位（1 bit），$E$ 为指数位（8 bits），$M$ 为尾数位（23 bits）。

字符串的编码在 Rust 中采用 UTF-8 编码。UTF-8 是一种变长编码方案：

• ASCII 字符（U+0000 ~ U+007F）：1 字节
• 拉丁扩展字符（U+0080 ~ U+07FF）：2 字节
• 大部分常用汉字（U+0800 ~ U+FFFF）：3 字节
• Emoji 等罕见字符（U+10000 ~ U+10FFFF）：4 字节

fn main() {
    // 整数在内存中的表示
    let a: i32 = -1;
    println!("i32 -1 的内存表示: {:032b}", a as u32); // 补码：全1

    // 浮点数的精度
    let pi: f64 = std::f64::consts::PI;
    println!("PI = {:.15}", pi);

    // 字符与字符串的UTF-8编码
    let ch = '中';
    println!("字符 '{}' 的Unicode码点: U+{:04X}", ch, ch as u32);
    println!("字符 '{}' 的UTF-8字节: {:?}", ch, ch.len_utf8()); // 3字节

    let s = String::from("Hello 世界");
    println!("字符串 '{}' 的字节数: {}", s, s.len());       // 12字节
    println!("字符串 '{}' 的字符数: {}", s, s.chars().count()); // 7个字符
}

10.3 面向对象与编码

类与对象的概念

“物以类聚，人以群分。” 面向对象编程（Object-Oriented Programming, OOP）通过抽象方法，提取同类事物的关键信息，形成“类“（Class）。类是对象的蓝图或模板，而对象是类的具体实例。

面向对象编程的三大核心特性：

对象标识符（OID）

按照 GB/T 17969.1 (ISO/IEC 9834-1) 的定义，对象是指“通信和信息处理世界中的任何事物，它是可标识（可以命名）的，同时它可被注册“。对象标识符（Object Identifier，OID）是与对象相关联的用来无歧义地标识对象的全局唯一的值，可保证对象在通信与信息处理中正确地定位和管理。通俗地讲，OID 就是网络通信中对象的身份证。

对象标识符 ObjectIdentifier OID

OID 采用点分十进制表示，例如 1.3.6.1.5.5.7.1.1 表示“权威信息访问“（Authority Information Access）证书扩展。

Rust 中的面向对象

Rust 并非传统的面向对象语言，但通过 struct、enum 和 trait 可以优雅地实现面向对象的核心思想：

use std::fmt;

// struct 替代"类"——封装数据
struct Person {
    name: String,
    age: u32,
}

// impl 块——封装行为（方法）
impl Person {
    fn new(name: &str, age: u32) -> Self {
        Person {
            name: name.to_string(),
            age,
        }
    }

    fn greet(&self) {
        println!("你好，我是{}，今年{}岁。", self.name, self.age);
    }
}

// trait 替代"接口"——实现多态
trait Describable {
    fn describe(&self) -> String;
}

impl Describable for Person {
    fn describe(&self) -> String {
        format!("Person(name={}, age={})", self.name, self.age)
    }
}

// enum 实现代数数据类型
enum Shape {
    Circle { radius: f64 },
    Rectangle { width: f64, height: f64 },
    Triangle { base: f64, height: f64 },
}

impl Shape {
    fn area(&self) -> f64 {
        match self {
            Shape::Circle { radius } => std::f64::consts::PI * radius * radius,
            Shape::Rectangle { width, height } => width * height,
            Shape::Triangle { base, height } => 0.5 * base * height,
        }
    }
}

impl fmt::Display for Shape {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            Shape::Circle { radius } => write!(f, "Circle(r={})", radius),
            Shape::Rectangle { width, height } => write!(f, "Rect(w={}, h={})", width, height),
            Shape::Triangle { base, height } => write!(f, "Tri(b={}, h={})", base, height),
        }
    }
}

fn main() {
    let p = Person::new("张三", 30);
    p.greet();
    println!("{}", p.describe());

    let shapes = vec![
        Shape::Circle { radius: 5.0 },
        Shape::Rectangle { width: 4.0, height: 6.0 },
        Shape::Triangle { base: 3.0, height: 8.0 },
    ];

    for s in &shapes {
        println!("{} 的面积 = {:.2}", s, s.area());
    }
}

10.4 唯一标识符（ID）

同一类型，拥有数以亿计的对象，如何区分这些独一无二的个体呢？其实要做到这一点并不难，只要给这些个体一个全局唯一的“身份“即可。身份证号、手机号、IP地址、统一社会信用代码——这些都是唯一标识符的现实应用。

10.4.1 身份证号校验

中国居民身份证号码为18位，其中前17位为本体码，最后1位为校验码。校验码的计算基于加权因子取模11的算法：

$$ C = \left( \sum_{i=1}^{17} a_i \times w_i \right) \bmod 11 $$

其中 $a_i$ 为第 $i$ 位数字，$w_i$ 为对应的加权因子 $[7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2]$。校验码映射表为：

#![allow(unused)]
fn main() {
use lazy_static::lazy_static;
use regex::Regex;
use std::collections::HashMap;

lazy_static! {
    static ref IDENTIFIER_REGEX: Regex = Regex::new("^([0-9ABCDEFGY]{1})([1239]{1})([0-9ABCDEFGHJKLMNPQRTUWXY]{6})([0-9ABCDEFGHJKLMNPQRTUWXY]{9})([0-9ABCDEFGHJKLMNPQRTUWXY])$").unwrap();
    static ref REGEX_18_ID_CARD_NO: Regex = Regex::new(r"^[0-9]{17}[0-9X]$").unwrap();
    static ref ID_CARD_POWER: Vec<usize> = vec![7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2];
    static ref WEIGHT: Vec<usize> = vec![1, 3, 9, 27, 19, 26, 16, 17, 20, 29, 25, 13, 8, 24, 10, 30, 28];
    static ref VERIFY_CODE_MAP: HashMap<char,usize> = {
        let verify_code = "0123456789ABCDEFGHJKLMNPQRTUWXY";
        let verify_code_vec :Vec<char> = verify_code.chars().collect();
        let mut verify_code_map = HashMap::new();
        for (i,item) in verify_code_vec.iter().enumerate().take(verify_code.len()){
            verify_code_map.insert(*item,i);

        }
        println!("{:?}",verify_code_map);
        verify_code_map
    };
    // 公司名称需要排除的字符串，不包含中英文括号
    static ref REGEX_NOT_COMPANY_NAME: Regex = Regex::new(r###"[`~!@#$%^&*+=|{}':;',\\.<>《》/?~！@#￥%……&*——+|\-{}\[\]【】'；：""'。，、？]"###).unwrap();
    // 金钱（千分位）
    static ref MONEY_REGEX: Regex = Regex::new(r"^(-)?\d{1,3}(,\d{3})*(.\d+)?$").unwrap();
}

/// 18位身份证号校验
fn is_18_id_card(id_card_no: &str) -> bool {
    if !REGEX_18_ID_CARD_NO.is_match(id_card_no) {
        println!("{} isn't match regex", id_card_no);
        return false;
    }

    let id_card_no_chars: Vec<char> = id_card_no.chars().collect();
    let mut sum = 0;
    for i in 0..17 {
        let ch = id_card_no_chars[i] as usize - 48;
        sum += ch * ID_CARD_POWER[i];
    }

    let check_code = match sum % 11 {
        10 => '2',
        9 => '3',
        8 => '4',
        7 => '5',
        6 => '6',
        5 => '7',
        4 => '8',
        3 => '9',
        2 => 'X',
        1 => '0',
        0 => '1',
        _ => 'N',
    };

    check_code == id_card_no_chars[17]
}


let id_card_no = "450101200012314321";
if is_18_id_card(id_card_no) {
    println!("{} is a valid ID card number", id_card_no);
} else {
    println!("{} is not a valid ID card number", id_card_no);
}


}

更多代码

10.4.2 统一社会信用代码校验

统一社会信用代码是18位的标识代码，同样采用加权因子校验算法。上述代码中的 IDENTIFIER_REGEX、WEIGHT 和 VERIFY_CODE_MAP 即为统一社会信用代码校验所需的核心数据：

• IDENTIFIER_REGEX：匹配18位统一社会信用代码的格式
• WEIGHT：加权因子数组 $[1, 3, 9, 27, 19, 26, 16, 17, 20, 29, 25, 13, 8, 24, 10, 30, 28]$
• VERIFY_CODE_MAP：校验字符映射表（不包含 I、O、Z、S、V）

10.4.3 UUID

UUID（Universally Unique Identifier，通用唯一识别码）是一个128位的标识符，通常以32个十六进制数字表示，格式为 8-4-4-4-12，例如：

550e8400-e29b-41d4-a716-446655440000

UUID 的理论空间为 $2^{128} \approx 3.4 \times 10^{38}$，足够为地球上的每一粒沙子分配一个唯一标识符。

UUID 版本对比：

use uuid::{Uuid, Version, Variant};

fn main() {
    // 生成 v4 UUID（随机）
    let uuid_v4 = Uuid::new_v4();
    println!("UUID v4: {}", uuid_v4);
    println!("版本: {:?}", uuid_v4.get_version()); // Some(Version::Random)
    println!("变体: {:?}", uuid_v4.get_variant()); // Some(Variant::RFC4122)

    // 生成 v1 UUID（基于时间戳）
    let uuid_v1 = Uuid::new_v1(&[1, 2, 3, 4, 5, 6]);
    println!("UUID v1: {}", uuid_v1);

    // 从字符串解析 UUID
    let parsed = Uuid::parse_str("550e8400-e29b-41d4-a716-446655440000");
    match parsed {
        Ok(u) => println!("解析成功: {}, 版本: {:?}", u, u.get_version()),
        Err(e) => println!("解析失败: {}", e),
    }

    // 生成 v5 UUID（基于命名空间和名称的确定性UUID）
    let namespace = Uuid::NAMESPACE_DNS;
    let uuid_v5 = Uuid::new_v5(namespace, b"example.com");
    println!("UUID v5 (example.com): {}", uuid_v5);
    // 相同输入始终产生相同结果
    let uuid_v5_again = Uuid::new_v5(namespace, b"example.com");
    assert_eq!(uuid_v5, uuid_v5_again);
    println!("确定性验证: v5 UUID 相同输入产生相同结果 ✓");
}

Cargo.toml 依赖：

[dependencies]
uuid = { version = "1", features = ["v1", "v4", "v5"] }

10.4.4 雪花算法（Snowflake）

雪花算法是 Twitter 开源的分布式ID生成算法，其核心思想是：将64位的 i64 划分为多个段，每段代表不同的语义信息。

$$ \text{Snowflake ID} = \underbrace{\text{符号位}}{1\text{bit}} \ | \ \underbrace{\text{时间戳}}{41\text{bits}} \ | \ \underbrace{\text{机器ID}}{10\text{bits}} \ | \ \underbrace{\text{序列号}}{12\text{bits}} $$

41位时间戳的表示范围：

$$ 2^{41} - 1 = 2199023255551 \text{ 毫秒} \approx 69.73 \text{ 年} $$

use std::sync::atomic::{AtomicU16, Ordering};
use std::time::{SystemTime, UNIX_EPOCH};

/// 雪花算法ID生成器
struct Snowflake {
    machine_id: u16,          // 机器ID (0 ~ 1023)
    sequence: AtomicU16,      // 序列号 (0 ~ 4095)
    last_timestamp: AtomicU64, // 上次生成ID的时间戳
    epoch: u64,               // 起始时间戳（毫秒）
}

impl Snowflake {
    fn new(machine_id: u16) -> Self {
        // 自定义纪元：2024-01-01 00:00:00 UTC
        let epoch = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap()
            .as_millis() as u64;

        Snowflake {
            machine_id: machine_id & 0x3FF, // 确保不超过10位
            sequence: AtomicU16::new(0),
            last_timestamp: AtomicU64::new(0),
            epoch,
        }
    }

    fn next_id(&self) -> i64 {
        let current_timestamp = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap()
            .as_millis() as u64;

        let last = self.last_timestamp.load(Ordering::SeqCst);

        if current_timestamp == last {
            // 同一毫秒内，递增序列号
            let seq = self.sequence.fetch_add(1, Ordering::SeqCst);
            if seq >= 4095 {
                // 序列号溢出，等待下一毫秒
                panic!("Sequence overflow: too many IDs in one millisecond");
            }
            self.make_id(last, seq)
        } else {
            // 新的毫秒，重置序列号
            self.sequence.store(0, Ordering::SeqCst);
            self.last_timestamp.store(current_timestamp, Ordering::SeqCst);
            self.make_id(current_timestamp, 0)
        }
    }

    fn make_id(&self, timestamp: u64, sequence: u16) -> i64 {
        // 时间戳左移22位（10位机器ID + 12位序列号）
        let ts_part = (timestamp - self.epoch) << 22;
        // 机器ID左移12位（12位序列号）
        let machine_part = (self.machine_id as i64) << 12;
        // 序列号
        let seq_part = sequence as i64;

        ts_part | machine_part | seq_part
    }
}

fn main() {
    let snowflake = Snowflake::new(1); // 机器ID为1

    // 连续生成10个ID
    for _ in 0..10 {
        let id = snowflake.next_id();
        println!("Snowflake ID: {}", id);
    }

    // 解析ID
    let id = snowflake.next_id();
    let timestamp_part = (id >> 22) + snowflake.epoch as i64;
    let machine_part = ((id >> 12) & 0x3FF) as u16;
    let sequence_part = (id & 0xFFF) as u16;
    println!("\n解析 ID = {}", id);
    println!("  时间戳部分: {}", timestamp_part);
    println!("  机器ID: {}", machine_part);
    println!("  序列号: {}", sequence_part);
}

10.4.5 nanoid

nanoid 是一种轻量级、安全、URL友好的唯一ID生成器。与UUID相比，nanoid生成的ID更短（默认21个字符），且使用URL安全的字符集。

nanoid 的核心思想是：使用密码学安全的随机数生成器，从一个自定义字符集中随机选取字符，组成指定长度的字符串。

use nanoid::nanoid;

fn main() {
    // 生成默认21字符的 nanoid
    let id1 = nanoid!();
    println!("nanoid (默认21字符): {}", id1);

    // 生成指定长度的 nanoid
    let id2 = nanoid!(10);
    println!("nanoid (10字符): {}", id2);

    // 使用自定义字符集
    let id3 = nanoid!(16, &['a', 'b', 'c', 'd', 'e', 'f', '1', '2', '3']);
    println!("nanoid (自定义字符集): {}", id3);
}

Cargo.toml 依赖：

[dependencies]
nanoid = "0.4"

10.4.6 各ID方案对比

10.5 一切皆文件

Unix 哲学：一切皆文件

Unix 操作系统有一个优雅的设计哲学——“一切皆文件”（Everything is a file）。在 Unix/Linux 系统中，无论是普通文件、目录、设备（如 /dev/null、/dev/tty）、管道、套接字，还是 /proc 下的进程信息，都可以通过统一的文件操作接口（open、read、write、close）来访问。

这种设计的优势在于：

• 统一接口：所有资源使用相同的 API 操作
• 组合性：通过管道将多个程序串联
• 简洁性：用少量原语解决大量问题

文件读写

#![allow(unused)]
fn main() {
use std::fs::File;
use std::io::{BufReader, Read, Write};

    // 将文件读取为字节数组
    if let Ok(cipher_data) = std::fs::read("why-rust.crypto") {
        let plaintext = cipher
            .decrypt(nonce, cipher_data.as_ref())
            .expect("decryption failure!");
        println!("{}", String::from_utf8(plaintext).unwrap());
    }

    /// 逐行读取文件
    #[test]
    fn read_file_lines() {
        match File::open("why-rust.txt") {
            Ok(f) => {
                let reader = BufReader::new(f);
                let lines = reader.lines();
                for line in lines.map(|x| x.unwrap()) {
                    println!("{}", line);
                }
            }
            Err(e) => panic!("can't open this file :{}", e),
        }
    }

    ///将文件读取为一个字符串
    match std::fs::read_to_string("provinces.json") {
        Ok(data) => {
            println!("open provinces.json...");
            let v: Vec<AdministrativeDivisions> = serde_json::from_str(&data).unwrap();

            for ad in v {
                println!("{:?}={:?}", ad.code, ad.name);
            }
        }
        Err(e) => panic!("can't open this file : {}", e),
    }

    // 将字节数组写入文件
    let mut all_bytes = Vec::<u8>::with_capacity(128);
    all_bytes.extend_from_slice(&key);
    all_bytes.extend_from_slice(&iv);
    all_bytes.extend_from_slice(&encrypt_bytes);

    std::fs::write("poem.crypto", &all_bytes);
}

文件编码：文本文件 vs 二进制文件

文件从编码角度可分为两大类：

文本文件本质上是“对人友好“的二进制文件——它们同样是由字节组成的，只不过这些字节按照特定的字符编码（如 UTF-8、GBK）可以被人类直接阅读。而二进制文件则采用特定格式编码，需要专门的解析器才能理解其内容。

10.6 文件格式与编码

文件格式本质

文件格式的本质就是编码规则——约定如何将特定类型的数据组织为字节序列。不论是简单的 txt、xml、json 等格式的数据还是复杂的 doc、xls、pdf、OFD 等格式，都是某种编码规则的体现。

办公三件套：Word，Excel，PPT

微软的 Office 办公三件套：Word，Excel，PowerPoint 成为办公领域的标准，每年为微软创造上百亿美元的收入。国内金山办公经过三十多年的追赶，其产品 WPS 终于在办公软件拥有一席之地、站稳了脚跟。

Excel / CSV / JSON 处理

Excel 读取

calamine 是 Rust 实现的 Excel 工具，目前只支持读操作（不支持写操作）。

#![allow(unused)]
fn main() {
use calamine::DataType::{
    Bool, DateTime, DateTimeIso, Duration, DurationIso, Empty, Error, Float, String,
};
use calamine::{
    open_workbook, open_workbook_auto, Ods, Reader, Sheet, SheetType, SheetVisible, Xls, Xlsb, Xlsx,
};
use calamine::{CellErrorType::*, DataType};

#[test]
fn any_sheets_xlsx() {
    let path = format!(
        "{}/examples/file/any_sheets.xlsx",
        env!("CARGO_MANIFEST_DIR")
    );
    println!("{}", &path);
    let mut workbook: Xlsx<_> = open_workbook(path).unwrap();

    let range = workbook.worksheet_range("Visible").unwrap();
    let total_cells = range.get_size().0 * range.get_size().1;
    let non_empty_cells: usize = range.used_cells().count();
    println!(
        "Found {} cells in 'Sheet1', including {} non empty cells",
        total_cells, non_empty_cells
    );
    // alternatively, we can manually filter rows
    assert_eq!(
        non_empty_cells,
        range
            .rows()
            .flat_map(|r| r.iter().filter(|&c| c != &DataType::Empty))
            .count()
    );
}

}

CSV 读写

CSV（Comma-Separated Values）是最简单的结构化文本格式，用逗号分隔各列数据。

use csv::{Reader, Writer, ReaderBuilder, WriterBuilder};
use serde::{Deserialize, Serialize};

#[derive(Debug, Serialize, Deserialize)]
struct RocketRecord {
    #[serde(rename = "发射序号")]
    serial_no: u32,
    #[serde(rename = "发射日期")]
    launch_date: String,
    #[serde(rename = "发射地点")]
    launch_site: String,
    #[serde(rename = "运载火箭")]
    rocket: String,
    #[serde(rename = "卫星/航天器")]
    satellite: String,
}

/// 写入CSV文件
fn write_csv() -> Result<(), Box<dyn std::error::Error>> {
    let mut wtr = WriterBuilder::new()
        .has_headers(true)
        .from_path("rocket_records.csv")?;

    let records = vec![
        RocketRecord {
            serial_no: 1,
            launch_date: "2024-01-17".to_string(),
            launch_site: "酒泉卫星发射中心".to_string(),
            rocket: "长征二号F".to_string(),
            satellite: "天舟七号".to_string(),
        },
        RocketRecord {
            serial_no: 2,
            launch_date: "2024-03-21".to_string(),
            launch_site: "文昌航天发射场".to_string(),
            rocket: "长征八号".to_string(),
            satellite: "鹊桥二号".to_string(),
        },
    ];

    for record in &records {
        wtr.serialize(record)?;
    }
    wtr.flush()?;
    println!("CSV 文件写入成功！");
    Ok(())
}

/// 读取CSV文件
fn read_csv() -> Result<(), Box<dyn std::error::Error>> {
    let mut rdr = ReaderBuilder::new()
        .flexible(true)
        .from_path("rocket_records.csv")?;

    for result in rdr.deserialize() {
        let record: RocketRecord = result?;
        println!("{:?}", record);
    }
    Ok(())
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    write_csv()?;
    println!("--- 读取CSV ---");
    read_csv()?;
    Ok(())
}

Cargo.toml 依赖：

[dependencies]
csv = "1.3"
serde = { version = "1", features = ["derive"] }

JSON 序列化与反序列化

JSON（JavaScript Object Notation）是当今最流行的数据交换格式。在 Rust 生态中，serde_json 是处理 JSON 的事实标准。

use serde::{Deserialize, Serialize};
use serde_json::{json, Value, from_str, to_string_pretty};

#[derive(Debug, Serialize, Deserialize)]
struct Province {
    code: String,
    name: String,
    level: u8,
    #[serde(skip_serializing_if = "Option::is_none")]
    parent_code: Option<String>,
}

/// 序列化：Rust 结构体 → JSON 字符串
fn serialize_example() -> Result<(), Box<dyn std::error::Error>> {
    let provinces = vec![
        Province {
            code: "110000".to_string(),
            name: "北京市".to_string(),
            level: 1,
            parent_code: None,
        },
        Province {
            code: "110101".to_string(),
            name: "东城区".to_string(),
            level: 2,
            parent_code: Some("110000".to_string()),
        },
    ];

    // 序列化为紧凑JSON
    let json_str = serde_json::to_string(&provinces)?;
    println!("紧凑JSON: {}", json_str);

    // 序列化为美化JSON
    let json_pretty = serde_json::to_string_pretty(&provinces)?;
    println!("美化JSON:\n{}", json_pretty);

    // 动态构建JSON
    let data = json!({
        "type": "FeatureCollection",
        "features": [
            {
                "type": "Feature",
                "properties": { "name": "北京市", "code": "110000" },
                "geometry": { "type": "Point", "coordinates": [116.4, 39.9] }
            }
        ]
    });
    println!("动态JSON: {}", data);
    Ok(())
}

/// 反序列化：JSON 字符串 → Rust 结构体
fn deserialize_example() -> Result<(), Box<dyn std::error::Error>> {
    let json_data = r#"
    [
        {"code": "440000", "name": "广东省", "level": 1},
        {"code": "440100", "name": "广州市", "level": 2, "parent_code": "440000"}
    ]
    "#;

    let provinces: Vec<Province> = from_str(json_data)?;
    for p in &provinces {
        println!("{} - {} (level: {})", p.code, p.name, p.level);
    }

    // 反序列化为动态 Value
    let v: Value = from_str(json_data)?;
    if let Some(arr) = v.as_array() {
        for item in arr {
            println!("名称: {}", item["name"]);
        }
    }
    Ok(())
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== 序列化 ===");
    serialize_example()?;
    println!("\n=== 反序列化 ===");
    deserialize_example()?;
    Ok(())
}

Cargo.toml 依赖：

[dependencies]
serde = { version = "1", features = ["derive"] }
serde_json = "1"

PDF / OFD 格式简介

• PDF (Portable Document Format) 可携带文件格式，由 Adobe 公司于1992年发布，已成为全球通用的文档交换标准。
• OFD 版式文档国家标准，是中国自主研发的电子文件格式，旨在替代 PDF 在政务和电子公文领域的应用。

Pandas vs Polars

10.7 万物编码的哲学

DIKW 金字塔

从数据到智慧的递进，可以用 DIKW 金字塔来描述：

$$ \text{Data（数据）} \xrightarrow{\text{赋予含义}} \text{Information（信息）} \xrightarrow{\text{总结规律}} \text{Knowledge（知识）} \xrightarrow{\text{洞察本质}} \text{Wisdom（智慧）} $$

编码贯穿了 DIKW 的每一个层级：

• 数据层：二进制编码（ASCII、UTF-8、IEEE 754）
• 信息层：结构化编码（JSON、XML、CSV）
• 知识层：逻辑编码（规则引擎、知识图谱）
• 智慧层：这一层或许已经超出了“编码“的范畴——智慧涉及直觉、经验和创造力，这些是否可以被编码，至今仍是哲学与人工智能领域的开放问题。

编码的边界：什么不能被编码？

尽管“万物皆可编码“是一个强大的理念，但编码并非万能。以下是一些编码的边界：

1. 主观体验（Qualia）：你看到的“红色“和我看到的“红色“是同一种感觉吗？这种主观体验难以被精确编码。
2. 情感与直觉：虽然可以用文字描述情感，但情感的微妙之处（如“淡淡的忧伤“）很难被完全编码。
3. 无限精度：实数 $\pi$ 的精确值无法被有限编码完全表示，只能用近似值。
4. 创造性思维：编码可以表达规则，但真正的创造力（如贝多芬的交响曲）似乎超越了纯粹的编码。
5. 意识本身：意识是否可以被编码为算法？这是心智哲学中最深刻的未解之谜之一。

正如哲学家维特根斯坦所言：“对于不可言说之物，必须保持沉默。“编码的边界，或许正是人类智慧与机器智能的分界线。

10.8 总结

本章从“万物皆可编码“的理念出发，系统介绍了编码的各个层次。

编码层次对比

ID 方案对比

10.9 练习题

练习1：编写一个 Rust 函数，接收一个 u8 值，分别输出其二进制表示、八进制表示和十六进制表示，并解释补码如何表示负数。

练习2：使用 struct 和 trait 实现一个简单的“动物“体系：定义 Animal trait（包含 speak 方法），并为 Dog、Cat、Bird 三个结构体分别实现该 trait。

练习3：编写一个函数，验证给定的18位身份证号码是否合法。要求支持批量验证，并统计合法与不合法的数量。

练习4：使用 uuid crate 生成 1000 个 UUID v4，统计其中以 0 开头的 UUID 数量，并验证其是否接近理论概率 $1/16$。

练习5：实现一个简化版的雪花算法 ID 生成器，要求支持自定义机器ID，并验证生成的 ID 是否全局唯一（生成 10000 个 ID 检查是否有重复）。

练习6：使用 csv 和 serde crate，读取一个 CSV 文件，筛选出满足特定条件的记录，并将结果写入新的 CSV 文件。

练习7：使用 serde_json 实现以下功能：将一个 Rust 结构体序列化为 JSON 字符串，再从 JSON 字符串反序列化为 Rust 结构体，验证数据的完整性。

练习8：思考题：有人说“一切皆可编码“，但也有人认为“意识不可编码“。请结合本章内容和 DIKW 金字塔，谈谈你对“编码的边界“的看法。字数不少于300字。

第十一章 数据的序列化、反序列化、持久化、可视化

11.1 概述

什么是序列化与反序列化

序列化（Serialization）是将对象的状态信息转换为可以存储或传输的形式的过程。在序列化期间，对象将其当前状态写入到临时或持久性存储区。以后，可以通过从存储区中读取或反序列化对象的状态，重新创建该对象。

序列化（编码）是将对象序列化为二进制形式（字节数组），主要用于网络传输、数据持久化等；而反序列化（解码）则是将从网络、磁盘等读取的字节数组还原成原始对象，主要用于网络传输对象的解码，以便完成远程调用。

反序列化的最重要的作用：根据字节流中保存的对象状态及描述信息，通过反序列化重建对象。

为什么需要序列化

在计算机系统中，数据存在于内存中时以结构化的对象形式存在，但当我们需要将数据跨进程、跨机器、跨时间传递时，就必须将其转换为一种统一的字节流格式。序列化解决的核心问题是：

序列化的完整流程

一个典型的数据序列化与传输流程可以表示为：

$$ \text{原始对象} \xrightarrow{\text{编码}} \text{字节流} \xrightarrow{\text{传输}} \text{字节流} \xrightarrow{\text{解码}} \text{重建对象} $$

用数学语言描述，设原始对象为 $O$，序列化函数为 $S$，传输通道为 $T$，反序列化函数为 $D$，则完整过程为：

$$ O’ = D(T(S(O))) $$

理想情况下，我们希望 $O’ = O$，即反序列化后的对象与原始对象完全一致。这要求序列化格式能够无损地表达原始数据的所有信息。

序列化和反序列化的底层实现原理是什么？

11.2 常见序列化格式

常见的序列化数据格式有：JSON、XML、BSON、YAML、TOML 等。每种格式都有其适用的场景和优缺点。

11.2.1 JSON

JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，由 Douglas Crockford 在 2001 年提出。它基于 JavaScript 的对象字面量语法，但独立于任何编程语言，几乎所有的现代编程语言都支持 JSON。

JSON 的核心特点：

• 轻量级：相比 XML，JSON 没有冗余的标签，数据体积更小
• 可读性好：人类可以直接阅读和编写
• 广泛支持：几乎所有语言和平台都内置了 JSON 支持
• 树形结构：支持嵌套的对象和数组

JSON 与 Rust 数据类型映射：

use serde::Serialize;

#[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct Person {
    first_name: String,
    last_name: String,
}

fn main() {
    let person = Person {
        first_name: "Graydon".to_string(),
        last_name: "Hoare".to_string(),
    };

    let json = serde_json::to_string_pretty(&person).unwrap();

    // Prints:
    //
    //    {
    //      "firstName": "Graydon",
    //      "lastName": "Hoare"
    //    }
    println!("{}", json);
}

11.2.2 XML

XML（eXtensible Markup Language，可扩展标记语言）是一种自描述性强的标记语言，由 W3C 于 1998 年标准化。XML 使用标签来描述数据的结构和语义，在 SOAP、SVG、HTML 等领域有广泛应用。

XML 的核心特点：

• 自描述性强：标签本身携带语义信息
• 严格的语法规范：必须有根元素、标签必须闭合
• 支持命名空间：避免标签名冲突
• 适合文档型数据：如配置文件、文档交换

JSON vs XML 对比：

在 Rust 中，可以使用 quick-xml 库来处理 XML 数据：

use quick_xml::events::Event;
use quick_xml::Reader;
use std::io::BufReader;

fn main() {
    let xml = r#"<?xml version="1.0" encoding="UTF-8"?>
    <config>
        <database>
            <host>localhost</host>
            <port>5432</port>
            <name>mydb</name>
        </database>
        <server>
            <host>0.0.0.0</host>
            <port>8080</port>
        </server>
    </config>"#;

    let mut reader = Reader::from_reader(xml.as_bytes());
    let mut buf = Vec::new();
    let mut depth = 0;

    loop {
        match reader.read_event_into(&mut buf) {
            Ok(Event::Start(e)) => {
                depth += 1;
                println!("{:indent$}<{}>", "", e.name(), indent = depth * 2);
            }
            Ok(Event::Empty(e)) => {
                println!("{:indent$}<{} />", "", e.name(), indent = depth * 2);
            }
            Ok(Event::Text(e)) => {
                let text = e.unescape().unwrap();
                if !text.trim().is_empty() {
                    println!("{:indent$}{}", "", text.trim(), indent = depth * 2 + 2);
                }
            }
            Ok(Event::End(e)) => {
                depth -= 1;
                println!("{:indent$}</{}>", "", e.name(), indent = depth * 2);
            }
            Ok(Event::Eof) => break,
            Err(e) => eprintln!("Error: {:?}", e),
            _ => {}
        }
        buf.clear();
    }
}

11.2.3 YAML

YAML（YAML Ain’t Markup Language）是一种人类友好的数据序列化格式，广泛用于配置文件（如 Kubernetes 的资源清单、CI/CD 配置文件等）。

YAML 的核心特点：

• 缩进表示层级：使用空格缩进而非花括号
• 人类友好：语法简洁，接近自然语言
• 支持注释：使用 # 添加注释
• 支持复杂数据类型：锚点（&）和别名（*）实现引用

# 应用配置
server:
  host: 0.0.0.0
  port: 8080
  workers: 4

database:
  url: "postgres://user:pass@localhost/mydb"
  pool_size: 10
  timeout: 30s

logging:
  level: info
  format: json

在 Rust 中，可以使用 serde_yaml 来处理 YAML：

use serde::Deserialize;

#[derive(Debug, Deserialize)]
struct Config {
    server: Server,
    database: Database,
    logging: Logging,
}

#[derive(Debug, Deserialize)]
struct Server {
    host: String,
    port: u16,
    workers: usize,
}

#[derive(Debug, Deserialize)]
struct Database {
    url: String,
    pool_size: u32,
    timeout: String,
}

#[derive(Debug, Deserialize)]
struct Logging {
    level: String,
    format: String,
}

fn main() {
    let yaml = r#"
server:
  host: 0.0.0.0
  port: 8080
  workers: 4

database:
  url: "postgres://user:pass@localhost/mydb"
  pool_size: 10
  timeout: 30s

logging:
  level: info
  format: json
"#;

    let config: Config = serde_yaml::from_str(yaml).unwrap();
    println!("Server: {}:{}", config.server.host, config.server.port);
    println!("Database pool: {}", config.database.pool_size);
    println!("Log level: {}", config.logging.level);
}

11.2.4 TOML

TOML（Tom’s Obvious, Minimal Language）由 GitHub 联合创始人 Tom Preston-Werner 创建，是一种语义明确、易于阅读的配置文件格式。Rust 社区对 TOML 有着天然的支持——Cargo.toml 就是 TOML 格式的配置文件。

TOML 的核心特点：

• 语义明确：类型清晰，不会产生歧义
• INI 风格：使用 [section] 和 key = value 的形式
• Rust 生态首选：Cargo.toml 就是 TOML
• 支持多种数据类型：字符串、整数、浮点数、布尔值、日期时间、数组、内联表

[package]
name = "my_app"
version = "0.1.0"
edition = "2021"

[dependencies]
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"

[profile.release]
opt-level = 3
lto = true

在 Rust 中，可以使用 toml crate 来解析 TOML：

use serde::Deserialize;
use std::fs;

#[derive(Debug, Deserialize)]
struct AppConfig {
    package: Package,
    dependencies: std::collections::HashMap<String, toml::Value>,
}

#[derive(Debug, Deserialize)]
struct Package {
    name: String,
    version: String,
    edition: String,
}

fn main() {
    let content = fs::read_to_string("Cargo.toml").unwrap();
    let config: AppConfig = toml::from_str(&content).unwrap();
    println!("项目名称: {}", config.package.name);
    println!("版本: {}", config.package.version);

    for (name, value) in &config.dependencies {
        println!("依赖 {}: {:?}", name, value);
    }
}

11.2.5 BSON

BSON（Binary JSON）是一种二进制形式的 JSON 序列化格式，由 MongoDB 开发。BSON 扩展了 JSON 的数据类型，支持日期时间、二进制数据、正则表达式等。

BSON 的主要优势在于：

• 二进制格式：解析速度比文本格式的 JSON 更快
• 扩展数据类型：支持 Date、Binary、ObjectId、Regex 等
• MongoDB 原生格式：MongoDB 内部使用 BSON 存储和传输数据

11.2.6 Protocol Buffers（Protobuf）

Protocol Buffers（简称 Protobuf）是 Google 开发的高效二进制序列化协议。与 JSON/XML 不同，Protobuf 需要先定义 .proto 模式文件，然后通过编译器生成各语言的代码。

// person.proto
syntax = "proto3";

message Person {
    string name = 1;
    int32 age = 2;
    repeated string emails = 3;
}

Protobuf 的核心优势：

• 极致性能：二进制编码，体积小、解析快
• 强类型约束：通过 .proto 文件定义数据结构
• 向前/向后兼容：字段编号机制保证兼容性
• 跨语言支持：支持 C++、Java、Python、Go、Rust 等多种语言

11.2.7 各格式对比总结

11.3 Rust 中的 Serde 生态

11.3.1 Serde 框架概述

Serde 是 Rust 生态中最核心的序列化/反序列化框架，其名字来源于 SErialize / DEserialize 的缩写。Serde 采用了一种优雅的设计：将数据结构的定义与序列化格式解耦，通过 trait 抽象实现“一次定义，多种格式输出“。

Serde 的架构可以用以下公式表达：

$$ \text{Data} \xleftrightarrow{\text{Serialize/Deserialize}} \text{Serializer/Deserializer} \xleftrightarrow{\text{Format}} \text{JSON/XML/YAML/…} $$

11.3.2 核心 Trait

Serde 定义了两个核心 trait：

• Serialize：将 Rust 数据结构转换为通用的中间表示
• Deserialize：从通用的中间表示重建 Rust 数据结构

这两个 trait 是 Serde 生态的基石，所有数据格式（JSON、XML、YAML 等）都基于这两个 trait 实现。

11.3.3 常用派生宏

在大多数场景下，我们不需要手动实现 Serialize 和 Deserialize，只需使用 #[derive] 派生宏即可：

#![allow(unused)]
fn main() {
use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize, Debug)]
struct User {
    id: u64,
    name: String,
    email: Option<String>,
    roles: Vec<String>,
}
}

11.3.4 常用属性

Serde 提供了丰富的属性来控制序列化行为：

use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize, Debug)]
#[serde(rename_all = "camelCase")]
struct ApiResponse {
    status_code: u16,
    message: String,
    #[serde(skip_serializing)]
    debug_info: String,
    #[serde(default)]
    retry_after: Option<u32>,
    #[serde(flatten)]
    metadata: Metadata,
}

#[derive(Serialize, Deserialize, Debug)]
struct Metadata {
    request_id: String,
    timestamp: i64,
}

fn main() {
    let resp = ApiResponse {
        status_code: 200,
        message: "OK".to_string(),
        debug_info: "internal trace".to_string(),
        retry_after: None,
        metadata: Metadata {
            request_id: "abc-123".to_string(),
            timestamp: 1700000000,
        },
    };

    let json = serde_json::to_string_pretty(&resp).unwrap();
    println!("{}", json);
}

11.3.5 Person 序列化示例

以下是一个完整的 Person 结构体序列化示例：

use serde::Serialize;

#[derive(Serialize)]
#[serde(rename_all = "camelCase")]
struct Person {
    first_name: String,
    last_name: String,
}

fn main() {
    let person = Person {
        first_name: "Graydon".to_string(),
        last_name: "Hoare".to_string(),
    };

    let json = serde_json::to_string_pretty(&person).unwrap();

    // Prints:
    //
    //    {
    //      "firstName": "Graydon",
    //      "lastName": "Hoare"
    //    }
    println!("{}", json);
}

11.3.6 自定义 Deserialize 实现

在某些场景下，派生宏无法满足需求（如自定义数据格式、条件解析等），此时需要手动实现 Deserialize trait。以下是一个完整的 Duration 结构体自定义反序列化实现：

use std::fmt;
use serde::Serialize;
use serde::de::{self, Deserialize, Deserializer, Visitor, SeqAccess, MapAccess};

#[allow(dead_code)]
#[derive(Serialize)]
struct Duration {
    secs: u64,
    nanos: u32,
}

impl Duration {
    fn new(secs: u64, nanos: u32) -> Self {
        Duration{
            secs,
            nanos
        }
    }
}

impl<'de> Deserialize<'de> for Duration {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        enum Field { Secs, Nanos }

        // This part could also be generated independently by:
        //
        //    #[derive(Deserialize)]
        //    #[serde(field_identifier, rename_all = "lowercase")]
        //    enum Field { Secs, Nanos }
        impl<'de> Deserialize<'de> for Field {
            fn deserialize<D>(deserializer: D) -> Result<Field, D::Error>
            where
                D: Deserializer<'de>,
            {
                struct FieldVisitor;

                impl<'de> Visitor<'de> for FieldVisitor {
                    type Value = Field;

                    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                        formatter.write_str("`secs` or `nanos`")
                    }

                    fn visit_str<E>(self, value: &str) -> Result<Field, E>
                    where
                        E: de::Error,
                    {
                        match value {
                            "secs" => Ok(Field::Secs),
                            "nanos" => Ok(Field::Nanos),
                            _ => Err(de::Error::unknown_field(value, FIELDS)),
                        }
                    }
                }

                deserializer.deserialize_identifier(FieldVisitor)
            }
        }

        struct DurationVisitor;

        impl<'de> Visitor<'de> for DurationVisitor {
            type Value = Duration;

            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.write_str("struct Duration")
            }

            fn visit_seq<V>(self, mut seq: V) -> Result<Duration, V::Error>
            where
                V: SeqAccess<'de>,
            {
                let secs = seq.next_element()?
                    .ok_or_else(|| de::Error::invalid_length(0, &self))?;
                let nanos = seq.next_element()?
                    .ok_or_else(|| de::Error::invalid_length(1, &self))?;
                Ok(Duration::new(secs, nanos))
            }

            fn visit_map<V>(self, mut map: V) -> Result<Duration, V::Error>
            where
                V: MapAccess<'de>,
            {
                let mut secs = None;
                let mut nanos = None;
                while let Some(key) = map.next_key()? {
                    match key {
                        Field::Secs => {
                            if secs.is_some() {
                                return Err(de::Error::duplicate_field("secs"));
                            }
                            secs = Some(map.next_value()?);
                        }
                        Field::Nanos => {
                            if nanos.is_some() {
                                return Err(de::Error::duplicate_field("nanos"));
                            }
                            nanos = Some(map.next_value()?);
                        }
                    }
                }
                let secs = secs.ok_or_else(|| de::Error::missing_field("secs"))?;
                let nanos = nanos.ok_or_else(|| de::Error::missing_field("nanos"))?;
                Ok(Duration::new(secs, nanos))
            }
        }

        const FIELDS: &'static [&'static str] = &["secs", "nanos"];
        deserializer.deserialize_struct("Duration", FIELDS, DurationVisitor)
    }
}

fn main(){
    let duration = Duration::new(10u64,140_000_000u32);
    let json = serde_json::to_string_pretty(&duration).unwrap();
    println!("{}",json);
    
    if let Ok(duration2) = serde_json::from_str::<Duration>(&json){
        println!("secs:{}, nanos:{}",duration2.secs, duration2.nanos); 
    }
    
}

11.3.7 serde_json 常用 API

11.3.8 错误处理

Serde 的错误处理通过 serde_json::Error 类型实现，它提供了丰富的错误信息：

use serde::Deserialize;

#[derive(Deserialize, Debug)]
struct Config {
    name: String,
    port: u16,
}

fn main() {
    let json = r#"{"name": "test", "port": "abc"}"#;
    
    match serde_json::from_str::<Config>(json) {
        Ok(config) => println!("配置加载成功: {:?}", config),
        Err(e) => {
            eprintln!("配置解析失败: {}", e);
            // 输出详细错误分类
            if e.is_syntax() {
                eprintln!("  -> JSON 语法错误");
            } else if e.is_data() {
                eprintln!("  -> 数据类型不匹配");
            } else if e.is_eof() {
                eprintln!("  -> JSON 数据不完整");
            }
        }
    }
}

11.3.9 相关库参考

Rust 库：

• serde — Serde 框架核心
• serde_json — JSON 序列化支持
• quick-xml — XML 解析库

Java 库（对比参考）：

• FasterXML — Java 高性能 XML/JSON 处理
• jackson — Java 多格式数据处理
• hessian — 二进制 RPC 协议

FastJson小技巧——@JSONField的史上最全最详细讲解——一看就会

11.4 数据持久化

11.4.1 什么是持久化

持久化（Persistence），即把数据（如内存中的对象）保存到可永久保存的存储设备中（如磁盘）。持久化的主要应用是将内存中的对象存储在数据库中，或者存储在磁盘文件中、XML 数据文件中等等。

从信息论的角度看，持久化是将易失性存储（内存，$T_{volatile} \approx 10^{-9}$ 秒访问延迟）中的数据转移到非易失性存储（磁盘/SSD，$T_{nonvolatile} \approx 10^{-6}$ 秒访问延迟）的过程：

$$ \text{Memory Data} \xrightarrow{\text{Serialize}} \text{Byte Stream} \xrightarrow{\text{Write}} \text{Persistent Storage} $$

11.4.2 持久化方式

11.4.3 文件存储示例

文件存储是最简单的持久化方式，适合配置文件和小型数据集：

use serde::{Serialize, Deserialize};
use std::fs;

#[derive(Serialize, Deserialize, Debug)]
struct AppSettings {
    theme: String,
    language: String,
    max_connections: u32,
    auto_save: bool,
}

fn save_settings(settings: &AppSettings, path: &str) -> std::io::Result<()> {
    let json = serde_json::to_string_pretty(settings).unwrap();
    fs::write(path, json)
}

fn load_settings(path: &str) -> std::io::Result<AppSettings> {
    let json = fs::read_to_string(path)?;
    let settings: AppSettings = serde_json::from_str(&json).unwrap();
    Ok(settings)
}

fn main() {
    let settings = AppSettings {
        theme: "dark".to_string(),
        language: "zh-CN".to_string(),
        max_connections: 100,
        auto_save: true,
    };

    save_settings(&settings, "settings.json").unwrap();
    println!("配置已保存");

    let loaded = load_settings("settings.json").unwrap();
    println!("加载的配置: {:?}", loaded);
}

11.4.4 数据库存储

sea-orm 是 Rust 生态中优秀的异步 ORM 框架，基于 SQLx 构建，提供了类型安全的数据库操作接口。

以下是一个使用 SQLite 进行数据持久化的示例：

use rusqlite::{Connection, Result};
use serde::{Serialize, Deserialize};

#[derive(Debug, Serialize, Deserialize)]
struct User {
    id: Option<i64>,
    name: String,
    email: String,
    age: u32,
}

fn init_db(conn: &Connection) -> Result<()> {
    conn.execute(
        "CREATE TABLE IF NOT EXISTS users (
            id    INTEGER PRIMARY KEY AUTOINCREMENT,
            name  TEXT NOT NULL,
            email TEXT NOT NULL UNIQUE,
            age   INTEGER NOT NULL
        )",
        [],
    )?;
    Ok(())
}

fn insert_user(conn: &Connection, user: &User) -> Result<i64> {
    conn.execute(
        "INSERT INTO users (name, email, age) VALUES (?1, ?2, ?3)",
        [&user.name, &user.email, &user.age.to_string()],
    )?;
    Ok(conn.last_insert_rowid())
}

fn query_users(conn: &Connection) -> Result<Vec<User>> {
    let mut stmt = conn.prepare("SELECT id, name, email, age FROM users")?;
    let user_iter = stmt.query_map([], |row| {
        Ok(User {
            id: Some(row.get(0)?),
            name: row.get(1)?,
            email: row.get(2)?,
            age: row.get(3)?,
        })
    })?;

    let mut users = Vec::new();
    for user in user_iter {
        users.push(user?);
    }
    Ok(users)
}

fn main() -> Result<()> {
    let conn = Connection::open("users.db")?;
    init_db(&conn)?;

    let user = User {
        id: None,
        name: "张三".to_string(),
        email: "zhangsan@example.com".to_string(),
        age: 28,
    };

    let id = insert_user(&conn, &user)?;
    println!("插入用户成功，ID: {}", id);

    let users = query_users(&conn)?;
    let json = serde_json::to_string_pretty(&users).unwrap();
    println!("所有用户:\n{}", json);

    Ok(())
}

11.4.5 对象存储

对象存储是一种适合存储海量非结构化数据（图片、视频、日志文件等）的存储方案，兼容 Amazon S3 API。

• MINIO — 全球增长最快的对象存储系统
• RustFS — 世界上增长最快的分布式对象存储

#![allow(unused)]
fn main() {
// 使用 minio-rs 上传文件的简要示例
// Cargo.toml: minio = "0.2"

use minio::s3::args::*;
use minio::s3::Client;

async fn upload_file(
    client: &Client,
    bucket: &str,
    object_name: &str,
    file_path: &str,
) {
    let args = PutObjectArgs::new(bucket, object_name, file_path);
    client.put_object(args).await.unwrap();
    println!("文件 {} 上传成功", object_name);
}
}

11.5 数据可视化

11.5.1 可视化的意义

数据可视化（Data Visualization）是将数据转化为图形或图像的过程，目的是让数据“说话“，帮助人们更直观地理解数据中隐藏的模式、趋势和关联。

在数据分析中，可视化扮演着不可替代的角色：

• 趋势分析：股价走势、气温变化、降雨量统计
• 对比分析：不同产品销量对比、部门绩效对比
• 分布分析：用户年龄分布、收入分布
• 关联分析：变量之间的相关性
• 实时监控：服务器负载、系统健康度、网络流量

11.5.2 常见可视化类型

11.5.3 Rust 可视化库

Rust 生态中有多个可视化库可供选择：

11.5.4 plotters 折线图示例

plotters 是 Rust 中最流行的纯绑图库，无需外部依赖，支持多种输出格式：

use plotters::prelude::*;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let root = BitMapBackend::new("line_chart.png", (800, 600))
        .into_drawing_area();
    root.fill(&WHITE)?;
    
    // 创建绑图区域
    let mut chart = ChartBuilder::on(&root)
        .caption("月度销售额趋势", ("Microsoft YaHei", 30))
        .x_label_area_size(40)
        .y_label_area_size(60)
        .margin(10)
        .build_cartesian_2d(1u32..12u32, 0f64..100f64)?;

    chart.configure_mesh()
        .x_desc("月份")
        .y_desc("销售额（万元）")
        .draw()?;

    // 绘制折线
    let data: Vec<(u32, f64)> = vec![
        (1, 25.0), (2, 32.0), (3, 28.0), (4, 45.0),
        (5, 52.0), (6, 48.0), (7, 61.0), (8, 58.0),
        (9, 72.0), (10, 68.0), (11, 80.0), (12, 95.0),
    ];

    chart.draw_series(LineSeries::new(
        data.iter().map(|&(x, y)| (x, y)),
        &RED,
    ))?
    .legend(|(x, y)| PathElement::new(vec![(x, y), (x + 20, y)], RED));

    root.present()?;
    println!("折线图已保存为 line_chart.png");
    Ok(())
}

11.5.5 plotters 柱状图示例

use plotters::prelude::*;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let root = BitMapBackend::new("bar_chart.png", (800, 600))
        .into_drawing_area();
    root.fill(&WHITE)?;

    let mut chart = ChartBuilder::on(&root)
        .caption("各编程语言使用率", ("Microsoft YaHei", 30))
        .x_label_area_size(50)
        .y_label_area_size(60)
        .margin(10)
        .build_cartesian_2d(0usize..5usize, 0f64..40f64)?;

    chart.configure_mesh()
        .x_desc("编程语言")
        .y_desc("使用率 (%)")
        .x_labels(&["Rust", "Python", "Java", "Go", "C++"])
        .draw()?;

    let data: Vec<(usize, f64)> = vec![
        (0, 13.5), (1, 28.1), (2, 16.3), (3, 8.7), (4, 10.2),
    ];

    let colors = [RED, BLUE, GREEN, ORANGE, PURPLE];

    chart.draw_series(
        data.iter().enumerate().map(|(i, &(x, y))| {
            Rectangle::new(
                [(x, 0), (x + 1, y)],
                colors[i].filled(),
            )
        }),
    )?;

    root.present()?;
    println!("柱状图已保存为 bar_chart.png");
    Ok(())
}

11.6 数据融合

11.6.1 什么是数据融合

数据融合（Data Fusion）是一种将来自不同来源、不同格式或不同结构的数据集成到一个统一的数据模型或数据集中的过程。它不仅仅是简单的数据拼接，而是一个复杂的系统工程，涉及到数据的采集、清洗、转换、整合和存储等多个环节。

数据融合是什么？

11.6.2 ETL 流程

数据融合的核心流程是 ETL（Extract-Transform-Load）：

$$ \text{数据源} \xrightarrow{\text{Extract（抽取）}} \text{原始数据} \xrightarrow{\text{Transform（转换）}} \text{清洗后数据} \xrightarrow{\text{Load（加载）}} \text{目标系统} $$

11.6.3 数据清洗与转换

数据融合中最关键的环节是数据清洗和转换，常见操作包括：

• 去重：删除重复记录，保证数据唯一性
• 格式统一：日期格式、编码格式、数值精度的统一
• 缺失值处理：填充默认值、插值或标记为空
• 类型转换：字符串转数值、时间戳转日期等
• 数据校验：范围检查、正则匹配、业务规则验证
• 聚合计算：分组统计、滚动窗口、连接关联

use serde::{Serialize, Deserialize};
use std::collections::HashMap;

#[derive(Debug, Serialize, Deserialize, Clone)]
struct Record {
    id: String,
    name: String,
    value: f64,
    source: String,
}

/// 数据清洗：去重和格式标准化
fn deduplicate(records: Vec<Record>) -> Vec<Record> {
    let mut seen = HashMap::new();
    for record in records {
        seen.entry(record.id.clone())
            .or_insert(record);
    }
    seen.into_values().collect()
}

/// 数据转换：值域映射
fn normalize_values(records: &mut [Record], min: f64, max: f64) {
    let range = max - min;
    for record in records.iter_mut() {
        record.value = (record.value - min) / range;
    }
}

/// 数据融合：合并多个来源的数据
fn merge_sources(sources: Vec<Vec<Record>>) -> Vec<Record> {
    let all: Vec<Record> = sources.into_iter().flatten().collect();
    let mut deduped = deduplicate(all);
    if let (Some(&min_val), Some(&max_val)) = (
        deduped.iter().map(|r| r.value).reduce(f64::min),
        deduped.iter().map(|r| r.value).reduce(f64::max),
    ) {
        normalize_values(&mut deduped, min_val, max_val);
    }
    deduped
}

fn main() {
    let source_a = vec![
        Record { id: "1".into(), name: "Alpha".into(), value: 100.0, source: "A".into() },
        Record { id: "2".into(), name: "Beta".into(), value: 200.0, source: "A".into() },
    ];
    let source_b = vec![
        Record { id: "1".into(), name: "Alpha".into(), value: 100.0, source: "B".into() },
        Record { id: "3".into(), name: "Gamma".into(), value: 300.0, source: "B".into() },
    ];

    let merged = merge_sources(vec![source_a, source_b]);
    println!("融合后共 {} 条记录:", merged.len());
    for r in &merged {
        println!("  {} - {} (normalized: {:.2})", r.id, r.name, r.value);
    }
}

11.7 列式存储与 Apache Arrow

11.7.1 行式存储 vs 列式存储

传统数据库大多采用行式存储（Row-oriented Storage），即一行数据连续存储。而列式存储（Column-oriented Storage）则将每一列的数据连续存储。两种存储方式各有优劣：

11.7.2 Apache Arrow 概述

Apache Arrow 是一种基于内存的列式数据结构，它的出现就是为了解决系统到系统之间的数据传输问题。在分布式系统内部，每个系统都有自己的内存格式，大量的 CPU 资源被消耗在序列化和反序列化过程中，并且由于每个项目都有自己的实现，没有一个明确的标准，造成各个系统都在重复着复制、转换工作，这种问题在微服务系统架构出现之后更加明显，Arrow 的出现就是为了解决这一问题。

Arrow 的核心优势在于：

• 零拷贝读取：不同系统之间共享内存，无需序列化/反序列化
• 列式内存格式：天然适合向量化操作和分析查询
• 语言无关：支持 C/C++、Java、Python、Rust 等多种语言
• 标准化：统一的内存格式规范，消除格式转换开销

11.7.3 SIMD 加速

Apache Arrow 的列式内存布局天然适合 SIMD（Single Instruction, Multiple Data）指令集加速。由于同一列的数据类型相同且连续存储，CPU 可以使用一条指令同时处理多个数据元素：

设列中有 $n$ 个元素，标量处理的时间复杂度为 $O(n)$，而 SIMD 处理（假设向量宽度为 $w$）的时间复杂度为 $O(n/w)$，理论上可获得 $w$ 倍的加速比。

11.7.4 DataFusion 查询引擎

DataFusion 是基于 Apache Arrow 构建的查询引擎，用 Rust 编写，提供了 SQL 查询能力和 DataFrame API，适合构建高性能的数据分析系统。

11.7.5 Rust arrow crate 示例

以下示例展示了如何使用 Rust 的 arrow crate 创建和操作列式数据：

use arrow::array::{Float64Array, Int64Array, StringArray};
use arrow::datatypes::{DataType, Field, Schema};
use arrow::record_batch::RecordBatch;
use std::sync::Arc;

fn main() {
    // 定义 Schema
    let schema = Schema::new(vec![
        Field::new("city", DataType::Utf8, false),
        Field::new("population", DataType::Int64, false),
        Field::new("avg_temperature", DataType::Float64, false),
    ]);

    // 创建列数据
    let cities = StringArray::from(vec![
        "北京", "上海", "广州", "深圳", "杭州",
    ]);
    let populations = Int64Array::from(vec![
        21_540_000, 24_870_000, 18_680_000, 17_560_000, 12_200_000,
    ]);
    let temperatures = Float64Array::from(vec![
        12.6, 16.1, 22.0, 22.4, 16.9,
    ]);

    // 创建 RecordBatch
    let batch = RecordBatch::try_new(
        Arc::new(schema),
        vec![
            Arc::new(cities),
            Arc::new(populations),
            Arc::new(temperatures),
        ],
    ).unwrap();

    println!("RecordBatch 包含 {} 行, {} 列", batch.num_rows(), batch.num_columns());
    println!("Schema: {:?}", batch.schema());

    // 访问列数据
    let temp_col = batch
        .column(2)
        .as_any()
        .downcast_ref::<Float64Array>()
        .unwrap();
    println!("平均温度: {:?}", temp_col.values());
}

11.7.6 相关链接

• Apache Arrow
• DataFusion
• https://arrow.apache.org/

11.8 总结

序列化格式对比

持久化方案对比

Rust 数据生态全景

Rust 在数据处理领域拥有完善的生态体系：

数据获取 ──→ 数据序列化 ──→ 数据存储 ──→ 数据分析 ──→ 数据可视化
   │              │              │              │              │
   ├─ HTTP       ├─ serde       ├─ sea-orm     ├─ arrow       ├─ plotters
   ├─ gRPC       ├─ serde_json  ├─ sqlx        ├─ datafusion  ├─ plotly
   ├─ CSV        ├─ serde_yaml  ├─ redis       ├─ polars      ├─ egui
   ├─ 数据库     ├─ quick-xml   ├─ rusqlite    └─ ndarray     └─ iced
   └─ 文件       └─ toml        └─ minio

11.9 练习题

练习 1：使用 serde_json 将以下 Rust 结构体序列化为 JSON，并要求字段名使用 snake_case，同时跳过 password 字段的序列化。

#![allow(unused)]
fn main() {
struct Account {
    user_id: u64,
    username: String,
    email: String,
    password: String,
    created_at: String,
}
}

练习 2：编写一个程序，读取一个 TOML 配置文件，解析为 Rust 结构体，并打印其中的数据库连接信息。

练习 3：使用 quick-xml 解析以下 XML 数据，提取所有 <book> 标签中的 title 和 author 属性：

<library>
    <book title="Rust编程之道" author="张三"/>
    <book title="Rust实战" author="李四"/>
    <book title="Rust系统编程" author="王五"/>
</library>

练习 4：实现一个简单的 ETL 流程：从 CSV 文件中读取数据（Extract），将价格字段从字符串转换为浮点数（Transform），然后将结果保存为 JSON 文件（Load）。

练习 5：使用 rusqlite 创建一个学生信息表，包含学号、姓名、成绩三个字段，实现插入、查询、更新和删除操作。

练习 6：使用 plotters 库绘制一个散点图，展示以下数据点的分布：

#![allow(unused)]
fn main() {
let data: Vec<(f64, f64)> = vec![
    (1.0, 2.3), (2.0, 4.1), (3.0, 5.8), (4.0, 8.2),
    (5.0, 9.7), (6.0, 12.1), (7.0, 14.5), (8.0, 16.0),
];
}

练习 7：使用 arrow crate 创建一个包含 1000 个随机浮点数的列式数据集，计算其均值和标准差，并与使用普通 Vec<f64> 的计算进行性能对比。

练习 8：设计一个数据融合方案：假设你有两个数据源，一个是 JSON 格式的用户信息（包含 user_id、name），另一个是 CSV 格式的订单信息（包含 user_id、amount、date），请编写程序将两个数据源按 user_id 进行关联，生成一个包含用户名称和订单总额的汇总报告。

第十二 网络

计算机网络是现代信息社会的基石。从浏览网页到发送即时消息，从在线视频到分布式计算，网络无处不在。理解网络的基本原理，并掌握 Rust 中的网络编程技术，是开发高性能网络应用的关键。

一、网络协议分层

计算机网络通信涉及复杂的软硬件协作。为了降低复杂度，人们将网络通信的功能划分为若干层次，每一层只负责特定的任务，上层依赖下层提供的服务。

1.1 OSI 七层模型

OSI（Open Systems Interconnection，开放式系统互联）模型是国际标准化组织（ISO）提出的理论框架，将网络通信分为七个层次：

记忆口诀： “物数网传会表应”（从下到上）或 “应表会传网数物”（从上到下）。

1.2 TCP/IP 四层模型

在实际工程中，TCP/IP 协议栈更为常用，它将 OSI 的七层简化为四层：

TCP/IP 模型更加简洁实用，是互联网实际运行的标准。Rust 网络编程主要关注应用层和传输层。

1.3 数据封装过程

数据在发送时自上而下逐层封装，每一层都会添加自己的头部信息：

应用数据
↓ + HTTP 头
TCP 段
↓ + TCP 头
IP 包
↓ + IP 头
以太网帧
↓ + 帧头帧尾
比特流（物理传输）

接收端则自下而上逐层解封装，最终还原为应用数据。

二、IP 地址与端口

2.1 IP 地址

IP（Internet Protocol）地址是网络中设备的唯一标识。目前主要使用两个版本：

IPv4： 32 位地址，通常表示为四段十进制数，如 192.168.1.1。理论上有约 43 亿个地址，但由于互联网设备激增，IPv4 地址已接近枯竭。

IPv6： 128 位地址，表示为八组十六进制数，如 2001:0db8:85a3::8a2e:0370:7334。地址空间极大，足以给地球上每一粒沙子分配一个地址。

在 Rust 中，IP 地址由 std::net::IpAddr 枚举表示：

use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};

fn main() {
    // IPv4 地址
    let v4 = Ipv4Addr::new(192, 168, 1, 1);
    println!("IPv4: {}", v4);  // 192.168.1.1

    // IPv6 地址
    let v6 = Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0x1, 0x1);
    println!("IPv6: {}", v6);  // 2001:db8::1:1

    // IpAddr 枚举可以同时持有两种类型
    let addr_v4: IpAddr = v4.into();
    let addr_v6: IpAddr = v6.into();

    println!("是否是 IPv4: {}", addr_v4.is_ipv4());  // true
    println!("是否是 IPv6: {}", addr_v6.is_ipv6());  // true

    // 特殊地址
    println!("本地回环: {}", Ipv4Addr::LOCALHOST);  // 127.0.0.1
    println!("任意地址: {}", Ipv4Addr::UNSPECIFIED);  // 0.0.0.0
}

2.2 端口号

端口号（Port）用于区分同一台主机上的不同网络服务，是一个 16 位无符号整数（0~65535）。

use std::net::SocketAddrV4;

fn main() {
    // SocketAddr 包含 IP 地址和端口号
    let addr = SocketAddrV4::new(Ipv4Addr::new(127, 0, 0, 1), 8080);
    println!("服务器地址: {}", addr);  // 127.0.0.1:8080

    // 常见服务端口
    let common_ports = [
        ("HTTP", 80),
        ("HTTPS", 443),
        ("SSH", 22),
        ("FTP", 21),
        ("DNS", 53),
        ("MySQL", 3306),
        ("Redis", 6379),
    ];

    for (name, port) in &common_ports {
        println!("{} 服务默认端口: {}", name, port);
    }
}

2.3 域名与 DNS

人类更容易记住域名（如 www.example.com），而不是 IP 地址。DNS（Domain Name System）负责将域名解析为 IP 地址。

use std::net::ToSocketAddrs;

fn main() {
    // 将域名解析为 SocketAddr
    let addrs = "www.rust-lang.org:443".to_socket_addrs();

    match addrs {
        Ok(iter) => {
            for addr in iter {
                println!("解析结果: {}", addr);
            }
        }
        Err(e) => println!("解析失败: {}", e),
    }
}

三、TCP 与 UDP

传输层是网络编程的核心，提供了两种主要的传输协议：TCP 和 UDP。

3.1 TCP：传输控制协议

TCP（Transmission Control Protocol）是一种面向连接、可靠、基于字节流的传输协议。

TCP 的核心特性：

TCP 三次握手：

客户端                    服务器
   |    SYN(seq=x)    |
   | ----------------> |
   |                   |
   |  SYN(seq=y,ACK=x+1)  |
   | <---------------- |
   |                   |
   |    ACK(y+1)      |
   | ----------------> |
   |                   |
   [连接建立，开始传输数据]

适用场景： 文件传输、网页浏览、电子邮件、数据库连接等对可靠性要求高的场景。

3.2 UDP：用户数据报协议

UDP（User Datagram Protocol）是一种无连接、不可靠、基于数据报的传输协议。

UDP 的核心特性：

适用场景： 视频直播、在线游戏、DNS 查询、实时语音等对延迟敏感、可容忍少量丢包的场景。

3.3 TCP 与 UDP 对比

四、HTTP 与 HTTPS

4.1 HTTP 协议

HTTP（HyperText Transfer Protocol，超文本传输协议）是互联网上应用最广泛的协议，基于请求-响应模型。

HTTP 请求格式：

GET /index.html HTTP/1.1
Host: www.example.com
User-Agent: Mozilla/5.0
Accept: text/html

HTTP 响应格式：

HTTP/1.1 200 OK
Content-Type: text/html; charset=utf-8
Content-Length: 1234

<html>...</html>

常见 HTTP 方法：

常见 HTTP 状态码：

4.2 HTTPS 协议

HTTPS（HTTP Secure）是 HTTP 的安全版本，在 HTTP 之下加入了 TLS/SSL 加密层，解决三个核心安全问题：

HTTPS 的通信过程：

1. TCP 连接建立（三次握手）
2. TLS 握手：协商加密算法、交换密钥、验证证书
3. 加密通信：使用协商好的密钥进行对称加密传输
4. 连接关闭

本书后续章节（第四十九至五十章）将详细介绍 PKI、TLS 和数字证书的原理与实现。

五、Rust 网络编程

Rust 的标准库 std::net 提供了基础的网络编程能力，而 tokio 等异步运行时则提供了高性能的异步网络编程能力。

5.1 使用 std::net 进行 TCP 编程

TCP 服务端

use std::io::{Read, Write};
use std::net::{TcpListener, TcpStream};
use std::thread;

fn handle_client(mut stream: TcpStream) {
    let mut buffer = [0u8; 1024];

    loop {
        match stream.read(&mut buffer) {
            Ok(0) => {
                println!("客户端断开连接");
                break;
            }
            Ok(n) => {
                let received = String::from_utf8_lossy(&buffer[..n]);
                println!("收到: {}", received.trim());

                let response = format!("服务端已收到: {}", received.trim());
                if stream.write_all(response.as_bytes()).is_err() {
                    break;
                }
            }
            Err(e) => {
                println!("读取错误: {}", e);
                break;
            }
        }
    }
}

fn main() -> std::io::Result<()> {
    let listener = TcpListener::bind("127.0.0.1:7878")?;
    println!("TCP 服务端已启动，监听 127.0.0.1:7878");

    for stream in listener.incoming() {
        match stream {
            Ok(stream) => {
                println!("新客户端连接: {:?}", stream.peer_addr()?);
                thread::spawn(|| handle_client(stream));
            }
            Err(e) => println!("连接失败: {}", e),
        }
    }

    Ok(())
}

TCP 客户端

use std::io::{self, Read, Write};
use std::net::TcpStream;

fn main() -> std::io::Result<()> {
    let mut stream = TcpStream::connect("127.0.0.1:7878")?;
    println!("已连接到服务端");

    // 发送消息
    let msg = "Hello, Rust Network!\n";
    stream.write_all(msg.as_bytes())?;

    // 读取响应
    let mut buffer = [0u8; 1024];
    let n = stream.read(&mut buffer)?;
    println!("服务端响应: {}", String::from_utf8_lossy(&buffer[..n]));

    Ok(())
}

5.2 使用 std::net 进行 UDP 编程

UDP 编程不需要建立连接，直接使用 UdpSocket 发送和接收数据报。

use std::net::UdpSocket;

fn main() -> std::io::Result<()> {
    // UDP 服务端
    let socket = UdpSocket::bind("127.0.0.1:8080")?;
    println!("UDP 服务端已启动，监听 127.0.0.1:8080");

    let mut buf = [0u8; 1024];

    loop {
        // 接收数据报
        let (amt, src) = socket.recv_from(&mut buf)?;
        let received = String::from_utf8_lossy(&buf[..amt]);
        println!("来自 {} 的消息: {}", src, received.trim());

        // 发送响应
        let response = format!("已收到: {}", received.trim());
        socket.send_to(response.as_bytes(), &src)?;
    }
}

use std::net::UdpSocket;

fn main() -> std::io::Result<()> {
    // UDP 客户端
    let socket = UdpSocket::bind("127.0.0.1:0")?;  // 让系统分配端口
    println!("UDP 客户端已启动");

    let server = "127.0.0.1:8080";
    let msg = "Hello, UDP!";

    // 发送数据报
    socket.send_to(msg.as_bytes(), server)?;
    println!("已发送: {}", msg);

    // 接收响应
    let mut buf = [0u8; 1024];
    let (amt, _src) = socket.recv_from(&mut buf)?;
    println!("收到响应: {}", String::from_utf8_lossy(&buf[..amt]));

    Ok(())
}

5.3 使用 reqwest 进行 HTTP 请求

在实际开发中，我们通常使用成熟的 HTTP 客户端库。reqwest 是 Rust 生态中最流行的 HTTP 客户端库之一。

Cargo.toml 依赖：

[dependencies]
reqwest = { version = "0.11", features = ["blocking", "json"] }
tokio = { version = "1", features = ["full"] }
serde = { version = "1.0", features = ["derive"] }

异步 GET 请求：

use reqwest;
use serde::Deserialize;

#[derive(Debug, Deserialize)]
struct Post {
    userId: u32,
    id: u32,
    title: String,
    body: String,
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 发送 GET 请求
    let resp = reqwest::get("https://jsonplaceholder.typicode.com/posts/1")
        .await?
        .json::<Post>()
        .await?;

    println!("获取到的文章: {:?}", resp);

    Ok(())
}

POST 请求与自定义请求头：

use reqwest::header::{HeaderMap, HeaderValue, CONTENT_TYPE};
use serde_json::json;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = reqwest::Client::new();

    // 构建请求体
    let body = json!({
        "title": "Rust 网络编程",
        "body": "这是一篇关于 Rust 网络编程的文章",
        "userId": 1
    });

    // 发送 POST 请求
    let resp = client
        .post("https://jsonplaceholder.typicode.com/posts")
        .header(CONTENT_TYPE, "application/json")
        .json(&body)
        .send()
        .await?;

    println!("状态码: {}", resp.status());
    println!("响应体: {}", resp.text().await?);

    Ok(())
}

5.4 使用 tokio 进行异步 TCP 编程

对于高并发网络服务，异步编程是更好的选择。tokio 是 Rust 最流行的异步运行时。

Cargo.toml 依赖：

[dependencies]
tokio = { version = "1", features = ["full"] }

异步 TCP 服务端：

use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::{TcpListener, TcpStream};

async fn handle_client(mut socket: TcpStream) {
    let mut buf = [0u8; 1024];

    loop {
        match socket.read(&mut buf).await {
            Ok(0) => {
                println!("客户端断开");
                return;
            }
            Ok(n) => {
                let received = String::from_utf8_lossy(&buf[..n]);
                println!("收到: {}", received.trim());

                let response = format!("异步服务端响应: {}", received.trim());
                if socket.write_all(response.as_bytes()).await.is_err() {
                    return;
                }
            }
            Err(e) => {
                println!("读取错误: {}", e);
                return;
            }
        }
    }
}

#[tokio::main]
async fn main() -> tokio::io::Result<()> {
    let listener = TcpListener::bind("127.0.0.1:8080").await?;
    println!("异步 TCP 服务端已启动，监听 127.0.0.1:8080");

    loop {
        let (socket, addr) = listener.accept().await?;
        println!("新连接: {}", addr);

        // 每个连接生成一个独立的异步任务
        tokio::spawn(async move {
            handle_client(socket).await;
        });
    }
}

异步 TCP 客户端：

use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpStream;

#[tokio::main]
async fn main() -> tokio::io::Result<()> {
    let mut stream = TcpStream::connect("127.0.0.1:8080").await?;
    println!("已连接到服务端");

    // 异步发送
    stream.write_all(b"Hello, Async Rust!\n").await?;

    // 异步读取
    let mut buf = [0u8; 1024];
    let n = stream.read(&mut buf).await?;
    println!("收到: {}", String::from_utf8_lossy(&buf[..n]));

    Ok(())
}

5.5 简单的 HTTP 服务端

使用 hyper 库可以快速构建 HTTP 服务端：

use hyper::service::{make_service_fn, service_fn};
use hyper::{Body, Request, Response, Server};
use std::convert::Infallible;
use std::net::SocketAddr;

async fn hello(_req: Request<Body>) -> Result<Response<Body>, Infallible> {
    Ok(Response::new(Body::from("Hello, Rust HTTP Server!")))
}

#[tokio::main]
async fn main() {
    let addr = SocketAddr::from(([127, 0, 0, 1], 3000));

    let make_svc = make_service_fn(|_conn| async {
        Ok::<_, Infallible>(service_fn(hello))
    });

    let server = Server::bind(&addr).serve(make_svc);

    println!("HTTP 服务已启动: http://{}", addr);

    if let Err(e) = server.await {
        eprintln!("服务器错误: {}", e);
    }
}

六、总结

练习建议：

1. 使用 std::net::TcpListener 和 TcpStream 实现一个简单的 echo 服务端（将收到的内容原样返回）
2. 使用 reqwest 编写程序，获取并解析一个公开 API 的 JSON 数据
3. 使用 tokio 实现一个支持多客户端并发聊天的 TCP 服务端
4. 对比同步和异步 TCP 服务端在大量并发连接下的性能差异
5. 使用 UdpSocket 实现一个简单的 ping 测试工具

第十三 压缩

数据压缩是计算机科学中一项核心技术，它通过消除数据中的冗余信息来减少存储空间或传输带宽。从节省手机存储空间的照片压缩，到加速网页传输的 Gzip，再到流式媒体的音视频编码，压缩技术无处不在。本章将介绍压缩的基本原理、经典算法以及在 Rust 中的实践。

一、数据压缩原理

1.1 信息冗余与压缩

数据压缩的本质是消除冗余。冗余是指数据中存在的不必要或可预测的信息。根据信息论，如果某些信息可以通过其他信息推导出来，那么它就是冗余的。

常见的冗余类型：

压缩率的计算：

压缩率 = 压缩后大小 / 压缩前大小 × 100%
压缩比 = 压缩前大小 / 压缩后大小

例如，一个 100KB 的文件压缩后为 25KB，则压缩率为 25%，压缩比为 4:1。

1.2 熵与信息论

香农（Claude Shannon）在 1948 年提出的信息论为数据压缩奠定了理论基础。

信息熵（Entropy） 表示随机变量的不确定性，也代表了数据的最小平均编码长度：

$$H(X) = -\sum_{i=1}^{n} p(x_i) \log_2 p(x_i)$$

其中 $p(x_i)$ 是符号 $x_i$ 出现的概率。熵越大，数据的不确定性越高，可压缩的空间越小；熵越小，数据的规律性越强，可压缩的空间越大。

fn shannon_entropy(data: &[u8]) -> f64 {
    let mut freq = [0usize; 256];
    for &byte in data {
        freq[byte as usize] += 1;
    }

    let len = data.len() as f64;
    let mut entropy = 0.0;

    for &count in &freq {
        if count > 0 {
            let p = count as f64 / len;
            entropy -= p * p.log2();
        }
    }

    entropy
}

fn main() {
    // 高度规律的数据，熵低，可压缩性高
    let repetitive = b"AAAAAAAAAABBBBBBBBBB";
    println!("重复数据熵: {:.4} bits/byte", shannon_entropy(repetitive));

    // 随机数据，熵高，接近 8 bits/byte，难以压缩
    let random = [0x3F, 0xA7, 0x12, 0xE9, 0x55, 0x8C, 0x21, 0x7B];
    println!("随机数据熵: {:.4} bits/byte", shannon_entropy(&random));

    // 英文文本，熵约 4-5 bits/byte
    let text = b"Hello, World! This is a test of entropy calculation.";
    println!("英文文本熵: {:.4} bits/byte", shannon_entropy(text));
}

1.3 压缩算法的分类

二、无损压缩

无损压缩保证压缩后的数据可以完全还原为原始数据，适用于文本、程序代码、可执行文件等对数据完整性要求高的场景。

2.1 Huffman 编码

Huffman 编码是一种经典的熵编码方法，由 David Huffman 于 1952 年提出。其核心思想是：出现频率高的符号使用较短的编码，出现频率低的符号使用较长的编码。

Huffman 编码的构建过程：

1. 统计每个符号的出现频率
2. 将每个符号作为一个叶子节点，构建一个森林
3. 每次取出频率最小的两个节点，合并为一个新节点（频率为两者之和）
4. 重复步骤 3，直到只剩一棵树
5. 从根节点出发，左分支标记 0，右分支标记 1，到达叶子节点的路径即为该符号的编码

use std::collections::{BTreeMap, BinaryHeap};

#[derive(Debug, Clone)]
struct HuffmanNode {
    freq: usize,
    symbol: Option<u8>,
    left: Option<Box<HuffmanNode>>,
    right: Option<Box<HuffmanNode>>,
}

impl HuffmanNode {
    fn new_leaf(symbol: u8, freq: usize) -> Self {
        HuffmanNode {
            freq,
            symbol: Some(symbol),
            left: None,
            right: None,
        }
    }

    fn new_internal(left: HuffmanNode, right: HuffmanNode) -> Self {
        HuffmanNode {
            freq: left.freq + right.freq,
            symbol: None,
            left: Some(Box::new(left)),
            right: Some(Box::new(right)),
        }
    }
}

impl PartialEq for HuffmanNode {
    fn eq(&self, other: &Self) -> bool {
        self.freq == other.freq
    }
}

impl Eq for HuffmanNode {}

impl PartialOrd for HuffmanNode {
    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
        other.freq.partial_cmp(&self.freq)  // 最小堆
    }
}

impl Ord for HuffmanNode {
    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
        other.freq.cmp(&self.freq)
    }
}

fn build_codes(node: &HuffmanNode, prefix: String, codes: &mut BTreeMap<u8, String>) {
    if let Some(symbol) = node.symbol {
        codes.insert(symbol, if prefix.is_empty() { "0".to_string() } else { prefix });
    } else {
        if let Some(ref left) = node.left {
            build_codes(left, format!("{}0", prefix), codes);
        }
        if let Some(ref right) = node.right {
            build_codes(right, format!("{}1", prefix), codes);
        }
    }
}

fn huffman_encode(data: &[u8]) -> (BTreeMap<u8, String>, String) {
    // 统计频率
    let mut freq = [0usize; 256];
    for &byte in data {
        freq[byte as usize] += 1;
    }

    // 构建最小堆
    let mut heap = BinaryHeap::new();
    for (symbol, count) in freq.iter().enumerate() {
        if *count > 0 {
            heap.push(HuffmanNode::new_leaf(symbol as u8, *count));
        }
    }

    // 构建 Huffman 树
    while heap.len() > 1 {
        let left = heap.pop().unwrap();
        let right = heap.pop().unwrap();
        heap.push(HuffmanNode::new_internal(left, right));
    }

    // 生成编码表
    let mut codes = BTreeMap::new();
    if let Some(root) = heap.pop() {
        build_codes(&root, String::new(), &mut codes);
    }

    // 编码数据
    let mut encoded = String::new();
    for &byte in data {
        encoded.push_str(codes.get(&byte).unwrap());
    }

    (codes, encoded)
}

fn main() {
    let text = b"this is an example of a huffman tree";
    let (codes, encoded) = huffman_encode(text);

    println!("原文: {}", String::from_utf8_lossy(text));
    println!("原文长度: {} bytes", text.len());
    println!("\nHuffman 编码表:");
    for (symbol, code) in &codes {
        println!("  '{}' => {}", *symbol as char, code);
    }

    println!("\n编码后: {}", encoded);
    println!("编码后长度: {} bits = {:.2} bytes", encoded.len(), encoded.len() as f64 / 8.0);
    println!("压缩率: {:.2}%", (encoded.len() as f64 / 8.0) / text.len() as f64 * 100.0);
}

Huffman 编码的特点：

• 前缀编码：没有任何编码是其他编码的前缀，保证解码的唯一性
• 最优性：对于给定的频率分布，Huffman 编码是最优的前缀编码
• 局限性：需要预先统计频率或动态维护编码表

2.2 LZ77 算法

LZ77（Lempel-Ziv 1977）是一种基于字典的压缩算法，由 Abraham Lempel 和 Jacob Ziv 于 1977 年提出。其核心思想是：用已出现过的字符串的引用（位置和长度）来替换重复出现的字符串。

LZ77 的工作原理：

算法维护一个滑动窗口，包含已处理的数据（搜索缓冲区）和待处理的数据（前瞻缓冲区）。对于前瞻缓冲区中的数据，在搜索缓冲区中寻找最长的匹配字符串，然后用 (偏移量, 长度, 下一个字符) 的三元组替换。

滑动窗口示意：
[已处理数据（搜索缓冲区）| 待处理数据（前瞻缓冲区）]

示例：压缩 "ABABABAB"
已处理: "ABAB"
待处理: "ABAB"
在搜索缓冲区中找到 "AB" 匹配，偏移量为 2，长度为 2
输出: (2, 2, 'A')

LZ77 是后续许多压缩算法的基础，包括 DEFLATE、Gzip、ZIP 等。

2.3 DEFLATE 算法

DEFLATE 是一种结合了 LZ77 和 Huffman 编码的压缩算法，由 Phil Katz 于 1993 年设计，是 ZIP 和 Gzip 的核心算法。

DEFLATE 的两阶段压缩：

1. LZ77 阶段：使用滑动窗口查找重复的字符串，用长度-距离对替换
2. Huffman 编码阶段：对 LZ77 的输出（字面量、长度、距离）进行 Huffman 编码

DEFLATE 支持多种压缩级别，从最快（级别 1）到最优（级别 9），在速度和压缩率之间进行权衡。

三、有损压缩

有损压缩在压缩过程中会丢失部分信息，但力求丢失的是人眼或人耳不敏感的信息，从而在大幅减小文件体积的同时保持可接受的感知质量。

3.1 JPEG 图像压缩原理

JPEG（Joint Photographic Experts Group）是最广泛使用的有损图像压缩标准。

JPEG 压缩的主要步骤：

DCT 变换的核心思想：

DCT（Discrete Cosine Transform，离散余弦变换）将空间域的图像数据转换到频率域。图像的能量主要集中在低频部分，高频部分（代表细节和噪声）可以被大量量化甚至丢弃而不明显影响视觉质量。

#![allow(unused)]
fn main() {
// JPEG 质量因子与压缩率的示意
fn jpeg_compression_info() {
    let qualities = [
        (95, "极佳", "几乎无损"),
        (85, "很好", "标准质量"),
        (75, "好", "Web 常用"),
        (50, "中等", "明显压缩痕迹"),
        (25, "低", "严重失真"),
        (10, "极低", "块状伪影明显"),
    ];

    println!("JPEG 质量设置与效果对照:");
    println!("{:<10} {:<10} {:<20}", "质量因子", "效果", "说明");
    for (q, effect, desc) in &qualities {
        println!("{:<10} {:<10} {:<20}", q, effect, desc);
    }
}
}

3.2 MP3 音频压缩原理

MP3（MPEG-1 Audio Layer III）是最流行的有损音频压缩格式。

MP3 压缩的核心技术：

MP3 压缩流程：

1. 将音频信号分帧（每帧约 26ms）
2. 对每帧进行改进的离散余弦变换（MDCT）
3. 应用心理声学模型，计算每个频带的掩蔽阈值
4. 根据掩蔽阈值分配比特，量化频谱系数
5. 使用 Huffman 编码压缩量化后的系数
6. 添加帧头和辅助信息，形成 MP3 比特流

比特率与音质：

四、Rust 压缩库实践

Rust 生态提供了丰富的压缩库，可以方便地进行数据压缩和解压操作。

4.1 使用 flate2 进行 Gzip 压缩

flate2 是 Rust 中最流行的 DEFLATE 压缩库，支持 Gzip 和 Zlib 格式。

Cargo.toml 依赖：

[dependencies]
flate2 = "1.0"

Gzip 压缩与解压：

use flate2::write::{GzEncoder, GzDecoder};
use flate2::Compression;
use std::io::{self, Write};

fn gzip_compress(data: &[u8]) -> io::Result<Vec<u8>> {
    let mut encoder = GzEncoder::new(Vec::new(), Compression::default());
    encoder.write_all(data)?;
    encoder.finish()
}

fn gzip_decompress(data: &[u8]) -> io::Result<Vec<u8>> {
    let mut decoder = GzDecoder::new(Vec::new());
    decoder.write_all(data)?;
    decoder.finish()
}

fn main() -> io::Result<()> {
    let original = b"Rust is a systems programming language that runs blazingly fast, \
                      prevents segfaults, and guarantees thread safety. \
                      Rust is also a great language for web development, \
                      with frameworks like Actix and Axum providing high-performance \
                      HTTP servers. The Rust ecosystem is growing rapidly, \
                      with thousands of crates available on crates.io.";

    println!("原始数据大小: {} bytes", original.len());

    // 压缩
    let compressed = gzip_compress(original)?;
    println!("压缩后大小: {} bytes", compressed.len());
    println!("压缩率: {:.2}%", compressed.len() as f64 / original.len() as f64 * 100.0);

    // 解压
    let decompressed = gzip_decompress(&compressed)?;
    println!("解压后大小: {} bytes", decompressed.len());
    println!("数据一致性: {}", original.to_vec() == decompressed);

    // 不同压缩级别对比
    println!("\n不同压缩级别对比:");
    for level in [Compression::none(), Compression::fast(), Compression::default(), Compression::best()] {
        let mut encoder = GzEncoder::new(Vec::new(), level);
        encoder.write_all(original)?;
        let result = encoder.finish()?;
        println!("级别 {:?}: {} bytes", level.level(), result.len());
    }

    Ok(())
}

使用 BufReader/BufWriter 进行流式压缩：

#![allow(unused)]
fn main() {
use flate2::read::GzDecoder;
use flate2::write::GzEncoder;
use flate2::Compression;
use std::fs::File;
use std::io::{self, BufReader, BufWriter, Read, Write};

fn compress_file(input_path: &str, output_path: &str) -> io::Result<()> {
    let input = File::open(input_path)?;
    let output = File::create(output_path)?;

    let mut reader = BufReader::new(input);
    let mut encoder = GzEncoder::new(BufWriter::new(output), Compression::default());

    let mut buffer = [0u8; 8192];
    loop {
        let n = reader.read(&mut buffer)?;
        if n == 0 {
            break;
        }
        encoder.write_all(&buffer[..n])?;
    }

    encoder.finish()?;
    Ok(())
}

fn decompress_file(input_path: &str, output_path: &str) -> io::Result<()> {
    let input = File::open(input_path)?;
    let output = File::create(output_path)?;

    let mut decoder = GzDecoder::new(BufReader::new(input));
    let mut writer = BufWriter::new(output);

    let mut buffer = [0u8; 8192];
    loop {
        let n = decoder.read(&mut buffer)?;
        if n == 0 {
            break;
        }
        writer.write_all(&buffer[..n])?;
    }

    writer.flush()?;
    Ok(())
}
}

4.2 使用 zip 库处理 ZIP 文件

zip 库提供了在 Rust 中创建和读取 ZIP 压缩文件的能力。

Cargo.toml 依赖：

[dependencies]
zip = "0.6"

创建 ZIP 压缩文件：

use std::fs::File;
use std::io::{self, Read, Write};
use zip::write::FileOptions;
use zip::CompressionMethod;

fn create_zip_archive(output_path: &str, files: &[(&str, &[u8])]) -> io::Result<()> {
    let file = File::create(output_path)?;
    let mut zip = zip::ZipWriter::new(file);

    let options = FileOptions::default()
        .compression_method(CompressionMethod::Deflated)
        .unix_permissions(0o755);

    for (name, content) in files {
        zip.start_file(*name, options)?;
        zip.write_all(content)?;
    }

    zip.finish()?;
    println!("ZIP 文件已创建: {}", output_path);
    Ok(())
}

fn main() -> io::Result<()> {
    let files = [
        ("readme.txt", b"This is a README file.\n" as &[u8]),
        ("data.json", b"{\"name\": \"Rust\", \"version\": \"1.70\"}\n" as &[u8]),
        ("hello.rs", b"fn main() { println!(\"Hello, Rust!\"); }\n" as &[u8]),
    ];

    create_zip_archive("archive.zip", &files)?;

    Ok(())
}

读取 ZIP 压缩文件：

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

fn read_zip_archive(path: &str) -> io::Result<()> {
    let file = File::open(path)?;
    let mut archive = ZipArchive::new(file)?;

    println!("ZIP 文件包含 {} 个条目:", archive.len());
    println!("{:<20} {:<10} {:<10}", "文件名", "压缩后", "原始大小");
    println!("{}", "-".repeat(45));

    for i in 0..archive.len() {
        let mut file = archive.by_index(i)?;
        let name = file.name();
        let compressed = file.compressed_size();
        let size = file.size();

        println!("{:<20} {:<10} {:<10}", name, compressed, size);

        // 读取文件内容
        let mut contents = String::new();
        file.read_to_string(&mut contents)?;
        println!("  内容预览: {}", &contents[..contents.len().min(50)]);
    }

    Ok(())
}

fn main() -> io::Result<()> {
    read_zip_archive("archive.zip")?;
    Ok(())
}

4.3 压缩算法选择指南

在实际项目中，应根据数据类型和需求选择合适的压缩方案：

不同压缩算法的对比：

#![allow(unused)]
fn main() {
fn compression_comparison() {
    let algorithms = [
        ("Gzip (flate2)", "通用，兼容性好", "中等", "高"),
        ("LZ4", "极速压缩解压", "低", "很高"),
        ("Zstd", "Facebook 开发，压缩率和速度均衡", "高", "高"),
        ("LZMA/XZ", "极高压缩率", "很高", "中等"),
        ("Brotli", "Google 开发，Web 优化", "高", "高"),
    ];

    println!("{:<15} {:<30} {:<10} {:<10}", "算法", "特点", "压缩率", "速度");
    println!("{}", "-".repeat(70));
    for (name, feature, ratio, speed) in &algorithms {
        println!("{:<15} {:<30} {:<10} {:<10}", name, feature, ratio, speed);
    }
}
}

4.4 内存中的压缩与解压示例

use flate2::{read::ZlibDecoder, write::ZlibEncoder, Compression};
use std::io::{self, Read, Write};

fn zlib_roundtrip(data: &[u8]) -> io::Result<bool> {
    // 压缩
    let mut encoder = ZlibEncoder::new(Vec::new(), Compression::default());
    encoder.write_all(data)?;
    let compressed = encoder.finish()?;

    // 解压
    let mut decoder = ZlibDecoder::new(&compressed[..]);
    let mut decompressed = Vec::new();
    decoder.read_to_end(&mut decompressed)?;

    Ok(data == decompressed.as_slice())
}

fn main() -> io::Result<()> {
    let test_data = [
        b"Short text".to_vec(),
        vec![0u8; 1000],           // 全零数据（高度可压缩）
        (0..=255).collect(),       // 均匀分布数据（难以压缩）
        "Rust ".repeat(100).into_bytes(),  // 重复数据
    ];

    for (i, data) in test_data.iter().enumerate() {
        let mut encoder = ZlibEncoder::new(Vec::new(), Compression::default());
        encoder.write_all(data)?;
        let compressed = encoder.finish()?;

        let ratio = compressed.len() as f64 / data.len() as f64;
        let ok = zlib_roundtrip(data)?;

        println!(
            "测试 {}: 原始 {} bytes, 压缩后 {} bytes, 比率 {:.2}%, 一致性 {}",
            i + 1,
            data.len(),
            compressed.len(),
            ratio * 100.0,
            ok
        );
    }

    Ok(())
}

五、总结

练习建议：

1. 实现一个简单的 Run-Length Encoding（RLE，游程编码）算法，测试其对不同类型数据的压缩效果
2. 使用 flate2 编写一个命令行工具，支持对文件进行 Gzip 压缩和解压（类似 gzip 命令）
3. 对比 flate2 的不同压缩级别（none/fast/default/best）在速度和压缩率上的表现
4. 使用 zip 库编写一个程序，递归地将一个目录打包为 ZIP 文件
5. 统计一段文本中各字符的出现频率，计算其信息熵，并与 Huffman 编码后的平均码长进行比较
6. 尝试用 reqwest 下载一个网页，并用 flate2 压缩其 HTML 内容，观察压缩率

中卷 运算与算法

“算法是计算机的灵魂，数学是算法的灵魂。”

中卷概述

如果说上卷“基础与类型“为我们搭建了Rust编程的基石，那么中卷“运算与算法“将带领我们进入计算机科学的核心地带——运算与算法的世界。从最简单的加减乘除到复杂的神经网络训练，从基本的位操作到高深的Lambda演算，运算与算法贯穿了编程的方方面面。

计算机的本质就是一台运算机器。无论是处理用户输入、渲染图形界面，还是训练人工智能模型、加密敏感数据，背后都离不开各种各样的运算和算法。理解运算的原理和算法的思想，是每一位程序员从“会写代码“迈向“写好代码“的关键一步。

本卷将从最基础的运算符出发，逐步深入到数据变换、数据处理、函数式编程、人工智能和数学运算等多个维度，全面展现Rust在运算与算法领域的强大能力和优雅表达。

从基本运算到复杂算法

基本运算：算术、关系、逻辑、位运算（第十四~十七章）

Rust的运算符分为四大类，它们是构成一切复杂运算的基础：

• 算术运算符：+ - * / % 。Rust不支持++ --运算符，可以使用+=1 -=1替代。算术运算是所有计算的起点，从简单的计数到复杂的科学计算，都离不开这些基本操作。
• 关系运算符：== != > >= < <= 。关系运算用于比较两个值的大小或相等性，是条件判断和排序算法的基石。
• 逻辑运算符：&& || ! ^ & | 。逻辑运算处理布尔值，用于组合多个条件，构建复杂的业务规则。
• 位运算符：& &= | |= ~ ^ ^= >> << 。位运算直接操作二进制位，在系统编程、图形处理、密码学等领域有着不可替代的作用。

这四类运算符看似简单，却是构建一切复杂逻辑的砖瓦。在Rust中，这些运算符不仅可以用于基本类型，还可以通过运算符重载（std::ops trait）扩展到自定义类型，体现了Rust“零成本抽象“的设计理念。

数据变换：交换、反转、旋转、类型转换（第十八~十九章）

数据在程序中的流动往往需要进行各种变换。交换两个变量的值、反转一个序列、旋转数组元素、在不同类型之间进行转换——这些看似简单的操作，却蕴含着丰富的编程技巧。

Rust的所有权系统和类型安全为数据变换提供了独特的视角。如何在遵守所有权规则的前提下高效地交换数据？如何利用类型转换实现安全的数值计算？这些问题将在本部分得到深入探讨。

数据处理：哈希、压缩、查询、排序（第二十~二十三章）

当数据量增大时，如何高效地处理数据成为关键问题。哈希算法提供了O(1)时间复杂度的数据查找能力；压缩算法帮助我们节省存储空间和传输带宽；查询与搜索算法让我们从海量数据中快速定位所需信息；排序算法则是数据处理中最基础也是最重要的操作之一。

Rust的标准库和生态系统为这些操作提供了丰富的工具：从std::collections::HashMap到flate2压缩库，从线性搜索到二分查找，从冒泡排序到快速排序，我们将看到如何用Rust优雅而高效地实现这些经典算法。

函数式编程：Lambda演算（第二十四章）

Lambda演算是函数式编程的理论基础，由阿隆佐·邱奇（Alonzo Church）于1930年代提出。它用一种极其简洁的方式定义了“计算“的本质——函数的应用和抽象。

Rust虽然不是纯函数式语言，但它深受函数式编程思想的影响：闭包（closure）、迭代器（iterator）、高阶函数（higher-order function）等特性让Rust具备了强大的函数式编程能力。理解Lambda演算，将帮助我们更深入地理解Rust中这些特性的设计原理。

人工智能：AI基础、神经网络、NLP、CV、RL、生成式AI（第二十五、三十六~四十章）

人工智能是当今最热门的技术领域之一，而Rust凭借其高性能和内存安全特性，正在AI基础设施领域崭露头角。

从神经网络的前向传播和反向传播，到自然语言处理中的词嵌入和Transformer模型；从计算机视觉中的卷积神经网络到强化学习中的策略优化；再到生成式AI中的扩散模型和大语言模型——本部分将展示如何用Rust实现和部署这些前沿AI技术。

数学运算：算法、代数、几何、行列式、矩阵、向量、函数、微积分、概率论、离散数学（第二十六~三十五章）

数学是计算机科学的基石。算法分析需要大O表示法和概率论；图形渲染需要线性代数和几何知识；机器学习需要微积分和统计学；密码学需要数论和离散数学。

本部分将系统地介绍这些数学领域在编程中的应用，并用Rust实现相关的计算。从求解方程组到计算矩阵特征值，从向量空间到概率分布，从函数的导数到积分的数值计算——我们将看到数学与编程如何完美结合。

中卷各章节内容预览

数学与编程的关系

数学与编程之间有着深刻而紧密的联系。从某种意义上说，编程就是数学的一种实践形式，而数学则为编程提供了理论基础。

算法分析需要数学。当我们评估一个算法的效率时，需要使用大O表示法来描述其时间复杂度和空间复杂度。概率论帮助我们理解随机算法的期望性能，摊还分析让我们更准确地评估数据结构的操作成本。

数据结构建立在数学之上。哈希表利用数论中的模运算；图算法基于图论；树结构源于组合数学；并查集利用等价关系的数学性质。

机器学习是应用数学。神经网络的前向传播是矩阵乘法，反向传播是链式法则（微积分）的应用，优化算法基于梯度下降（微积分），正则化技术源于统计学的偏差-方差权衡。

密码学是数论的应用。RSA算法基于大整数分解的困难性；椭圆曲线密码利用代数几何；零知识证明依赖于计算复杂性理论。

Rust语言的设计也深受数学思想的影响。其类型系统可以看作是一种形式化逻辑系统；所有权模型借鉴了线性类型的数学理论；泛型编程体现了抽象代数的思想。理解这些数学背景，将帮助我们写出更加优雅和安全的Rust代码。

中卷知识图谱

                    运算与算法
                       |
        +--------------+--------------+--------------+
        |              |              |              |
    基本运算       数据变换       数据处理       高阶主题
        |              |              |              |
   +----+----+    +----+----+    +----+----+    +----+----+
   |    |    |    |    |    |    |    |    |    |    |    |
  算术 关系 逻辑 位运算 交换 反转 旋转 类型转换 哈希 压缩 查询 排序 Lambda  AI   数学
   |    |    |    |              |              |              |
  第十四 第十五 第十六 第十七    第十八~十九    第二十~二十三   第二十四~四十
                                    |              |
                              +-----+-----+  +-----+-----+
                              |           |  |           |
                            人工智能      数学运算      算法基础
                              |           |
                        第二十五,三十六~四十  第二十六~三十五

阅读建议

1. 循序渐进：本卷内容从基础到高级逐步深入。建议先掌握第十四~十七章的基本运算，再学习后续章节。对于数学基础较弱的读者，可以先跳过第二十六~三十五章的数学内容，待需要时再回头学习。

2. 理论与实践结合：每个算法和运算都配有Rust代码示例。建议读者在阅读的同时动手实践，修改参数、观察输出，以加深理解。

3. 关注性能：Rust的核心优势之一是性能。在学习算法时，不仅要关注正确性，还要思考如何用Rust的特性（如零成本抽象、内存安全）来实现高效的实现。

4. 建立联系：运算与算法不是孤立的知识点。尝试将不同章节的内容联系起来——比如，位运算如何加速某些算法？概率论如何优化搜索策略？矩阵运算如何应用于神经网络？

5. 拓展阅读：本卷涉及的数学内容较为广泛，如需深入学习某个领域，建议参考相关的数学教材和专业书籍。

复杂运算拓展

在掌握基本运算之后，我们还需要了解更复杂的数学运算：

• 模运算：模运算在密码学、哈希算法、循环队列等场景中有广泛应用。理解模运算的性质对于编写正确的算法至关重要。
• 三角函数：三角函数在图形学、信号处理、物理模拟等领域不可或缺。Rust的标准库提供了完整的三角函数支持。

愿你在运算与算法的世界中，发现数学之美，体验编程之乐！

第十四 算数运算

算数运算符

use std::f64::consts::{PI, E,FRAC_PI_2, SQRT_2};
fn main() {
    let x = 11;
    let y = 2;
    let z = -31;
    let r : f64 = 2.0;
    println!("{}", x + y); 
    println!("{}", x - y); 
    println!("{}", x * y); 
    println!("{}", x / y); 
    println!("{}", x % y); 
    println!("{}", z % x); 
    println!("{}", PI * r.powi(2));
    println!("{}", f64::sin(FRAC_PI_2));
    println!("{}", SQRT_2);
    println!("{}", 4096_f64.log2());
    println!("{}", 4096_f64.log10());
    //高考真题: a = 0.1e^0.1 , b = 1/9 , c = -ln(0.9)，求三者的大小关系
    //正确答案：c < a < b
    println!("{}", 0.1 * E.powf(0.1));
    println!("{}", 1.0_f64 / 9.0_f64);
    println!("{}", -(0.9_f64).ln());
}

模运算的性质

$$ (a + b)\mod n = ((a\mod n) + (b\mod n)) \mod n $$ $$ (a - b)\mod n = ((a\mod n) - (b\mod n)) \mod n $$ $$ (a * b)\mod n = ((a\mod n) * (b\mod n)) \mod n $$

三角函数，反三角函数

use std::f64::consts::PI;

fn main() {
    // 弧度
    let x: f64 = PI / 2.0;
    println!("{}", f64::sin(PI)); 
    println!("{}", x.sin()); 
    println!("{}", x.cos()); 
    println!("{}", x.tan());
    println!("{}", (PI / 4.0).tan());
    // 计算 30 度 (π/6 弧度) 的正弦值
    let angle_deg = 30.0_f64;
    // 转换为弧度
    let angle_rad = angle_deg.to_radians(); 
    let sin_val = angle_rad.sin();
    println!("sin(30°) = {}", sin_val);
    println!("sin(60°) = {}", 60.0_f64.to_radians().sin());

    // 验证 tan(x) 是否等于 sin(x) / cos(x)
    let x = 6.0_f64;
    let tan_direct = x.tan();
    let tan_computed = x.sin() / x.cos();
    println!("tan(6°) = {}", tan_direct);
    println!("sin(6°)/cos(6°) = {}", tan_computed);

    //勾三股四弦五，求勾所对应的角度是多少？
    //sin(x) = 3/5，求对应的角度x
    let x = 0.6_f64;
    let theta = x.asin();
    let theta_deg = theta * 180.0 / PI;
    println!("弧度 = {} ，角度 = {}", theta, theta_deg);
}

20以内所有阶乘

fn factorial_checked(n: u64) -> Option<u64> {
    (2..=n).try_fold(1u64, |acc: u64, x: u64| {
        let acc = acc.checked_mul(x)?;
        Some(acc)
    })
}

fn main() {
    // 使用示例
    for i in 2..=20 {
            match factorial_checked(i) {
                Some(result) => println!("{}! = {}", i, result),
                None => println!("计算溢出"),
            }
    }
}

例子

高考真题: a = 0.1e^0.1 , b = 1/9 , c = -ln(0.9)，求三者的大小关系
正确答案：c < a < b

求证：$$\boldsymbol{-\ln(1-x) < x e^x < \frac{x}{1-x},\quad x\to0^+,;0<x<1}$$

分两段证明：$$\boldsymbol{-\ln(1-x)<xe^x}$$、$$\boldsymbol{xe^x<\dfrac{x}{1-x}}$$。

一、先证右侧：$$\boldsymbol{xe^x < \dfrac{x}{1-x}\ (0<x<1)}$$

$x>0$，两边同除以$x$等价于： $$e^x < \frac1{1-x}\iff e^x(1-x)<1$$ 设 $$F(x)=e^x(1-x)-1,\quad F(0)=e^0\cdot1-1=0$$ 求导： $$F’(x)=e^x(1-x)-e^x=-x e^x<0,\quad x>0$$ $F(x)$在$x>0$严格递减$$\Rightarrow F(x)<F(0)=0$$，即 $$e^x(1-x)<1\Rightarrow e^x<\frac1{1-x}\Rightarrow xe^x<\frac{x}{1-x}.$$ ✅ 右半不等式成立。

二、再证左侧：$$\boldsymbol{-\ln(1-x)<xe^x\ (0<x<1)}$$

变形： $$xe^x+\ln(1-x)>0$$ 构造 $$G(x)=xe^x+\ln(1-x),\quad G(0)=0+\ln1=0$$ 求一阶导： $$G’(x)=e^x+xe^x-\frac1{1-x}=e^x(1+x)-\frac1{1-x} $$ $$ G’(0)=1\cdot1-1=0 $$

再求二阶导： $$ \begin{aligned} G’‘(x)&=e^x(1+x)+e^x-\frac1{(1-x)^2}\ &=e^x(x+2)-\frac1{(1-x)^2} \end{aligned} $$ $$G’’(0)=2-1=1>0$$。

由**泰勒展开（$x\to0^+$）**辅助验证： $$ \begin{aligned} -\ln(1-x)&=x+\frac{x^2}{2}+\frac{x^3}{3}+\frac{x^4}{4}+\cdots\ \end{aligned} $$

$$ \begin{aligned} xe^x&=x\left(1+x+\frac{x^2}{2}+\frac{x^3}{6}+\cdots\right)=x+x^2+\frac{x^3}{2}+\frac{x^4}{6}+\cdots \end{aligned} $$

逐项比较： $$ \begin{cases} x=x\ , \dfrac12x^2<x^2\ , \dfrac13x^3<\dfrac12x^3\ , \cdots \end{cases} $$ 故小正数x：$$-\ln(1-x)<xe^x$$。

从导数单调性：$$G’(0)=0,G’‘(0)>0\Rightarrow x\to0^+$$ 时$G’(x)>0$，$$G(x)\nearrow \Rightarrow G(x)>G(0)=0$$， $$xe^x+\ln(1-x)>0\iff -\ln(1-x)<xe^x.$$ ✅ 左半不等式成立。

三、合并结论

$$\boldsymbol{-\ln(1-x) < x e^x < \frac{x}{1-x},\quad x\to0^+,;0<x<1}$$

补充：三者等价无穷小（ $$x \to 0^+ $$）

$$-\ln(1-x)\sim x,\quad xe^x\sim x,\quad \frac{x}{1-x}\sim x$$ 三者是同阶等价无穷小，只是从低到高：$$-\ln(1-x)<xe^x<\tfrac{x}{1-x}$$。

第十五 关系运算

关系运算（Relational Operation）用于比较两个值之间的大小关系，返回一个布尔值（true 或 false）。它是条件判断和程序控制流的基础，也是排序、搜索等算法的核心操作。

一、Rust 中的关系运算符

1.1 六种关系运算符

Rust 提供了六种关系运算符，用于比较两个值的大小关系：

fn main() {
    let a = 10;
    let b = 20;

    println!("a == b: {}", a == b);  // false
    println!("a != b: {}", a != b);  // true
    println!("a > b:  {}", a > b);   // false
    println!("a >= b: {}", a >= b);  // false
    println!("a < b:  {}", a < b);   // true
    println!("a <= b: {}", a <= b);  // true
}

1.2 关系运算的优先级

关系运算符的优先级低于算术运算符，高于逻辑运算符：

算术运算符（+ - * / %）> 关系运算符（> >= < <= == !=）> 逻辑运算符（&& ||）

fn main() {
    let x = 3 + 5;       // 先算术：x = 8
    let result = x > 5 && x < 15;  // 再关系：8 > 5 为 true，8 < 15 为 true
    println!("{}", result);  // true

    // 等价于：
    let result2 = (3 + 5) > 5 && (3 + 5) < 15;
    println!("{}", result2);  // true
}

1.3 关系运算符的返回类型

关系运算符的返回值始终是 bool 类型：

fn main() {
    let is_equal: bool = 10 == 10;
    let is_greater: bool = 10 > 5;

    println!("is_equal = {}", is_equal);    // true
    println!("is_greater = {}", is_greater); // true

    // bool 类型可以参与逻辑运算
    let combined = is_equal && is_greater;
    println!("combined = {}", combined);   // true
}

二、PartialOrd 与 Ord Trait

2.1 为什么需要 PartialOrd

在 Rust 的类型系统中，并非所有类型都能进行完整的比较。例如，浮点数中存在 NaN（Not a Number），NaN 与任何值的比较都没有意义。因此，Rust 将比较能力分为两个层次：

2.2 PartialOrd Trait

PartialOrd 定义了 partial_cmp 方法，它返回 Option<Ordering>，而不是直接返回 Ordering：

use std::cmp::Ordering;

fn main() {
    let a = 3.14;
    let b = 2.71;

    // partial_cmp 返回 Option<Ordering>
    match a.partial_cmp(&b) {
        Some(Ordering::Less) => println!("{} < {}", a, b),
        Some(Ordering::Equal) => println!("{} == {}", a, b),
        Some(Ordering::Greater) => println!("{} > {}", a, b),
        None => println!("无法比较"),
    }
}

Ordering 枚举的三种取值：

2.3 NaN 的比较问题

NaN 是 PartialOrd 但不是 Ord 的典型例子：

use std::cmp::Ordering;

fn main() {
    let nan = f64::NAN;

    // NaN 与任何值的比较都返回 None
    println!("NaN > 1.0: {:?}", nan.partial_cmp(&1.0));   // None
    println!("NaN < 1.0: {:?}", nan.partial_cmp(&1.0));   // None
    println!("NaN == NaN: {:?}", nan.partial_cmp(&nan));  // None

    // 使用 == 运算符，NaN != NaN 也是 true
    println!("NaN == NaN: {}", nan == nan);  // false
    println!("NaN != NaN: {}", nan != nan);  // true

    // 这就是为什么浮点数只实现了 PartialOrd，没有实现 Ord
}

重要： NaN 是唯一一个“不等于自身“的值，即 NaN != NaN 为 true。这是 IEEE 754 浮点数标准的规定。

2.4 Ord Trait

Ord trait 表示完全有序，任意两个值之间一定有确定的大小关系。它定义了 cmp 方法，返回 Ordering（不是 Option<Ordering>）：

use std::cmp::Ordering;

fn main() {
    let a = 42;
    let b = 17;

    // cmp 返回 Ordering（不是 Option）
    match a.cmp(&b) {
        Ordering::Less => println!("{} < {}", a, b),
        Ordering::Equal => println!("{} == {}", a, b),
        Ordering::Greater => println!("{} > {}", a, b),
    }
}

实现了 Ord 的常用类型：

2.5 为自定义类型实现 Ord

use std::cmp::Ordering;

#[derive(Debug)]
struct Student {
    name: String,
    score: u32,
}

// 实现 PartialOrd
impl PartialOrd for Student {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        Some(self.score.cmp(&other.score))
    }
}

// 实现 PartialEq（Ord 的前提）
impl PartialEq for Student {
    fn eq(&self, other: &Self) -> bool {
        self.score == other.score
    }
}

// 实现 Ord
impl Ord for Student {
    fn cmp(&self, other: &Self) -> Ordering {
        self.score.cmp(&other.score)
    }
}

fn main() {
    let alice = Student { name: "Alice".into(), score: 95 };
    let bob = Student { name: "Bob".into(), score: 87 };

    println!("Alice vs Bob: {:?}", alice.cmp(&bob));  // Greater

    // 可以直接排序
    let mut students = vec![
        Student { name: "Charlie".into(), score: 72 },
        Student { name: "Alice".into(), score: 95 },
        Student { name: "Bob".into(), score: 87 },
    ];
    students.sort();
    for s in &students {
        println!("{}: {}", s.name, s.score);
    }
    // Charlie: 72
    // Bob: 87
    // Alice: 95
}

提示： 在实际开发中，通常使用 #[derive(PartialEq, PartialOrd, Eq, Ord)] 自动派生，前提是所有字段都实现了 Ord。

三、浮点数比较的陷阱

3.1 浮点数精度问题

浮点数在计算机中采用 IEEE 754 标准存储，存在精度限制。许多看似简单的十进制小数无法精确表示为二进制浮点数：

fn main() {
    // 0.1 + 0.2 在数学上等于 0.3
    // 但在浮点数中并不相等！
    let sum = 0.1_f64 + 0.2_f64;
    println!("0.1 + 0.2 = {:.20}", sum);       // 0.30000000000000004441
    println!("sum == 0.3: {}", sum == 0.3_f64); // false
}

原因： 0.1 在二进制中是一个无限循环小数（类似十进制中的 1/3 = 0.333…），因此无法精确存储。

3.2 正确的浮点数比较方法

方法一：使用误差范围（epsilon）

fn approx_equal(a: f64, b: f64, epsilon: f64) -> bool {
    (a - b).abs() < epsilon
}

fn main() {
    let a = 0.1_f64 + 0.2_f64;
    let b = 0.3_f64;

    println!("直接比较: a == b → {}", a == b);                          // false
    println!("误差比较: approx_equal(a, b, 1e-10) → {}", approx_equal(a, b, 1e-10)); // true
}

方法二：使用相对误差

当数值很大时，固定误差范围可能不够用，此时应使用相对误差：

fn approx_equal_relative(a: f64, b: f64, max_relative_error: f64) -> bool {
    let abs_diff = (a - b).abs();
    let largest = a.abs().max(b.abs());

    // 处理两个值都接近 0 的情况
    if largest < 1e-10 {
        abs_diff < 1e-10
    } else {
        abs_diff / largest < max_relative_error
    }
}

fn main() {
    let a = 1000000.00001_f64;
    let b = 1000000.00002_f64;

    println!("相对误差比较: {}", approx_equal_relative(a, b, 1e-10)); // true
}

方法三：使用 assert_approx_eq 宏（测试中常用）

// 简单的近似相等断言宏
macro_rules! assert_approx_eq {
    ($a:expr, $b:expr, $eps:expr) => {
        let a = $a as f64;
        let b = $b as f64;
        let diff = (a - b).abs();
        assert!(
            diff < $eps,
            "断言失败: |{} - {}| = {} >= {}",
            a, b, diff, $eps
        );
    };
}

fn main() {
    let result = 0.1_f64 + 0.2_f64;
    assert_approx_eq!(result, 0.3, 1e-10);
    println!("测试通过！");
}

3.3 浮点数排序中的 NaN 处理

由于 NaN 无法参与正常比较，排序时需要特殊处理：

use std::cmp::Ordering;

fn main() {
    let mut data = vec![3.5, f64::NAN, 1.2, f64::NAN, 2.8, 0.5];

    // 方法一：分离 NaN 后排序
    let mut numbers: Vec<f64> = data.iter().cloned().filter(|&x| !x.is_nan()).collect();
    let nans: Vec<f64> = data.iter().cloned().filter(|&x| x.is_nan()).collect();

    numbers.sort_by(|a, b| a.partial_cmp(b).unwrap_or(Ordering::Equal));

    let sorted = [numbers, nans].concat();
    println!("排序结果: {:?}", sorted);
    // [0.5, 1.2, 2.8, 3.5, NaN, NaN]

    // 方法二：使用 total_cmp（Rust 1.62+，将 NaN 排在最后）
    let mut data2 = vec![3.5, f64::NAN, 1.2, f64::NAN, 2.8, 0.5];
    data2.sort_by(f64::total_cmp);
    println!("total_cmp 排序: {:?}", data2);
    // [0.5, 1.2, 2.8, 3.5, NaN, NaN]
}

提示： Rust 1.62 引入了 f64::total_cmp 和 f32::total_cmp，提供了浮点数的完全有序比较，NaN 被视为大于所有非 NaN 值。

3.4 特殊浮点值的比较

fn main() {
    let inf = f64::INFINITY;
    let neg_inf = f64::NEG_INFINITY;
    let nan = f64::NAN;

    // 正无穷
    println!("INFINITY > 1000: {}", inf > 1000.0);        // true
    println!("INFINITY == INFINITY: {}", inf == inf);      // true

    // 负无穷
    println!("NEG_INFINITY < -1000: {}", neg_inf < -1000.0); // true

    // NaN 的特殊性
    println!("NaN > 0:   {}", nan > 0.0);    // false
    println!("NaN < 0:   {}", nan < 0.0);    // false
    println!("NaN == 0:  {}", nan == 0.0);   // false
    println!("NaN != NaN: {}", nan != nan);   // true（唯一不等于自身的值）

    // 判断是否为特殊值
    println!("NaN.is_nan(): {}", nan.is_nan());             // true
    println!("INFINITY.is_infinite(): {}", inf.is_infinite()); // true
    println!("0.0.is_finite(): {}", 0.0_f64.is_finite());   // true
}

四、不同类型的比较

4.1 整数比较

整数比较是精确的，不存在精度问题：

fn main() {
    let a: i32 = 42;
    let b: i32 = -17;

    println!("a > b:  {}", a > b);   // true
    println!("a == b: {}", a == b);  // false

    // 不同大小的整数可以比较（Rust 会自动转换）
    let small: u8 = 10;
    let large: i32 = 100;
    // println!("{}", small > large);  // 错误！类型不同不能直接比较

    // 需要显式转换
    println!("{}", (small as i32) > large);  // false
}

4.2 字符比较

字符按 Unicode 码点进行比较：

fn main() {
    let a = 'A';
    let b = 'a';
    let c = '中';

    println!("'A' < 'a': {}", a < b);  // true（大写字母的码点小于小写字母）
    println!("'A' 码点: {}", a as u32);  // 65
    println!("'a' 码点: {}", b as u32);  // 97
    println!("'中' 码点: {}", c as u32);  // 20013

    // 字符可以排序
    let mut chars = vec!['z', 'A', '中', 'a', '0'];
    chars.sort();
    println!("排序结果: {:?}", chars);
    // ['0', 'A', 'a', 'z', '中']
}