introduzir
O modo mediador (mediador) usa um objeto mediador para encapsular uma série de interações de objetos. O intermediário faz com que os objetos não precisem ser explicitamente referenciados um ao outro, juntando -os e podem alterar independentemente suas interações.
O conteúdo principal vem de: http://www.addyosmani.com/resources/essentialjsdesignpatterns/book/#mediAorpatternjavascript
texto
No desenvolvimento de software, os intermediários são um padrão de design comportamental que permite que diferentes partes do sistema se comuniquem fornecendo uma interface unificada. Geralmente, se o sistema tiver muitos submódulos que precisam ser comunicados diretamente, um ponto de controle central deve ser criado para cada módulo interagir através do ponto de controle central. O modelo intermediário permite que esses submódulos atinjam o objetivo de desacoplar sem comunicação direta.
Por exemplo, o sistema comum de controle de tráfego aeroportuário, a torre é um intermediário, que controla a decolagem e o pouso da aeronave (submódulo), porque toda a comunicação é concluída da aeronave que relata a torre, em vez de se comunicar diante da aeronave. O sistema de controle central é a chave do sistema, ou seja, o papel do intermediário no design de software.
Vamos primeiro entender usando pseudo-código:
A cópia do código é a seguinte:
// O código a seguir é pseudo-código, por favor, não preste muita atenção ao código
// aqui o espaço para nome de aplicativos é equivalente a desempenhar o papel de um intermediário
var app = app || {};
// Faça solicitações de Ajax através do App Intermediary
App.sendRequest = function (opções) {
retornar $ .ajax ($. Extend ({}, opções);
}
// Depois de solicitar o URL, exiba a visualização
App.populateView = function (URL, View) {
$ .When (app.sendRequest ({url: url, método: 'get'})
.then (function () {
// mostra conteúdo
});
}
// Limpar conteúdo
App.resetView = function (View) {
view.html ('');
}
No JavaScript, os intermediários são muito comuns, equivalentes ao barramento de mensagens no padrão do observador. No entanto, eles não são implementados ligando para observadores pub/sub, mas são gerenciados por intermediários de maneira unificada. Vamos dar um exemplo com base no observador:
A cópia do código é a seguinte:
var mediador = (function () {
// Inscreva -se em um evento e forneça uma função de retorno de chamada depois que o evento é acionado
var assinscribe = function (canal, fn) {
if (! mediator.Channels [canal]) mediator.Channels [canal] = [];
mediator.channels [canal] .push ({context: this, retorno de chamada: fn});
devolver isso;
},
// Eventos de transmissão
publish = function (canal) {
if (! mediator.Channels [canal]) retorna false;
var args = array.prototype.slice.call (argumentos, 1);
for (var i = 0, l = mediator.Channels [canal] .Length; i <l; i ++) {
var assinatura = mediator.Channels [canal] [i];
Subscription.Callback.Apply (Subscription.Context, Args);
}
devolver isso;
};
retornar {
canais: {},
Publicar: Publish,
Inscreva -se: Inscreva -se,
InstallTo: function (obj) {
obj.subScribe = assine;
obj.publish = publish;
}
};
} ());
Chamar o código é relativamente simples:
A cópia do código é a seguinte:
(função (mediador) {
função inicialize () {
// Valor padrão
mediator.name = "dudu";
// assina uma namechange de evento
// A função de retorno de chamada exibe informações antes e depois da modificação
mediator.subscribe ('namechange', função (arg) {
console.log (this.name);
this.name = arg;
console.log (this.name);
});
}
função updateName () {
// Evento de gatilho de transmissão, o parâmetro é um novo dados
mediator.publish ('Namechange', 'Tom'); // Dudu, Tom
}
inicializar(); // inicialize
updatename (); // Chamar
})(mediador);
Intermediários e observadores
Neste ponto, todos podem estar confusos. O intermediário e o observador parecem ser semelhantes. Qual é a diferença? Na verdade, é um pouco semelhante, mas vamos dar uma olhada na descrição específica:
Padrão de observador, um único objeto que não encapsula restrições. Pelo contrário, o observador observador e a classe concreta trabalham juntos para manter restrições. A comunicação interage através de múltiplos observadores e várias classes de concreto: cada classe de concreto geralmente contém vários observadores e, às vezes, um observador na classe de concreto também é a classe concreta de outro observador.
O que o modelo intermediário faz não é simplesmente a distribuição, mas desempenha o papel de manter essas restrições.
Padrões intermediários e de aparência
Muitas pessoas também podem estar confusas sobre a diferença entre padrões intermediários e de aparência. Ambos abstravam os módulos existentes, mas existem algumas diferenças sutis.
O que o intermediário faz é se comunicar entre os módulos, que é multidirecional, mas o modo de aparência simplesmente define uma interface simples para um determinado módulo ou sistema sem adicionar funcionalidade adicional. O conceito de outros módulos no sistema não possui conexão direta com o modo de aparência e pode ser considerada unidirecional.
Aqui está outro exemplo completo:
A cópia do código é a seguinte:
<! doctype html>
<html lang = "en">
<head>
<title> Javascript Patterns </ititle>
<meta charset = "utf-8">
</head>
<Body>
<div id = "Resultados"> </div>
<Cript>
Player de função (nome) {
this.points = 0;
this.name = nome;
}
Player.prototype.play = function () {
this.points += 1;
mediator.played ();
};
varboard var = {
// Contêiner para exibir conteúdo
Elemento: Document.getElementById ('Results'),
// Display de pontuação de atualização
ATUALIZAÇÃO: function (pontuação) {
var i, msg = '';
para (i na pontuação) {
if (score.HasownProperty (i)) {
msg + = '<p> <strong>' + i + '<// fort>:';
msg += pontuação [i];
msg += '<// p>';
}
}
this.Element.innerhtml = msg;
}
};
var mediador = {
// Todos os jogadores
jogadores: {},
// inicialização
configuração: function () {
var players = this.players;
players.home = novo jogador ('casa');
Players.Guest = New Player ('Guest');
},
// Após o jogo, atualize a pontuação
jogado: function () {
var players = this. jogadores,
pontuação = {
Home: Players.home.points,
Convidado: Players.guest.points
};
scoreboard.update (pontuação);
},
// Lidar com a interação da chave do usuário
keypress: function (e) {
e = e || Window.Event; // ou seja
if (e.which === 49) {// chave de número "1"
mediator.players.home.play ();
retornar;
}
if (e.which === 48) {// teclas de número "0"
mediator.players.guest.play ();
retornar;
}
}
};
// ir!
mediator.setup ();
window.onkeypress = mediator.keypress;
// terminar após 30 segundos
setTimeout (function () {
window.onkeypress = null;
console.log ('jogo over!');
}, 30000);
</script>
</body>
</html>
Resumir
O modo intermediário é geralmente usado em situações em que um grupo de objetos foi bem definido, mas se comunica de uma maneira complexa. De um modo geral, o modo intermediário é fácil de usar no sistema, mas também é fácil de usar mal no sistema. Quando um grupo de objetos complexo de interações muitas para muitos aparece no sistema, não se apresse em usar o modo intermediário primeiro, mas pense se há algo errado com o design do sistema.
Além disso, como o modelo intermediário transforma a complexidade da interação na complexidade do próprio intermediário, o objeto intermediário será mais complexo do que qualquer outro objeto.