AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

Rust 笔记：有限状态机原理/状态模式 及其 在Rust 编程中的应用

2024-01-29 284
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
云解析 DNS，旗舰版 1个月
全局流量管理 GTM，标准版 1个月
公共DNS（含HTTPDNS解析），每月1000万次HTTP解析
简介： Rust 笔记：有限状态机原理/状态模式 及其 在Rust 编程中的应用

Rust 笔记、设计模式有限状态机原理及其在Rust 编程中的应用

1. 概述

1.1 有限状态机简介

有限状态机（Finite State Machine，简称为 FSM）是一种抽象的计算模型，是一个来源于离散数学中的思想，它用于描述系统或对象在不同状态之间转换的行为。

它由一组状态、转移条件 和 动作 组成。其中：

  • 状态：表示系统或对象所处的特定情况；
  • 转移条件：定义了从一个状态到另一个状态的条件，在数字系统中它往往是外部输入（摩尔），以及自身的状态输出（米利）；
  • 动作：表示在状态转换发生时执行的操作。在基于有限状态机的数字电路系统设计中，动作 往往称之为 输出。（笔者是学电的出生）

1.2 有限状态的应用场景

有限状态机在软件以及硬件开发中有广泛的应用。

在电子信息工程中，实现有限状态机可以用于描述通信协议的不同状态和状态之间的转换，例如网络协议、串口通信协议等。

在用户界面设计领域，有限状态机可用于管理用户交互的不同状态，例如表单输入的验证、页面导航等。在游戏开发方向，游戏中的角色、游戏流程等可以使用有限状态机进行建模和管理。

在文本处理领域，状态机更是非常实用。我们可以轻松地使用状态机进行及其复杂的文本分析，比如使用状态机实现正则表达式（实际上很多语言提供的正则表达式底层大量使用了状态机实现），又或者是在计算机语言编译或者解释时完成 抽象语法树（AST）的构建。

在自动化控制系统中实现中，有限状态机可以描述设备或机器的工作状态和状态转换规则。

在计算机的核心部件——芯片设计中，有限状态机更加是占据相当重要的地位。笔者最早接触有限状态机大概在 2015 年还在学校学习数字电路设计的时候。当时我们使用 有限状态机 以及 EDA 技术，通过 FPGA 完成各种数字电路的设计作业。

2. FSM 的两大类别

依据有限状态机的状态是否与输出有关，将其分为两大类：莫尔型状态机（Moore State Machine）和 米利型状态机（Mealy State Machine）。

2.1 莫尔型状态机

在 莫尔型状态机（Moore State Machine）中，状态机的输出仅取决于当前状态，与输入无关。每个状态都定义了固定的输出动作，与状态转换无关。

2.2 米利型状态机

在 米利型状态机 （Mealy State Machine）中，状态机的输出取决于当前状态和输入。每个状态都可以定义输出动作，它们可以随着状态转换而改变。

3. 好的建模是设计状态机的关键

3.1 理解 状态 是状态机建模的开始

笔者在本文的开篇 1.1 有限状态机简介 中提到：状态：表示系统或对象所处的特定情况。这听起来还有一些抽象，因此本节带领大家进一步剖析何谓 状态。

3.2 “李华打球” 建模实战

从我们人类自生的生活中的心情情况来理解 状态，以前我写过一篇介绍机器学习划分数据集的博客（https://blog.csdn.net/qq_28550263/article/details/114892718），给出过这样一个例子：

李华是否打球的决策

以下是李华在过去9天是否打球的历史数据：

上次我们是从决策的角度引出了 决策树 的思想，这次我们仍然使用这个例子（笔者懒得画其它的图了），通过 状态机 的视角来分析与建模。

在这个例子中，其实只有 心情 一项是与李华自身因素有关的，而 是否上课、天气 相对于李华，都可以看作 外部条件。

因此，我们不妨考虑：

  1. 将李华的 心情 抽象为不同的状态（显然，这是几个状态可以看作是离散的取值点）；
  2. 将 有课与否、天气情况，看作是 外部输入；
  3. 将 打球与否 看作是 输出（动作）。
  4. 将编号看成日期序号，表示时间尺度上的变化，体现后一个状态与前一个状态之间的逻辑；
  5. 假定日期序号切换，状态切换；

现在我们可以依据这九天的李华心情收到输入变化的规律做出以下 变化规律图：

这就是所谓 状态转换图，简称为 状态图。

得到 状态图 后，我们需要将状态变为 计算机能够接受的东西——毕竟计算机也不能理解人类的心情（即使AI也同样需要对现实数据进行抽象）。

实际上，在计算机内部，它并不会关心你状态文字表述的背后含义，仅仅需要机械式地考虑以区分状态的不同。因此对于建模人员来说，我们往往考虑使用最计算机中简单的东西去表示状态，这个过程就称之为 编码。编码方式有很多种，如最省字节的 独热码，等等。不过在软件开发中，出于对编码者的友好，我们更多地使用的是以有具体含义的 字符串 来标识状态。关于 编码 的更多内容我们将在后面继续讨论。

3.3 建模流程与方法归纳

3.3.1 FSM 建模的通用流程

通过上面给出的小案例，我们已经对从时间经过分析到绘制状态转换图的过程有了一定的了解。

