定义

限定类的实例化次数只能是一次。

假如该实例不存在的情况下，能够经由过程一个要领建立一个类来完成建立类的新实例，假如实例已存在，它会简朴返回该对象的援用。

实用场景

1. 须要频仍实例化然后烧毁的对象。
2. 频仍接见数据库或文件的对象。
3. 建立对象时耗时过量或许耗资本过量，但又常常用到的对象。

Talk is cheap

经由过程打印privateRandomNumber来考证是不是为同一个实例

let mySingleton = (()=> {
    let instance;

    let init = ()=> {
        let privateMethod = ()=> {//私有要领
            console.log('I am privateMethod');
        }

        let privateVariable = 'I am also private';
        let privateRandomNumber = Math.random();

        return {//共有要领和变量
            publicMethod: ()=> {
                console.log('I am public');
            },
            publicProperty: 'I am also public',
            getRandomNumber: ()=> {
                return privateRandomNumber;
            }
        }
    }

    return {//猎取Singleton的实例，假如存在就返回，不存在就建立新实例
        getInstance: ()=> {
            if(!instance) {
                instance = init();
            }

            return instance;
        }
    }

})();

let singleA = mySingleton.getInstance();
let singleB = mySingleton.getInstance();

console.log(singleA.getRandomNumber() === singleB.getRandomNumber());//ture

简朴封装node衔接mongodb数据库

const MongoDB = require('mongodb')
const MongoClient = require('mongodb').MongoClient
const ObjectID = MongoDB.ObjectID
const Config = require('./config')

class Db {
    static getInstance() {
        if(!Db.instance) {
            Db.instance = new Db()
        }
        return Db.instance
    }
    constructor() {
        this.dbClient = ''
        this.connect()
    }
    connect() {//衔接数据库
        let that = this

        return new Promise((resolve, reject)=> {
            if(!that.dbClient) {
                MongoClient.connect(Config.dbUrl, {useNewUrlParser:true}, (err, client)=> {
                    if(err) {
                        reject(err)
                    }else {
                        that.dbClient = client.db(Config.dbName)
                        resolve(that.dbClient)
                    }
                })
            }else {
                resolve(that.dbClient)
            }
        })
    }
    find(collectionName, json) {
        return new Promise((resolve, reject)=> {
            this.connect().then((db)=> {
                let result = db.collection(collectionName).find(json)

                result.toArray((err, docs)=> {
                    if(err) {
                        reject(err)
                        return
                    }
                    resolve(docs)
                })
            })
        })
    }
    update(collectionName, json1, json2) {
        return new Promise((resolve, reject)=> {
            this.connect().then((db)=> {
                db.collection(collectionName).updateOne(json1, {
                    $set: json2
                },(err, result)=> {
                    if(err) {
                        reject(err)
                    }else {
                        resolve(result)
                    }
                })
            })
        })
    }
    insert(collectionName, json) {
        return new Promise((resolve, reject)=> {
            this.connect().then((db)=> {
                db.collection(collectionName).insertOne(json, (err, result)=> {
                    if(err) {
                        reject(err)
                    }else {
                        resolve(result)
                    }
                })
            })
        })
    }
    remove(collectionName, json) {
        return new Promise((resolve, reject)=> {
            this.connect().then((db)=> {
                db.collection(collectionName).removeOne(json, (err, result)=> {
                    if(err) {
                        reject(err)
                    }else {
                        resolve(result)
                    }
                })
            })
        })
    }
    getObjectId(id) {
        return new ObjectID(id)
    }
}

module.exports = Db.getInstance()

参考

《Javascript设想形式》

JS设想形式系列文章

JS设想形式之Obeserver（观察者）形式、Publish/Subscribe（宣布/定阅）形式
JS设想形式之Factory（工场）形式
JS设想形式之Singleton（单例）形式
JS设想形式之Facade（表面）形式
JS设想形式之Module（模块）形式、Revealing Module（展现模块）形式