blocks|key|3144965|text|大多数工作流都可以实现为状态机。例如，处理请假申请或订单。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3144966|如果您使用的是.NET，请尝试Windows+Workflow+Foundation。您可以使用它非常快速地实现状态机工作流。|3144967|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Most workflows can be implemented as state machines. For example, processing leave applications or orders.

If you're using .NET, try Windows Workflow Foundation. You can implement a state machine workflow quite quickly with it.

blocks|key|3144990|text|状态机无处不在。状态机是通信接口中的关键，在通信接口中，需要在接收消息时对其进行解析。此外，在嵌入式系统开发中，由于严格的时间限制，我需要将一个任务分成多个任务。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3144991|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

State machines are everywhere. State machines are key in communications interfaces where a message needs to be parsed as it is received. Also, there have been many times in embedded systems development that I've needed to separate a task into multiple tasks because of strict timing constraints.

blocks|key|3145038|text|QA基础设施，旨在通过屏幕抓取或以其他方式在测试过程中运行。(这是我的特殊经验领域；我用Python为我的上一个雇主构建了一个状态机框架，支持将当前状态推送到堆栈上，并使用各种状态处理程序选择方法，以便在所有基于TTY的屏幕抓取器中使用)。概念模型非常适合，因为在TTY应用程序中运行时，它会经历有限数量的已知状态，并且可以移回旧状态(考虑使用嵌套菜单)。此代码已发布(经上述雇主许可)；如果您想查看代码，请使用Bazaar查看http://web.dyfis.net/bzr/isg_state_machine_framework/。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3145039|票证、流程管理和工作流系统--如果您的票证有一组规则来确定它在新的、分类的、正在进行的、需要-QA、失败-QA和已验证(例如)之间的移动，那么您就有了一个简单的状态机。|3145040|构建小型的、易于证明的嵌入式系统--交通信号灯信号是一个关键示例，其中所有可能状态的列表都必须完全枚举和了解。|3145041|解析器和词法分析器在很大程度上是基于状态机的，因为确定流入的内容的方式是基于您当时所处的位置。|3145042|entityMap|0|LINK|mutability|MUTABLE|url|http://bazaar-vcs.org/^0|5Y|1H|5Q|6|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@$9|U|A|V|B|C]]|D|@$9|W|A|X|1|Y]]|E|$]]|$1|F|3|G|5|6|7|Z|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|10|8|@]|D|@]|E|$]]|$1|J|3|K|5|6|7|11|8|@]|D|@]|E|$]]|$1|L|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|M|$N|$5|O|P|Q|E|$R|S]]]]

QA infrastructure, intended to screen-scrape or otherwise run through a process under test. (This is my particular area of experience; I built a state machine framework in Python for my last employer with support for pushing the current state onto a stack and using various methods of state handler selection for use in all our TTY-based screen scrapers). The conceptual model fits well, as running through a TTY application, it goes through a limited number of known states, and can be moved back into old ones (think about using a nested menu). This has been released (with said employer's permission); use <A HREF="http://bazaar-vcs.org/" rel="nofollow noreferrer">Bazaar</A> to check out <code>http://web.dyfis.net/bzr/isg_state_machine_framework/</code> if you want to see the code.

Ticket-, process-management and workflow systems -- if your ticket has a set of rules determining its movement between NEW, TRIAGED, IN-PROGRESS, NEEDS-QA, FAILED-QA and VERIFIED (for example), you've got a simple state machine.

Building small, readily provable embedded systems -- traffic light signaling is a key example where the list of all possible states has to be fully enumerated and known.

Parsers and lexers are heavily state-machine based, because the way something streaming in is determined is based on where you're at at the time.

blocks|key|357884|text|如果你使用的是C#，那么每当你写一个迭代器代码块的时候，你就是在要求编译器为你构建一个状态机(跟踪你在迭代器中的位置等)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|357885|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

If you're using C#, any time you write an iterator block you're asking the compiler to build a state machine for you (keeping track of where you are in the iterator etc).

blocks|key|357887|text|State设计模式是一种通过有限状态机表示对象状态的面向对象的方法。它通常有助于降低该对象实现的逻辑复杂性(嵌套的if、多个标志等)。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|357888|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/State_pattern^0|0|5|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

The <a href="http://en.wikipedia.org/wiki/State_pattern" rel="noreferrer">State</a> design pattern is an object-oriented way to represent the state of an object by means of a finite state machine. It usually helps to reduce the logical complexity of that object's implementation (nested if's, many flags, etc.)

blocks|key|3145132|text|有限状态机可用于任何自然语言的形态分析。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3145133|从理论上讲，这意味着词法和句法在计算层面上是分开的，一个至多是有限状态，另一个至多是轻微的上下文敏感(因此需要其他理论模型来解释词到词而不是语素到语素的关系)。|3145134|这在机器翻译和单词注释领域很有用。从表面上看，它们是用于NLP中不那么琐碎的机器学习应用程序的低成本特征，例如句法或依存关系解析。|3145135|如果你有兴趣了解更多，你可以查看Beesley和Karttunen的有限状态形态学，以及他们在PARC设计的施乐有限状态工具包。|3145136|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

Finite state machines can be used for morphological parsing in any natural language.

Theoretically, this means that morphology and syntax are split up between computational levels, one being at most finite-state, and the other being at most mildly context sensitive (thus the need for other theoretical models to account for word-to-word rather than morpheme-to-morpheme relationships).

