js设计模式

单例模式

顾名思义：一个类有且只有一个实例，称之为单例模式。

代码实现：

// 首先封装一个构造函数
function Person() { };
// 封装一个单例模式的调用方式 （自执行函数）
const newFn = (function () {
    var instance;
    return function () {
        if (!instance) {
            instance = new Person();
        };
        return instance;
    };
})();

var f1 = newFn(); // Person
var f2 = newFn(); // Person
console.log(f1 === f2); // true

组合模式(观察者模式)

组合模式将对象组合成树形结构，以表示“部分-整体”的层次结构。除了用来表示树形结构之外，组合模式的另一个好处是通过对象的多态性表现，使得用户对单个对象和组合对象的使用具有一致性

使用场景：
A.含有某种层级结构的对象集合(具体结构在开发过程中无法确定)
B.希望对这些对象或者其中的某些对象执行某种操作

缺点：
因为组合对象的任何操作都会对所有的子对象调用同样的操作，所以当组合的结构很大时会有性能问题。

代码实现：

class GoHome {
    init() {
        console.log("到家了，开门")
    }
};

class OpenMusic {
    init() {
        console.log("打开音乐")
    }
}

class OpenComputer {
    init() {
        console.log("打开电脑")
    }
};

class Comb {
    constructor() {
        this.skills = [];
    }
    add(task) {
        this.skills.push(task)
    }
    action() {
        this.skills.forEach((item) => {
            item.init();
        })
    }
};

var comb = new Comb();
comb.add(new GoHome());
comb.add(new OpenComputer());
comb.add(new OpenMusic());
// 到家了
// 打开电脑
// 打开音乐
comb.action();

适配器模式

适配器模式，将一个接口装换成客户希望的另一个接口，使接口兼容那些类可以一起工作。

class Fn{
    test(){
        return '旧接口'
    }
};

class Target{
    constructor(){
        this.fn = new Fn();
    };
    test(){
        const info = this.fn.test();
        return `适配${info}`;
    }
};
const target = new Target();
console.log(target.test()) // 适配旧接口

代理模式

代理模式，访问者和目标对象之间添加一层代理，通过代理授权和控制。简单理解就是为原对象找一个替代对象。

 const idol = {
    name:'lisa',
    price:10000,
    iphone:110000
};

const proxy = new Proxy(idol,{
    get(target,key,value){
        return '经纪人电话1100000';
    },
    // set 方法需要返回一个boolean值，true表示赋值成功
    set(target,key,value){
        if(key==='price'){
            if(value<target.price) throw new Error('报价过低');
            target.price = value;
        };
        return true;
    }
});
proxy.iphone // 经纪人电话
proxy.price = 1000; // Uncaught Error 报价过低