对事物建立状态机模型可以通过以下几个步骤完成：

  1. 分析归纳：通过对事物的行为进行观察和分析，确定状态和状态转换条件，并将其抽象为状态机模型。
  2. 制作状态表格：将状态和状态转换以表格的形式表示，表格中列出了所有可能的输入和对应的状态转换。
  3. 绘制状态转换图：使用状态图（State Diagram）绘制状态和状态转换的图形表示。状态图使用状态节点表示状态，使用箭头表示状态之间的转换条件和动作。绘制状态图时，可以使用 UML（Unified Modeling Language）标准中的状态图符号和表示法。在状态图中，状态以圆角矩形或椭圆形节点表示，状态之间的转换使用箭头表示，并标注转换条件和动作。此外，还可以使用初始状态和终止状态符号表示状态机的起始和结束点。
  4. 编码状态：有限状态机中的 状态 是离散的有限取值，这样我们可以将其一一列出来，通过一种能区分每个状态的方式对他们进行标识。

3.3.2 FSM 中的状态编码

1. 编码的目的

通过对状态的编码，实现让每一个状态都有自己的 唯一标识符，这个唯一标识符是我们接下来编程中区别不同状态的基础。

2. 编码的原则

原则是依据目的所拟出来的，最重要的一点就是能够区分所有的不同状态以达到能够作为 唯一标识符的目的。此外，我们还希望状态机的编码尽可能让我们自己好理解，这样能够便于维护，等等。归纳起来，在有限状态机中对状态进行编码时，需要注意以下原则：

  1. 唯一性：每个状态的编码应该是唯一的，不与其他状态冲突。确保每个状态都有一个独立的编码，以避免混淆和歧义。
  2. 可读性：状态编码应该具有良好的可读性，便于人类理解和记忆。使用清晰、有意义的命名方式，以便于开发人员阅读和维护状态机代码。
  3. 紧凑性：尽可能使用较短的编码来表示状态，以减少存储和传输的开销。对于状态数量较多的情况，可以考虑使用压缩编码方式，如独热码。
  4. 顺序性：状态编码的顺序应该与状态转换图中状态的顺序保持一致，便于查找和对比不同状态之间的关系。
  5. 扩展性：为了支持未来的扩展和变更，状态编码应该设计为可以扩展的形式。确保在需要添加新状态时，能够方便地进行编码的扩展而不会影响现有的编码。
  6. 一致性：在整个状态机中，保持状态编码的一致性。即相同的状态在不同的上下文中应该具有相同的编码，以避免混淆和错误。
  7. 编码冲突的解决：当出现状态编码冲突时，需要采取适当的解决措施，例如使用更长的编码、重新设计编码方案或使用其他编码方式。

考虑以上这些原则可以帮助设计和实现清晰、可读性高且易于维护的有限状态机。根据具体的应用场景和项目需求，可以选择合适的编码方式和策略。

3. 最省字节的编码：二进制数码

首先我要告诉各位读者的是，在实际开发尤其是软件领域，几乎没有使用二进制码来标识状态的，但是这种编码方式包含了一个思想，即 在计算机底层是怎么考虑最小区分不同事物的。

二进制数码（Binary Encoding）是一种使用自然二进制数进行编码的方式。学过数字电路的读者对于二进制可谓很熟悉了，与十进制数中有 0-9 这十个数码不一样，二进制数只有 0、1 这两个数码，并且1就进位。

在 1 位二进制数中，它有两个数码：0、1，因此使用 1 位二进制数最多 可以标识 21 个不同的状态。

类似地，2位 二进制数中，一共有 00、01、10、11这四个数字，因此最多 可以标识 22 个不同地状态。

以此类推，n位 二进制数 最多 可以标识 2n 个不同的状态。

这是我们在编码时考虑使用多少个 bit 的理论依据。

4. 高识别性的编码：独热码

虽然同样是在 bit 层面考虑，但是与二进制数编码将 bit 用到极致不一样，独热码为了提升状态的可识别性，规定 n 位独热码中最多有且只有1位为1，其余位全为0。

比如：

2位独热码有：01、10，这2个状态

3位独热码有：001、010、100，这3个状态

4位独热码有：0001、0010、0100、1000，这4个状态

以此类推，

n 位独热码一共仅仅可以表示 n 个状态。

独热码在状态数量较多时仍然保持编码长度的最小化，并且具有良好的可识别性。然而，随着状态数量增加，独热码的编码长度将线性增长，可能导致较高的存储和计算成本。

5. 其它在 bit 层面的编码

在 bit 层面的编码方式还有很多如：

  • 8421码（BCD码）：BCD码是二进制编码的十进制表示方式，每个十进制数字使用4位二进制进行编码。BCD码中的每一位表示十进制数中的一个数字，范围为0-9。例如，数字7用BCD码表示为0111。
  • 5421码：5421码也是一种二进制编码的十进制表示方式，每个十进制数字使用4位二进制进行编码。不同于BCD码，5421码中的每一位表示十进制数中的权重，分别为5、4、2和1。通过将权重位上的二进制数相加，可以得到对应的十进制数字。例如，数字7用5421码表示为0111。

等等。

6. 十进制数码

需要指出的是，bit 表示的是由 0/1 表示的一个二进制位，是计算机存储的最小的单元。而 1 Byte 相当于 8 bit，是我们操作数据的最小单元。由于我们几乎不会直接在 bit 层面对数据进行手动修改。因此，不论是 二进制数码 还是 独热码 等等这类基于操作 bit 的编码方式都不会在软件开发中用到。嗯，除非你是搞硬件开发的。

有二进制数编码则当然可以有十进制数码，这在编程语言中都是直接支持的。与二进制数编码方式类似：

n位 十进制数 最多 可以标识 10n 个不同的状态。

