==与===的区别 与设计模式

==与===的区别

等于（==）与全等于（===）都是比较运算符，只是全等更为严格，不仅要数值相等，数据类型也得相同才会返回true，否则返回false，而==只要数值相等就返回true，不判断数据类型

实例

 <script>
        let a = 12
        let b = '12'
        console.log(a == b)  //true
        console.log(a === b) //false
    </script>

设计模式

设计者模式是为解决程序中的某个问题,而特别定义的程序规范，同一个构造函数,生成的实例化对象应该指向的是同一个对象，下面就介绍三种最常用的设计模式。

单例模式

定义：只允许存在一个实例的模式
        

// 核心代码步骤
        // 1 , 创建一个构造函数 , 空的构造函数
        function CreateObj(){}       
        // 2 , 创建一个变量,原始数值,可以是不赋值,或者undefined 或者 null 或者 基本数据类型
        let res = null;
        // 3 , 建立单例模式的函数
        function  Singleton(){
            // 如果res中存储的数值为null
            // 也就是证明没有执行过构造函数
            // 可以第一次执行构造函数
            // 将构造函数的执行结果,存储在res中

            // 之后再次执行程序,res中已经存储了一个实例化对象
            // res === null 执行结果是false
            // 不会再次执行 res = new CreateObj();
            // 也就是不会再次执行构造函数,生成实例化对象
            if(res === null){
                // 此时是第一次执行构造函数,res中存储的是构造函数的执行结果
                // 也就是实例化对象   
                res = new CreateObj();
            }   
            // 最终的返回值,就是我们创建的变量
            // 返回值,就是res中存储的实例化对象
            // 之后再次执行单例函数,返回值仍然是res中存储的之前的实例化对象
            return res;
        }
        // 4 通过单例模式函数来生成实例化对象
        const obj1 = Singleton();
        const obj2 = Singleton();
        console.log(obj1 === obj2);

组合模式

定义：通过一个调用,执行所有需要执行的程序

<script>
        class A{
            constructor(){}
            init(){
                this.a1();
                this.a2();
            }
            a1(){}
            a2(){}
        }
        class B{
            constructor(){}
            init(){
                this.b1();
                this.b2();
            }
            b1(){}
            b2(){}
        }
        const a = new A();
        const b = new B();
        const c = new C();
        a.init();
        b.init();
        c.init();   
        // 所谓的组合模式
        // 通过一个'遥控器' , 同时控制 a.init();b.init();c.init();
        // 乃至所有的 init() 入口函数
    
    
    </script>

观察者模式

定义：又称发布订阅者模式，经典案例：事件监听，一个元素同时监听多个同类型事件，元素对象即为发布者，每一个事件处理函数即为订阅者。

<script>
        // 要实现观察者模式 , 需要5个部分的操作
        // 1,有一个主体对象
        // 2,有一个属性(消息盒子),是存储事件
        // 3,有一个方法(on方法),向属性中写入事件
        // 4,有一个方法(emit方法),执行属性中写入的事件
        // 5,有一个方法(off方法),删除属性中写入事件
        // 基本代码
        // 通过构造函数来实现,创建主体对对象
        // 观察者模式构造函数
        class Observer{
            constructor(){
                // 定义属性,来存储需要执行的事件
                // 这个属性也称为消息盒子
                // 一般是数组形式
                this.message = [];
            }
            // 事件1:on()方法,向消息盒子中,添加事件
            on(){};
            // 事件2:emit()方法,执行消息盒子中存储的事件
            emit(){};

            // 事件3:off()方法,删除消息盒子中存储的事件
            off(){};
        }
        // 通过 构造函数 生成实例化对象
        const obj = new Observer();
    </script>