您的当前位置:首页JavaScript中介者模式定义和如何引用代码详解
广告

JavaScript中介者模式定义和如何引用代码详解

2023-12-01 来源:吉希宠物网

面向对象设计鼓励将行为分布到各个对象中,把对象划分成更小的粒度,有助于增强对象的可复用性。但由于这些细粒度对象之间的联系激增,又可能反过来降低它们的可复用性。

中介者模式的作用就是解除对象与对象之间的紧耦合关系。

示例:

假设我们正在开发一个购买手机的页面,购买流程中,可以选择手机颜色以及输入购买数量,同时页面中可以对应展示输入内容。还有一个按钮动态显示下一步操作(该颜色库存量充足,显示下一步;否则显示库存不足)。

<p> <span>请选择颜色</span> <select id="selColor"> <option value="roseGold">玫瑰金</option> <option value="luxuryGold">土豪金</option> </select></p><p> <span>请输入购买数量:</span> <input type="text" id="selNum" /> </p><p> <span>您选择的颜色为:</span><strong id="conColor"></strong> <span>您选择的数量为:</span><strong id="conNum"></strong></p><button id="nextBtn">加入购物车</button>

当页面中新增加另外一个下拉列表框,代表手机内存,上述代码改动面很大。

引入中介模式

所有的节点对象只跟中介者通信。 当下拉选择框selColor、selMemory亦或文本框selNum发生了事件行为时,仅通知中介者它们被改变了,同时把自己当做参数传入中介者,以便中介者辨别是谁发生了改变,剩下的事情交给中介者对象来完成。

<p> <span>请选择颜色:</span> <select id="selColor"> <option value="roseGold">玫瑰金</option> <option value="luxuryGold">土豪金</option> </select></p><p> <span>请选择内存:</span> <select id="selMemory"> <option value="16G">16G</option> <option value="64G">64G</option> </select></p><p> <span>请输入购买数量:</span> <input type="text" id="selNum" /> </p><p> <span>您选择的颜色为:</span><strong id="conColor"></strong> <span>您选择的内存为:</span><strong id="conMemory"></strong> <span>您选择的数量为:</span><strong id="conNum"></strong></p><button id="nextBtn">加入购物车</button>

缺点:最大的缺点是系统中会增加一个中介对象,因为对象之间交互的复杂性,转移成了中介对象的复杂性,使得中介者对象经常是巨大的,很难维护。

一般来说,如果对象之间的复杂耦合确实导致调用和维护出现了困难,而且这些耦合度随项目的变化呈指数增长,那么我们可以考虑用中介者模式来重构代码。

小编还为您整理了以下内容,可能对您也有帮助:

设计模式(五)行为型模式

在上一篇结构型模式中,我们以功能为基本单位,研究了一些设计模式,用于实现功能转换、功能组合、功能封装等目的。

我们知道,面向对象编程有两个核心元素:对象、对象间通信协作。从面向对象的角度看,任何系统和功能,都是由一个个对象,相互分工合作实现的。推而广之,很多系统也都是这样组织和运行的。

本章的设计模式,列举了通用场景下常用功能机制的经典实现方法,讲解了经典实现中是如何高效组织对象、控制对象协作交互的,具有很好的参考价值。

示例:https://www.runoob.com/design-pattern/chain-of-responsibility-pattern.html

责任链模式,就是把程序处理对象前后排列起来,形成一条处理线。处理线上需要被处理的信息,在处理线上向下传递,任何一个节点都可以随时中断传递。

GUI系统中的事件传递机制(在Javascript中叫做事件冒泡),是责任链模式最典型的应用之一。

当某一事件发生时,最顶层GUI对象会首先收到事件,但是它先不处理,而是依次交给命中的子GUI对象处理。当子GUI对象返回为False时,表示事件未被接收,此时父GUI对象才真正对发生的事件进行业务处理。

可以看出,事件传递机制,是一种增强版的责任链模式,它的节点处理权,经历了向下和向上的双向传递过程。

总结:当项目中一个数据对象,需要被多个处理对象进行处理时,可以将处理对象链接起来,然后把数据对象传递给头节点,随着处理的进行,数据对象的处理权会在处理链中流动,从而完成整个处理过程。

责任链模式结构适用于需求固定的场景,用于实现简单高效的处理机制。假如需求不断变化,而且功能很复杂,那么用责任链模式很可能就无法胜任了,需要采用新的高复杂度的设计。例如,如果想要数据对象在所有处理对象中根据状态来实现跳转,可以选择使用状态机等其他方案来实现。

示例:https://www.runoob.com/design-pattern/command-pattern.html

想要实现撤销、重做、事务等功能,可以使用此设计模式。通常在编辑器、数据库中有此类功能需求。

命令也就是请求,或者叫调用。命令模式要求将请求参数和请求相关的方法封装在一起。

请求对象中封装了实现“撤销”、“重做”、“事务”功能所需要的所有信息,实现了关联信息的高内聚,所以可以实现我们想要的功能。

例如,可以在请求对象中保存修改之前的值、修改之后的值。利用修改之前的值,可以实现“撤销”功能;利用修改之后的值,可以实现“重做”功能。如果将所有请求对象都记录下来,并按照先后顺序排列起来,形成“撤销重做”堆栈,这样就可以实现连续的“撤销”、“重做”。“事务”则是“撤销”与“重做”的结合体,正常执行流程等同于“重做”,发生错误需要回滚,等同于“撤销”。