这是我们在编码时考虑至少要几位十进制数才能表示我们所有状态的理论依据。

需要指出的是，在软件开发领域，这种使用整数来表示状态，如 0、1、2 等。每个状态都对应一个唯一的数字编码。这种编码方式简单直观，易于理解和实现。但是当状态数量较多时，数字编码可能变得晦涩难懂，不易于维护和调试。

以下是一个使用十进制数编码状态的例子：

const STATE_0: u32 = 0;
const STATE_1: u32 = 1;
const STATE_2: u32 = 2;
fn main() {
    let state: u32 = STATE_2;
    match state {
        STATE_0 => {
            println!("Current state is STATE_0");
        },
        STATE_1 => {
            println!("Current state is STATE_1");
        },
        STATE_2 => {
            println!("Current state is STATE_2");
        },
        _ => {
            println!("Invalid state");
        },
    }
}
7. 字符串编码

使用字符串来表示状态，每个状态对应一个唯一的字符串。字符串编码具有较好的可读性和可理解性，易于扩展和维护。使用字符串编码时，可以使用有意义的状态名称来提高代码的可读性。但是字符串编码可能会增加内存消耗，并且比较操作可能较慢。

以下是一个使用字符串编码状态例子：

const STATE_0: &str = "State0";
const STATE_1: &str = "State1";
const STATE_2: &str = "State2";
const STATE_3: &str = "State3";
fn main() {
    let state: &str = STATE_2;
    match state {
        STATE_0 => {
            println!("Current state is STATE_0");
        },
        STATE_1 => {
            println!("Current state is STATE_1");
        },
        STATE_2 => {
            println!("Current state is STATE_2");
        },
        STATE_3 => {
            println!("Current state is STATE_3");
        },
        _ => {
            println!("Invalid state");
        },
    }
}
8. 枚举编码

在 Rust 语言中恰好为我们提供了 枚举，因此我们还可以使用 枚举 来表示状态，每个状态都是枚举的一个成员。

枚举编码提供了更具可读性的状态表示方式，使得状态的含义更加清晰。同时，枚举编码也避免了数字编码的晦涩性。

但是有时候当状态数量较多时，枚举编码可能导致代码冗长，并且不够灵活。

以下是一个使用枚举编码状态的例子：

enum State {
    A,
    B,
    C,
}
fn main() {
    let mut state = State::A;
    loop {
        match state {
            State::A => {
                println!("In state A");
                state = State::B;
            }
            State::B => {
                println!("In state B");
                state = State::C;
            }
            State::C => {
                println!("In state C");
                state = State::A;
            }
        }
    }
}
9. 其他自定义类型编码

只要能够有效地区分状态，在使用有限状态机时，你当然可以自定义一种编码类型对状态进行编码。

有时候，通过定义状态类型的属性和方法，可以更灵活地表示和操作状态。自定义类型编码可以提供更多的语义和上下文信息，使代码更易于理解和维护。不过自定义类型编码可能会增加代码设计的难度，要求开发者需要有更多的设计经验。

最后需要指出的是，每种状态编码方式都有其适用的场景和优缺点。选择适合的编码方式取决于具体的需求和项目要求。在实际应用中，可以根据状态机的复杂度、可读性需求、代码维护性等因素来选择合适的编码方式。在某些情况下，也可以结合不同的编码方式来满足不同的需求。

3.3.3 使用 Visio 绘制标准的 UML 状态图

1. 关于 Visio

Visio是一款流程图和图表绘制工具，由微软公司开发。它提供了丰富的图形和模板库，使用户能够创建各种类型的图表，包括流程图、组织结构图、网络图、UML图等。Visio的用户界面直观易用，适合专业人士和非专业人士使用。

在绘制UML（统一建模语言）方面，Visio是一个常用的工具。UML是一种用于软件系统建模的标准化语言，用于描述系统的结构、行为和交互。Visio提供了专门用于UML的模板和工具，使用户可以轻松地创建各种UML图，如用例图、类图、时序图、活动图和状态图等。

通过Visio的UML模板和工具，用户可以按照UML标准绘制各种UML图形，并使用图形符号和关系来表示系统的不同方面。用户可以添加和连接各种UML元素，如类、接口、对象、状态、行为和关系等。此外，Visio还提供了布局、样式和注释等功能，使用户能够改善图形的外观和可读性。

目前 Visio 几乎是出版界的标准工具，就行 Auto CAD 是工业制图界的标准工具。使用 Visio 绘制 UML 图的的优势在于

  1. 可视化：通过图形化表示，更直观地展示系统的结构和行为。
  2. 易于理解：UML图形符号和关系具有标准化的含义，使得其他人能够快速理解和解读图形。
  3. 可编辑性：Visio提供了编辑和修改UML图的功能，使用户能够灵活地调整和更新图形。
  4. 可扩展性：Visio支持添加新的UML元素和自定义符号，以满足不同项目的需求。

并且现在很多国内的相关软件也基本是跟着 Visio 的动态走。不断地被各种友商所模仿。

2. 使用Visio绘制标准的UML状态图
打开 Visio 的 UML状态图模板

首先你需要打开Visio：启动Visio并选择“新建”以创建新的绘图。

选择UML状态图模板：在Visio中，选择“流程图”类别，然后选择“UML状态图”模板。这将为您提供一个空白的UML状态图画布。

添加状态

4. 状态机的实现方式类别

