• 单例模式
  ES5

function Duck1(name:string){
    this.name=name
    this.instance=null
}

Duck1.prototype.getName=function(){
    console.log(this.name)
}

Duck1.getInstance=function(name:string){
    if(!this.instance){
        this.instance= new Duck1(name)
    }
}
const a=Duck1.getInstance('a')
const b=Duck1.getInstance('b')

console.log(a===b) // true

ES6

class Duck{
    name="xxx"
    static instance:any=null
    action(){
        console.log('123')
    }
    static getInstance(){
       if(!this.instance){
            this.instance=new Duck()
       } 
       return this.instance
    }
}


const obj1=Duck.getInstance()
const obj2=Duck.getInstance()

console.log(obj1===obj2) // true

• 工厂模式

class Duck{
    name="xxx"
    constructor(name:string){
        this.name=name
    }   
}

function factory(name:string){
    return new Duck(name)
}

const a=factory('x')
const b=factory('s')

• 策略模式
  代码里有多个if的情况时，做成策略模式，好处：
  策略模式利用组合，委托等技术和思想，有效的避免很多if条件语句
  策略模式提供了开放-封闭原则，使代码更容易理解和扩展
  策略模式中的代码可以复用
  策略模式优化的例子
  `
• 代理模式

class Duck{
    
    name="xxx"

    constructor(name:string){
        this.name=name
    }   

    getName(){
        console.log('name: ',this.name)
    }
    setName(newValue:string){
        this.name=newValue
    }
}

const tp=new Duck('a')

const obj = new Proxy(tp,{
    set:function(target,property,value){
        return Reflect.set(target,property,'new:'+value)
    },
    get(target,property){
        if(property==='getName'){
            return function(value:String){
                 Reflect.get(target,property,'new:'+value)
            }
        }
        return Reflect.get(target,property)
    }
})

console.log(obj.name)

obj.setName('jack')

console.log(obj.name)

输出：