单例模式

单例模式

1.作用：将某次类的实例化存档

2.举例：

游戏可以被认为是一个特定的类（Singleton），而存档是单例（instance），每次访问特定类的时候，都会拿到同一个实例。主要有下面几个概念：

1. Singleton ：特定类，这是我们需要访问的类，访问者要拿到的是它的实例；
2. instance ：单例，是特定类的实例，特定类一般会提供 getInstance 方法来获取该单例；
3. getInstance ：获取单例的方法，或者直接由 new 操作符获取；

3.1 IIFE 方式创建单例模式

const Singleton = (function() { //返回内部功能函数:
    let _instance = null        // 缓存的单例,外部无法修改
    
    const Singleton = function() { //功能函数
        if (_instance) return _instance     // 判断是否已有单例
        _instance = this   				  //  指向改变
        this.init()                        // 初始化操作
        return _instance
    }
    
    Singleton.prototype.init = function() { // 标识函数
        this.foo = 'Singleton Pattern'
    }
    Singleton.getInstance = function() {
        if (_instance) return _instance
        _instance = new Singleton()
        return _instance
    }
    return Singleton
})()

const visitor1 = new Singleton() // 第一次实例
const visitor2 = new Singleton() // new直接返回第一次实例对象
const vistor = Singleton.getInstance() // 获取第一次实例对象
console.log(visitor1 === visitor2)	// true

3.2单例模式赋能

/* 功能类 */
class FunClass {
    constructor(bar) {
        this.bar = bar
        this.init()
    }
} 
init () {
    this.foo = 'Singleton Pattern'
}}
/* 单例模式的赋能类 */
const Singleton = (function(){
    let _instance = null // 缓存单例
	const proxySingleton = function (bar) { // 构造函数
        if (_instance) return _instance
        _instance = new FuncClass(bar)
        return _instance
    }
    
    ProxySingleton.getInstance  = function (bar) {
        if (_instance) return _instance
        _instance = new Singleton(bar)
        return _instance
	}
    return ProxySingleton
})()
const vistor1 = new Singleton("单例1")
const vistor2 = new Singleton("单例2")
const vistor3 = Singleton.getInstance()

console.log(visitor1 === visitor2)	// true
console.log(visitor1 === visitor3)	// true

3.3单例模式赋能简便写法

/* Person 类 */
class Person {
    constructor(name, age) {
        this.name = name
    	this.age = age
    }
}

/* 单例模式的赋能方法 */
function Singleton(FuncClass) { // 构造函数
    let _instance  // 缓存
    return new Proxy(FuncClass,{ // 实例化对象并且拥有自己的构造方法
        constructor(target, args) {
            return _instance || (_instance = Reflect.construct(FuncClass, args))// 或者用new
            // return _instance || (_instancce = new Funclass(args))
        }
    })
}
const PersonInstance = Singleton(Person)

const person1 = new PersonInstance('张小帅', 25)
const person2 = new PersonInstance('李小美', 23)

console.log(person1 === person2)	// true