在 软件设计中1 根据实现方式的不同，有限状态机可以分为以下几种类型：表驱动状态机、基于条件语句的状态机、基于状态模式的状态机、事件驱动状态机：

  1. 基于条件语句的状态机（Conditional Statement-Based State Machine）：使用条件语句（例如 if-else、switch（相当于 rust 中用 match））来定义状态转换和动作执行逻辑。
  2. 表驱动状态机（Table-Driven State Machine）：使用状态转换表来定义状态和转换条件，通过查表实现状态转换和动作执行。
  3. 状态模式（State Pattern）：利用 面向对象编程的特性，将* 状态* 封装为 对象，并通过状态对象之间的切换实现状态转换和动作执行。
  4. 事件驱动状态机（Event-Driven State Machine）：基于事件和事件处理机制来驱动状态转换和动作执行，常见于异步编程和事件驱动的系统中。

本节我们先给出分类，在后面的章节中，我们将一一讲解并给出实际案例。

5. 基于条件语句的状态机 从理论到实战

5.1 基于条件语句的状态机 简介

基于条件语句的状态机（Conditional Statement State Machine）通过在 不同的状态下 执行不同的条件语句 来 实现状态的转换和相关逻辑。

每个状态由一个或多个条件语句来描述，并且根据条件语句的结果选择下一个状态。状态机中的状态和状态之间的转换通常通过条件判断来确定。

5.1.1 优势

这种状态机具有以下优点：

  1. 简单直观：基于条件语句的状态机实现相对简单，易于理解和调试。状态和状态转换的逻辑直接体现在条件语句中，代码结构清晰明了。
  2. 灵活性：使用条件语句可以方便地对每个状态进行个性化的处理，根据不同的条件执行不同的代码逻辑。可以灵活地根据具体需求来设计和修改状态机。

5.1.2 缺陷

当然它还具有以下不足：

  1. 可读性 和 可维护性：随着状态机的状态和转换规则的增加，条件语句的数量和复杂度可能会迅速增加，导致代码可读性和可维护性下降。维护大型状态机可能会变得困难。
  2. 扩展性：当需要添加新的状态或修改现有状态时，可能需要修改大量的条件语句，可能会导致代码的脆弱性增加。随着状态机的增长，添加新状态或修改现有状态的复杂度会增加。

5.1.3 适用情况

这种方式适用于 简单 和 小型 的 状态机，逻辑相对直观和简单的情况下，实现简单且易于理解。但对于复杂的状态机，特别是具有大量状态和状态转换的情况，使用条件语句实现可能会导致代码的可读性、可维护性和扩展性的问题。在这种情况下，使用其他更为结构化和模块化的状态机实现方式，如表驱动的状态机或基于类和方法的状态机，可能更合适。

5.2 基于 INI 文件进行建模

5.1.1 INI 文件格式解析

INI（Initialization）文件格式是一种常见的配置文件格式，用于存储和组织应用程序的配置信息。它由一系列的配置项组成，每个配置项由一个键值对表示。INI文件采用了一种分区（Section）的结构来组织配置项，允许将相关的配置项归类到不同的部分。

以下是INI文件中的主要元素：

  1. Section（部分）：Section是INI文件中的顶层结构，用于将相关的配置项进行分组。Section由方括号（[]）括起来，并位于配置项之前。Section的名称在方括号内，并且通常是唯一的，用于标识不同的配置区域。
    示例：[Section1]
  2. Property（属性）：Property是配置项的键值对，表示具体的配置信息。每个Property由一个键（Key）和一个值（Value）组成，中间使用等号（=）分隔。键用于标识配置项，值则表示配置项的具体数值。
    示例：Key1 = Value1
  3. Comment（注释）：Comment是INI文件中的注释部分，用于提供对配置的说明和备注。注释通常以分号（;）开头，可以在Section、Property或文件任意位置使用。注释不会影响配置项的解析，仅作为文档的一部分。
    示例：; This is a comment
  4. 其他规则：
  • 空行：INI文件中的空行会被忽略，可以用于提高可读性和分隔配置区域。
  • 键值对的格式：键值对之间使用等号（=）进行分隔，键和值两侧可以有空格，但通常是不包含空格的。
  • 键和值的转义：在键或值中包含特殊字符时，可以使用转义字符进行处理，如\n表示换行符。
  • 多行值：有些INI解析器支持多行值，可以使用特定的转义字符或换行符来表示一个跨越多行的值。

INI文件格式的简洁性和易读性使其广泛应用于各种应用程序的配置文件、设置文件等场景。虽然INI文件没有严格的规范和标准，但通常可以通过解析器来解析和处理INI文件，以获取其中的配置信息。