This can be useful in the area of machine translation and word glossing. Ostensibly, they're low-cost features to extract for less trivial machine learning applications in NLP, such as syntactic or dependency parsing. 

If you're interested in learning more, you can check out Finite State Morphology by Beesley and Karttunen, and the Xerox Finite State Toolkit they designed at PARC.

blocks|key|3145141|text|什么样的任务？|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|3145142|除了我所看到的，任何类型的解析通常都是作为状态机实现的。|3145143|为什么？|3145144|解析语法通常不是一项简单的任务。在设计阶段，通常会绘制状态图来测试解析算法。将其转换为状态机实现是一项相当简单的任务。|3145145|How?|3145146|嗯，你只是受到你的想象力的限制。|3145147|我在case+statements+and+loops上见过。|3145148|我见过用labels+and+goto语句完成这项工作|3145149|我甚至见过用函数指针的结构来表示当前状态。当状态改变时，将更新一个或多个function+pointer。|3145150|我见过它只在代码中完成，其中状态的改变仅仅意味着您在不同的代码部分中运行。(没有状态变量，并在必要时编写冗余代码。这可以作为一个非常简单的排序来演示，它只对非常小的数据集有用。|3145151|int+a[10]+=+{some+unsorted+integers};

not_sorted_state:;
++++z+=+-1;
++++while+(z+<+(sizeof(a)+/+sizeof(a[0])+-+1)
++++{
++++++++z+=+z+%2B+1
++++++++if+(a[z]+>+a[z+%2B+1])
++++++++{
++++++++++++//+ASSERT+The+array+is+not+in+order
++++++++++++swap(a[z],+a[z+%2B+1];++++++++//+make+the+array+more+sorted
++++++++++++goto+not_sorted_state;++++++//+change+state+to+sort+the+array
++++++++}
++++}
++++//+ASSERT+the+array+is+in+order|code-block|syntax|javascript|3145152|没有状态变量，但代码本身表示状态|3145153|entityMap|0|LINK|mutability|MUTABLE|url|http://www.kirit.com/Implementing%2520a%2520state%2520engine%2520using%2520instance%2520behaviour|1|http://backpan.perl.org/authors/id/D/DW/DWHEELER/FSA-Rules-0.05.readme|2|http://www.gamedev.net/reference/articles/article2116.asp^0|0|7|0|0|0|4|0|0|0|4|0|0|2|P|0|0|4|F|1|0|10|G|2|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1G|8|@$9|1H|A|1I|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1J|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|1K|8|@$9|1L|A|1M|B|C]]|D|@]|E|$]]|$1|J|3|K|5|6|7|1N|8|@]|D|@]|E|$]]|$1|L|3|M|5|6|7|1O|8|@$9|1P|A|1Q|B|C]]|D|@]|E|$]]|$1|N|3|O|5|6|7|1R|8|@]|D|@]|E|$]]|$1|P|3|Q|5|6|7|1S|8|@]|D|@$9|1T|A|1U|1|1V]]|E|$]]|$1|R|3|S|5|6|7|1W|8|@]|D|@$9|1X|A|1Y|1|1Z]]|E|$]]|$1|T|3|U|5|6|7|20|8|@]|D|@$9|21|A|22|1|23]]|E|$]]|$1|V|3|W|5|6|7|24|8|@]|D|@]|E|$]]|$1|X|3|Y|5|Z|7|25|8|@]|D|@]|E|$10|11]]|$1|12|3|13|5|6|7|26|8|@]|D|@]|E|$]]|$1|14|3|-4|5|6|7|27|8|@]|D|@]|E|$]]]|15|$16|$5|17|18|19|E|$1A|1B]]|1C|$5|17|18|19|E|$1A|1D]]|1E|$5|17|18|19|E|$1A|1F]]]]

What sort of task?

Any task but from what I have seen, Parsing of any sort is frequently implemented as a state machine.

Why?

Parsing a grammar is generally not a straightforward task. During the design phase it is fairly common that a state diagram is drawn to test the parsing algorithm. Translating that to a state machine implementation is a fairly simple task.

How?

Well, you are limited only by your imagination.

I have seen it done with <a href="http://www.kirit.com/Implementing%20a%20state%20engine%20using%20instance%20behaviour" rel="noreferrer">case statements and loops</a>.

I have seen it done with <a href="http://backpan.perl.org/authors/id/D/DW/DWHEELER/FSA-Rules-0.05.readme" rel="noreferrer">labels and goto</a> statements

I have even seen it done with structures of function pointers which represent the current state. When the state changes, one or more <a href="http://www.gamedev.net/reference/articles/article2116.asp" rel="noreferrer">function pointer</a> is updated.

I have seen it done in code only, where a change of state simply means that you are running in a different section of code. (no state variables, and redundent code where necessary. This can be demonstrated as a very simply sort, which is useful for only very small sets of data.

<pre><code>int a[10] = {some unsorted integers};

not_sorted_state:;
 z = -1;
 while (z &lt; (sizeof(a) / sizeof(a[0]) - 1)
 {
 z = z + 1
 if (a[z] &gt; a[z + 1])
 {
 // ASSERT The array is not in order
 swap(a[z], a[z + 1]; // make the array more sorted
 goto not_sorted_state; // change state to sort the array
 }
 }
 // ASSERT the array is in order
</code></pre>

There are no state variables, but the code itself represents the state

blocks|key|3357886|text|Regular+expressions是有限状态机(或“有限状态自动机”)发挥作用的另一个例子。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3357887|编译后的regexp是一个有限状态机，正则表达式可以匹配的字符串集正是有限状态自动机可以接受的语言(称为“正则语言”)。|3357888|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Regular_expression^0|0|J|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]]|C|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]]]

<a href="http://en.wikipedia.org/wiki/Regular_expression" rel="nofollow noreferrer">Regular expressions</a> are another example of where finite state machines (or "finite state automata") come into play. 

A compiled regexp is a finite state machine, and
the sets of strings that regular expressions can match are exactly the languages that finite state automata can accept (called "regular languages").

blocks|key|358758|text|许多数字硬件设计都涉及创建状态机来指定电路的行为。如果你在写VHDL，它会出现很多。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|358759|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

A lot of digital hardware design involves creating state machines to specify the behaviour of your circuits. It comes up quite a bit if you're writing VHDL.

blocks|key|356610|text|当你有多个状态，并且需要在刺激下转换到不同的状态时，就会使用FSM。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|356611|(事实证明，这至少在理论上包含了大多数问题)|356612|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

A FSM is used everywhere you have multiple states and need to transition to a different state on stimulus. 

(turns out that this encompasses most problems, at least theoretically)

blocks|key|3145353|text|状态驱动代码是实现某些类型逻辑的好方法(解析器就是一个例子)。它可以通过几种方式来完成，例如：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3145354|3145355|状态驱动在给定点实际执行哪一位代码(即状态隐含在您正在编写的代码片段中)。Recursive+descent+parsers就是这类代码的一个很好的例子。|unordered-list-item|offset|length|3145356|状态驱动在条件中要做什么，比如切换和状态机，比如由解析器生成工具生成的状态机，比如Lex和Lex|3145357|3145358|并不是所有的状态驱动代码都用于解析。通用状态机生成器是smc。它吸入状态机的定义(以其语言表示)，并以各种语言输出状态机的代码。|3145359|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Recursive_descent_parser|1|http://en.wikipedia.org/wiki/Lex_programming_tool|2|3|http://smc.sourceforge.net/^0|0|0|11|P|0|0|15|3|1|19|3|2|0|0|R|3|3|0^^$0|@$1|2|3|4|5|6|7|Z|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|10|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|11|8|@]|9|@$F|12|G|13|1|14]]|A|$]]|$1|H|3|I|5|E|7|15|8|@]|9|@$F|16|G|17|1|18]|$F|19|G|1A|1|1B]]|A|$]]|$1|J|3|-4|5|6|7|1C|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|1D|8|@]|9|@$F|1E|G|1F|1|1G]]|A|$]]|$1|M|3|-4|5|6|7|1H|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]|U|$5|P|Q|R|A|$S|V]]|W|$5|P|Q|R|A|$S|V]]|X|$5|P|Q|R|A|$S|Y]]]]

State driven code is a good way to implement certain types of logic (parsers being an example). It can be done in several ways, for example:

<ul>
<li>State driving which bit of code is actually being executed at a given point (i.e. the state is implicit in the piece of code you are writing). <a href="http://en.wikipedia.org/wiki/Recursive_descent_parser" rel="nofollow noreferrer">Recursive descent parsers</a> are a good example of this type of code.</li>
<li>State driving what to do in a conditional such as a switch statement.</li>
<li>Explicit state machines such as those generated by parser generating tools such as <a href="http://en.wikipedia.org/wiki/Lex_programming_tool" rel="nofollow noreferrer">Lex</a> and <a href="http://en.wikipedia.org/wiki/Yacc" rel="nofollow noreferrer">Yacc</a>.</li>
</ul>

Not all state driven code is used for parsing. A general state machine generator is <a href="http://smc.sourceforge.net/" rel="nofollow noreferrer">smc</a>. It inhales a definition of a state machine (in its language) and it will spit out code for the state machine in a variety of languages.

blocks|key|3358072|text|我有一个来自我正在处理的系统的例子。我正在构建一个股票交易系统。跟踪订单状态的过程可能很复杂，但如果为订单的生命周期构建状态图，则会使将新的传入事务应用于现有订单变得简单得多。如果您从事务的当前状态知道新事务只能是三种事物中的一种，而不是20种事物中的一种，那么在应用该事务时需要进行的比较就会少得多。它使代码更有效率。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3358073|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I have an example from a current system I'm working on. I'm in the process of building a stock trading system. The process of tracking the state of an order can be complex, but if you build a state diagram for the life cycle of an order it makes applying new incoming transactions to the existing order much simpler. There are many fewer comparisons necessary in applying that transaction if you know from its current state that the new transaction can only be one of three things rather than one of 20 things. It makes the code much more efficient.

blocks|key|3358101|text|在哪些编程领域，我将使用状态机？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3358102|使用状态机表示一个(真实的或逻辑的)对象，该对象可以存在于有限数量的条件(“状态”)中，并根据一组固定的规则从一个状态前进到下一个状态。|3358103|为什么我要使用状态机？|3358104|状态机通常是一种非常简洁的方式来表示一组复杂的规则和条件，并处理各种输入。您将在内存有限的嵌入式设备中看到状态机。如果实现良好，状态机是自文档化的，因为每个逻辑状态代表一个物理条件。与其过程等效物相比，状态机可以包含在极少量的代码中，并且运行效率极高。此外，控制状态更改的规则通常可以作为数据存储在表中，从而提供易于维护的紧凑表示。|3358105|我如何实现一个？|3358106|简单的例子：|3358107|enum+states+{++++++//+Define+the+states+in+the+state+machine.
++NO_PIZZA,++++++++//+Exit+state+machine.
++COUNT_PEOPLE,++++//+Ask+user+for+#+of+people.
++COUNT_SLICES,++++//+Ask+user+for+#+slices.
++SERVE_PIZZA,+++++//+Validate+and+serve.
++EAT_PIZZA++++++++//+Task+is+complete.
}+STATE;

STATE+state+=+COUNT_PEOPLE;
int+nPeople,+nSlices,+nSlicesPerPerson;

//+Serve+slices+of+pizza+to+people,+so+that+each+person+gets
///+the+same+number+of+slices.+++
while+(state+!=+NO_PIZZA)++{
+++switch+(state)++{
+++case+COUNT_PEOPLE:++
+++++++if+(promptForPeople(&nPeople))++//+If+input+is+valid..
+++++++++++state+=+COUNT_SLICES;+++++++//+..+go+to+next+state..
+++++++break;++++++++++++++++++++++++++//+..+else+remain+in+this+state.
+++case+COUNT_SLICES:++
+++++++if+(promptForSlices(&nSlices))
++++++++++state+=+SERVE_PIZZA;
++++++++break;
+++case+SERVE_PIZZA:
+++++++if+(nSlices+%25+nPeople+!=+0)++++//+Can't+divide+the+pizza+evenly.
+++++++{+++++++++++++++++++++++++++++
+++++++++++getMorePizzaOrFriends();+++//+Do+something+about+it.
+++++++++++state+=+COUNT_PEOPLE;++++++//+Start+over.
+++++++}
+++++++else
+++++++{
+++++++++++nSlicesPerPerson+=+nSlices/nPeople;
+++++++++++state+=+EAT_PIZZA;
+++++++}
+++++++break;
+++case+EAT_PIZZA:
+++++++//+etc...
+++++++state+=+NO_PIZZA;++//+Exit+the+state+machine.
+++++++break;
+++}+//+switch
}+//+while|code-block|syntax|javascript|3358108|​|3358109|备注：|offset|length|style|BOLD|3358110|3358111|为简单起见，本例使用具有显式case/break状态的switch()。|unordered-list-item|CODE|3358112|为了便于维护大型状态机，可以将在每个case中完成的工作封装在一个"worker“函数中。获取while()顶部的任何输入，将其传递给worker函数，并检查worker的返回值以计算下一个状态。|3358113|为了紧凑，可以将整个switch()替换为函数指针数组。每个状态都由一个函数实现，该函数的返回值是指向下一个状态的指针。警告:这可能会简化状态机或使其完全不可维护，因此请考虑将carefully!|3358114|An+embedded+device实现为仅在发生灾难性错误时退出的状态机，然后执行硬重置并重新进入状态机。|3358115|3358116|entityMap^0|0|0|0|0|0|0|0|0|0|3|0|0|E|4|J|5|R|8|0|I|4|1B|7|0|A|8|0|0|0^^$0|@$1|2|3|4|5|6|7|1C|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1D|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1E|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|1F|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|1G|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|1H|8|@]|9|@]|A|$]]|$1|L|3|M|5|N|7|1I|8|@]|9|@]|A|$O|P]]|$1|Q|3|R|5|6|7|1J|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|1K|8|@$U|1L|V|1M|W|X]]|9|@]|A|$]]|$1|Y|3|-4|5|6|7|1N|8|@]|9|@]|A|$]]|$1|Z|3|10|5|11|7|1O|8|@$U|1P|V|1Q|W|12]|$U|1R|V|1S|W|12]|$U|1T|V|1U|W|12]]|9|@]|A|$]]|$1|13|3|14|5|11|7|1V|8|@$U|1W|V|1X|W|12]|$U|1Y|V|1Z|W|12]]|9|@]|A|$]]|$1|15|3|16|5|11|7|20|8|@$U|21|V|22|W|12]]|9|@]|A|$]]|$1|17|3|18|5|11|7|23|8|@]|9|@]|A|$]]|$1|19|3|-4|5|6|7|24|8|@]|9|@]|A|$]]|$1|1A|3|-4|5|6|7|25|8|@]|9|@]|A|$]]]|1B|$]]

<h2>In what areas of programming would I use a state machine?</h2>

Use a state machine to represent a (real or logical) object that can exist in a limited number of conditions ("states") and progresses from one state to the next according to a fixed set of rules.

<h2>Why would I use a state machine?</h2>

A state machine is often a very compact way to represent a set of complex rules and conditions, and to process various inputs. You'll see state machines in embedded devices that have limited memory. Implemented well, a state machine is self-documenting because each logical state represents a physical condition. A state machine can be embodied in a tiny amount of code in comparison to its procedural equivalent and runs extremely efficiently. Moreover, the rules that govern state changes can often be stored as data in a table, providing a compact representation that can be easily maintained.

<h2>How can I implement one?</h2>

Trivial example:

<pre><code>enum states { // Define the states in the state machine.
 NO_PIZZA, // Exit state machine.
 COUNT_PEOPLE, // Ask user for # of people.
 COUNT_SLICES, // Ask user for # slices.
 SERVE_PIZZA, // Validate and serve.
 EAT_PIZZA // Task is complete.
} STATE;

STATE state = COUNT_PEOPLE;
int nPeople, nSlices, nSlicesPerPerson;

// Serve slices of pizza to people, so that each person gets
/// the same number of slices. 
while (state != NO_PIZZA) {
 switch (state) {
 case COUNT_PEOPLE: 
 if (promptForPeople(&amp;nPeople)) // If input is valid..
 state = COUNT_SLICES; // .. go to next state..
 break; // .. else remain in this state.
 case COUNT_SLICES: 
 if (promptForSlices(&amp;nSlices))
 state = SERVE_PIZZA;
 break;
 case SERVE_PIZZA:
 if (nSlices % nPeople != 0) // Can't divide the pizza evenly.
 { 
 getMorePizzaOrFriends(); // Do something about it.
 state = COUNT_PEOPLE; // Start over.
 }
 else
 {
 nSlicesPerPerson = nSlices/nPeople;
 state = EAT_PIZZA;
 }
 break;
 case EAT_PIZZA:
 // etc...
 state = NO_PIZZA; // Exit the state machine.
 break;
 } // switch
} // while
</code></pre>



Notes:

<ul>
<li>The example uses a <code>switch()</code> with explicit <code>case</code>/<code>break</code> states for simplicity. In practice, a <code>case</code> will often "fall through" to the next state.</li>
<li>For ease of maintaining a large state machine, the work done in each <code>case</code> can be encapsulated in a "worker" function. Get any input at the top of the <code>while()</code>, pass it to the worker function, and check the return value of the worker to compute the next state.</li>
<li>For compactness, the entire <code>switch()</code> can be replaced with an array of function pointers. Each state is embodied by a function whose return value is a pointer to the next state. Warning: This can either simplify the state machine or render it totally unmaintainable, so consider the implementation carefully!</li>
<li>An embedded device may be implemented as a state machine that exits only on a catastrophic error, after which it performs a hard reset and re-enters the state machine.</li>
</ul>

blocks|key|3145478|text|已经有一些很棒的答案了。从稍微不同的角度来看，可以考虑在更大的字符串中搜索文本。有人已经提到了正则表达式，这真的只是一个特例，尽管很重要。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3145479|考虑下面的方法调用：|3145480|very_long_text+=+"Bereshit+bara+Elohim+et+hashamayim+ve'et+ha'arets."+…
word+=+"Elohim"
position+=+find_in_string(very_long_text,+word)|code-block|syntax|javascript|3145481|您将如何实现find_in_string？简单的方法是使用嵌套循环，如下所示：|offset|length|style|CODE|3145482|for+i+in+0+…+length(very_long_text)+-+length(word):
++++found+=+true
++++for+j+in+0+…+length(word):
++++++++if+(very_long_text[i]+!=+word[j]):
++++++++++++found+=+false
++++++++++++break
++++if+found:+return+i
return+-1|3145483|除了效率低下之外，它还形成了一个状态机！这里的状态在某种程度上是隐藏的；让我稍微重写一下代码，使它们更可见：|3145484|state+=+0
for+i+in+0+…+length(very_long_text)+-+length(word):
++++if+very_long_text[i]+==+word[state]:
++++++++state+%2B=+1
++++++++if+state+==+length(word)+%2B+1:+return+i
++++else:
++++++++state+=+0
return+-1|3145485|这里的不同状态直接表示我们搜索的单词中的所有不同位置。对于图中的每个节点，有两个转换:如果字母匹配，则转到下一个状态；对于其他输入(即，当前位置上的每个字母)，返回到零。|3145486|这种轻微的重构有一个巨大的优势:现在可以使用一些基本技术对其进行调整，以产生更好的性能。事实上，每个高级字符串搜索算法(暂时不考虑索引数据结构)都建立在这个状态机之上，并改进了它的某些方面。|3145487|entityMap^0|0|0|0|6|E|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|11|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|12|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|13|8|@$K|14|L|15|M|N]]|9|@]|A|$]]|$1|O|3|P|5|F|7|16|8|@]|9|@]|A|$G|H]]|$1|Q|3|R|5|6|7|17|8|@]|9|@]|A|$]]|$1|S|3|T|5|F|7|18|8|@]|9|@]|A|$G|H]]|$1|U|3|V|5|6|7|19|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|1A|8|@]|9|@]|A|$]]|$1|Y|3|-4|5|6|7|1B|8|@]|9|@]|A|$]]]|Z|$]]

