Javascript设计模式

加入QQ群：864680898，一起学习进步！点击群名可查看本人网站，有最新文章！

前端设计模式

设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问，设计模式于己于他人于系统都是多赢的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同大厦的一块块砖石一样。项目中合理地运用设计模式可以完美地解决很多问题，每种模式在现实中都有相应的原理来与之对应，每种模式都描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是设计模式能被广泛应用的原因。

单例模式

这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象

• 1、单例类只能有一个实例。
• 2、单例类必须自己创建自己的唯一实例。
• 3、单例类必须给所有其他对象提供这一实例。

就如在单页面中，全局就只有一个Audio对象，在需要音频的地方更换 src ，然后控制其播放，暂停等一系列：

window.audioContext = new Audio()

在小程序中，只有一个背景音频，然后切换音频就是更改 src ，然后控制其播放，暂停等一系列 ：

// app.js
App({
  onLaunch(){

  },
  audioContext: wx.getBackgroundAudioManager()
})

然后播放页面中使用即可

// play.js
const app = getApp()
Page({
  onLoad(){

  },
  onShow(){
    this.playAudio()
  },
  playAudio(){
    let audioDom = app.audioContext
    audioDom.title = '起风了'
    audioDom.src = 'http://audio.22family.com/audio/url/1553691835029489897'
    audioDom.coverImgUrl = 'http://audio.22family.com/audio/cover/1553691837836859778'
    audioDom.play()
  }
})

工厂模式

这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象

就如express就是是工厂模式：

function express(){
  var express = {}, req = {}, res = {};
  express.get = function(pathName, cb){
    // 根据nodejs的path模块获取现在的路由
    // if(path=== pathName){ cb(req, res) }
    cb(req, res)
  }
  res.send = function(msg){
    document.write(msg)
  }
  return express;
}
var app = express()
app.get('/', function(req, res){
  res.send(111)
})

观察者模式

观察者模式( 又叫发布者-订阅者模式 )应该是最常用的模式之一. 在很多语言里都得到大量应用. 包括我们平时接触的dom事件. 也是js和dom之间实现的一种观察者模式.

• 就像常见的监听

window.addEventListener('click', function(){
  console.log('正在点击')
})

• 在vue中的watch和computed：

vue中watch和computed就相当于订阅了data的数据，当数据变化是通知到它们，然后执行相应的操作；vue的虚拟Dom树也订阅了data，computed，watch的数据，当其变化时通知Dom树渲染；低版本的vue可能复杂的数据结构数据变化监听不到，要是用set来设置数据，或者使用$forceUpdate()来强制渲染一次

export default{
  data(){
    return{
      name: 'mySkey'
    }
  },
  computed:{
    nameLen(){
      return this.name.length
    }
  },
  watch:{
    status(){
      return this.name === 'mySkey'
    }
  }
}

• 直播和订阅

现在火热的直播，女主播叫点个订阅，点了订阅就能收到飞机票了，你点了订阅就能下次给你发推送了！

• 微信公众号关注

公众号能给关注的用户发推送，也是这种设计模式

原型模式

原型模式（Prototype Pattern）是用于创建重复的对象，同时又能保证性能。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
这种模式是实现了一个原型接口，该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时，则采用这种模式。例如，一个对象需要在一个高代价的数据库操作之后被创建。我们可以缓存该对象，在下一个请求时返回它的克隆，在需要的时候更新数据库，以此来减少数据库调用。

就像我们经常使用的js对象，Array，String······

// 这样定义一个数组
var arr = [1,2,3]
// 其实是执行了下面这样
var arr = new Array(1,2,3)

然后，arr便继承了Array的原型属性和方法（比如length属性，slice，pop，push，shift，unshift，splice等方法）

同样的我们也能自己来扩展js的原生对象的原型链，比如String没有reverse方法：

if(!String.prototype.reverse){
  String.prototype.reverse = function(){
    return Array.prototype.slice.call(this.split('')).reverse().join('')
  }
}
var str = 'hello world'
console.log(str.reverse())

js面向对象继承构造函数的属性和方法，就是通过js的_proto_来传递的

function Person(name, age){
  this.name = name
  this.age = age
}

// 在prototype中定义的属性和方法，不会在每次实例化的时候都初始化一次，所以把这类必定相同的属性和方法写在prototype中
Person.prototype = {
  sing: function(){
      console.log('sing')
  }
}
var mySkey = new Person('mySkey', 24)
mySkey.sing()
console.log(mySkey.name, mySkey.age)

