getasynckeystate php design pattern State state pattern

State state mode is one of the 23 modes of GOF. Like the command mode, it is also a behavioral mode. The state mode is quite similar to the command mode. They are both the application of the "interface-implementation class" mode and the embodiment of the interface-oriented programming principle.
The state pattern is an object creation pattern. Its intention is to allow an object to change its behavior when its internal state changes. The object will appear to have modified its class. A more common example is in a class TCPConnection that represents a network connection. The status of a TCPConnection object is in one of several different states: the connection has been established (Established), is listening, and the connection has been closed (closed). When a TCPConnection object receives a request from another object, it responds differently based on its own status.
For example: the result of an Open request depends on whether the connection is closed or the connection is established. State mode describes how TCPConnection exhibits different behaviors in each state. The key idea of ​​this model is to introduce an abstract class called TCPState to represent the connection status of the network. The TCPState class declares a public interface for various subclasses that represent different operating states. Subclasses of TCPState implement behaviors related to specific states. For example, the TCPEstablished and TCPClosed classes implement behaviors specific to the connection established and closed states of TCPConnection, respectively.
For example: a person has states such as angry, happy, and crazy. Doing the same thing in these states may have different results, and a person's mood may cycle through these three states. Use a moodState class to represent a person's mood, and use mad, Happy, and Angry classes to represent different moods.
Let’s look at an example first:

Copy the code The code is as follows:

/**
* State Pattern
*
* Allows an object to change its behavior when its internal state changes, making the object appear to modify the class it belongs to
*
*/
interface State
{
public function handle($state);
public function display();
}
class Context
{
private $_state = null;
public function __construct($state)
{
$this->setState($state);
}
public function setState($state)
{
$this->_state = $state;
}
public function request()
{
$this->_state->display();
$this->_state->handle($ this);
}
}
class StateA implements State
{
public function handle($context)
{
$context->setState(new StateB());
}
public function display()
{
echo "state A
";
}
}
class StateB implements State
{
public function handle($context)
{
$context->setState(new StateC());
}
public function display()
{
echo "state B
";
}
}
class StateC implements State
{
public function handle($context)
{
$context->setState(new StateA() );
}
public function display()
{
echo "state C
";
}
}
// Instantiate it
$objContext = new Context(new StateB());
$objContext ->request();
$objContext->request();
$objContext->request();
$objContext->request();
$objContext->request();

There are two key points in understanding the state mode:
1. Usually there is only one method in the interface of the command mode. The state mode interface has one or more methods. Moreover, the methods of the state pattern implementation class generally return a value; or change the value of an instance variable. In other words, the state pattern is generally related to the state of the object. The methods of the implementing class have different functions, overriding the methods in the interface. Like command mode, state mode can also be used to eliminate conditional selection statements such as if...else.
2. The main purpose is that as an instance variable, it is an object reference. The main way to use the command mode is the parameter callback mode. The command interface is passed in as a method parameter. Then, call back the interface in the method body. The main way to use the state mode is as an instance variable, passing in the instance of the specific implementation class of the state interface through the set attribute method or the constructor. Therefore, the similarities and differences between command mode and status mode can be compared like this.
State mode and command mode are both very commonly used, relatively small-granularity modes, and are part of many larger modes. Basically, state mode and command mode are very similar. As long as developers have a clear understanding of single cases and multiple cases, it will be fine even if they are not divided into two modes.

The above introduces the getasynckeystate PHP design pattern State state mode, including the content of getasynckeystate. I hope it will be helpful to friends who are interested in PHP tutorials.