转换Singleton JS对象以使用ES6类

Question

我使用ES6每个我的文章的WebPack ES6-transpiler这里:http://www.railsonmaui.com/blog/2014/10/02/integrating-webpack-and-the-es6-transpiler-into-an-现有的护栏项目/

将两个Singleton对象转换为使用ES6类是否有意义？

import { CHANGE_EVENT } from "../constants/Constants";

var EventEmitter = require('events').EventEmitter;
var merge = require('react/lib/merge');

var _flash = null;

var BaseStore = merge(EventEmitter.prototype, {

  emitChange: function() {
    this.emit(CHANGE_EVENT);
  },

  /**
   * @param {function} callback
   */
  addChangeListener: function(callback) {
    this.on(CHANGE_EVENT, callback);
  },

  /**
   * @param {function} callback
   */
  removeChangeListener: function(callback) {
    this.removeListener(CHANGE_EVENT, callback);
  },

  getFlash: function() {
    return _flash;
  },

  setFlash: function(flash) {
    _flash = flash;
  }
});

export { BaseStore };

这是文件ManagerProducts.jsx,它有一个应该从BaseStore扩展的单例.

/**
 * Client side store of the manager_product resource
 */
import { BaseStore } from "./BaseStore";
import { AppDispatcher } from '../dispatcher/AppDispatcher';
import { ActionTypes } from '../constants/Constants';
import { WebAPIUtils } from '../utils/WebAPIUtils';
import { Util } from "../utils/Util";
var merge = require('react/lib/merge');

var _managerProducts = [];

var receiveAllDataError = function(action) {
  console.log("receiveAllDataError %j", action);
  WebAPIUtils.logAjaxError(action.xhr, action.status, action.err);
};

var ManagerProductStore = merge(BaseStore, {
  getAll: function() {
    return _managerProducts;
  }
});

var receiveAllDataSuccess = function(action) {
  _managerProducts = action.data.managerProducts;
  //ManagerProductStore.setFlash({ message: "Manager Product data loaded"});
};


ManagerProductStore.dispatchToken = AppDispatcher.register(function(payload) {
  var action = payload.action;
  if (Util.blank(action.type)) { throw `Invalid action, payload ${JSON.stringify(payload)}`; }

  switch(action.type) {
    case ActionTypes.RECEIVE_ALL_DATA_SUCCESS:
      receiveAllDataSuccess(action);
      break;
    case ActionTypes.RECEIVE_ALL_DATA_ERROR:
      receiveAllDataError(action);
      break;
    default:
      return true;
  }
  ManagerProductStore.emitChange();
  return true;
});

export { ManagerProductStore };

Answer 1

没有意义.

这是es6中单例对象的一个​​非常简单的例子:

let appState = {};
export default appState;

如果你真的想在你的单例方法中使用一个类,我建议不要使用"静态",因为它比单独使用更加困惑,至少对于JS而言,而是将类的实例作为单例返回...

class SomeClassUsedOnlyAsASingleton {
  // implementation
}

export default new SomeClassUsedOnlyAsASingleton();

这样你仍然可以使用JavaScript提供的所有类别的东西,但它会减少混乱,因为JavaScript类中不完全支持IMO静态,因为它在c#或Java等类型语言中,因为它只支持静态方法除非你假装它并将它们直接附加到一个类(在撰写本文时).

Answer 2

我认为,在任何语言中都不需要单身人士(管理他们自己的单身生活的班级).这并不是说单例生存期没有用,只是因为我更喜欢类以外的东西管理对象的生命周期,比如DI容器.

话虽这么说,单例模式可以应用于JavaScript类,借用ActionScript中使用的"SingletonEnforcer"模式.在将现有的使用单例的代码库移植到ES6中时,我可以看到想要做这样的事情.

在这种情况下,我们的想法是singleton使用公共静态instancegetter 创建一个私有(通过未公开的Symbol)静态实例.然后,您可以将构造函数限制为可以访问singletonEnforcer未在模块外部公开的特殊符号的内容.这样,如果除了单身人员以外的任何人试图"新"它,那么构造函数就会失败.它看起来像这样:

const singleton = Symbol();
const singletonEnforcer = Symbol()

class SingletonTest {

  constructor(enforcer) {
    if(enforcer != singletonEnforcer) throw "Cannot construct singleton";
  }

  static get instance() {
    if(!this[singleton]) {
      this[singleton] = new SingletonTest(singletonEnforcer);
    }
    return this[singleton];
  }
}

export default SingletonTest

然后你可以像任何其他单身一样使用它:

import SingletonTest from 'singleton-test';
const instance = SingletonTest.instance;

Answer 3

我必须这样做,所以这里是一个简单而直接的方法来做一个单身人士,屈从于单身人士 - 在 - es6

(原始链接http://amanvirk.me/singleton-classes-in-es6/)

let instance = null;

class Cache{  
    constructor() {
        if(!instance){
              instance = this;
        }

        // to test whether we have singleton or not
        this.time = new Date()

        return instance;
      }
}


let cache = new Cache()
console.log(cache.time);

setTimeout(function(){
  let cache = new Cache();
  console.log(cache.time);
},4000);

两个console.log调用应该打印相同cache.time(Singleton)

Answer 4

为了创建Singleton模式,使用具有ES6类的单个实例;

'use strict';

import EventEmitter from 'events';

class Single extends EventEmitter {
    constructor() {
        this.state = {};
    }

    getState() {
        return this.state;
    }

}

export default let single = new Single();

更新:根据@Bergi的解释,下面一个不是有效的参数.

这是因为(参考史蒂文)

>如果我正确理解了CommonJS +浏览器实现,则模块的>输出被缓存,因此导出默认的新MyClass()将>导致表现为单例的东西(每个类只有一个>该类的实例)进程/客户端取决于> env它正在运行).

你可以在这里找到ES6 Singleton的例子.

注意:此模式用于Flux Dispacher

Flux:www.npmjs.com/package/flux

Dispacher示例:github.com/facebook/flux/blob/master/examples/flux-todomvc/js/dispatcher/AppDispatcher.js#L16