单列模式

整个应用只用实例化一次的类，常用于整个应用中的音频管理（比如游戏中的控制播放声音的操作）
无论调用多少次都只会初始化一次

class AudioManager {
    
    
	private static _instance = null;
	// 通过私有化构造函数让外界无法直接new
    private constructor() {
    
    
        console.log('初始化')
    }
	// 这个方法必须是静态方法
	public static Instance(){
    
    
		if(!AudioManager._instance){
    
    
			AudioManager._instance = new AudioManager()
		}
		return AudioManager._instance
	}
}
let audioManager = AudioManager.Instance()
AudioManager.Instance()
AudioManager.Instance()
AudioManager.Instance()
AudioManager.Instance()

或者

class AudioManager {
    
     
    private static _instance;
    private constructor() {
    
    
        console.log("初始化")
    }
    static get instance() {
    
    
        if (!AudioManager._instance) {
    
    
            AudioManager._instance = new AudioManager()
        }
        return AudioManager._instance
    }
}
AudioManager.instance

代理模式

通过设置代理对象调用代理对象的方法去实现

interface ProxyObject {
    
     
    calc(num1: number, num2: number): number;
}
class Person{
    
    
    constructor() {
    
    
        
    }
    proxyObject: ProxyObject;
    calc(num1: number, num2: number) {
    
    
       return this.proxyObject.calc(num1,num2)
    }
}
class Proxy1 implements ProxyObject{
    
    
    calc(num1: number, num2: number) {
    
    
        return num1 + num2
    }
}
class Proxy2 implements ProxyObject{
    
    
    calc(num1: number, num2: number) {
    
    
        return num1 * num2
    }
}
let person = new Person() 
person.proxyObject = new Proxy1()
console.log(person.calc(1, 6))
person.proxyObject = new Proxy2()
console.log(person.calc(1,6))

观察者模式

通过设置监听者在要监听的内容变化时触发内容

interface Observer{
    
    
    onMessage(message:string):void
}
class ChatRoom{
    
    
    // private _observerList: Array<Observer> = new Array<Observer>();
    private _observerList: Observer[] = new Array<Observer>();
    private _message: string;
    set message(str) {
    
    
        this._message = str
        for (let observer of this._observerList) {
    
    
            observer.onMessage(str)
        }
    }
    get message() {
    
    
       return this._message
    }
    addRoom(observer:Observer) {
    
    
        this._observerList.push(observer)
    }
}
class Item implements Observer {
    
    
    onMessage(message) {
    
    
        console.log(message)
    }
}
let chatRoom = new ChatRoom();
let item = new Item()
chatRoom.addRoom(item)
chatRoom.message = '监听'

工厂模式

为了更快捷生成对象

enum ColorType{
    
    
    'red',
    'green',
    'blue'
}

class Color{
    
    
    static createColor(colorType: ColorType) {
    
    
        let color:Color = null;
        switch (colorType) {
    
    
            case ColorType.red:
                color = new Red();
                break;
            case ColorType.green:
                color = new Green();
                break;
            case ColorType.blue:
                color = new Blue();
                break;
        }
        return color;
    }
}
class Red extends Color{
    
     }
class Green extends Color{
    
     }
class Blue extends Color{
    
     }
console.log(Color.createColor(ColorType.red))
console.log(Color.createColor(ColorType.green))
console.log(Color.createColor(ColorType.blue))