如果不采用这种方式,会导致实现这些功能的信息,分散在源码中多个地方,或者已经丢失,没有保存,就无法实现“撤销”、“重做”、“事务”功能。

同时,实现请求参数高内聚,也可以很方便地将它们保存到磁盘上,保存到文件的过程叫做“序列化”,从文件中读取的过程叫“反序列化”。这里的序列指的就是二进制流。

Qt中与命令模式相关的部分是:Undo Framework,里面有示例项目,不熟悉的同学可以抽点时间看一看。

示例:https://www.runoob.com/design-pattern/interpreter-pattern.html

顾名思义,解释器模式是用来实现解释器的。 解释器是这样一个程序:解释器以符合语法的文本为输入,解释输入内容,完成一定的计算功能。文本可以在程序运行时动态加载,动态解释、动态执行。

实现简单的解释器:命令行程序,如ping命令、cd命令等; 实现复杂的解释器:脚本语言解释器,如python,lua,javascript;计算器。

我们知道,在GUI图形用户界面被发明之前,人类和程序之间的交互是通过敲命令行实现的,缺点是使用难度较大,门槛较高。 在GUI发明以后,交互更加友好,电脑更加易于使用了,所以也更加普及了。

但是GUI交互的缺点在于,不够灵活,对参数的控制粒度不够细致。例如,现在大多数开发者都使用集成开发环境来开发软件,一般情况下都使用默认参数,比较方便。但是如果你想要更改某些编译选项,可能还是需要直接修改底层的编译命令。命令相对于GUI元素更加灵活,过于灵活的地方用GUI比较难于实现,例如组合、递归、跳转等等。在这些场景下,使用解释器是非常合适的。但是通常情况下,这个模式并不常用。

示例:https://www.runoob.com/design-pattern/iterator-pattern.html

在需要多次遍历同一个数据集合的时候,为了少些一些for,或者想要把遍历过程封装起来,降低耦合,就可以使用迭代器模式。这个模式非常常用。

迭代器就是一个专门用来遍历数组的类。它只需要实现两个接口:hasNext()、next()。 hasNext()接口用于控制循环何时停止;next()接口用于取出当前位置的数据元素,并将遍历指针指向下一个元素。 当然,构造迭代器对象的时候,需要将数据集合传递给迭代器,让迭代器知道要遍历哪些数据。

原本需要用for循环来遍历的代码,现在通过封装,提取出了“遍历”这一功能所需要的必要信息,定义了两个接口,把不必要暴露的信息封装在了迭代器中,妥妥的实现了解耦。

示例:https://www.runoob.com/design-pattern/mediator-pattern.html

中介者模式是指,在原本直接通信的对象之间,添加一个通信中间层,使对象间通信变为间接通信,降低对象间的耦合。

此模式和代理模式基本思想上是一致的。二者的区别是:代理模式是通过加一个中间层,来实现两个原本很难交互的功能主体,实现顺畅交互;中介者模式是为了降低对象间通信时的耦合而提出的,为的是提高代码的可维护性。

比较大的项目中会用到,一般存在于某些框架中。因为大的项目中对象繁多,通信也比较复杂,适合使用中介者模式。

在大的项目中,一般会有一个全局的通信管理器,任何对象都可以使用通信管理器提供的接口,将自己注册为某一个具有唯一ID消息的发送者和接收者。这样发送者只需要发送消息,不需要管谁来接收,不需要拥有发送者的实例指针,发出消息后,已注册的接收者都会收到消息。接收者不需要管信号是谁发的,即不需要拥有发送者的实例指针。

所以,中介者模式也可以叫“通信中介模式”。

示例:https://www.runoob.com/design-pattern/memento-pattern.html

这个模式和状态存档功能是绑定在一起的。为了在程序中实现状态存档功能,可以使用备忘录模式。

原例子中有三个类,个人觉得没有必要,这里我们简化成两个类,即备忘录模式中有两个类:状态对象类和状态对象管理类。 状态对象类是状态字段是集合,并提供了存取接口;状态对象管理类负责组织和保存状态对象。当然实际实现中可以根据需求增加类,配合使用,完成状态保存恢复。

当一个对象会影响到其他多个对象时,即当对象间存在一对多关系时,使用观察者模式。 一般应用于单向通知的场景,如GUI中鼠标事件、按键事件、窗口事件通知。使用Qt中的信号槽机制可以实现此模式。

“一”是指发生变化的那个对象,“多”是指需要获取此变化通知的对象组。其中,变化消息是单向地由“一”到“多”传递的。如果不是单向的或者对象间不是一对多的关系,更加复杂,就需要重新思考其他对象间通信模型。

如果不使用此模式,可能会导致观察者不能动态增加或删除;可能会造成发送者的业务代码和接收者的响应代码混在一起,耦合严重。

使用此模式,需要为观察者设计一个基类,并设计一个接收通知的接口,所有观察者需要实现通知接口;所有观察者指针可以保存在队列中,实现动态增删。

状态模式用于实现状态机。 如果一个程序功能中存在某些状态,在一定情况下,这些状态可以互相转换,并且在转换前后需要作出对应的操作,这种情况下使用状态机来实现就非常合适。

