Eine kurze Analyse des Memomusters

Während des Anwendungsdesignprozesses müssen einige spezifische Vorgänge das Rückgängigmachen unterstützen, wie zum Beispiel ein Dateiverwaltungssystem, an dem ich kürzlich geschrieben habe. Einige grundlegende Dateivorgänge wie Umbenennen, Kopieren, Ausschneiden usw. müssen Rückgängig- und Wiederherstellungsvorgänge unterstützen, um eine bessere Benutzererfahrung zu bieten. Wie wir alle wissen, erfordern Rückgängig- und Wiederherstellungsvorgänge zwei Modi zur Unterstützung: Der Memento-Modus (Memento) speichert den Status der Objektoperationsdaten und der Befehlsmodus (Befehl) kapselt Benutzeranforderungen. In Kombination bieten sie gute Rückgängig- und Wiederherstellungsvorgänge. Informationen zum Befehlsmodus finden Sie im obigen Artikel. Klicken Sie hier, um den Link zu öffnen. Im Folgenden wird hauptsächlich auf die Implementierung des Memomodus eingegangen. Bitte teilen Sie mir dies mit.

Es gibt drei Hauptteilnehmer im Memo-Modus:
a. Memento-Objekt (Memento), das Statusinformationen speichert
b 🎜> c. Memo-Objekt-Manager (CareTaker)

Der Urheber stellt zwei externe Schnittstellen bereit:

create_memento(); //保存对象状态信息创建一个备忘录返回
set_memento(Memento $mem); //根据传入的备忘录获取状态信息，恢复状态   

Das Memo-Objekt stellt zwei Schnittstellen bereit:

    set_state(State $state);    //设备备忘录当前状态
    get_state();                //获取备忘录当前状态

Memo-Objekt-Implementierung:

Die set_state-Schnittstelle stellt die Eindeutigkeit des Parametertyps durch die State-Parameter-Eingabeaufforderung sicher. Es ist zu beachten, dass PHP beim Zuweisen von Objekten standardmäßig nicht den Kopierkonstruktor ausführt. PHP basiert auf einem Referenzobjektzähler und der Standardzähler der Objektzuweisung wird um eins erhöht. Hier verwenden wir die von PHP bereitgestellte Klonoperation, um sicherzustellen, dass wir ein brandneues Objekt erhalten.

class Memento {
        private $state;
        public function get_state(){
            return $this->state;
        }        
        public function set_state(State $state){
            $this->state = clone $state;
        }
    }

Quellimplementierung:

 class Originator{
        private $state;        

        function _construct(){
            $this->state = new State();
            $this->state->set('action', 'create originator');
        }

        function do_action1(){
            $this->state->set('action', 'do_action 1');            
        }

        function do_action2(){
            $this->state->set('action', 'do_action 2');            
        }

        function create_memento(){
            $mem = new Memento();
            $men->set_state($this->state);
            return $mem;
        }

        function set_memento(Memento $mem){
            $this->state = $mem->get_state();
        }
        
        function dump(){
            echo $this->state->get('action') . "\n";
        }
    }

Statusinformationsobjekt:

Schließlich der Memo-Manager Einfache Implementierung von:

class State{
        private $values = array();

        public function set($key, $value){
            $this->values[$key] = $value;
        }

        public function get($key){
            if(isset($this->values[$key])){
                return $this->values[$key];
            }
            return null;
        }
    }

class CareTaker{
        private $command;
        
        function __construct($cmd="Originator1"){
            $this->command = $cmd;        
        }
        
        private function do_execute(){
               switch($this->command){
                    case 'Originator1':{
                        $action = new Originator();
                        $mem1 = $action->create_memento();
                        $action->dump();
                        $action->do_action1();
                        $mem2 = $action->create_memento();
                        $action->dump();
                        $action->do_action2();
                        $mem3 = $action->create_memento();
                        $action->dump();
                        //状态恢复
                        $action->set_memento($mem2);
                        $action->dump();
                        $action->set_memento($mem1);
                        $action->dump();
                    }
                }         
        }
    }

Es gibt mehrere Bereiche, die verbessert werden können. Erstens sollte der Manager eine Warteschlange zur Verwaltung einer Reihe von Memoobjekten bereitstellen. Zweitens wird der Client-Anforderungsbefehl mithilfe eines großen Switch-Cases verteilt, anstatt den Befehlsmodus zu verwenden, um die Anforderung als Objekt zu kapseln, was zu einer verwirrenden Klassenstruktur führt. Im nächsten Artikel wird eine vollständige Version des Rückgängig-Wiederholen-Vorgangs implementiert.

Das Ende.

Das Obige hat eine kurze Analyse des Memo-Modus und seiner Aspekte vorgestellt. Ich hoffe, dass es für Freunde hilfreich sein wird, die sich für PHP-Tutorials interessieren.