在es6中使用类class，这些属性和方法还能被继承。但是在js中原理都一个，它们通过一条原型链传递

class Person{
  constructor(name,age){
    this.name = name
    this.age = age
  }
  sing(){
    console.log('sing')
  }
}
var mySkey = new Person('mySkey', 24)
mySkey.sing()
console.log(mySkey.name, mySkey.age)

适配器模式

适配器模式（Adapter Pattern）是作为两个不兼容的接口之间的桥梁。这种类型的设计模式属于结构型模式，它结合了两个独立接口的功能。就像我们手机只能使用20v的电压，为了在家用电充电，我们需要一个充电头，它就能将220v的电压转成20v的，而且每个厂家的充电头还不一样，所以原装的还贵

在开发中使用到适配器模式的情况也多不胜数：

• 1、数据库设计管理员类型type（甚至其他字段），状态status，一般就不会使用vachar类型，选择int类型更加节省空间，就将status定义为 0 禁用 1 可用

在页面中显示时，我们肯定不是显示数字的

let statusArr = ['禁用', '可用']

通过访问数组的键来得到值，这就是适配器模式

• 2、通常我们需要对日期，金钱这些数据进行格式化操作

let getYear = (t)=>{
  let date = new Date(t)
  return date.getFullYear()
}

桥接模式

桥接（Bridge）是用于把抽象化与实现化解耦，使得二者可以独立变化。这种类型的设计模式属于结构型模式，它通过提供抽象化和实现化之间的桥接结构，来实现二者的解耦。

• 1、举一个简单的例子

我之前不明白为什么公司代码里要将ui框架的toast，confirm，alert这些二次封装，然后来调用。你试想一下，如果有一天，你需要更换个ui框呢？你之前直接使用ui框架的写法，是不是就全部得重写，这是很恐怖的，而你全部写在一个文件中的话，只用更改这个文件的写法，这就是桥接模式。

• 2、在实现api的时候，桥接模式就很好用

将请求接口的工具二次封装，方便下次更换

import axios from 'axios'
let API_URL = 'https://www.baidu.com'
export default{
  get (url, data){
    return new Promise((resolve,reject)=>{
      axios({
        url: API_URL + url,
        method: 'get',
        params: data,
        headers: {
          'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8'
        }
      }).then((res) => {
        if(res.data.code == 404){
          alert('系统似乎出了点问题～');
          return reject(res.data);
        }else{
          return resolve(res.data);
        }
      });
    }).catch((err)=>{
      reject(err)
    })
  }
}

过滤器模式

过滤器模式（Filter Pattern）或标准模式（Criteria Pattern）是一种设计模式，这种模式允许开发人员使用不同的标准来过滤一组对象，通过逻辑运算以解耦的方式把它们连接起来。这种类型的设计模式属于结构型模式，它结合多个标准来获得单一标准

• 1、购物车订单

购物车订单提交的时候，我们只需要提交被用户选择的商品的id

sunmit(orders){
  let idsArr = orders.filter(v=> v.isSelected)
  let ids = idsArr.join('')
  ajax.post('/order', { ids })
}

• 2、去除关键词

经常遇到一些喷子（性情暴躁，语言粗鲁），系统要将这些骂人的话屏蔽掉

let filterWords = (words)=>{
  let reg = /(cao|sb|你妹|日你妈|狗日的|傻狗)/gi
  if(words.match(reg)){
    let arr = words.match(reg)
    arr.forEach(e=>{
      words = words.replace(e, e.split('').map(v=>'*').join(''))
    }) 
  }
  return words
}
console.log(filterWords('你好， 傻狗'))

装饰器模式

装饰器模式（Decorator Pattern）允许向一个现有的对象添加新的功能，同时又不改变其结构。这种类型的设计模式属于结构型模式，它是作为现有的类的一个包装。这种模式创建了一个装饰类，用来包装原有的类，并在保持类方法签名完整性的前提下，提供了额外的功能

• 就像我们使用形容词一样

对类进行修饰，在实例化的时候加上形容词；知道中间件的人最能将这两者联系起来，其实装饰器就和中间件差不多

function war(status){
  return function (target){
    target.prototype.wear = '穿着' + status
    target.prototype.sing = function(){
      console.log('sing')
    }
  }
}

@war('朴素的')
class Father{}

@war('时髦的')
class Daughter{}

var father = new Father()
var daughter = new Daughter()
console.log(father.wear + '父亲， ' + daughter.wear + '女儿')