如果不使用状态机(状态模式),一般的实现方法是使用一连串的if-else,或者使用长长的switch-case来实现。这样做的缺点,一方面状态判断不够高效,另一方面是业务代码集中在一块,不好维护。

使用状态机,每个状态都是一个类,相关的业务代码分布到各自的状态类中,能够实现不同的状态及与状态相关的业务代码解耦。同时某个状态和下一个状态是关联好的,在状态切换时,效率更高,不需要执行长长的判断。

Qt中已实现状态机框架,The State Machine Framework,在此框架下,我们可以更加专注于业务实现,而不是状态机本身的技术细节。

示例:https://www.runoob.com/design-pattern/null-object-pattern.html

使用基类保存子类对象通常有两种做法:

第一种方法用指针是基本方法,但是指针用起来要非常小心,要考虑内存释放的问题。此时空对象就可以用空指针表示。 第二种方法用基类对象保存子类对象,这种方法使用起来相对省心,不用与指针打交道,使用者不用直接管理内存。例如Qt中的Qt XML C++ Classes类的设计就是采用这种方式设计的。这种情况下,因为不使用指针,就需要使用空对象来代替空指针。

可以仿造Qt XML中的类进行设计。一般需要提供isNull()接口,对象类型转换接口等。

策略模式和桥接模式类似,用于实现功能切换与组合。二者区别在于,策略模式专注于一个功能的不同实现方式;桥接模式专注于多个功能之间的组合。

将功能抽象成单独的类,功能切换只需要切换不同的功能子类即可,同一个功能需要实现同一个功能接口。

示例:https://www.runoob.com/design-pattern/template-pattern.html

模板模式应该是我们最熟悉的。 这里的模板就是接口类,接口类定义了使用者和功能提供者之间交互的函数列表。子类负责功能的具体实现。

示例:https://www.runoob.com/design-pattern/visitor-pattern.html

访问者模式用于将数据结构与数据操作相分离。

访问者模式和迭代器模式类似。迭代器模式一般用来遍历数组,所以没有把for封装起来。而访问者模式可以遍历一切类型的数据结构,具体的遍历过程被封装在接收者内部。同时,对每一个遍历得到的数组元素的操作,被封装在访问者内部。每一种对元素不同的操作,都需要新建一个访问者类。

接收者需要实现accept()接口,访问者需要实现visit()接口。

每种设计模式都有使用场景,都有优点和缺点。随着需求的改变,任何一种设计模式可能都将不再适用。

设计模式(五)行为型模式

在上一篇结构型模式中,我们以功能为基本单位,研究了一些设计模式,用于实现功能转换、功能组合、功能封装等目的。

我们知道,面向对象编程有两个核心元素:对象、对象间通信协作。从面向对象的角度看,任何系统和功能,都是由一个个对象,相互分工合作实现的。推而广之,很多系统也都是这样组织和运行的。

本章的设计模式,列举了通用场景下常用功能机制的经典实现方法,讲解了经典实现中是如何高效组织对象、控制对象协作交互的,具有很好的参考价值。

示例:https://www.runoob.com/design-pattern/chain-of-responsibility-pattern.html

责任链模式,就是把程序处理对象前后排列起来,形成一条处理线。处理线上需要被处理的信息,在处理线上向下传递,任何一个节点都可以随时中断传递。

GUI系统中的事件传递机制(在Javascript中叫做事件冒泡),是责任链模式最典型的应用之一。

当某一事件发生时,最顶层GUI对象会首先收到事件,但是它先不处理,而是依次交给命中的子GUI对象处理。当子GUI对象返回为False时,表示事件未被接收,此时父GUI对象才真正对发生的事件进行业务处理。

可以看出,事件传递机制,是一种增强版的责任链模式,它的节点处理权,经历了向下和向上的双向传递过程。

总结:当项目中一个数据对象,需要被多个处理对象进行处理时,可以将处理对象链接起来,然后把数据对象传递给头节点,随着处理的进行,数据对象的处理权会在处理链中流动,从而完成整个处理过程。

责任链模式结构适用于需求固定的场景,用于实现简单高效的处理机制。假如需求不断变化,而且功能很复杂,那么用责任链模式很可能就无法胜任了,需要采用新的高复杂度的设计。例如,如果想要数据对象在所有处理对象中根据状态来实现跳转,可以选择使用状态机等其他方案来实现。

示例:https://www.runoob.com/design-pattern/command-pattern.html

想要实现撤销、重做、事务等功能,可以使用此设计模式。通常在编辑器、数据库中有此类功能需求。

命令也就是请求,或者叫调用。命令模式要求将请求参数和请求相关的方法封装在一起。

请求对象中封装了实现“撤销”、“重做”、“事务”功能所需要的所有信息,实现了关联信息的高内聚,所以可以实现我们想要的功能。

例如,可以在请求对象中保存修改之前的值、修改之后的值。利用修改之前的值,可以实现“撤销”功能;利用修改之后的值,可以实现“重做”功能。如果将所有请求对象都记录下来,并按照先后顺序排列起来,形成“撤销重做”堆栈,这样就可以实现连续的“撤销”、“重做”。“事务”则是“撤销”与“重做”的结合体,正常执行流程等同于“重做”,发生错误需要回滚,等同于“撤销”。

