introduire
Le mode d'état permet à un objet de modifier son comportement lorsque son état interne change, et l'objet semble modifier sa classe.
texte
Par exemple, lorsque nous téléchargeons des choses, nous avons généralement plusieurs états, tels que ReadyState, DownloadingState, PausedState, DownlodedState, DownlodedState et Failsstate. C'est-à-dire que, dans chaque État, vous ne pouvez faire que ce que l'état actuel peut faire, mais pas ce que les autres États peuvent faire.
Parce que le modèle d'état décrit comment les téléchargements (téléchargement) se comportent différemment dans chaque état. L'idée clé de ce modèle est d'introduire une classe abstraite appelée State (ou une fonction dans JS) pour représenter l'état de téléchargement. La fonction d'état (en tant que prototype) déclare certaines interfaces communes pour les sous-classes (fonctions d'héritage) de chaque état. Chaque fonction d'héritage met en œuvre des comportements liés à un état spécifique, tels que le téléchargement State et le téléchargement State met respectivement les comportements téléchargés et téléchargés. Ces comportements peuvent être maintenus par téléchargement.
Implémentons un jeu, définissons d'abord la fonction d'état comme un prototype d'autres fonctions de base:
La copie de code est la suivante:
var state = function () {
};
State.prototype.download = function () {
Jetez une nouvelle erreur ("Cette méthode doit être surchargée!");
};
State.prototype.pause = function () {
Jetez une nouvelle erreur ("Cette méthode doit être surchargée!");
};
State.prototype.fail = function () {
Jetez une nouvelle erreur ("Cette méthode doit être surchargée!");
};
State.prototype.finish = function () {
Jetez une nouvelle erreur ("Cette méthode doit être surchargée!");
};
Nous définissons 4 interfaces de méthode pour le prototype d'état, qui correspondent au téléchargement (téléchargement), à la pause, à l'échec et à la fin afin que la sous-fonction puisse être réécrite.
Avant d'écrire une sous-fonction, nous écrivons d'abord une fonction ReadyState afin que l'état puisse être transmis au premier état de téléchargement:
La copie de code est la suivante:
var readystate = function (odownload) {
State.apply (ceci);
this.odownload = odownload;
};
ReadyState.prototype = new State ();
Readystate.prototype.download = function () {
this.odownload.setState (this.odownload.getDownloadingState ());
// Après prêt, vous pouvez commencer à télécharger, vous définissez donc la méthode d'acquisition d'état dans la fonction de téléchargement
console.log ("Démarrer le téléchargement!");
};
Readystate.prototype.pause = function () {
Jetez une nouvelle erreur ("Le téléchargement n'a pas encore commencé, ne peut pas être fait une pause!");
};
Readystate.prototype.fail = function () {
Jetez une nouvelle erreur ("Le fichier n'a pas encore commencé à télécharger, comment peut-on dire qu'il a échoué!");
};
Readystate.prototype.finish = function () {
Jetez une nouvelle erreur ("Le fichier n'a pas commencé à télécharger, bien sûr, il ne peut pas être terminé!");
};
Cette fonction prend une instance de la fonction de maintenance de téléchargement comme paramètre. La fonction de téléchargement est utilisée pour contrôler les modifications et les acquisitions d'état (similaires au contrôleur central, permettant des appels externes). ReadyState réécrit la méthode de téléchargement du prototype pour commencer le téléchargement. Continuons à regarder les fonctions principales de la fonction de téléchargement:
La copie de code est la suivante:
var download = function () {
this.ostate = new ReadyState (this);
};
Download.prototype.setState = function (OSTate) {
this.ostate = ostate;
};
// quatre méthodes publiques exposées à l'extérieur pour les appels externes
Download.prototype.download = function () {
this.ostate.download ();
};
Download.prototype.pause = function () {
this.ostate.pause ();
};
Download.prototype.fail = function () {
this.ostate.fail ();
};
Download.prototype.finish = function () {
this.ostate.finish ();
};
// Obtenez divers états et passez dans le courant cet objet
Download.prototype.getReadyState = function () {
Renvoie un nouveau ReadyState (ceci);
};
Download.prototype.getDownloadingState = function () {
Renvoie un nouveau téléchargement à téléchargement (this);
};
Download.prototype.getDownloadPausedState = function () {
Renvoie un nouveau téléchargementPausedState (this);
};
Download.prototype.getDownloadDState = function () {
Renvoie un nouveau téléchargement à téléchargement (ceci);
};
Download.prototype.getDownloadElodFailedState = function () {
Renvoie un nouveau téléchargement FailedState (this);
};
Le prototype de la fonction de téléchargement fournit 8 méthodes, 4 sont des comportements opérationnels pour le téléchargement des états, et les 4 autres sont utilisés pour obtenir les quatre états différents actuels. Ces 4 méthodes reçoivent toutes ce paramètre, c'est-à-dire passer l'instance de téléchargement elle-même en tant que paramètre à l'objet d'état (ReadyState et la fonction d'hérédité à implémenter plus tard), ce qui rend l'objet d'état accessible à Odownlaod que si nécessaire.
Ensuite, continuez à définir 4 fonctions d'état connexes:
La copie de code est la suivante:
var downloadingState = function (odownload) {
State.apply (ceci);
this.odownload = odownload;
};
DownloadingState.prototype = new State ();
Téléchargementstate.prototype.download = function () {
Jetez une nouvelle erreur ("Le fichier télécharge déjà!");
};
DownloadingState.prototype.pause = function () {this.odownload.setState (this.odownload.getDownloadPausedState ());
console.log ("Pause Download!");
};
DownloadingState.prototype.fail = function () {this.odownload.setState (this.odownload.getDownloadEdFailedState ());
console.log ("Download a échoué!");
};
Téléchargementstate.prototype.finish = function () {
this.odownload.setState (this.odownload.getDownloadState ());
console.log ("téléchargé!");
};
La principale chose à noter sur le téléchargement de l'état est que le fichier qui est déjà téléchargé ne peut pas être téléchargé à nouveau et que d'autres états peuvent être effectués en permanence.
La copie de code est la suivante:
var downloadPausedState = function (odownload) {
State.apply (ceci);
this.odownload = odownload;
};
DownloadPausedState.prototype = new State ();
DownloadPausedState.prototype.download = function () {
this.odownload.setState (this.odownload.getDownloadingState ());
console.log ("Continuez à télécharger!");
};
DownloadPausedState.prototype.pause = function () {
Jetez une nouvelle erreur ("Cela a été arrêté, pourquoi devez-vous encore faire une pause!");
};
DownloadPausedState.prototype.fail = function () {this.odownload.setState (this.odownload.getDowloadEdFailedState ());
console.log ("Download a échoué!");
};
DownloadPausedState.prototype.Finish = function () {
this.odownload.setState (this.odownload.getDownloadState ());
console.log ("téléchargé!");
};
Il convient de noter dans la fonction de téléchargement PAUSEDSTATE que les téléchargements qui ont été interrompus ne peuvent plus être interrompus.
La copie de code est la suivante:
var téléchargéstate = function (odownload) {
State.apply (ceci);
this.odownload = odownload;
};
Téléchargéstate.prototype = new State ();
Téléchargéstate.prototype.download = function () {
this.odownload.setState (this.odownload.getDownloadingState ());
Console.log ("Re-Downowload!");
};
Téléchargéstate.prototype.pause = function () {
Jetez une nouvelle erreur ("Que allez-vous faire une pause après le téléchargement?");
};
Téléchargéstate.prototype.fail = function () {
Jetez une nouvelle erreur ("Le téléchargement a été réussi, pourquoi va-t-il échouer?");
};
Téléchargéstate.prototype.finish = function () {
Jetez une nouvelle erreur ("Le téléchargement réussit, vous ne pouvez plus le faire!");
};
Fonction téléchargée, de même, après le téléchargement réussi, vous ne pouvez plus définir la finition, vous ne pouvez définir que l'état de téléchargement de refonte.
La copie de code est la suivante:
var downloadFailedState = function (odownload) {
State.apply (ceci);
this.odownload = odownload;
};
DownloadFailedState.prototype = new State ();
DownloadFailedState.prototype.download = function () {
this.odownload.setState (this.odownload.getDownloadingState ());
console.log ("Essayez de redémarrer!");
};
TéléchargerfailedState.prototype.pause = function () {
Jetez une nouvelle erreur ("Le téléchargement échoué ne peut pas être fait une pause!");
};
TéléchargerfailedState.prototype.fail = function () {
Jetez une nouvelle erreur ("Tout a échoué, pourquoi a-t-il échoué!");
};
TéléchargerfailedState.prototype.Finish = function () {
Jetez une nouvelle erreur ("Le téléchargement échoué ne réussira certainement pas!");
};
De même, l'état de défaillance de la fonction Téléchargement FailedState ne peut pas échouer, mais vous pouvez essayer de le télécharger à nouveau après avoir terminé.
Appeler le code de test est très simple. Voyons-le en HTML. Tout d'abord, vous avez besoin de jQuery, puis il y a 3 boutons représentant: commencez à télécharger, à pause et à re-télécharger. (Notez que vous utilisez Firebug pour afficher les résultats dans Firefox, car la méthode Console.log est utilisée).
La copie de code est la suivante:
<html>
<adal>
<link type = "text / css" rel = "stylesheet" href = "http://www.cnblogs.com/css/style.css" />
<Title> État Pattern </Title>
<script type = "text / javascript" src = "/ jquery.js"> </ script>
<script type = "text / javascript" src = "download.js"> </ script>
<script type = "text / javascript" src = "states / state.js"> </ script>
<script type = "text / javascript" src = "states / downloadfailedState.js"> </ script>
<script type = "text / javascript" src = "states / downloadpausedState.js"> </ script>
<script type = "text / javascript" src = "states / téléchargéState.js"> </ script>
<script type = "text / javascript" src = "states / downloadingstate.js"> </ script>
<script type = "text / javascript" src = "states / readystate.js"> </ script>
</ head>
<body>
<entrée type = "Button" value = "Démarrer le téléchargement" id = "téléchargement_button" />
<input type = "bouton" value = "pause" id = "pause_button" />
<input type = "Button" value = "redownload" id = "resume_button" />
<script type = "text / javascript">
var odownload = nouveau téléchargement ();
$ ("# téléchargement_button"). Cliquez sur (fonction () {
Odownload.Download ();
});
$ ("# Pause_Button"). Cliquez sur (fonction () {
odownload.pause ();
});
$ ("# resume_button"). cliquez sur (fonction () {
Odownload.Download ();
});
</cript>
</docy>
</html>
Résumer
Les scénarios d'utilisation du mode d'état sont également particulièrement clairs, avec les deux points suivants:
1. Le comportement d'un objet dépend de son état, et il doit changer son comportement en fonction de son état au moment de l'exécution.
2. Une opération contient un grand nombre d'instructions de branche, et ces instructions de branche dépendent de l'état de l'objet. L'état est généralement une représentation d'une ou plusieurs constantes d'énumération.