Some great answers already. For a slightly different perspective, consider searching a text in a larger string. Someone has already mentioned regular expressions and this is really just a special case, albeit an important one.

Consider the following method call:

<pre><code>very_long_text = "Bereshit bara Elohim et hashamayim ve'et ha'arets." …
word = "Elohim"
position = find_in_string(very_long_text, word)
</code></pre>

How would you implement <code>find_in_string</code>? The easy approach would use a nested loop, something like this:

<pre><code>for i in 0 … length(very_long_text) - length(word):
 found = true
 for j in 0 … length(word):
 if (very_long_text[i] != word[j]):
 found = false
 break
 if found: return i
return -1
</code></pre>

Apart from the fact that this is inefficient, it forms a state machine! The states here are somewhat hidden; let me rewrite the code slightly to make them more visible:

<pre><code>state = 0
for i in 0 … length(very_long_text) - length(word):
 if very_long_text[i] == word[state]:
 state += 1
 if state == length(word) + 1: return i
 else:
 state = 0
return -1
</code></pre>

The different states here directly represent all different positions in the word we search for. There are two transitions for each node in the graph: if the letters match, go to the next state; for every other input (i.e. every other letter at the current position), go back to zero.

This slight reformulation has a huge advantage: it can now be tweaked to yield better performance using some basic techniques. In fact, every advanced string searching algorithm (discounting index data structures for the moment) builds on top of this state machine and improves some aspects of it.