如果不采用这种方式,会导致实现这些功能的信息,分散在源码中多个地方,或者已经丢失,没有保存,就无法实现“撤销”、“重做”、“事务”功能。

同时,实现请求参数高内聚,也可以很方便地将它们保存到磁盘上,保存到文件的过程叫做“序列化”,从文件中读取的过程叫“反序列化”。这里的序列指的就是二进制流。

Qt中与命令模式相关的部分是:Undo Framework,里面有示例项目,不熟悉的同学可以抽点时间看一看。

示例:https://www.runoob.com/design-pattern/interpreter-pattern.html

顾名思义,解释器模式是用来实现解释器的。 解释器是这样一个程序:解释器以符合语法的文本为输入,解释输入内容,完成一定的计算功能。文本可以在程序运行时动态加载,动态解释、动态执行。

实现简单的解释器:命令行程序,如ping命令、cd命令等; 实现复杂的解释器:脚本语言解释器,如python,lua,javascript;计算器。

我们知道,在GUI图形用户界面被发明之前,人类和程序之间的交互是通过敲命令行实现的,缺点是使用难度较大,门槛较高。 在GUI发明以后,交互更加友好,电脑更加易于使用了,所以也更加普及了。

但是GUI交互的缺点在于,不够灵活,对参数的控制粒度不够细致。例如,现在大多数开发者都使用集成开发环境来开发软件,一般情况下都使用默认参数,比较方便。但是如果你想要更改某些编译选项,可能还是需要直接修改底层的编译命令。命令相对于GUI元素更加灵活,过于灵活的地方用GUI比较难于实现,例如组合、递归、跳转等等。在这些场景下,使用解释器是非常合适的。但是通常情况下,这个模式并不常用。

示例:https://www.runoob.com/design-pattern/iterator-pattern.html

在需要多次遍历同一个数据集合的时候,为了少些一些for,或者想要把遍历过程封装起来,降低耦合,就可以使用迭代器模式。这个模式非常常用。

迭代器就是一个专门用来遍历数组的类。它只需要实现两个接口:hasNext()、next()。 hasNext()接口用于控制循环何时停止;next()接口用于取出当前位置的数据元素,并将遍历指针指向下一个元素。 当然,构造迭代器对象的时候,需要将数据集合传递给迭代器,让迭代器知道要遍历哪些数据。

原本需要用for循环来遍历的代码,现在通过封装,提取出了“遍历”这一功能所需要的必要信息,定义了两个接口,把不必要暴露的信息封装在了迭代器中,妥妥的实现了解耦。

示例:https://www.runoob.com/design-pattern/mediator-pattern.html

中介者模式是指,在原本直接通信的对象之间,添加一个通信中间层,使对象间通信变为间接通信,降低对象间的耦合。

此模式和代理模式基本思想上是一致的。二者的区别是:代理模式是通过加一个中间层,来实现两个原本很难交互的功能主体,实现顺畅交互;中介者模式是为了降低对象间通信时的耦合而提出的,为的是提高代码的可维护性。

比较大的项目中会用到,一般存在于某些框架中。因为大的项目中对象繁多,通信也比较复杂,适合使用中介者模式。

在大的项目中,一般会有一个全局的通信管理器,任何对象都可以使用通信管理器提供的接口,将自己注册为某一个具有唯一ID消息的发送者和接收者。这样发送者只需要发送消息,不需要管谁来接收,不需要拥有发送者的实例指针,发出消息后,已注册的接收者都会收到消息。接收者不需要管信号是谁发的,即不需要拥有发送者的实例指针。

所以,中介者模式也可以叫“通信中介模式”。

示例:https://www.runoob.com/design-pattern/memento-pattern.html

这个模式和状态存档功能是绑定在一起的。为了在程序中实现状态存档功能,可以使用备忘录模式。

原例子中有三个类,个人觉得没有必要,这里我们简化成两个类,即备忘录模式中有两个类:状态对象类和状态对象管理类。 状态对象类是状态字段是集合,并提供了存取接口;状态对象管理类负责组织和保存状态对象。当然实际实现中可以根据需求增加类,配合使用,完成状态保存恢复。

当一个对象会影响到其他多个对象时,即当对象间存在一对多关系时,使用观察者模式。 一般应用于单向通知的场景,如GUI中鼠标事件、按键事件、窗口事件通知。使用Qt中的信号槽机制可以实现此模式。

“一”是指发生变化的那个对象,“多”是指需要获取此变化通知的对象组。其中,变化消息是单向地由“一”到“多”传递的。如果不是单向的或者对象间不是一对多的关系,更加复杂,就需要重新思考其他对象间通信模型。

如果不使用此模式,可能会导致观察者不能动态增加或删除;可能会造成发送者的业务代码和接收者的响应代码混在一起,耦合严重。

使用此模式,需要为观察者设计一个基类,并设计一个接收通知的接口,所有观察者需要实现通知接口;所有观察者指针可以保存在队列中,实现动态增删。

状态模式用于实现状态机。 如果一个程序功能中存在某些状态,在一定情况下,这些状态可以互相转换,并且在转换前后需要作出对应的操作,这种情况下使用状态机来实现就非常合适。