• 理解成中间件

可将一些日志操作及其他放置在装饰器中，在类的声明时就能记录相应的日志

function method(){
  console.log('使用了函数方法')
}

@method
class Method{}  // 使用了函数方法

外观模式

外观模式（Facade Pattern）隐藏系统的复杂性，并向客户端提供了一个客户端可以访问系统的接口。这种类型的设计模式属于结构型模式，它向现有的系统添加一个接口，来隐藏系统的复杂性

就像你需要获取一个用户的姓名和他的年龄，有两个函数分别执行这两个功能

let getName = ()=>'mySkey'
let getAge = ()=>23

那么你需要分别调用两个函数才能一次获取姓名和年龄，为何不提供一个高级的接口呢？

let getUserinfo = ()=>{
  return getNum() + getAge()
}

享元模式

享元模式（Flyweight Pattern）主要用于减少创建对象的数量，以减少内存占用和提高性能。这种类型的设计模式属于结构型模式，它提供了减少对象数量从而改善应用所需的对象结构的方式

• 时间显示控件

演示一下未使用享元模式的程序，这个代码就会多次实例化Date对象，虽然很小，但是随着时间推移，会使浏览器的内存越来越少，最终肯定会挂掉

let getCurrentTime = ()=>{
  let date = new Date()
  let year = date.getFullYear()
  let month = date.getMonth() + 1
  let day = date.getDate()
  let hour = date.getHours()
  let minute = date.getMinutes()
  let second = date.getSeconds()
  let dateArr = [year, month, day, hour, minute, second]
  dateArr = dateArr.map((v,k)=>{
      if(k!=0) v=v.toString().padStart(2, '0')
      return v
  })
  return dateArr.join('-')
}

setInterval(() => {
    console.log(getCurrentTime())
}, 1000)

所以使用享元模式来重改这段代码，只实例化一次Date对象，就不会造成多次实例化，占用大量内存空间了

let date = new Date()
let timestamp = Date.parse(date)
let getCurrentTime = ()=>{
  timestamp += 1000
  date.setTime(timestamp)
  let year = date.getFullYear()
  let month = date.getMonth() + 1
  let day = date.getDate()
  let hour = date.getHours()
  let minute = date.getMinutes()
  let second = date.getSeconds()
  let dateArr = [year, month, day, hour, minute, second]
  dateArr = dateArr.map((v,k)=>{
      if(k!=0) v=v.toString().padStart(2, '0')
      return v
  })
  return dateArr.join('-')
}

setInterval(() => {
    console.log(getCurrentTime())
}, 1000)

代理模式

在代理模式（Proxy Pattern）中，一个类代表另一个类的功能。这种类型的设计模式属于结构型模式

就像我们搬家，以前只能自己搬，掌握了代理模式之后就能交给搬家公司来搬，这样就不用每家每户都是自己来搬家了

class Home{
  constructor(name){
    this.name = name
  }
  move(){
    console.log('自己搬家')
  }
}
class moveCompany{
  superMove(user){
    console.log('专业搬家三十年，接单客户：' + user)
  }
}

let myHome = new Home('mySkey')
let company = new moveCompany()
myHome.move()
company.superMove(myHome.name)

• ajax请求

调用ajax请求的时候，无论是各种开源库，还是自己写的Ajax类, 都会给xhr对象设置一个代理. 我们不可能频繁的去操作xhr对象发请求, 而应该是这样

var request = Ajax.get( 'cgi.xx.com/xxx' );
request.send();
request.done(function(){
 
});

职责链模式

责任链模式（Chain of Responsibility Pattern）为请求创建了一个接收者对象的链。这种模式给予请求的类型，对请求的发送者和接收者进行解耦。这种类型的设计模式属于行为型模式

• 产品的流程

就举个例子，互联网产品到底经历了什么？首先是一个需求，有需求才是市场嘛！客户用一个功能需求，他便联系了一个互联网公司，提了需求，公司这边报了价，客户同意了报价。由（售前）工作人员和客户签订合同，然后把需求报给（产品经理），产品经理设计出基本交互原型，然后把需求传递给（UI）设计师，然后调整多次开UI评审会，通过后交给（程序员）开发人员开发

let makeProduction = ()=>{
  salerBefore()
  productManager()
  uiDesign()
  if('ui评审会通过'){
    programmer()
  }
}
let salerBefore = ()=>console.log('接单签合同')
let productManager = ()=>console.log('确定需求绘制原型')
let uiDesign = ()=>console.log('设计优化')
let programmer = ()=>console.log('写BUG')
makeProduction('商城')