blocks|key|3358218|text|以下是状态机的测试和工作示例。假设你在一个串行流上(串口、tcp/ip数据或文件都是典型的例子)。在这种情况下，我正在寻找一个特定的数据包结构，它可以分为三个部分:同步、长度和有效负载。我有三个状态，一个是空闲，等待同步，第二个是我们有一个好的同步，下一个字节应该是长度，第三个状态是累积有效负载。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3358219|该示例是纯串行的，只有一个缓冲区，正如这里所写的，它将从坏字节或包中恢复，可能会丢弃包，但最终会恢复，您可以做其他事情，如滑动窗口，以允许立即恢复。下面的代码不会检测到这一点，它将丢弃部分包和整个包，并在下一个包上恢复。如果你真的需要处理所有的数据包，滑动窗口可以帮你解决这个问题。|3358220|我一直在使用这种状态机，无论是串行数据流、tcp/ip、文件i/o，还是tcp/ip协议本身，比如说你想发送一封电子邮件，打开端口，等待服务器发送响应，发送HELO，等待服务器发送数据包，发送数据包，等待回复，等等。基本上在这种情况下，以及在下面的情况下，你可能会空闲地等待下一个字节/数据包进入。为了记住你等待的是什么，也要重用等待的代码，你可以使用状态变量。与在逻辑中使用状态机的方式相同(等待下一个时钟，我在等待什么)。|3358221|就像在逻辑中一样，你可能想要为每个状态做一些不同的事情，在这种情况下，如果我有一个好的同步模式，我会将偏移量重置到我的存储器中，同时重置校验和累加器。数据包长度状态说明了您可能想要退出正常控制路径的情况。不是所有的，事实上，许多状态机可能会在正常路径内跳跃或循环，下面的一个几乎是线性的。|3358222|我希望这是有用的，并希望状态机在软件中得到更多的使用。|3358223|测试数据有故意的问题，状态机从中恢复。在第一个好的包之后有一些垃圾数据，一个具有坏的校验和的包，以及一个长度无效的包。我的输出是：|3358224|好数据包:FA0712345678EB无效同步模式0x12无效同步模式0x34无效同步模式0x56校验和错误0xBF无效数据包长度0无效同步模式0x12无效同步模式0x34无效同步模式0x56无效同步模式0x78无效同步模式0xEB好数据包:FA081234567800EA没有更多测试数据|3358225|流中的两个好的数据包被提取出来，尽管有坏的数据。并对不良数据进行检测和处理。|3358226|+#include+<stdio.h>
+#include+<stdlib.h>
+#include+<string.h>