如果不使用状态机(状态模式),一般的实现方法是使用一连串的if-else,或者使用长长的switch-case来实现。这样做的缺点,一方面状态判断不够高效,另一方面是业务代码集中在一块,不好维护。

使用状态机,每个状态都是一个类,相关的业务代码分布到各自的状态类中,能够实现不同的状态及与状态相关的业务代码解耦。同时某个状态和下一个状态是关联好的,在状态切换时,效率更高,不需要执行长长的判断。

Qt中已实现状态机框架,The State Machine Framework,在此框架下,我们可以更加专注于业务实现,而不是状态机本身的技术细节。

示例:https://www.runoob.com/design-pattern/null-object-pattern.html

使用基类保存子类对象通常有两种做法:

第一种方法用指针是基本方法,但是指针用起来要非常小心,要考虑内存释放的问题。此时空对象就可以用空指针表示。 第二种方法用基类对象保存子类对象,这种方法使用起来相对省心,不用与指针打交道,使用者不用直接管理内存。例如Qt中的Qt XML C++ Classes类的设计就是采用这种方式设计的。这种情况下,因为不使用指针,就需要使用空对象来代替空指针。

可以仿造Qt XML中的类进行设计。一般需要提供isNull()接口,对象类型转换接口等。

策略模式和桥接模式类似,用于实现功能切换与组合。二者区别在于,策略模式专注于一个功能的不同实现方式;桥接模式专注于多个功能之间的组合。

将功能抽象成单独的类,功能切换只需要切换不同的功能子类即可,同一个功能需要实现同一个功能接口。

示例:https://www.runoob.com/design-pattern/template-pattern.html

模板模式应该是我们最熟悉的。 这里的模板就是接口类,接口类定义了使用者和功能提供者之间交互的函数列表。子类负责功能的具体实现。

示例:https://www.runoob.com/design-pattern/visitor-pattern.html

访问者模式用于将数据结构与数据操作相分离。

访问者模式和迭代器模式类似。迭代器模式一般用来遍历数组,所以没有把for封装起来。而访问者模式可以遍历一切类型的数据结构,具体的遍历过程被封装在接收者内部。同时,对每一个遍历得到的数组元素的操作,被封装在访问者内部。每一种对元素不同的操作,都需要新建一个访问者类。

接收者需要实现accept()接口,访问者需要实现visit()接口。

每种设计模式都有使用场景,都有优点和缺点。随着需求的改变,任何一种设计模式可能都将不再适用。

常用设计模式概览:提高程序可维护性和可扩展性的秘密武器?

设计模式是在软件开发中常用的一种编程技巧,它提供了一种通用的解决方案,以便在面对特定的问题时,能够提高软件的可维护性、可扩展性和可重用性。设计模式是一种经过实践证明并被广泛使用的最佳实践。在本文中,我们将简要介绍常见的设计模式。

一、创建型模式

1、工厂方法模式(Factory Method)

工厂方法模式是一种用于创建对象的设计模式。它定义了一个接口来创建对象,并由子类来实现这个接口,从而创建出不同的对象。这样,我们就可以在不暴露对象创建细节的情况下创建对象。工厂方法模式可以帮助我们解决创建对象时的复杂性。

2、抽象工厂模式(Abstract Factory)

抽象工厂模式是工厂方法模式的一种扩展。它可以帮助我们创建一组相关的对象,而不是单个对象。抽象工厂模式定义了一个抽象工厂接口,具体的工厂实现了这个接口来创建对象。通过使用抽象工厂模式,我们可以将对象的创建过程封装起来,从而让客户端代码更加简单。

3、单例模式(Singleton)

单例模式是一种确保一个类只有一个实例的模式。它通过将类的构造函数私有化来实现。这样,就可以防止通过构造函数创建多个实例。单例模式通常提供一个静态方法来获取类的唯一实例。单例模式可以帮助我们确保全局只有一个实例,并且可以让我们方便地访问这个实例。

4、建造者模式(Builder)

建造者模式是一种用于创建复杂对象的模式。它将对象的构造过程分解成多个步骤,并且允许在每个步骤中使用不同的构造方法。这样,就可以创建出不同的对象。建造者模式可以帮助我们解决创建复杂对象时的复杂性。

5、原型模式(Prototype)

原型模式是一种用于创建对象的模式。它允许我们通过克隆一个现有对象来创建一个新的对象。这样,我们就可以在不知道对象创建细节的情况下创建新的对象。原型模式可以帮助我们提高对象创建的效率。

二、结构型模式

1、适配器模式(Adapter)

适配器模式是一种用于将不兼容接口转换为兼容接口的模式。适配器模式通过包装一个对象来适配不同的接口。这样,就可以让原本不兼容的接口能够相互协作。适配器模式可以帮助我们将旧系统与新系统无缝集成。

2、桥接模式(Bridge)

桥接模式是一种用于将抽象部分与实现部分分离的模式。桥接模式通过将抽象部分与实现部分分离,从而可以让它们能够地变化。这样,就可以在不影响其他部分的情况下修改抽象部分或实现部分。

3、组合模式(Composite)

组合模式是一种用于将对象组合成树形结构的模式。组合模式通过将对象组合成树形结构,从而可以让客户端代码以统一的方式处理单个对象和组合对象。组合模式可以帮助我们简化代码结构,从而提高代码的可读性和可维护性。

