设计模式

1.单例模式
保证全局只有一个实例，节省资源，类似java的静态类 static，一般用到的地方有历史记录、线程池等等

let Singleton=function(){
  this.name=1
}
//因为javascript 没有静态类的标识 故用闭包保持唯一性 外部无法访问instance
Singleton.getInstance=(function(){
  let instance=null
  return function(){
    if(!instance ){
        instance=new Singleton()
    }
    return instance
  }
})()

let s1=Singleton.getInstance()
let s2=Singleton.getInstance()
console.log(s1===s2)//true
console.log(s1.name)//1
s1.name=2
console.log(s1.name)//2
console.log(s2.name)//2

2.策略类
比如算法，各种算法封装在策略类，各种方法的使用交给环境类
看代码：

let strategy={
  //冒泡排序 逐个调换位置
  A(numbers){
    for(let i=0;i<numbers.length;i++){
      for(let j=0;j<numbers.length;j++){
        let itemNext=numbers[j+1]
        let item=numbers[j]
        if(itemNext<item){
            numbers[j+1]=item
            numbers[j]=itemNext
        }
      }
    }
    return numbers
  },
  //选择排序 每次循环把最小的放入前置位
  B(numbers){
    for(let i=0;i<numbers.length;i++){
      let itemI=numbers[i]
      for(let j=i+1;j<numbers.length;j++){
        let itemJ=numbers[j]
        if(itemI>itemJ){
            numbers[i]=itemJ
            numbers[j]=itemI
            itemI=itemJ
        }
      }
    }
    return numbers
  }
}
let content=name=>{
  let numbers=[1,3,5,6,1,3,4,6,5]
  return strategy[name](numbers)
}
console.log(content('A'))
console.log(content('B'))

3.代理模式
高度解耦，对象保护，易修改，因为是代理，所以会慢一点
示例代码：

let myImg={
  setSrc(img,src){
    img.src=src
  }
}

let proxyImg={
  setImg(imgNode,src){
    //实现图片懒加载
    myImg.setSrc(imgNode,'默认图.png')//占位图片
    let img=new Image()
    imgNode.onLoad=function(){
      myImg.setSrc(imgNode,src)
    }
    img.src=src//真正要加载的产品图片
  }
}
let imgNode=document.crateElement('img')
let imgUrl='产品图.png'
document.body.append(imgUrl)

proxyImg.setImg(imgNode,imgUrl)

4.迭代器模式
迭代器模式是指提供一种方法顺序访问一个集合对象的各个元素，使用者不需要了解集合对象的底层实现。
不太清楚其用途~

let Iterator=obj=>{
  let current=0;
  let next = ()=>current+=1
  let end = ()=>current>=obj.length
  let get = ()=>obj[current]
  return{
    next,
    end,
    get
  }
}
let myIter = Iterator([1, 2, 3]);
while(!myIter.end()) { 
  console.log(myIter.get()) myIter.next(); 
}

5.订阅发布模式
订阅-发布模式定义了对象之间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖它的对象都可以得到通知。

event.js
class Event{
  constructor(){
    this._cbs={}
  }
  //订阅
  on(key,fn){
    if(typeof fn != "function"){
      return false
    }
    this._cbs = this._cbs || {};
    (this._cbs[key] = this._cbs[key] || []).push(fn)
  }
  //发布
  emit(){
     let _cbs=this._cbs
     let key=Array.prototype.shift.apply(arguments)
     let affair =_cbs[key]||[]
     if(!affair||affair.length<1){
      return false
     }
     for(let fn of affair){
       fn.apply(null,arguments)
     }
     return true
  }
  //销毁
  off(key,fn){
    this._cbs = this._cbs || {}
    // all
    if (!arguments.length) {
      this._cbs = {}
      return true
    }
    var callbacks = this._cbs[key]
    if (!callbacks) return
    // remove all handlers
    if (arguments.length === 1) {
      delete this._cbs[key]
      return true
    }
 // remove specific handler
    var cb
    for (var i = 0, len = callbacks.length; i < len; i++) {
      cb = callbacks[i]
      if (cb === fn || cb.fn === fn) {
        callbacks.splice(i, 1)
        break
      }
    }
    return true
  }
}

