JavaScript中介者模式

JavaScript中介者模式

中介者模式是迎合迪米特法则的一种实现。迪米特法则也叫最少知识原则,是指一个对象应该尽可能少地了解另一个对象。如果对象间的耦合性太高,一个对象发生改变后,难免会影响到其他的对象。在中介者模式里,对象间几乎不知道彼此的存在,它们只能通过中介者对象来互相影响。因此,中介者模式使各个对象得以解耦,以中介者和对象之间的一对多的关系取代了对象间的多对多的网状关系。各个对象只需关注自身功能的实现,对象之间的交互关系就交给中介者对象来实现和维护。
      下面是一段使用中介者模式改良后的游戏的代码:

function Player( name, teamColor ){
            this.name = name; // 角色名字
            this.teamColor = teamColor; // 队伍颜色
            this.state = ‘alive‘; // 玩家生存状态
      }

Player.prototype.win = function(){
            console.log( this.name + ‘ win‘ );
      }

Player.prototype.lose = function(){
            console.log( this.name + ‘ lose‘ );
      }

/***************玩家死亡**************/
      Player.prototype.die = function(){
            this.state = ‘dead‘;
            playerDirector.ReceiveMessage( ‘playerDead‘, this ); // 给中介者发消息,玩家死亡
      }

/***************移除玩家**************/
      Player.prototype.remove = function(){
            playerDirector.ReceiveMessage( ‘removePlayer‘, this ); // 给中介者发消息,移除一个玩家
      }

/***************玩家换队**************/
      Player.prototype.changeTeam = function(){
            playerDirector.ReceiveMessage( ‘changeTeam‘, this, color ); // 给中介者发消息,玩家换队
      }

var playerFactory = function( name, teamColor ){

var newPlayer = new Player( name, teamColor );     // 创建一个新的玩家对象

playerDirector.ReceiveMessage( ‘addPlayer‘, newPlayer );   // 给中介者发送消息,新增玩家

return newPlayer;

}

//中介者
      var playerDirector = (function(){
            var players = {}, // 保存所有玩家
            operations = {}; // 中介者可以执行的操作

/***************新增一个玩家**************/
            operations.addPlayer = function( player ){
                  var teamColor = player.teamColor; // 队伍颜色
                  players[ teamColor ] = players[ teamColor ] || []; //如果该颜色的玩家还没成立队伍,则新成立一个队伍

players[ teamColor ].push( player );
            };

/***************移除一个玩家**************/
            operations.removePlayer = function( player ){
                  var teamColor = player.teamColor; // 队伍颜色
                  teamPlayers = players[ teamColor ] || [];
                  for( var i = teamPlayers.length - 1; i >= 0; i-- ){
                        if( teamPlayers[ i ] === player ){
                              teamPlayers.splice( i, 1 );
                        }
                  }

};

/***************玩家换队**************/
            operations.changeTeam = function( player, newTeamColor ){
                  operations.removePlayer( player );
                  player.teamColor = newTeamColor;
                  operations.addPlayer( player );
            };

/***************玩家死亡**************/
           operations.playerDead = function( player ){

var teamColor = player.teamColor,
                  teamPlayers = players[ teamColor ]; //玩家所在队伍

var all_dead = true;

for( var i = 0, player; player = teamPlayrs[ i++ ]; ){
                        if( player.state != ‘dead‘ ){
                              all_dead = false;
                              break;
                        }
                  }

if( all_dead ){
                        for( var i = 0, player; player = teamPlayrs[ i++ ]; ){
                              player.lose(); // 本队所有玩家输
                        }
                        for( var color in players ){
                              if( color !== teamColor ){
                                    var teamPlayrs = players[ color ]; // 其他队伍的玩家
                                    for( var i = 0, player; player = teamPlayrs[ i++ ]; ){
                                          player.win(); // 其他队伍所有玩家赢
                                    }
                               }
                         }
                   }

}

/***************对外接口,接受各个玩家的消息**************/
            var ReceiveMessage = function(){
                  var message = Array.prototype.shift.call( arguments ); // arguments的第一个参数为消息名称
                  operations[ message ].apply( this, arguments );
            }

return {
                  ReceiveMessage: ReceiveMessage
            };

})();

var  player1 = playerFactory( ‘皮蛋‘, ‘red‘ ),
            player2 = playerFactory( ‘小乖‘, ‘red‘ ),
            player3 = playerFactory( ‘宝宝‘, ‘red‘ ),
            player4 = playerFactory( ‘小强‘, ‘red‘ );

var  player5 = playerFactory( ‘黑妞‘, ‘blue‘ ),
            player6 = playerFactory( ‘葱头‘, ‘blue‘ ),
            player7 = playerFactory( ‘胖墩‘, ‘blue‘ ),
            player8 = playerFactory( ‘海盗‘, ‘blue‘ );

player1.die();
      player2.die();
      player3.die();
      player4.die();
      // 输出结果:lost -->> 皮蛋、小乖、宝宝、小强 ; win -->> 黑妞、葱头、胖墩、海盗

不过,中介者模式也存在一些缺点。其中,最大的缺点是系统中会新增一个中介者对象,这是一个很大的对象,往往它就是一个很难维护的对象。所以在选择这个模式的时候,要考虑清楚利与弊。