use std::collections::HashMap;
// 定义状态枚举
enum StatesEnum {
    Start,       // 起始状态，表示解析器刚开始解析INI字符串
    Section,     // 节状态，表示当前解析的是节（section）
    Property,    // 属性状态，表示当前解析的是属性（property）
    Comment,     // 注释状态，表示当前解析的是注释
}
fn parse_ini_string(input: &str) -> HashMap<String, HashMap<String, String>> {
    // 初始化解析器的状态和其他变量
    let mut state = StatesEnum::Start;
    let mut current_section = String::new();
    let mut properties: HashMap<String, HashMap<String, String>> = HashMap::new();
    let mut comments: HashMap<String, Vec<String>> = HashMap::new();
    // 遍历输入的每一行
    for line in input.lines() {
        let line = line.trim();
        // 如果行以 ';' 开头，表示是注释行
        if line.starts_with(';') {
            // 提取注释内容，并根据当前状态将注释添加到对应的section中
            let comment = line[1..].trim().to_owned();
            match state {
                StatesEnum::Start | StatesEnum::Section | StatesEnum::Property => {
                    comments
                        .entry(current_section.clone())
                        .or_insert_with(Vec::new)
                        .push(comment);
                }
                _ => {}
            }
            state = StatesEnum::Comment;
        }
        // 如果行以 '[' 开头并以 ']' 结尾，表示是section行
        else if line.starts_with('[') && line.ends_with(']') {
            // 提取section名称，并更新当前section变量
            let section = line[1..line.len() - 1].trim().to_owned();
            current_section = section.clone();
            // 在properties中插入新的section，并初始化该section的属性HashMap
            properties.entry(section).or_insert_with(HashMap::new);
            state = StatesEnum::Section;
        }
        // 如果行包含 '='，表示是属性行
        else if let Some(index) = line.find('=') {
            // 提取key和value，并将其添加到当前section的属性HashMap中
            let key = line[..index].trim().to_owned();
            let value = line[index + 1..].trim().to_owned();
            properties
                .entry(current_section.clone())
                .or_insert_with(HashMap::new)
                .insert(key, value);
            state = StatesEnum::Property;
        }
        // 其他情况下，表示是注释行或空行
        else {
            // 根据当前状态将注释添加到对应的section中
            match state {
                StatesEnum::Start | StatesEnum::Section | StatesEnum::Property => {
                    let comment = line.to_owned();
                    comments
                        .entry(current_section.clone())
                        .or_insert_with(Vec::new)
                        .push(comment);
                }
                _ => {}
            }
            state = StatesEnum::Comment;
        }
    }
    properties
}

上面的 if-else 语句该用 后，以后会更好维护：

use std::collections::HashMap;
// 定义状态枚举
enum StatesEnum {
    Start,       // 起始状态，表示解析器刚开始解析INI字符串
    Section,     // 节状态，表示当前解析的是节（section）
    Property,    // 属性状态，表示当前解析的是属性（property）
    Comment,     // 注释状态，表示当前解析的是注释
}
// 解析 INI 字符串
fn parse_ini_string(input: &str) -> HashMap<String, HashMap<String, String>> {
    let mut state = StatesEnum::Start;
    let mut current_section = String::new();
    let mut properties: HashMap<String, HashMap<String, String>> = HashMap::new();
    let mut comments: HashMap<String, Vec<String>> = HashMap::new();
    // 逐行处理文本
    for line in input.lines() {
        let line = line.trim();
        // 描述各个状态的转换规律
        match state {
            // 起始状态（Start）
            StatesEnum::Start => {
                // 如果行以 ';' 开头，则为注释
                if line.starts_with(';') { 
                    let comment = line[1..].trim().to_owned();
                    comments
                        .entry(current_section.clone())
                        .or_insert_with(Vec::new)
                        .push(comment);
                    state = StatesEnum::Comment; 
                } 
                // 如果行以 '[' 开头，以 ']' 结尾，则为节（section）
                else if line.starts_with('[') && line.ends_with(']') { 
                    let section = line[1..line.len() - 1].trim().to_owned();
                    current_section = section.clone();
                    properties.entry(section).or_insert_with(HashMap::new);
                    state = StatesEnum::Section; // 进入节状态
                } 
                // 如果行包含 '='，则为属性（property）
                else if let Some(index) = line.find('=') { 
                    let key = line[..index].trim().to_owned();
                    let value = line[index + 1..].trim().to_owned();
                    properties
                        .entry(current_section.clone())
                        .or_insert_with(HashMap::new)
                        .insert(key, value);
                    state = StatesEnum::Property; // 进入属性状态
                } 
                // 其他情况为注释
                else { 
                    let comment = line.to_owned();
                    comments
                        .entry(current_section.clone())
                        .or_insert_with(Vec::new)
                        .push(comment);
                    state = StatesEnum::Comment; // 进入注释状态
                }
            }
            // 节状态（Section）
            StatesEnum::Section => {
                // 如果行以 ';' 开头，则为注释
                if line.starts_with(';') { 
                    let comment = line[1..].trim().to_owned();
                    comments
                        .entry(current_section.clone())
                        .or_insert_with(Vec::new)
                        .push(comment);
                    state = StatesEnum::Comment; // 进入注释状态
                } 
                // 如果行包含 '='，则为属性（property）
                else if let Some(index) = line.find('=') { 
                    let key = line[..index].trim().to_owned();
                    let value = line[index + 1..].trim().to_owned();
                    properties
                        .entry(current_section.clone())
                        .or_insert_with(HashMap::new)
                        .insert(key, value);
                    state = StatesEnum::Property; // 进入属性状态
                } 
                // 如果行以 '[' 开头，以 ']' 结尾，则为节（section）
                else if line.starts_with('[') && line.ends_with(']') { 
                    let section = line[1..line.len() - 1].trim().to_owned();
                    current_section = section.clone();
                    properties.entry(section).or_insert_with(HashMap::new);
                } 
                // 其他情况为注释
                else { 
                    let comment = line.to_owned();
                    comments
                        .entry(current_section.clone())
                        .or_insert_with(Vec::new)
                        .push(comment);
                }
            }
            // 属性状态（Property）
            StatesEnum::Property => {
                // 如果行以 ';' 开头，则为注释
                if line.starts_with(';') { 
                    let comment = line[1..].trim().to_owned();
                    comments
                        .entry(current_section.clone())
                        .or_insert_with(Vec::new)
                        .push(comment);
                    state = StatesEnum::Comment; // 进入注释状态
                } 
                // 如果行以 '[' 开头，以 ']' 结尾，则为节（section）
                else if line.starts_with('[') && line.ends_with(']') { 
                    let section = line[1..line.len() - 1].trim().to_owned();
                    current_section = section.clone();
                    properties.entry(section).or_insert_with(HashMap::new);
                    state = StatesEnum::Section; // 进入节状态
                } 
                // 如果行包含 '='，则为属性（property）
                else if let Some(index) = line.find('=') { 
                    let key = line[..index].trim().to_owned();
                    let value = line[index + 1..].trim().to_owned();
                    properties
                        .entry(current_section.clone())
                        .or_insert_with(HashMap::new)
                        .insert(key, value);
                } 
                // 其他情况为注释
                else { 
                    let comment = line.to_owned();
                    comments
                        .entry(current_section.clone())
                        .or_insert_with(Vec::new)
                        .push(comment);
                    state = StatesEnum::Comment; // 进入注释状态
                }
            }
            // 注释状态（Comment）
            StatesEnum::Comment => {
                // 如果行以 '[' 开头，以 ']' 结尾，则为节（section）
                if line.starts_with('[') && line.ends_with(']') { 
                    let section = line[1..line.len() - 1].trim().to_owned();
                    current_section = section.clone();
                    properties.entry(section).or_insert_with(HashMap::new);
                    state = StatesEnum::Section; // 进入节状态
                } 
                // 如果行包含 '='，则为属性（property）
                else if let Some(index) = line.find('=') { 
                    let key = line[..index].trim().to_owned();
                    let value = line[index + 1..].trim().to_owned();
                    properties
                        .entry(current_section.clone())
                        .or_insert_with(HashMap::new)
                        .insert(key, value);
                    state = StatesEnum::Property; // 进入属性状态
                } 
                // 其他情况为注释
                else { 
                    let comment = line.to_owned();
                    comments
                        .entry(current_section.clone())
                        .or_insert_with(Vec::new)
                        .push(comment);
                }
            }
        }
    }
    properties
}

