面向对象思想：封装、继承、多态
#构造器模式
无非就是继承来实现的啦 - -!
构造器模式案例省略...
思考：为什么ES5的继承要写在 prototype 中，而不是直接写在构造方法里？
答：写在构造器中，无法做到数据共享（会造成资源浪费）
所以 prototype 中会存放需要共享数据的方法和属性（基本上都是方法）
而构造器中会存放不需要共享的属性和方法
#模块化模式
模块化嘛：AUCommonJS/Module 都是模块化，对象、闭包也是模块化
在JS中，模块化模式其实是模拟了"类"的概念。好处是有私密空间，不会造成全局污染。
虽然JS没有私有属性。但闭包能很好的实现私有属性的概念
简单的模块化模式：（闭包 - -.!）
var module = (function () {
var num = 0;
return {
getNum: function () {
return num;
},
addNum: function () {
return num++;
}
};
})();
console.log(module)
module.addNum()
console.log(module.getNum())
#单例模式
单例：就是限制一个类只能有一个实例化对象
使用场景案例：“警告/确认/提示弹窗”（只能存在一个的情况）
最简单的单例：：闭包 + Flag 来实现
const mySingleton = (function () {
let _instance;
return function () {
if (!_instance) {
_instance = {
x: 1,
setX: (arg) => {
_instance.x = arg;
}
};
}
return _instance;
}
})()
const instanceA = mySingleton();
const instanceB = mySingleton();
console.log(instanceA === instanceB);
封装一下：（PS: ES5的new如果有return使用return的值）
const Singleton = (function() {
var _instance;
return function(obj) {
return _instance || (_instance = obj);
}
})();
var a = new Singleton({x: 1});
var b = new Singleton({y: 2});
console.log(a === b);
#观察者模式
由观察者和观察者组成。通过观察者调用被观察者的实例。
观察者模式：观察者对象和被观察者对象 之间的订阅和触发事件
使用场景案例：“Vue 双向绑定实现”
简单的观察者模式: （仿 Vue 实现）
// 观察者
class Dep {
constructor() {
this.subs = []
}
addSub(sub) {
this.subs.push(sub)
}
depend() {
if (Dep.target) {
Dep.target.addDep(this);
}
}
notify() {
this.subs.forEach(sub => sub.update())
}
}
// 被观察者
class Watcher {
constructor(vm, expOrFn) {
this.vm = vm;
this.getter = expOrFn;
this.value;
}
get() {
Dep.target = this;
var vm = this.vm;
var value = this.getter.call(vm, vm);
return value;
}
evaluate() {
this.value = this.get();
}
addDep(dep) {
dep.addSub(this);
}
update() {
console.log('更新, value:', this.value)
}
}
// 观察者实例
var dep = new Dep();
// 被观察者实例
var watcher = new Watcher({x: 1}, (val) => val);
watcher.evaluate();
// 观察者监听被观察对象
dep.depend()
dep.notify()
#发布/订阅者模式
由订阅者 Subscriber 和发布者 Publisher 组成。
发布/订阅者模式：是观察者模式的变体，比观察者模式多了一个调度中心
发布者发布信息到调度中心
调度中心和订阅者直接完成订阅和触发事件事件
使用场景案例：“DOM 的 addEventListener 事件”
一个简单的发布/订阅者模式实现：（仿 EventBus 实现）
// EventTarget 就是一个调度中心
class EventTarget {
constructor() {
this.dep = {}
}
on(key, fn) {
this.dep[key] = fn;
}
emit(key) {
typeof this.dep[key] === 'function' ? this.dep[key]() : ''
}
}
let eventTarget = new EventTarget()
eventTarget.on('click', function() {console.log(1)})
eventTarget.emit('click')
#中介者模式
中介：撮合多个卖家 和 多个买家
class Saler {
constructor(name, cost) {
this.name = name;
this.cost = cost;
}
send() {
console.log(`${cost}元出售${name}`)
}
}
class Agency {
constructor() {
this.cargos = []
}
register(saler) {
this.cargos.push(saler);
}
query(name) {
const matchCargos = this.cargos.filter(cargo => cargo && cargo.name === name);
if (matchCargos.length) {
console.log(`查询到正在出售的商品:${JSON.stringify(matchCargos)}`)
} else {
console.log(`没有${name}在出售`);
}
}
}
let agency = new Agency();
agency.query('cart');
const cartA = new Saler('cart', '100');
const cartB = new Saler('cart', '300');
const house = new Saler('house', '500');
agency.register(cartA);
agency.register(cartB);
agency.register(house);
agency.query('cart');
agency.query('house');
agency.query('ABC');
#命令模式
为方法的调用进行解耦
const command = {
buy(name, cost) {
console.log(`购买${name}消费了${cost}元`)
},
sale(name, cost) {
console.log(`出售了${name}赚得${cost}元`)
},
say(name, cost) {
console.log(`这里${cost}元可以买到${name}`)
},
execute(fnName) {
const fn= this[fnName];
(typeof fn === 'function') && fn.apply(this, [].slice.call(arguments, 1))
}
}
command.execute('buy', 'VIP', '200');
command.execute('sale', '节操', '998');
command.execute('say', 'VIP', '123');
#策略模式
策略模式最大的好处是：减少if-else的使用，同时增加代码可读性
简单的年终奖计算。（策略模式放在必填项/规则验证会很便捷）
// 策略模式
const bonus = {
A: function(base) {
return base * 4;
},
B: function(base) {
return base * 3;
},
C: function(base) {
return base * 2;
},
D: function(base) {
return base;
}
}
const level = "B";
const base = "1008611";
const yearBouns = bonus[level](base);
console.log(yearBouns)
#工厂模式
一个工厂(类) 能生产各种零件(实例)
#简单的工厂模式
通过一个类获取不同类的实例
class Cat {}
class Dog {}
class Pig {}
function Factory(type, args) {
switch (type){
case 'cat':
return new Cat(args);
break;
case 'dog':
return new Dog(args);
break;
default:
return new Pig(args);
break;
}
}
const cat = new Factory('cat', {name: 'cat'});
const dog = new Factory('dog', {name: 'dog'});
const pig = new Factory('pig', {name: 'pig'});
console.log(cat, dog, pig)
#抽象工厂模式
通过继承抽象的类（含有未实现的方法）、结合简单工厂模式，生成抽象工厂
抽象工厂的好处：通用方法写在工厂函数中，不需要重复实现，不同个性化代码在子类中实现
实现：省略...
#复杂工厂模式
允许工厂产生的不同零件一起工作：
class Wheel {
turn() {
console.log('轮子开始转动啦');
}
}
class Oil {
warn() {
console.log('汽油不足')
}
}
class Cart {
constructor() {
this.cart = {}
}
getPart(name, args) {
return this.cart[name] ? new this.cart[name](args) : null;
}
setPart(name, Part) {
this.cart[name] = Part;
}
}
const cart = new Cart();
cart.setPart('wheel', Wheel)
cart.setPart('oil', Oil)
const wheel = cart.getPart('wheel', {name: '轮子A'});
const oil = cart.getPart('oil', {name: '汽油A'});
wheel.turn();
oil.warn();
#修饰器模式
修饰：不改变原有对象，在其基础上进行拓展
基本上每天都在用的设计模式...
简单的修饰模式实现：
const after = function(fn, afterFn) {
return function() {
fn.apply(this, arguments)
afterFn.apply(this, arguments)
}
}
const myAfter = after(after(fn1, fn2), fn3)
myAfter()