稿源:勤快学QKXue.NET

扩展阅读:

http://qkxue.net/info/39293/JavaScript

时间: 2024-12-25 19:19:58

JavaScript中介者模式的相关文章

深入理解JavaScript系列(36):设计模式之中介者模式

介绍 中介者模式(Mediator),用一个中介对象来封装一系列的对象交互.中介者使各对象不需要显式地相互引用,从而使其耦合松散,而且可以独立地改变它们之间的交互. 主要内容来自:http://www.addyosmani.com/resources/essentialjsdesignpatterns/book/#mediatorpatternjavascript 正文 软件开发中,中介者是一个行为设计模式,通过提供一个统一的接口让系统的不同部分进行通信.一般,如果系统有很多子模块需要直接沟通,

学习javascript设计模式之中介者模式

1.中介者模式的作用就是解除对象与对象之间的紧耦合关系.增加一个中介者对象后,所有的相关对象都通过中介者来通信,而不是互相引用,所以当一个对象发生改变时,只需要通知中介对象即可.中介者使各对象之间耦合松散,而且可以独立的改变他们之间的交互.中介者模式使网状的多对多关系变成了相对简单的一对多关系. <select id="colorselect"> <option value="">请选择颜色</option> <option

《JavaScript设计模式与开发实践》读书笔记之中介者模式

1. 中介者模式 中介者模式的作用就是用来解除对象与对象之间的紧耦合关系,增加中介者后,所有相关对象都通过中介者来通信,而不再相互引用 1.1中介者模式的例子 以泡泡堂游戏为例,先定义一个玩家构造函数,它有三个原型方法 Player.prototype.win,Player.prototype.lose,Player.prototype.die 当只有两个玩家时,一个玩家死亡时游戏结束,同时通知他的对手胜利 function Player(name){ this.name=name; this.

javascript设计模式学习之十五——中介者模式

一.中介者模式的定义和应用场景 中介者模式的作用在于解除对象之间的紧耦合关系,增加一个中介者之后,所有对象都通过中介者来通信,而不是互相引用,当一个对象发生变化的时候,仅需要通知中介者即可.从而将网状的多对多关系转换为了简单的一对多关系. 二.

javascript设计模式之中介者模式

/* * 小游戏演示中介者模式 * Home 按键 1 * Guest 按键 0 * 半分钟内看谁按下的次数多 * * 参与的对象: * 玩家 * 计分板 * 中介者 * * 中介者模式使对象之间松耦合,提高了可维护性 */ // 玩家 var Player = function (name) { this.name = name; this.point = 0; }; Player.prototype.play = function () { this.point += 1; mediator

javascript设计模式——中介者模式

前面的话 程序由大大小小的单一对象组成,所有这些对象都按照某种关系和规则来通信.当程序的规模增大,对象会越来越多,它们之间的关系也越来越复杂,难免会形成网状的交叉引用.当改变或删除其中一个对象的时候,很可能需要通知所有引用到它的对象.面向对象设计鼓励将行为分布到各个对象中,把对象划分成更小的粒度,有助于增强对象的可复用性,但由于这些细粒度对象之间的联系激增,又有可能会反过来降低它们的可复用性.中介者模式的作用就是解除对象与对象之间的紧耦合关系.增加一个中介者对象后,所有的相关对象都通过中介者对象

javascript设计模式(中介者模式)

中介者模式的作用就是解除对象与对象之间的紧耦合关系,它也称‘调停者’.所有的对象都通过中介者对象来通信,而不是相互引用,所以当一个对象发生改变时,只需要通知中介者即可. 如:机场的指挥塔,每架飞机都只需要和指挥塔通信即可,指挥塔知道每架飞机的飞行状况,可以安排所有起降时间,调整航线等 中介者模式符合迪米特法则,即最少知识原则,指一个对象应该尽可能少地了解另外的对象.如果对象之间的耦合性太高,则改变一个对象,会牵动很多对象,难于维护.当对象耦合很紧时,要修改一个对象而不影响其它的对象是很困难的.

JavaScript设计模式样例二十 —— 中介者模式

中介者模式(Mediator Pattern) 定义:用来降低多个对象和类之间的通信复杂性.目的:用一个中介对象来封装一系列的对象交互,中介者使各对象不需要显式地相互引用,从而使其耦合松散,而且可以独立地改变它们之间的交互.场景:MVC框架中的控制器C就是模型M和识图V的中介者. let mediator = (() => { let msg = {} return { register: (type, action) => { if (!msg[type]) msg[type] = [] m

设计模式(五):中介者模式

在<JavaScript设计模式>关于中介者模式的介绍里,里面有些错误和擅自添加的例子,虽然例子(英文版没有)是为了让人更好理解,但是该篇章加上的例子却给人误导的感觉,所以如果有人读这个章节时,建议看英文版. 在看这个模式时候,我只想弄明白一点,中介者模式与订阅/发布模式的区别在哪? 中介者模式定义 中介者作为一种行为设计模式,它公开一个统一的接口,系统的不同对象或组件可以通过该接口进行通信.增加一个中介者对象后,所有的相关对象通过中介者对象来通信,而不是互相引用,所以当一个对象发生改变时,只