4、装饰器模式(Decorator)

装饰器模式是一种用于在运行时添加功能的模式。装饰器模式通过将对象包装在另一个对象中,从而可以在运行时动态地添加功能。装饰器模式可以帮助我们将复杂的功能分解成简单的功能,并且可以让我们方便地扩展对象的功能。

5、外观模式(Facade)

外观模式是一种用于简化接口的模式。外观模式通过提供一个简单的接口来隐藏系统的复杂性。这样,就可以让客户端代码更加简单。外观模式可以帮助我们简化代码结构,并且可以提高代码的可读性和可维护性。

6、享元模式(Flyweight)

享元模式是一种用于共享对象的模式。享元模式通过将共享对象的状态分离出来,从而可以让多个对象共享同一个状态。这样,就可以减少对象的数量,从而提高系统的性能。享元模式可以帮助我们优化系统性能,并且可以减少内存使用量。

三、行为型模式

1、职责链模式(Chain of Responsibility)

职责链模式是一种用于处理请求的模式。职责链模式通过将请求沿着一条链传递下去,从而可以让多个对象都有机会处理这个请求。职责链模式可以帮助我们将复杂的业务逻辑分解成简单的逻辑,并且可以让我们方便地扩展处理请求的对象。

2、命令模式(Command)

命令模式是一种用于封装操作的模式。命令模式通过将操作封装成对象,从而可以让我们能够以统一的方式处理不同的操作。命令模式可以帮助我们简化代码结构,并且可以让我们方便地撤销和重做操作。

3、解释器模式(Interpreter)

解释器模式是一种用于处理语言的模式。解释器模式通过将语言分解成语法树,从而可以让我们方便地解析和执行语言。解释器模式可以帮助我们扩展语言的语法和功能,并且可以让我们方便地添加新的语言。

4、迭代器模式(Iterator)

迭代器模式是一种用于访问集合的模式。迭代器模式通过将集合的遍历过程封装成对象,从而可以让客户端代码以统一的方式访问集合中的元素。迭代器模式可以帮助我们简化代码结构,并且可以让我们方便地扩展集合的遍历方式。

5、中介者模式(Mediator)

中介者模式是一种用于处理对象之间的交互的模式。中介者模式通过将对象之间的交互集中在一个中介者对象中,从而可以让对象之间的交互变得更加简单。中介者模式可以帮助我们解耦对象之间的交互,并且可以让我们方便地添加新的对象和交互方式。

6、备忘录模式(Memento)

备忘录模式是一种用于保存对象状态的模式。备忘录模式通过将对象的状态保存在一个备忘录对象中,从而可以让对象在后续操作中恢复到之前的状态。备忘录模式可以帮助我们实现撤销和重做操作,并且可以让我们方便地保存对象的历史状态。

7、观察者模式(Observer)

观察者模式是一种用于处理对象之间的通知的模式。观察者模式通过将对象之间的通知封装成事件,从而可以让对象之间的通知变得更加简单。观察者模式可以帮助我们解耦对象之间的通知,并且可以让我们方便地添加新的对象和通知方式。

8、状态模式(State)

状态模式是一种用于处理对象状态的模式。状态模式通过将对象的状态分解成不同的状态类,从而可以让对象的状态变得更加清晰。状态模式可以帮助我们简化代码结构,并且可以让我们方便地扩展对象的状态。

9、策略模式(Strategy)

策略模式是一种用于处理算法的模式。策略模式通过将算法封装成不同的策略类,从而可以让客户端代码选择不同的算法。策略模式可以帮助我们简化代码结构,并且可以让我们方便地扩展算法。

10、模板方法模式(Template Method)

模板方法模式是一种用于处理算法的模式。模板方法模式通过将算法的骨架定义在抽象基类中,从而可以让子类实现具体的算法细节。模板方法模式可以帮助我们简化代码结构,并且可以让我们方便地扩展算法的骨架和细节。

11、访问者模式(Visitor)

访问者模式是一种用于处理对象结构的模式。访问者模式通过将对象结构和访问操作分离,从而可以让客户端代码以统一的方式访问对象结构中的元素。访问者模式可以帮助我们简化代码结构,并且可以让我们方便地添加新的访问操作和元素类型。

12、享元模式(Flyweight)

像元模式是一种用于处理大量相似对象的模式。享元模式通过共享相同的状态,从而可以让我们节省内存和时间开销。享元模式可以帮助我们提高程序的性能,并且可以让我们方便地添加新的对象类型。

总结:设计模式是一种被广泛使用的软件设计方法,它可以帮助我们简化代码结构、提高程序的可维护性和可扩展性。在本文中,我们介绍了12种常用的设计模式,包括工厂模式、单例模式、命令模式、解释器模式、迭代器模式、中介者模式、备忘录模式、观察者模式、状态模式、策略模式、模板方法模式和访问者模式。

每种设计模式都有自己的特点和用途,我们可以根据不同的情况选择适合的模式来解决问题。虽然设计模式可以帮助我们提高程序的质量和效率,但是过度使用设计模式也会带来一些问题,例如增加代码的复杂性和维护成本。因此,在使用设计模式时,我们应该权衡利弊,根据实际情况作出选择。