unsigned+char+testdata[]+=
{
++++0xFA,0x07,0x12,0x34,0x56,0x78,0xEB,++
++++0x12,0x34,0x56,++
++++0xFA,0x07,0x12,0x34,0x56,0x78,0xAA,++
++++0xFA,0x00,0x12,0x34,0x56,0x78,0xEB,++
++++0xFA,0x08,0x12,0x34,0x56,0x78,0x00,0xEA++
};

unsigned+int+testoff=0;

//packet+structure++
//+[0]+packet+header+0xFA++
//+[1]+bytes+in+packet+(n)++
//+[2]+payload++
//+...+payload++
//+[n-1]+checksum++
//++

unsigned+int+state;

unsigned+int+packlen;++
unsigned+int+packoff;++
unsigned+char+packet[256];++
unsigned+int+checksum;++

int+process_packet(+unsigned+char+*data,+unsigned+int+len+)++
{++
++++unsigned+int+ra;++

++++printf("good+packet:");
++++for(ra=0;ra<len;ra%2B%2B)+printf("%2502X",data[ra]);
++++printf("\n");
}++
int+getbyte+(+unsigned+char+*d+)++
{++
++++//check+peripheral+for+a+new+byte++
++++//or+serialize+a+packet+or+file++

++++if(testoff<sizeof(testdata))
++++{
++++++++*d=testdata[testoff%2B%2B];
++++++++return(1);
++++}
++++else
++++{
++++++++printf("no+more+test+data\n");
++++++++exit(0);
++++}
++++return(0);
}