export default Event

  //a.js
  import Event from event.js
  let e=new Event()
  e.on('one',v=>{
    console.log('订阅')
    console.log(v)
  })

   e.emit('one',1000)
   e.off('one')
   e.emit('one',1000)

6.工厂模式
工厂方法模式的实质是“定义一个创建对象的接口，但让实现这个接口的类来决定实例化哪个类。工厂方法让类的实例化推迟到子类中进行。” 简单来说：就是把new对象的操作包裹一层，对外提供一个可以根据不同参数创建不同对象的函数。

class Dog{
  run(){
      console.log('狗')
  }
}

class Cat{
  run(){
      console.log('猫')
  }
}

class Animal{
  constructor(name){
    name = name.toLocaleLowerCase()
    switch(name){
      case 'cat':
        return new Dog()
      case 'dog':
        return new Cat()
      default:
        console.log('没有哦')
    }
  }
}

let ss=new Animal('cat')
ss.run()

7.组合模式
用小的子对象构造更大的父对象，而这些子对象也由更小的子对象构成 单个对象和组合对象对于用户暴露的接口具有一致性，而同种接口不同表现形式亦体现了多态性

// 文件类
class File {
  constructor(name) {
    this.name = name || "File";
  }

  add() {
    throw new Error("文件夹下面不能添加文件");
  }

  scan() {
    console.log("扫描文件: " + this.name);
  }
}

// 文件夹类
class Folder {
  constructor(name) {
    this.name = name || "Folder";
    this.files = [];
  }

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

  scan() {
    console.log("扫描文件夹: " + this.name);
    for (let file of this.files) {
      file.scan();
    }
  }
}

let home = new Folder("用户根目录");

let folder1 = new Folder("第一个文件夹"),
  folder2 = new Folder("第二个文件夹");

let file1 = new File("1号文件"),
  file2 = new File("2号文件"),
  file3 = new File("3号文件");

// 将文件添加到对应文件夹中
folder1.add(file1);

folder2.add(file2);
folder2.add(file3);

// 将文件夹添加到更高级的目录文件夹中
home.add(folder1);
home.add(folder2);

// 扫描目录文件夹
home.scan();

8.享元模式
享元模式：运用共享技术来减少创建对象的数量，从而减少内存占用、提高性能。

class ObjectPool{
  constructor(){
    this._pool=[]
  }
  create(obj){
    return this._pool.length===0?
    new obj(this):
    this._pool.shift()
  }
  recover(obj){
    return this._pool.push(obj);
  }
  // 对象池大小 
  size() { 
    return this._pool.length; 
  }
}

// 模拟文件对象
class File {
  constructor(pool) {
    this.pool = pool;
  }

  // 模拟下载操作
  download() {
    console.log(`+ 从 ${this.src} 开始下载 ${this.name}`);
    setTimeout(() => {
      console.log(`- ${this.name} 下载完毕`); // 下载完毕后, 将对象重新放入对象池
      this.pool.recover(this);
    }, 100);
  }
}

/****************** 以下是测试函数 **********************/

let objPool = new ObjectPool();

let file1 = objPool.create(File);
file1.name = "文件1";
file1.src = "https://download1.com";
file1.download();

let file2 = objPool.create(File);
file2.name = "文件2";
file2.src = "https://download2.com";
file2.download();

setTimeout(() => {
  let file3 = objPool.create(File);
  file3.name = "文件3";
  file3.src = "https://download3.com";
  file3.download();
}, 200);

setTimeout(
  () =>
    console.log(
      `${"*".repeat(50)}\n下载了3个文件，但其实只创建了${objPool.size()}个对象`
    ),
  1000
);