观察者模式--发布，订阅者模式

image.png

前一个没有中间商，后一个有中间商赚差价

观察者模式

1 .当对像间存在一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于他的对象都得到通知并自动更新。

class watch{
    constructor(){
        this.watchlist=[]
        //这里数组还会存储函数,有顺序的话广播的时候会有优先级排列
    }
    publish(data){
        if(!this.watchlist.length){
            return false
        }
        this.watchlist.forEach((e)=>{
            e(data)
            console.log(data)
        })
    }

    subscribe(fn){
        this.watchlist.push(fn)
    }
    unsubscribe(fn){
        this.watchlist=this.watchlist.filter(
            function(el){
                if(el!==fn){
                    return el;
                    // 这里还会比较到函数。
                }
            }
        )
    }
    update(f1,f2){
        // 旧的函数，新的函数
        this.watchlist.forEach((e,index)=>{
            if(e==f1){
                this.watchlist.splice(index,1,f2)
            }else{
                console.log('没有对应的函数')
            }
        })
    }
    showwatch(){
        console.log(this.watchlist)
    }   
}
const o=new watch
let f1=(data)=>{
    console.log(data)
    // 所有的订阅函数都收到了对象变化的部分或者任何想要广播的信息
}
// 给函数加个变量，以便退订

let f2=(data)=>{
    console.log('robbin'+data+'开始吃饭了')
}
o.subscribe(f1)
o.subscribe(f2)
o.unsubscribe(f2)
// o.publish('libateer')
// o.showwatch()
o.update(f1,f2)
o.showwatch()
//就差观察一个变量，等他变化的时候进行广播，现在都是自动的调用，还需要一个类

缺点

1 .如果一个被观察的对象有很多直接或者间接的观察者的时候，将每个观察者都通知到会话费很多时间
2 .观察者和被观察者之间有循环依赖的时候，观察目标会触发循环依赖，导致系统崩溃
3 .观察者模式没有响应的机制让观察者知道所观察者知道目标对象时怎们变化的，仅仅知道观察目标发生了变化
4 .顺序执行的时候，某一个观察者错误会导致系统卡壳，一般采用异步模式。

发布，订阅者

1 .发布者和订阅者都不知道对方的存在，需要一个第三方组件，叫做信息中介，他将订阅者和发布者串联起来
2 .发布，订阅模式用来处理不同系统组件的信息交流，即时这些组件不知道对方的存在。组件是松散解耦的
3 .消息触发大多是异步的，使用消息队列。