命令模式

命令模式（Command Pattern）是一种数据驱动的设计模式，它属于行为型模式。请求以命令的形式包裹在对象中，并传给调用对象。调用对象寻找可以处理该命令的合适的对象，并把该命令传给相应的对象，该对象执行命令

• redux的reducer

使用过react和redux的人一定写过reducer，外部不需要了解到底需要操作什么，只根据action的type来执行响应操作

let defaultData = [
  { audios: [], page: {} },   // 推荐
  { audios: [], page: {} },   // 最热
  { audios: [], page: {} },   // 原创
  { audios: [], page: {} },   // 飙升
  { audios: [], page: {} },   // 最新
]
let musics = (state, action) => {
  if (typeof state === 'undefined') {
    return defaultData
  }
  switch (action.type) {
    case 'setMusics':
      return action.musics

    case 'saveMusics':
      let saveMusics = [].concat(state)
      saveMusics[action.musics.type] = { 
        audios: saveMusics[action.musics.type].audios.concat(action.musics.audios), 
        page: action.musics.page
      }
      return saveMusics

    default:
      return state
  }
}

export { musics }

• npm和yarn这种包管理工具

包管理工具也是通过命令来区分操作

解释器模式

解释器模式（Interpreter Pattern）提供了评估语言的语法或表达式的方式，它属于行为型模式。这种模式实现了一个表达式接口，该接口解释一个特定的上下文。这种模式被用在 SQL 解析、符号处理引擎等

每门语言都有解释器的，就像宪法规定什么行为合法，什么不合法一样！

迭代器模式

迭代器模式（Iterator Pattern），这种模式用于顺序访问集合对象的元素，不需要知道集合对象的底层表示

• 1、数组迭代器

let forEach = (arr, cb)=>{
  for(let i=0;i<arr.length;i++){
    cb(arr[i], i)
  }
}
forEach(['hi','he','she'],(v,i)=>console.log(v,i))

• 2、对象迭代器

let forEach = (obj, cb)=>{
  for(let i in obj){
    cb(obj[i], i)
  }
}
forEach({ name: 'mySkey', age: '23' },(v,i)=>console.log(v,i))

中介者模式

中介者模式（Mediator Pattern）是用来降低多个对象和类之间的通信复杂性。这种模式提供了一个中介类，该类通常处理不同类之间的通信，并支持松耦合，使代码易于维护。中介者模式属于行为型模式

就像房屋中介，房主将自己房子挂在他们那里，然后你去找中介的时候，他们就把带你去看他们手上的房源；就像淘宝网，淘宝商家发布了商品，你发起订单，付款到淘宝，商家发货，你确认收货后，淘宝将钱打入商家账户

备忘录模式

备忘录模式（Memento Pattern）保存一个对象的某个状态，以便在适当的时候恢复对象。备忘录模式属于行为型模式。

• 1、vue中的keep-alive就能缓存数据
• 2、小程序能缓存数据
• 3、无限下拉刷新

let cache = {}
onReachBottom(){
  page += 1   // 页码加 1
  ajax.get('/list', { page }).then(res=>{
    cache[page] = res.data.list   // 将每页数据缓存起来，减少服务器开销
    this.list = this.list.concat(res.data.list)
  })
}

状态模式

在状态模式（State Pattern）中，类的行为是基于它的状态改变的。这种类型的设计模式属于行为型模式

还是拿分页来举个例子，如果要更换下查询条件，但是现在分页的页码已经大于1了，但是我们明显需要传入的页码是1，那么就可以改变一下获取数据的函数

let getList = (clear = false)=>{
  if(clear){  // 需要重置页码的地方调用时传入个 true
    page = 1
  }
  ajax.get('/list', { page }).then(res=>{
    this.list = res.data.list
  })
}

策略模式

在策略模式（Strategy Pattern）中，一个类的行为或其算法可以在运行时更改。这种类型的设计模式属于行为型模式。在策略模式中，我们创建表示各种策略的对象和一个行为随着策略对象改变而改变的 context 对象。策略对象改变 context 对象的执行算法

其实就是定义一系列的算法，把它们一个个封装起来，并且使它们可相互替换

• 就像验证提交数据的正确性，可以将校验规则单独封装起来，集中管理，之后判断返回的是true还是false