int+main+(+void+)++
{++
++++unsigned+char+b;

++++state=0;+//idle

++++while(1)
++++{
++++++++if(getbyte(&b))
++++++++{
++++++++++++switch(state)
++++++++++++{
++++++++++++++++case+0:+//idle
++++++++++++++++++++if(b!=0xFA)
++++++++++++++++++++{
++++++++++++++++++++++++printf("Invalid+sync+pattern+0x%2502X\n",b);
++++++++++++++++++++++++break;
++++++++++++++++++++}
++++++++++++++++++++packoff=0;
++++++++++++++++++++checksum=b;
++++++++++++++++++++packet[packoff%2B%2B]=b;

++++++++++++++++++++state%2B%2B;
++++++++++++++++++++break;
++++++++++++++++case+1:+//packet+length
++++++++++++++++++++checksum%2B=b;
++++++++++++++++++++packet[packoff%2B%2B]=b;

++++++++++++++++++++packlen=b;
++++++++++++++++++++if(packlen<3)
++++++++++++++++++++{
++++++++++++++++++++++++printf("Invalid+packet+length+%25u\n",packlen);
++++++++++++++++++++++++state=0;
++++++++++++++++++++++++break;
++++++++++++++++++++}

++++++++++++++++++++state%2B%2B;
++++++++++++++++++++break;
++++++++++++++++case+2:+//payload
++++++++++++++++++++checksum%2B=b;
++++++++++++++++++++packet[packoff%2B%2B]=b;

++++++++++++++++++++if(packoff>=packlen)
++++++++++++++++++++{
++++++++++++++++++++++++state=0;
++++++++++++++++++++++++checksum=checksum&0xFF;
++++++++++++++++++++++++if(checksum)
++++++++++++++++++++++++{
++++++++++++++++++++++++++++printf("Checksum+error+0x%2502X\n",checksum);
++++++++++++++++++++++++}
++++++++++++++++++++++++else
++++++++++++++++++++++++{
++++++++++++++++++++++++++++process_packet(packet,packlen);
++++++++++++++++++++++++}
++++++++++++++++++++}
++++++++++++++++++++break;
++++++++++++}
++++++++}

++++++++//do+other+stuff,+handle+other+devices/interfaces

++++}
}|code-block|syntax|javascript|3358227|entityMap^0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Y|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|Z|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|10|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|11|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|12|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|13|8|@]|9|@]|A|$]]|$1|P|3|Q|5|R|7|14|8|@]|9|@]|A|$S|T]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