6. 表驱动状态机 从理论到实战

7. 状态模式 从理论到实战

8. 事件驱动状态机 从理论到实战

9. 使用拆分法：编写 主从状态机

有时候如果遇到了一个比较复杂的事物，尤其是事物的某个环节

use std::collections::HashMap;
// 定义主状态
#[derive(Debug)]
enum MainState {
    Start,
    Section,
    Comment,
}
// 定义子状态
#[derive(Debug)]
enum SubState {
    Start,
    Comment,
    Key,
}
// 解析 INI 字符串
fn parse_ini_string(input: &str) -> HashMap<String, HashMap<String, String>> {
    let mut main_state = MainState::Start;
    let mut sub_state = SubState::Start;
    let mut properties: HashMap<String, HashMap<String, String>> = HashMap::new();
    let mut current_section: Option<String> = None;
    // 逐行解析 INI 字符串
    for line in input.lines() {
        let line = line.trim();
        match main_state {
            MainState::Start => {
                if line.starts_with('[') && line.ends_with(']') {
                    // 当遇到新的 Section 时，创建新的 Section 对应的 HashMap
                    let section = line[1..line.len() - 1].trim().to_owned();
                    properties.insert(section.clone(), HashMap::new());
                    current_section = Some(section);
                    main_state = MainState::Section;
                } else if line.starts_with(';') {
                    main_state = MainState::Comment;
                }
            }
            MainState::Section => {
                if line.starts_with('[') && line.ends_with(']') {
                    // 当遇到新的 Section 时，创建新的 Section 对应的 HashMap
                    let section = line[1..line.len() - 1].trim().to_owned();
                    properties.insert(section.clone(), HashMap::new());
                    current_section = Some(section);
                } else if line.starts_with(';') {
                    sub_state = SubState::Comment;
                } else if !line.is_empty() {
                    if let Some(section) = &current_section {
                        let section_properties = properties.get_mut(section).unwrap();
                        if let Some(key_value) = extract_key_value(line) {
                            let (key, value) = key_value;
                            // 将键值对添加到当前 Section 的 HashMap 中
                            section_properties.insert(key, value);
                        }
                    }
                    sub_state = SubState::Key;
                }
            }
            MainState::Comment => {
                if line.starts_with('[') && line.ends_with(']') {
                    // 当遇到新的 Section 时，创建新的 Section 对应的 HashMap
                    let section = line[1..line.len() - 1].trim().to_owned();
                    properties.insert(section.clone(), HashMap::new());
                    current_section = Some(section);
                    main_state = MainState::Section;
                }
            }
        }
        match sub_state {
            SubState::Start => {
                if line.starts_with(';') {
                    sub_state = SubState::Comment;
                } else if !line.is_empty() {
                    if let Some(section) = &current_section {
                        let section_properties = properties.get_mut(section).unwrap();
                        if let Some(key_value) = extract_key_value(line) {
                            let (key, value) = key_value;
                            // 将键值对添加到当前 Section 的 HashMap 中
                            section_properties.insert(key, value);
                        }
                    }
                    sub_state = SubState::Key;
                }
            }
            SubState::Comment => {
                if line.starts_with('[') && line.ends_with(']') {
                    // 当遇到新的 Section 时，创建新的 Section 对应的 HashMap
                    let section = line[1..line.len() - 1].trim().to_owned();
                    properties.insert(section.clone(), HashMap::new());
                    current_section = Some(section);
                    main_state = MainState::Section;
                    sub_state = SubState::Start;
                } else if !line.starts_with(';') && !line.is_empty() {
                    if let Some(section) = &current_section {
                        let section_properties = properties.get_mut(section).unwrap();
                        if let Some(key_value) = extract_key_value(line) {
                            let (key, value) = key_value;
                            // 将键值对添加到当前 Section 的 HashMap 中
                            section_properties.insert(key, value);
                        }
                    }
                    sub_state = SubState::Key;
                }
            }
            SubState::Key => {
                if line.starts_with(';') {
                    sub_state = SubState::Comment;
                } else if !line.is_empty() {
                    if let Some(section) = &current_section {
                        let section_properties = properties.get_mut(section).unwrap();
                        if let Some(key_value) = extract_key_value(line) {
                            let (key, value) = key_value;
                            // 将键值对添加到当前 Section 的 HashMap 中
                            section_properties.insert(key, value);
                        }
                    }
                }
            }
        }
    }
    properties
}