JavaScript 中介者模式与观察者模式有何不同

本篇文章给大家带来的内容是关于js设计模式:什么是中介者模式?js中介者模式的介绍,有一定的参考价值,有需要的朋友可以参考一下,希望对你有所帮助。

什么是中介者模式?

中介者模式:对象和对象之间借助第三方中介者进行通信。

定义:用一个中介对象来封装一系列的对象交互,中介者使各对象不需要显式地相互引用,从而使其耦合松散,而且可以独立地改变它们之间的交互。

主要解决:对象与对象之间存在大量的关联关系,这样势必会导致系统的结构变得很复杂,同时若一个对象发生改变,我们也需要跟踪与之相关联的对象,同时做出相应的处理。

何时使用:多个类相互耦合,形成了网状结构。

如何解决:将上述网状结构分离为星型结构。

js中介者模式应用实例: 1、中国加入 WTO 之前是各个国家相互贸易,结构复杂,现在是各个国家通过 WTO 来互相贸易。 2、机场调度系统。 3、MVC 框架,其中C(控制器)就是 M(模型)和 V(视图)的中介者。

js中介者模式优点: 1、降低了类的复杂度,将一对多转化成了一对一。 2、各个类之间的解耦。 3、符合迪米特原则。

js中介者模式缺点:中介者会庞大,变得复杂难以维护。

js中介者模式使用场景: 1、系统中对象之间存在比较复杂的引用关系,导致它们之间的依赖关系结构混乱而且难以复用该对象。 2、想通过一个中间类来封装多个类中的行为,而又不想生成太多的子类。

注意事项:不应当在职责混乱的时候使用。

js中介者模式场景Demo

一场测试结束后,公布结果:告知解答出题目的人挑战成功,否则挑战失败。

const player = function(name) { this.name = name playerMiddle.add(name)}player.prototype.win = function() { playerMiddle.win(this.name)}player.prototype.lose = function() { playerMiddle.lose(this.name)}const playerMiddle = (function() { // 将就用下这个 demo,这个函数当成中介者 const players = [] const winArr = [] const loseArr = [] return { add: function(name) { players.push(name) }, win: function(name) { winArr.push(name) if (winArr.length + loseArr.length === players.length) { this.show() } }, lose: function(name) { loseArr.push(name) if (winArr.length + loseArr.length === players.length) { this.show() } }, show: function() { for (let winner of winArr) { console.log(winner + '挑战成功;') } for (let loser of loseArr) { console.log(loser + '挑战失败;') } }, }}())const a = new player('A 选手')const b = new player('B 选手')const c = new player('C 选手')a.win()b.win()c.lose()// A 选手挑战成功;// B 选手挑战成功;// C 选手挑战失败;

在这段代码中 A、B、C 之间没有直接发生关系,而是通过另外的 playerMiddle 对象建立链接,姑且将之当成是中介者模式了。

JavaScript 中介者模式与观察者模式有何不同

本篇文章给大家带来的内容是关于js设计模式:什么是中介者模式?js中介者模式的介绍,有一定的参考价值,有需要的朋友可以参考一下,希望对你有所帮助。

什么是中介者模式?

中介者模式:对象和对象之间借助第三方中介者进行通信。

定义:用一个中介对象来封装一系列的对象交互,中介者使各对象不需要显式地相互引用,从而使其耦合松散,而且可以独立地改变它们之间的交互。

主要解决:对象与对象之间存在大量的关联关系,这样势必会导致系统的结构变得很复杂,同时若一个对象发生改变,我们也需要跟踪与之相关联的对象,同时做出相应的处理。

何时使用:多个类相互耦合,形成了网状结构。

如何解决:将上述网状结构分离为星型结构。

js中介者模式应用实例: 1、中国加入 WTO 之前是各个国家相互贸易,结构复杂,现在是各个国家通过 WTO 来互相贸易。 2、机场调度系统。 3、MVC 框架,其中C(控制器)就是 M(模型)和 V(视图)的中介者。

js中介者模式优点: 1、降低了类的复杂度,将一对多转化成了一对一。 2、各个类之间的解耦。 3、符合迪米特原则。

js中介者模式缺点:中介者会庞大,变得复杂难以维护。

js中介者模式使用场景: 1、系统中对象之间存在比较复杂的引用关系,导致它们之间的依赖关系结构混乱而且难以复用该对象。 2、想通过一个中间类来封装多个类中的行为,而又不想生成太多的子类。

注意事项:不应当在职责混乱的时候使用。

js中介者模式场景Demo

一场测试结束后,公布结果:告知解答出题目的人挑战成功,否则挑战失败。

const player = function(name) { this.name = name playerMiddle.add(name)}player.prototype.win = function() { playerMiddle.win(this.name)}player.prototype.lose = function() { playerMiddle.lose(this.name)}const playerMiddle = (function() { // 将就用下这个 demo,这个函数当成中介者 const players = [] const winArr = [] const loseArr = [] return { add: function(name) { players.push(name) }, win: function(name) { winArr.push(name) if (winArr.length + loseArr.length === players.length) { this.show() } }, lose: function(name) { loseArr.push(name) if (winArr.length + loseArr.length === players.length) { this.show() } }, show: function() { for (let winner of winArr) { console.log(winner + '挑战成功;') } for (let loser of loseArr) { console.log(loser + '挑战失败;') } }, }}())const a = new player('A 选手')const b = new player('B 选手')const c = new player('C 选手')a.win()b.win()c.lose()// A 选手挑战成功;// B 选手挑战成功;// C 选手挑战失败;

在这段代码中 A、B、C 之间没有直接发生关系,而是通过另外的 playerMiddle 对象建立链接,姑且将之当成是中介者模式了。

Java设计模式的中介者模式是怎样的

如果对象之间的关系原本一目了然,中介对象的加入便是“画蛇添足”。

来看下中介者模式的组成部分吧。

1)抽象中介者(Mediator)角色:抽象中介者角色定义统一的接口用于各同事角色之间的通信。

2)具体中介者(ConcreteMediator)角色:具体中介者角色通过协调各同事角色实现协作行为。

javascript:;怎么解决?

JavaScript中的"javascript:;"是一种特殊的URL格式,用于在网站中使用JavaScript来执行特定的任务或操作。点击学习大厂名师精品课

以下是一些解决方法,可以有效解决“javascript:;”带来的问题:

1、使用未定义的JavaScript函数:可以将“javascript:;”替换为一个未定义的函数名称,例如“javascript:void(0);”或“javascript:none;”。这样可以防止页面自动滚动回顶部,并确保JavaScript代码不会执行;

2、将JavaScript代码移动到外部文件中:可以将JavaScript代码移动到一个单独的外部文件中,并使用链接或按钮的“src”属性来引用该文件。这样可以避免使用“javascript:;”标记,并使JavaScript代码更加易于维护和管理;

3、使用事件绑定:可以使用事件绑定来执行所需的JavaScript代码,而不需要使用“javascript:;”标记。例如,可以使用jQuery的“click”方法来绑定一个单击事件,并在该事件处理程序中执行所需的JavaScript代码。

有任何问题欢迎咨询慕课网。慕课网课程紧跟前沿技术,帮助用户在技术快速更迭的环境下,与时俱进,保持核心竞争力。以短视频小节课为特色,每个视频小节10-15分钟,符合用户碎片化的学习习惯,使学习效果最大化。

吉希宠物网还为您提供以下相关内容希望对您有帮助:

Java设计模式的中介者模式是怎样的

1)抽象中介者(Mediator)角色:抽象中介者角色定义统一的接口用于各同事角色之间的通信。2)具体中介者(ConcreteMediator)角色:具体中介者角色通过协调各同事角色实现协作行为。