Here is a tested and working example of a state machine. Say you are on a serial stream (serial port, tcp/ip data, or file are typical examples). In this case I am looking for a specific packet structure that can be broken into three parts, sync, length, and payload. I have three states, one is idle, waiting for the sync, the second is we have a good sync the next byte should be length, and the third state is accumulate the payload.

The example is purely serial with only one buffer, as written here it will recover from a bad byte or packet, possibly discarding a packet but eventually recovering, you can do other things like a sliding window to allow for immediate recovery. This would be where you have say a partial packet that is cut short then a new complete packet starts, the code below wont detect this and will throw away the partial as well as the whole packet and recover on the next. A sliding window would save you there if you really needed to process all the whole packets.

I use this kind of a state machine all the time be it serial data streams, tcp/ip, file i/o. Or perhaps tcp/ip protocols themselves, say you want to send an email, open the port, wait for the server to send a response, send HELO, wait for the server to send a packet, send a packet, wait for the reply, etc. Essentially in that case as well as in the case below you may be idling waiting for that next byte/packet to come in. To remember what you were waiting for, also to re-use the code that waits for something you can use state variables. The same way that state machines are used in logic (waiting for the next clock, what was I waiting for). 

Just like in logic, you may want to do something different for each state, in this case if I have a good sync pattern I reset the offset into my storage as well as reset the checksum accumulator. The packet length state demonstrates a case where you may want to abort out of the normal control path. Not all, in fact many state machines may jump around or may loop around within the normal path, the one below is pretty much linear.

I hope this is useful and wish that state machines were used more in software.

The test data has intentional problems with it that the state machine recovers from. There is some garbage data after the first good packet, a packet with a bad checksum, and a packet with an invalid length. My output was:

good packet:FA0712345678EB
Invalid sync pattern 0x12
Invalid sync pattern 0x34
Invalid sync pattern 0x56
Checksum error 0xBF
Invalid packet length 0
Invalid sync pattern 0x12
Invalid sync pattern 0x34
Invalid sync pattern 0x56
Invalid sync pattern 0x78
Invalid sync pattern 0xEB
good packet:FA081234567800EA
no more test data

The two good packets in the stream were extracted despite the bad data. And the bad data was detected and dealt with.

<pre><code> #include &lt;stdio.h&gt;
 #include &lt;stdlib.h&gt;
 #include &lt;string.h&gt;

unsigned char testdata[] =
{
 0xFA,0x07,0x12,0x34,0x56,0x78,0xEB, 
 0x12,0x34,0x56, 
 0xFA,0x07,0x12,0x34,0x56,0x78,0xAA, 
 0xFA,0x00,0x12,0x34,0x56,0x78,0xEB, 
 0xFA,0x08,0x12,0x34,0x56,0x78,0x00,0xEA 
};

unsigned int testoff=0;

//packet structure 
// [0] packet header 0xFA 
// [1] bytes in packet (n) 
// [2] payload 
// ... payload 
// [n-1] checksum 
// 

unsigned int state;

unsigned int packlen; 
unsigned int packoff; 
unsigned char packet[256]; 
unsigned int checksum; 

int process_packet( unsigned char *data, unsigned int len ) 
{ 
 unsigned int ra; 

 printf("good packet:");
 for(ra=0;ra&lt;len;ra++) printf("%02X",data[ra]);
 printf("\n");
} 
int getbyte ( unsigned char *d ) 
{ 
 //check peripheral for a new byte 
 //or serialize a packet or file 

 if(testoff&lt;sizeof(testdata))
 {
 *d=testdata[testoff++];
 return(1);
 }
 else
 {
 printf("no more test data\n");
 exit(0);
 }
 return(0);
}

int main ( void ) 
{ 
 unsigned char b;

 state=0; //idle

 while(1)
 {
 if(getbyte(&amp;b))
 {
 switch(state)
 {
 case 0: //idle
 if(b!=0xFA)
 {
 printf("Invalid sync pattern 0x%02X\n",b);
 break;
 }
 packoff=0;
 checksum=b;
 packet[packoff++]=b;

 state++;
 break;
 case 1: //packet length
 checksum+=b;
 packet[packoff++]=b;

 packlen=b;
 if(packlen&lt;3)
 {
 printf("Invalid packet length %u\n",packlen);
 state=0;
 break;
 }

 state++;
 break;
 case 2: //payload
 checksum+=b;
 packet[packoff++]=b;

 if(packoff&gt;=packlen)
 {
 state=0;
 checksum=checksum&amp;0xFF;
 if(checksum)
 {
 printf("Checksum error 0x%02X\n",checksum);
 }
 else
 {
 process_packet(packet,packlen);
 }
 }
 break;
 }
 }

 //do other stuff, handle other devices/interfaces

 }
}
</code></pre>