其中：

// 用于提取键值对
fn extract_key_value(line: &str) -> Option<(String, String)> {
    let parts: Vec<&str> = line.splitn(2, '=').map(str::trim).collect();
    if parts.len() == 2 {
        let key = parts[0].to_owned();
        let value = parts[1].to_owned();
        Some((key, value))
    } else {
        None
    }
}

可以使用该

  1. 这里不包括硬件电路设计。电气工程领域采用状态机设计数字电路，所使用的用于描述硬件编程方式称作 硬件描述语言，如 VHDL、Verilog HDL，往往将状态机的实现方式分为 一段论、二段论、三段论。有兴趣的读者可以自行了解，不过硬件语言是所有电路同时存在同时执行的，不像计算机语言是一条一条执行来执行的，由于区别太大，可能对于仅仅想做软件的读者帮助不大。 ↩︎
文章标签：
云解析DNS
uml
Rust
存储
人工智能
设计模式
关键词：
Rust编程
Rust应用
Rust笔记
Rust原理
jcLee95
目录
相关文章
土木林森
|
17天前
|
Rust 安全 Go
揭秘Rust语言：为何它能让你在编程江湖中，既安全驰骋又高效超车，颠覆你的编程世界观！
【8月更文挑战第31天】Rust 是一门新兴的系统级编程语言，以其卓越的安全性、高性能和强大的并发能力著称。它通过独特的所有权和借用检查机制解决了内存安全问题，使开发者既能享受 C/C++ 的性能，又能避免常见的内存错误。Rust 支持零成本抽象，确保高级抽象不牺牲性能，同时提供模块化和并发编程支持，适用于系统应用、嵌入式设备及网络服务等多种场景。从简单的 “Hello World” 程序到复杂的系统开发，Rust 正逐渐成为现代软件开发的热门选择。
土木林森
34 1
DreamSpark
|
11天前
|
Rust 网络协议 安全
Rust在系统编程中的案例分享
Rust在系统编程中的案例分享
DreamSpark
30 10
土木林森
|
17天前
|
数据采集 Rust 安全
Rust在网络爬虫中的应用与实践：探索内存安全与并发处理的奥秘
【8月更文挑战第31天】网络爬虫是自动化程序，用于从互联网抓取数据。随着互联网的发展，构建高效、安全的爬虫成为热点。Rust语言凭借内存安全和高性能特点，在此领域展现出巨大潜力。本文探讨Rust如何通过所有权、借用及生命周期机制保障内存安全；利用`async/await`模型和`tokio`运行时处理并发请求；借助WebAssembly技术处理动态内容；并使用`reqwest`和`js-sys`库解析CSS和JavaScript，确保代码的安全性和可维护性。未来，Rust将在网络爬虫领域扮演更重要角色。
土木林森
37 1
土木林森
|
17天前
|
Rust 开发者
揭秘Rust编程：模块与包的终极对决，谁将主宰代码组织的新秩序？
【8月更文挑战第31天】在软件工程中，模块化设计能显著提升代码的可读性、可维护性和可重用性。Rust 作为现代系统编程语言，其模块和包管理机制为开发者提供了强有力的工具来组织代码。本文通过对比模块和包的概念及使用场景，探讨了 Rust 中的最佳实践。
土木林森
14 2
土木林森
|
17天前
|
Rust 安全 JavaScript
探索Rust在系统编程领域的前景：虚拟机和编译器开发的新篇章
【8月更文挑战第31天】在系统编程领域，性能与安全性至关重要。Rust作为一种新兴语言，凭借其独特的内存安全和并发特性，正逐渐成为虚拟机和编译器开发的首选。本文通过案例分析，探讨Rust在这些领域的应用，例如Facebook的Compiler VM (CVM)项目和实验性的JavaScript JIT编译器Mithril。Rust的静态类型系统和所有权模型确保了高性能和安全性，而其强大的包管理和库生态则简化了虚拟机的开发。随着Rust社区的不断成熟，预计未来将有更多基于Rust的创新项目涌现，推动系统编程的发展。对于追求高性能和安全性的开发者而言，掌握Rust将成为一个重要战略方向。
土木林森
36 1
土木林森
|
17天前
|
Rust 安全 物联网
解锁物联网安全新纪元！Rust如何悄然革新系统级编程，让智能设备“零风险”连接未来？
【8月更文挑战第31天】随着物联网（IoT）技术的发展，设备安全与效率成为关键挑战。Rust语言凭借其内存安全、高性能和并发优势，逐渐成为物联网开发的新宠。本文通过智能门锁案例，展示Rust如何确保生物识别数据的安全传输，并高效处理多用户请求。Rust的应用不仅限于智能家居，还广泛用于工业自动化和智慧城市等领域，为物联网开发带来革命性变化。
土木林森
28 1
土木林森
|
17天前
|
Rust 安全 编译器
【颠覆传统】Rust跨平台开发秘籍：如何轻松驾驭多操作系统，打造无缝兼容应用？
【8月更文挑战第31天】Rust语言凭借其内存安全、卓越性能及丰富的标准库支持，正逐渐成为跨平台开发的新宠。本文通过具体代码示例，展示如何用Rust编写可在多种操作系统上无缝运行的应用程序。Rust通过所有权、借用和生命周期等机制提升代码安全性，并在编译时检测潜在错误。其编译器支持广泛平台，包括Windows、macOS和Linux等，非常适合跨平台开发。此外，Rust还可用于开发复杂的GUI应用，利用GTK、Qt等成熟框架实现跨平台图形界面。无论开发命令行工具还是图形界面应用，Rust均能提供高效稳定的解决方案。
土木林森
52 1
土木林森
|
17天前
|
开发者 vr&ar 机器学习/深度学习
Xamarin 开发者的未来趋势展望：掌握跨平台开发新机遇，引领移动应用创新潮流与技术变革方向
【8月更文挑战第31天】Xamarin 作为领先的跨平台开发框架，通过 C# 和 .NET 框架实现一次编写、多平台运行，简化了 iOS、Android 和 Windows 应用的开发流程。未来几年，Xamarin 开发者将面临跨平台开发普及、云集成、机器学习、AR/VR、性能优化及安全性等关键趋势。通过学习新技术并积极采用新工具，开发者能够提升应用质量和用户体验，如利用 Azure AD B2C 实现身份认证，从而在竞争激烈的市场中脱颖而出。
土木林森
35 0
土木林森
|
17天前
|
Rust 安全 开发者
惊爆！Xamarin 携手机器学习，开启智能应用新纪元，个性化体验与跨平台优势完美融合大揭秘！
【8月更文挑战第31天】随着互联网的发展，Web应用对性能和安全性要求不断提高。Rust凭借卓越的性能、内存安全及丰富生态，成为构建高性能Web服务器的理想选择。本文通过一个简单示例，展示如何使用Rust和Actix-web框架搭建基本Web服务器，从创建项目到运行服务器全程指导，帮助读者领略Rust在Web后端开发中的强大能力。通过实践，读者可以体验到Rust在性能和安全性方面的优势，以及其在Web开发领域的巨大潜力。
土木林森
28 0
土木林森
|
17天前
|
监控 UED 开发者
从设计到监控：用Xamarin打造高可用性移动应用的实战策略与案例深度剖析
【8月更文挑战第31天】在数字化时代，移动应用成为生活工作的重要组成部分，其稳定性和可靠性至关重要。Xamarin作为跨平台开发框架，已广受认可，但如何确保应用高可用性是开发者面临的挑战。本文以电商应用“SmartShop”为例，从设计、异常处理、性能优化、多线程及测试监控五个方面探讨构建高可用性Xamarin应用的最佳实践。通过模块化设计、有效异常处理、性能优化、多线程技术和全面测试监控，确保应用稳定高效，提升用户体验。
土木林森
26 0