export default {
  email(email){
    let reg = /^\w+@[a-zA-Z0-9]{2,10}(?:\.[a-z]{2,4}){1,3}$/
    return reg.test(email)
  },
  phone(phone){
    let reg = /^((0\d{2,3}-\d{7,8})|(1[3584]\d{9}))$/
    return reg.test(phone)
  }
}

然后使用时就能需要的地方引入来校验

import valid from '/valid.js'
console.log(valid.phone('12345678912'))

模板模式

在模板模式（Template Pattern）中，一个抽象类公开定义了执行它的方法的方式/模板。它的子类可以按需要重写方法实现，但调用将以抽象类中定义的方式进行。这种类型的设计模式属于行为型模式

就像我们的组件一样，哪里需要哪里搬，我们就是搬砖的，其实就是相当于把代码copy了一份过来

• 各种游戏都有初始化，开始，结束流程

class Game{
  //初始化游戏
  initialize(){}

  //开始游戏
  startPlay(){}

  //结束游戏
  endPlay(){}

  play(){
    this.initialize();
    this.startPlay();
    this.endPlay();
  }
}

class Chess extends Game{
  initialize(){
    console.log('初始化棋牌游戏')
  }
  startPlay(){
    console.log('开始棋牌游戏')
  }
  endPlay(){
    console.log('结束棋牌游戏')
  }
}

var game = new Chess()
game.play()

访问者模式

在访问者模式（Visitor Pattern）中，我们使用了一个访问者类，它改变了元素类的执行算法。通过这种方式，元素的执行算法可以随着访问者改变而改变。这种类型的设计模式属于行为型模式。根据模式，元素对象已接受访问者对象，这样访问者对象就可以处理元素对象上的操作

• 就像一个函数是相同的，但是调用的对象不一样导致结果不同

function showName(){
  console.log(this.name)
}
window.name = 'hello world'
let mySkey = { name: 'mySkey' }
let xiaoming = { name: '小明' }
showName()
showName.call(mySkey)
showName.call(xiaoming)

组合模式

组合模式又叫部分-整体模式，它将所有对象组合成树形结构。使得用户只需要操作最上层的接口，就可以对所有成员做相同的操作

• 经常我们需要隐藏整个板块，那么隐藏父级容器就能达到效果

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>combination</title>
</head>
<body>
  <ul id="container">
    <li></li>
    <li></li>
    <li></li>
  </ul>
<script type="text/javascript">
var dom = document.getElementById('container')
dom.style.display = 'none'
</script>
</body>
</html>

• 文件夹，我们删除文件夹也会删除下面的文件夹及文件，给文件夹添加权限也会影响到下面的

mixin模式

mixin模式就是一些提供能够被一个或者一组子类简单继承功能的类,意在重用其功能。在面向对象的语言中，我们会通过接口继承的方式来实现功能的复用。但是在javascript中，我们没办法通过接口继承的方式，但是我们可以通过javascript特有的原型链属性，将功能引用复制到原型链上，达到功能的注入。

其实就是一个包括了混入对象所有的属性方法的超集，最简单的一个例子：

let a = { a: 'A' }
let b = { b: 'B' }
let c = { ...a, ...b }
console.log(c)

一个比较健壮的mixin模式

function extend(destClass) {
    var classes = Array.prototype.slice.call(arguments, 1);
    for (var i=0; i<classes.length; i++) {
        var srcClass = classes[i];
        var srcProto  = srcClass.prototype;
        var destProto = destClass.prototype;  
        for (var method in srcProto) {
            if (!destProto[method]) {
                destProto[method] = srcProto[method];
            }
        }      
    }
}
function Book() {}
Book.prototype.getName = function() {
  console.log('Book getName')
}
Book.prototype.setName  = function() {
  console.log('Book setName')
}

function Tech(){}
Tech.prototype.showTech = function(){
  console.log('Tech showTech')
}

function JS() {}

extend(JS, Book, Tech);
var js = new JS();
js.getName()

MVC模式

MVC 是一种使用 MVC（Model View Controller 模型-视图-控制器）设计创建 Web 应用程序的模式：

• Model（模型）

表示应用程序核心（比如数据库记录列表），是应用程序中用于处理应用程序数据逻辑的部分。通常模型对象负责在数据库中存取数据

• View（视图）

显示数据（数据库记录），是应用程序中处理数据显示的部分。通常视图是依据模型数据创建的

• Controller（控制器）

