常见设计模式

设计模式遵循的原则

1. 单一职责原则，即一个部分负责补个功能，如果多个功能划分为多个部分
2. 最少知识yuanze，每个部分尽量减少与其他部分之间的联系，如果两个对象之间必须要有联系的话，可以把这种联系交给第三方
3. 封闭开放原则，程序功能的修改可以增加代码而不能直接修改代码

常见的设计模式

单例设计模式

确保只有一个实例，提供全局的访问
方式：通过立即执行函数

const getIns = (function() {
	let ins = null;
	return () => {
		if (!ins) {
			// 这里可以赋值成任何一个变量或者对象的一个实例
			ins = {a:1}
		}
		return ins
	}
})()

// 通过传入函数来统一生成单例的方式，之后只需修改传入的函数就可以来获取不同的单例
const getIns = function(fn) {
	let ins = null;
	return function() {
		if (!ins) {
			ins = fn.apply(this, arguments)
		}
		return ins
	}
}
class A {
	constructor(a) {
        this.a = a
    }
}
const ins = getIns(function(a) {
	this.b = new A(a)
	return this.b
})
ins('a')

策略模式

将相似的算法封装成一个策略类，类中的方法可以根据需求进行替换，
然后在一个类中或者一个函数中对这些类的策略进行操作替换达到需求，可以减少条件语句的使用

const errorMsgs = {
    default: '输入数据不正确',
    minLength: '输入数据长度不足',
    isNunber: '请输入数字',
    require: '内容不能为空'
}

class Rule {
    constructor() {

    }

    minLength(value, length, errorMsg) {
        if (value.length < length) {
            return errorMsg || errorMsgs['minlength']
        } else {
            return 'success'
        }
    }

    isNumber(value, errorMsg) {
        if (!/\d+/.test(value)) {
            return errorMsg || errorMsgs['isNumber'];
        } else {
            return 'success'
        }
    }

    require(value, errorMsg) {
        if (value === '') {
            return errorMsg || errorMsgs['require'];
        } else {
            return 'success'
        }
    }
}

class Validator {
    constructor() {
        this.items = []
    }

    add(value, rule, errorMsg) {
        if (rule.includes('minLength')) {
            this.items.push(() => {
                return new Rule()[rule.split(':')[0]](value, rule.split(':')[0], errorMsg)
            })
        } else {
            this.items.push(() => {
                return new Rule()[rule](value, errorMsg)
            })
        }
    }

    start() {
        this.items.forEach((item) => {
            console.log(item())
        })
    }
}

const validator =  new Validator()
validator.add('ccc', 'isNumber', '只能是数字')
validator.add('', 'require')
validator.add('123', 'minLength:5', '最少5位')

validator.start()

代理模式

对接口进行一些包装，外部的访问只能访问这个包装的接口

迭代器模式

编写迭代函数，使得指针指向下一个对象

发布订阅模式

事件机制

命令模式

命令模式由三种角色构成：

发布者 invoker（发出命令，调用命令对象，不知道如何执行与谁执行）；
接收者 receiver (提供对应接口处理请求，不知道谁发起请求）；
命令对象 command（接收命令，调用接收者对应接口处理发布者的请求）。

发布者 invoker 和接收者 receiver 各自独立，将请求封装成命令对象 command ，请求的具体执行由命令对象 command 调用接收者 receiver 对应接口执行。

命令对象 command 充当发布者 invoker 与接收者 receiver 之间的连接桥梁（中间对象介入）。实现发布者与接收之间的解耦，对比过程化请求调用，命令对象 command 拥有更长的生命周期，接收者 receiver 属性方法被封装在命令对象 command 属性中，使得程序执行时可任意时刻调用接收者对象 receiver 。因此 command 可对请求进行进一步管控处理，如实现延时、预定、排队、撤销等功能。

class Receiver {  // 接收者类
  execute() {
    console.log('接收者执行请求');
  }
}

class Command {   // 命令对象类
  constructor(receiver) {
    this.receiver = receiver;
  }
  execute () {    // 调用接收者对应接口执行
    console.log('命令对象->接收者->对应接口执行');
    this.receiver.execute();
  }
}

class Invoker {   // 发布者类
  constructor(command) {
    this.command = command;
  }
  invoke() {      // 发布请求，调用命令对象
    console.log('发布者发布请求');
    this.command.execute();
  }
}

const warehouse = new Receiver();       // 仓库
const order = new Command(warehouse);   // 订单
const client = new Invoker(order);      // 客户
client.invoke();

/*
输出：
  发布者发布请求
  命令对象->接收者->对应接口执行
  接收者执行请求
*/

组合模式

又叫整体部分模式， 整体和部分实现同一个接口类，用户调用的时候不需要管是整体还是部分，保持调用的一致性

// 树对象 - 文件目录
class CFolder {
    constructor(name) {
        this.name = name;
        this.files = [];
    }

    add(file) {
        this.files.push(file);
    }

    scan() {
        for (let file of this.files) {
            file.scan();
        }
    }
}

// 叶对象 - 文件
class CFile {
    constructor(name) {
        this.name = name;
    }

    add(file) {
        throw new Error('文件下面不能再添加文件');
    }

    scan() {
        console.log(`开始扫描文件：${this.name}`);
    }
}

let mediaFolder = new CFolder('娱乐');
let movieFolder = new CFolder('电影');
let musicFolder = new CFolder('音乐');

let file1 = new CFile('钢铁侠.mp4');
let file2 = new CFile('再谈记忆.mp3');
movieFolder.add(file1);
musicFolder.add(file2);
mediaFolder.add(movieFolder);
mediaFolder.add(musicFolder);
mediaFolder.scan();

职责链模式

将多重行为构成一条链，对数据的处理直接放到这条链中就可以
比如对象的原型链，我们的函数可以一直沿着原型链寻找到这个函数

中介者模式

将多个对象之间的相互的操作进行抽象，让这些类操作中介这，然后中介这对这些行为处理

装饰者模式

通过继承给原来的对象添加额外的功能

状态模式

把事物的每种状态都封装成单独的类，跟此种状态有关的行为都被封装在这个类的内部
然后在外部只需要修改这个类的状态就好。行为自然会做出相应的调整

适配器模式

对两个或者多个不兼容的代码进行兼容处理

外观模式

在接口上面加上一层，对接口进行封装，保持一致的外观