热门文章

最新文章

  • 1
    Rust 笔记：Rust 语言中使用 vector（向量）
  • 2
    rust实现解析yml配置
  • 3
    Rust与Java：性能与效率的较量
  • 4
    历时四年，Dropbox 用 Rust 重写同步引擎核心代码
  • 5
    Rust 大展拳脚的新兴领域：机密计算
  • 6
    性能的极致,Rust的加持,Zed-Dev编辑器快速搭建Python3.10开发环境
  • 7
    Serverless时代Rust即将称王，详解C、Java、Go、Rust高并发背后的技术？
  • 8
    2021 年 Rust 生态版图调研报告 | 星辰大海（下篇）
  • 9
    Rust安装
  • 10
    Rust 数据类型 之 结构体（Struct）
  • 1
    一名C++程序员的Rust入门初体验
    298
  • 2
    探索新一代编程语言：Rust
    52
  • 3
    Rust并发编程实践：快速入门系统级编程
    179
  • 4
    Rust 基础语法和数据类型
    67
  • 5
    Rust vs Go：解析两者的独特特性和适用场景
    182
  • 6
    异常处理的三国演义：Python、Go、Rust的对比探究
    64
  • 7
    Rust代码编写高性能屏幕监控软件的核心算法
    187
  • 8
    开发语言漫谈-rust
    57
  • 9
    Rust安装
    98
  • 10
    Rust流程控制
    48

    • 相关课程

    更多
  • Go语言核心编程 - 面向对象、文件、单元测试、反射、TCP编程
  • Python语言基础 - 函数、面向对象、异常处理
  • Go语言核心编程 - 数据结构和算法
  • 5天玩转Java面向对象编程
  • Java面向对象编程
  • Java面向对象开发

    • 相关电子书

    更多
  • 用RxSwift写易维护易读的愉悦代码
  • 为什么要学函数式编程？
  • 基于JVM的脚本语言开发、运用实践

    • 相关实验场景

    更多
  • 语言入门-2：基本类型
  • 语言入门-1：环境构建
  • 使用Java面向对象编写网络通信程序应用
  • Python网络通信程序典型应用
    • 下一篇
    基于LNMP搭建WordPress