javascript:;怎么解决?

这样可以防止页面自动滚动回顶部,并确保JavaScript代码不会执行;2、将JavaScript代码移动到外部文件中:可以将JavaScript代码移动到一个单独的外部文件中,并使用链接或按钮的“src”属性来引用该文件。这样可以避免使用“javascrip...

JavaScript 中介者模式与观察者模式有何不同

中介模式(Mediator Pattern)让我们假设这样一个场景: 有一个Manager一声令下,需要让工人A和工人B开工,代码可以是这样的 Manager.start = function () { A.work();B.work();} 其实还可以这么写,新增一个中介模块,这...

设计模式(五)行为型模式

如果不使用此模式,可能会导致观察者不能动态增加或删除;可能会造成发送者的业务代码和接收者的响应代码混在一起,耦合严重。 使用此模式,需要为观察者设计一个基类,并设计一个接收通知的接口,所有观察者需要实现通知接口;所有观察者指针...

如何在html中调用JS文件

数组的定义:var name=new Array(5) 用 new 来生成数组。数组的赋值:name[1]="Marry"数组的初始化:var name=new Array("Marry","Petty","Mike","Jphn")数组的引用:name[1]注:数组的第一个素由1开始。八、...

如何在一个网页中引用另一个网页的html源代码

可以用iframe框架来解决 定义和用法 iframe 元素会创建包含另外一个文档的内联框架(即行内框架)。上面代码中的src为另一个网页效果如下

前端设计模式之责任链模式

什么是责任链模式 责任链(Chain of Responsibility)模式的定义:为了避免请求发送者与多个请求处理者耦合在一起,将所有请求的处理者通过前一对象记住其下一个对象的引用而连成一条链;当有请求发生时,可将请求沿着这条链...

在一个html页面中想用JavaScript代码引用另一个abc.html页面的代码怎么...

(function () { document.getElementById("ifm").src ="";//Url地址 ("#ifm").load(function () { var h = document.body.clientHeight;var w = document.body.clientWidth;document.getElementById("ifm")....

深入探讨中介者模式和门面模式外观模式)的区别,该如何处理

中介者模式: 你的电脑 CPU 显卡 电源 还有你 ,那你要用电脑 还需要个主板把这些零件整起来 那用到的主板就是 用了 中介者模式。门面模式:一个 CLASS A 还有一个 CLASS B ,你创建一个 CLASS C ,这个 CLASS C...

怎么把调用的js代码放在html中

&lt;/Script&gt; 把上述语句放在HTML的与之间,也可放在与之 间。将JavaScript标识放置&lt;Head&gt;… &lt;/Head&gt;在头部之间,使之在主页和其余部分代码之前装载,从而可使代码的功能更强大;将JavaScript标识放置 在&lt;Body&gt;… &lt;/Body&gt;主体...

Top