introduzir
O modo de estado permite que um objeto altere seu comportamento quando seu estado interno mudar, e o objeto parece modificar sua classe.
texto
Por exemplo, quando baixamos coisas, geralmente temos vários estados, como ReadyState, DownloadState, PausedState, BaixedEdState, BaixededState e FaildState. Ou seja, em cada estado, você só pode fazer o que o estado atual pode fazer, mas não o que outros estados podem fazer.
Porque o padrão de estado descreve como os downloads (download) se comportam de maneira diferente em cada estado. A idéia principal desse padrão é introduzir uma classe abstrata chamada State (ou uma função no JS) para representar o estado de download. A função de estado (como protótipo) declara algumas interfaces comuns para subclasses (funções de herança) de cada estado. Cada função de herança implementa comportamentos relacionados a um estado específico, como o download do estateiro e o download do Estado, respectivamente, implementa os comportamentos que estão sendo baixados e baixados. Esses comportamentos podem ser mantidos através do download.
Vamos implementar um jogo, primeiro defina a função de estado como um protótipo de outras funções básicas:
A cópia do código é a seguinte:
var state = function () {
};
State.prototype.download = function () {
lançar um novo erro ("Este método deve ser sobrecarregado!");
};
State.prototype.pause = function () {
lançar um novo erro ("Este método deve ser sobrecarregado!");
};
State.prototype.fail = function () {
lançar um novo erro ("Este método deve ser sobrecarregado!");
};
State.prototype.finish = function () {
lançar um novo erro ("Este método deve ser sobrecarregado!");
};
Definimos 4 interfaces do método para o protótipo de estado, que corresponde ao download (download), pausa, falha e final para que a subcunção possa ser reescrita.
Antes de escrever uma subfunção, primeiro escrevemos uma função ReadyState para que o estado possa ser passado para o primeiro estado de download:
A cópia do código é a seguinte:
var ReadyState = function (ODOWNLOAD) {
Estado.Apply (isto);
this.oDownload = ODOWNLOAD;
};
ReadyState.prototype = new State ();
ReadyState.prototype.Download = function () {
this.oDownload.setState (this.oDownload.getDownloadingState ());
// Depois de pronto, você pode começar a baixar, para definir o método de aquisição do estado na função de download
console.log ("Start Download!");
};
ReadyState.prototype.pause = function () {
lançar um novo erro ("O download ainda não começou, não pode ser pausado!");
};
Readystate.prototype.fail = function () {
lançar um novo erro ("O arquivo ainda não começou a baixar, como pode ser dito que falhou!");
};
Readystate.prototype.finish = function () {
lançar um novo erro ("O arquivo não começou a baixar, é claro que não pode ser concluído!");
};
Esta função leva uma instância da função de manutenção de download como um parâmetro. A função de download é usada para controlar as alterações e aquisições do estado (semelhante ao controlador central, permitindo chamadas externas). ReadyState reescreve o método de download do protótipo para começar a baixar. Vamos continuar analisando as principais funções da função de download:
A cópia do código é a seguinte:
var download = function () {
this.ostate = new ReadyState (this);
};
Download.prototype.setState = function (ostato) {
this.ostate = ostato;
};
// quatro métodos públicos expostos ao exterior para chamadas externas
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 ();
};
// Obtenha vários estados e passa na corrente deste objeto
Download.prototype.getReadyState = function () {
retornar new ReadyState (isto);
};
Download.prototype.getDownloadingState = function () {
retornar novo DownloadingState (this);
};
Download.prototype.getDownloadPaUsedState = function () {
retornar new DownloadPaUsedState (this);
};
Download.prototype.getDownloadedState = function () {
devolver new BaixededState (this);
};
Download.prototype.getDownloadedFailedState = function () {
retornar new DownloadFailedState (this);
};
O protótipo da função de download fornece 8 métodos, 4 são comportamentos operacionais para download de estados e os outros 4 são usados para obter os quatro estados diferentes. Todos esses 4 métodos recebem isso como um parâmetro, ou seja, passam a própria instância de download como um parâmetro para o objeto de estado (ReadyState e a função de herança a ser implementada posteriormente), o que torna o objeto de estado acessível a Odownlaod do que o necessário.
Em seguida, continue a definir 4 funções estatais relacionadas:
A cópia do código é a seguinte:
var downloadingState = function (ODOWNLOAD) {
Estado.Apply (isto);
this.oDownload = ODOWNLOAD;
};
DownloadingState.prototype = new State ();
DownloadingState.prototype.Download = function () {
lançar um novo erro ("O arquivo já está baixando!");
};
DownloadingState.Prototype.Pause = function () {this.oDownload.setState (this.oDownload.getDownloadPaUsedState ());
console.log ("Download de pausa!");
};
DownloadingState.prototype.fail = function () {this.oDownload.setState (this.oDownload.getDownloadDailedState ());
console.log ("Download falhou!");
};
Downloadingstate.prototype.finish = function () {
this.oDownload.setState (this.oDownload.getDownloadedState ());
console.log ("Download!");
};
A principal coisa a observar sobre o download do Estado é que o arquivo que já está baixando não pode ser baixado novamente e outros estados podem ser executados continuamente.
A cópia do código é a seguinte:
var downloadPaUsedState = function (ODOWNLOAD) {
Estado.Apply (isto);
this.oDownload = ODOWNLOAD;
};
DownloadPaUsedState.prototype = new State ();
DownloadPausedState.prototype.Download = function () {
this.oDownload.setState (this.oDownload.getDownloadingState ());
console.log ("Continue Download!");
};
DownloadPaUsedState.prototype.pause = function () {
lançar um novo erro ("Foi pausado, por que você ainda precisa fazer uma pausa!");
};
DownloadPaUsedState.prototype.fail = function () {this.oDownload.setState (this.oDownload.getDownloadedFailedState ());
console.log ("Download falhou!");
};
DownloadPaUsedState.prototype.finish = function () {
this.oDownload.setState (this.oDownload.getDownloadedState ());
console.log ("Download!");
};
Deve ser observado na função DownloadPausedState que os downloads que foram pausados não podem ser pausados novamente.
A cópia do código é a seguinte:
var downloadedState = function (ODOWNLOAD) {
Estado.Apply (isto);
this.oDownload = ODOWNLOAD;
};
BaixededState.prototype = new State ();
Downloadedstate.prototype.download = function () {
this.oDownload.setState (this.oDownload.getDownloadingState ());
console.log ("Rear download!");
};
Downloadedstate.prototype.pause = function () {
lançar um novo erro ("O que mais você vai fazer uma pausa após o download?");
};
Downloadedstate.prototype.fail = function () {
lançar um novo erro ("O download foi bem -sucedido, por que falhará?");
};
Downloadedstate.prototype.finish = function () {
lançar um novo erro ("O download é bem -sucedido, você não pode mais fazê -lo!");
};
Função baixada do estate, da mesma forma que, após o download bem-sucedido, você não pode mais definir acabamento, você pode definir apenas o status de download.
A cópia do código é a seguinte:
var downloadFailedState = function (ODOWNLOAD) {
Estado.Apply (isto);
this.oDownload = ODOWNLOAD;
};
DownloadFailedState.prototype = new State ();
DownloadFailedState.prototype.Download = function () {
this.oDownload.setState (this.oDownload.getDownloadingState ());
console.log ("Tente fazer o download!");
};
DownloadFailedState.prototype.pause = function () {
lançar um novo erro ("o download falhado não pode ser pausado!");
};
DownloadFailedState.prototype.fail = function () {
lançar um novo erro ("Tudo falhou, por que ainda falhou!");
};
DownloadFailedState.prototype.finish = function () {
lançar um novo erro ("o download com falha definitivamente não terá sucesso!");
};
Da mesma forma, o estado de falha da função DownloadFailedState não pode falhar novamente, mas você pode tentar baixá -lo novamente após o término.
Chamar o código de teste é muito simples. Vamos demonstrar isso em HTML. Primeiro, você precisa do jQuery e, em seguida, existem 3 botões representando: Iniciar Download, Pausa e Rear download. (Observe que você usa o Firebug para visualizar os resultados no Firefox, porque o método do console.log é usado).
A cópia do código é a seguinte:
<html>
<head>
<link type = "text/css" rel = "Stylesheet" href = "http://www.cnblogs.com/css/style.css"/>
<Title> padrão de estado </title>
<script type = "text/javascript" src = "/jQuery.js"> </script>
<script type = "text/javascript" src = "download.js"> </script>
<script type = "text/javascript" src = "estates/state.js"> </script>
<script type = "text/javascript" src = "estados/downloadFailedState.js"> </script>
<script type = "text/javascript" src = "estados/downloadpausedstate.js"> </sCript>
<script type = "text/javascript" src = "estados/baixarstate.js"> </script>
<script type = "text/javascript" src = "estados/downloadsstate.js"> </script>
<script type = "text/javascript" src = "estatais/prontystate.js"> </script>
</head>
<Body>
<input type = "button" value = "Iniciar download" id = "download_button" />
<input type = "button" value = "pause" id = "pause_button" />
<input type = "button" value = "re-baixar" id = "retume_button" />
<script type = "text/javascript">
var ODOWNLOAD = new Download ();
$ ("#download_button"). Clique (function () {
ODOWNLOAD.DOWNLOAD ();
});
$ ("#pause_button"). clique (function () {
ODOWNLOAD.PAUSE ();
});
$ ("#currume_button"). Clique (function () {
ODOWNLOAD.DOWNLOAD ();
});
</script>
</body>
</html>
Resumir
Os cenários de uso do modo de status também são particularmente claros, com os dois pontos a seguir:
1. O comportamento de um objeto depende de seu estado e deve mudar seu comportamento de acordo com seu estado no tempo de execução.
2. Uma operação contém um grande número de declarações de ramificação, e essas declarações de ramificação dependem do estado do objeto. O estado geralmente é uma representação de uma ou mais constantes de enumeração.