blocks|key|361484|text|我在这里没有看到任何解释我看到它们被使用的原因的东西。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|361485|出于实际目的，当程序员被迫在操作过程中返回线程/出口时，通常必须添加一个。|361486|例如，如果您有一个多状态HTTP请求，您的服务器代码可能如下所示：|361487|Show+form+1
process+form+1
show+form+2
process+form+2|code-block|syntax|javascript|361488|问题是，每次显示表单时，您都必须退出服务器上的整个线程(在大多数语言中)，即使您的代码都逻辑地流动在一起并使用相同的变量。|361489|在代码中添加中断并返回线程的操作通常通过switch语句完成，并创建所谓的状态机(非常基本的版本)。|361490|当你变得越来越复杂时，想要弄清楚哪些状态是有效的就会变得非常困难。然后，人们通常定义一个"State+Transition+Table“来描述所有的状态转换。|offset|length|361491|我写了一个state+machine+library，主要的概念是你可以直接实现你的状态转换表。这真的是一次整洁的练习，虽然不确定它会有多好。|361492|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/State_transition_table|1|http://code.google.com/p/state-machine/^0|0|0|0|0|0|0|19|M|0|0|5|L|1|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|15|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|16|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|17|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|18|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|19|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|1A|8|@]|9|@$Q|1B|R|1C|1|1D]]|A|$]]|$1|S|3|T|5|6|7|1E|8|@]|9|@$Q|1F|R|1G|1|1H]]|A|$]]|$1|U|3|-4|5|6|7|1I|8|@]|9|@]|A|$]]]|V|$W|$5|X|Y|Z|A|$10|11]]|12|$5|X|Y|Z|A|$10|13]]]]

I didn't see anything here that actually explained the reason I see them used.

For practical purposes, a programmer usually has to add one when he is forced to return a thread/exit right in the middle of an operation.

For instance, if you have a multi-state HTTP request, you might have server code that looks like this:

<pre><code>Show form 1
process form 1
show form 2
process form 2
</code></pre>

The thing is, every time you show a form, you have to quit out of your entire thread on the server (in most languages), even if your code all flows together logically and uses the same variables.

The act of putting a break in the code and returning the thread is usually done with a switch statement and creates what is called a state machine (Very Basic Version).

As you get more complex, it can get really difficult to figure out what states are valid. People usually then define a "<a href="http://en.wikipedia.org/wiki/State_transition_table" rel="nofollow noreferrer">State Transition Table</a>" to describe all the state transitions.

I wrote a <a href="http://code.google.com/p/state-machine/" rel="nofollow noreferrer">state machine library</a>, the main concept being that you can actually implement your state transition table directly. It was a really neat exercise, not sure how well it's going to go over though...

blocks|key|3358333|text|很好的答案。这是我的两分钱。有限状态机是一个理论上的想法，它可以通过多种不同的方式实现，比如一个表，或者作为一个while-switch+(但不要告诉任何人这是一种goto+horrors的方式)。这是一个定理，任何FSM对应于正则表达式，反之亦然。因为一个正则表达式对应于一个结构化程序，你可以写一个结构化的程序来实现你的。例如，一个简单的数字解析器可以写成如下代码：|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|3358334|/*+implement+dd*[.d*]+*/
if+(isdigit(*p)){
++++while(isdigit(*p))+p%2B%2B;
++++if+(*p=='.'){
++++++++p%2B%2B;
++++++++while(isdigit(*p))+p%2B%2B;
++++}
++++/*+got+it!+*/
}|code-block|syntax|javascript|3358335|你明白了吧。如果有一种方法跑得更快，我不知道是什么。|3358336|entityMap^0|4I|N|0|0|0|Q|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|N|$]]

Good answers. Here's my 2 cents. Finite State Machines are a theoretical idea that can be implemented multiple different ways, such as a table, or as a while-switch (but don't tell anybody it's a way of saying goto horrors). It is a theorem that any FSM corresponds to a regular expression, and vice versa. Since a regular expression corresponds to a structured program, you can sometimes just write a structured program to implement your FSM. For example, a simple parser of numbers could be written along the lines of:

<pre><code>/* implement dd*[.d*] */
if (isdigit(*p)){
 while(isdigit(*p)) p++;
 if (*p=='.'){
 p++;
 while(isdigit(*p)) p++;
 }
 /* got it! */
}
</code></pre>

You get the idea. And, if there's a way that runs faster, I don't know what it is.

blocks|key|358165|text|一个典型的用例是红绿灯。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|358166|关于实现说明:Java5的枚举可以有抽象的方法，这是封装依赖于状态的行为的一种很好的方法。|358167|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

A typical use case is traffic lights.

On an implementation note: Java 5's enums can have abstract methods, which is an excellent way to encapsulate state-dependent behavior.

In what areas of programming would I use state machines ? Why ? How could I implement one ?

EDIT: please provide a practical example , if it's not too much to ask .

uses for state machines

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

在哪些编程领域，我将使用状态机？为什么？我怎么能实现一个呢？编辑：如果要求不是太高，请提供一个实用的示例。

问状态机的用法
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问状态机的用法EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问状态机的用法
EN