处理输入（写入数据库记录），是应用程序中处理用户交互的部分。通常控制器负责从视图读取数据，控制用户输入，并向模型发送数据

• MVC优点：

1、耦合性低，视图层和业务层分离，这样就允许更改视图层代码而不用重新编译模型和控制器代码。
2、重用性高
3、生命周期成本低
4、MVC使开发和维护用户接口的技术含量降低
5、可维护性高，分离视图层和业务逻辑层也使得WEB应用更易于维护和修改
6、部署快

• MVC缺点：

1、不适合小型，中等规模的应用程序，花费大量时间将MVC应用到规模并不是很大的应用程序通常会得不偿失。
2、视图与控制器间过于紧密连接，视图与控制器是相互分离，但却是联系紧密的部件，视图没有控制器的存在，其应用是很有限的，反之亦然，这样就妨碍了他们的独立重用。
3、视图对模型数据的低效率访问，依据模型操作接口的不同，视图可能需要多次调用才能获得足够的显示数据。对未变化数据的不必要的频繁访问，也将损害操作性能

• 应用：

在web app 流行之初， MVC 就应用在了java（struts2）和C#（ASP.NET）服务端应用中，后来在客户端应用程序中，基于MVC模式，AngularJS应运而生

MVP模式

• Model（模型）

表示应用程序核心（比如数据库记录列表），是应用程序中用于处理应用程序数据逻辑的部分。通常模型对象负责在数据库中存取数据

• View（视图）

显示数据（数据库记录），是应用程序中处理数据显示的部分。通常视图是依据模型数据创建的

• Presenter （发布者）

在View和Model之间起到桥梁的作用，又是一个独立的大模块，封装了业务的复杂度，将UI和业务逻辑拆分开来，使UI和业务都可以独立的进行变化。从整体的数据流向上看，Presenter从Model层获取数据，并通过接口发送给View层展示；View层将用户交互传递给Presenter，由Presenter完成相应的业务逻辑，这其中可能会有Model层的参与，比如Presenter调用Model层的接口来保存数据。

• MVP优点：

1、模型与视图完全分离，我们可以修改视图而不影响模型
2、可以更高效地使用模型，因为所有的交互都发生在一个地方——Presenter内部
3、我们可以将一个Presenter用于多个视图，而不需要改变Presenter的逻辑。这个特性非常的有用，因为视图的变化总是比模型的变化频繁
4、如果我们把逻辑放在Presenter中，那么我们就可以脱离用户接口来测试这些逻辑（单元测试）

• MVP缺点：

视图和Presenter的交互会过于频繁，使得他们的联系过于紧密。也就是说，一旦视图变更了，presenter也要变更

• MVP应用：

可应用与Android开发

MVVM模式

WPF的数据绑定与Presentation Model相结合是非常好的做法,使得开发人员可以将View和逻辑分离出来,但这种数据绑定技术非常简单实用，也是WPF所特有的，所以我们又称之为Model-View-ViewModel(MVVM)

• Model（模型）

表示应用程序核心（比如数据库记录列表），是应用程序中用于处理应用程序数据逻辑的部分。通常模型对象负责在数据库中存取数据

• View（视图）

显示数据（数据库记录），是应用程序中处理数据显示的部分。通常视图是依据模型数据创建的

• viewModel（视图控制）

View 和 Model 之间并没有直接的联系，而是通过ViewModel进行交互，ViewModel 通过双向数据绑定把 View 层和 Model 层连接了起来，而View 和 Model 之间的同步工作完全是自动的，无需人为干涉，因此开发者只需关注业务逻辑，不需要手动操作DOM， 不需要关注数据状态的同步问题，复杂的数据状态维护完全由 MVVM 来统一管理

• MVVM优点：

1、低耦合。视图（View）可以独立于Model变化和修改，一个ViewModel可以绑定到不同的"View"上，当View变化的时候Model可以不变，当Model变化的时候View也可以不变。
2、可重用性。你可以把一些视图逻辑放在一个ViewModel里面，让很多view重用这段视图逻辑。
3、独立开发。开发人员可以专注于业务逻辑和数据的开发（ViewModel），设计人员可以专注于页面设计，使用Expression Blend可以很容易设计界面并生成xaml代码。
4、可测试。界面素来是比较难于测试的，而现在测试可以针对ViewModel来写

• 应用：

vue开发，小程序

参考文献

设计模式导图

菜鸟教程设计模式

前端设计模式

MVC、MVP和MVVM的区别

《Javascript设计模式》