我正在尝试在 Backbone.js 中实现我的“实例存储”版本，正如 Soundcloud 在他们最近的博客文章中所描述的那样:

http://backstage.soundcloud.com/2012/06/building-the-next-soundcloud/

相关摘录:

为了解决这个问题，我们使用了一个我们称之为实例存储的结构。这个存储是一个对象，每次调用模型的构造函数时都会隐式访问和修改它。首次构建模型时，它会将自己注入(inject)到商店中，使用其 id 作为唯一键。如果使用相同的 id 调用相同的模型构造函数，则返回原始实例。

var s1 = new Sound({id: 123}),
    s2 = new Sound({id: 123});

s1 === s2; // true, these are the exact same object.

这之所以有效，是因为 Javascript 有一个鲜为人知的特性。如果构造函数返回一个对象，那么这就是分配的值。因此，如果我们返回对先前创建的实例的引用，我们将获得所需的行为。在幕后，构造函数基本上是这样做的:

var store = {};

function Sound(attributes) {
    var id = attributes.id;

    // check if this model has already been created
    if (store[id]) {
        // if yes, return that
        return store[id];
    }
    // otherwise, store this instance
    store[id] = this;
}

我通过覆盖 Backbone.Model 类来创建我自己的构造函数来实现我的版本。

var MyModel = Backbone.Model.extend({
    constructor: function (attributes, options) {
        var id = attributes ? attributes.id : undefined;

        if (this.store[id]) {
            return this.store[id];
        }

        Backbone.Model.prototype.constructor.apply(this, arguments);

        if (id) {
            this.store[id] = this;
        }
    }
});

var MyOtherModel = MyModel.extend({
    store: {},

    //other model stuff
});

这工作得很好，但肯定发生了一些变化，现在它停止工作了，我不确定为什么。新创建的实例毫无问题地存储在存储对象中——每个扩展 MyModel 类的类都有自己的空存储，以避免具有相同 ID 的不同类型的实例发生冲突。当使用现有 id 调用构造函数时，也可以毫无问题地检索到正确的实例，但是当它们从构造函数返回时，返回值将被忽略。我对规范的理解是，构造函数可以返回一个对象——但不是原始对象——当使用 new 运算符调用构造函数时，返回的对象将被分配到赋值语句的左侧。这不会发生，即使构造函数返回一个对象，也会使用由 new 运算符创建的空对象。

一些调试信息。不确定此信息会有多大帮助。这是第一次实例化对象的 MyModel 构造函数中的“this”。

child
    _callbacks: Object
    _escapedAttributes: Object
    _previousAttributes: Object
    _setting: false
    attributes: Object
        id: "4fd6140032a6e522f10009ac"
        manufacturer_id: "4f4135ae32a6e52a53000001"
        name: "Tide"
        uniqueName: "tide"
    __proto__: Object
    cid: "c50"
    collection: child
    id: "4fd6140032a6e522f10009ac"
    __proto__: ctor
        constructor: function (){ parent.apply(this, arguments); }
        defaults: Object
        store: Object
        url: function () {
        urlRoot: function () {
        __proto__: ctor

当它是从实例存储返回的对象时，这是 MyModel 构造函数中的“this”:

child
    _callbacks: Object
    _escapedAttributes: Object
    _previousAttributes: Object
    _setting: false
    attributes: Object
        _validate: function (attrs, options) {
        bind: function (events, callback, context) {
        change: function (options) {
        changedAttributes: function (diff) {
        clear: function (options) {
        clone: function () {
        constructor: function (){ parent.apply(this, arguments); }
        defaults: Object
        destroy: function (options) {
        escape: function (attr) {
        fetch: function (options) {
        get: function (attr) {
        has: function (attr) {
        hasChanged: function (attr) {
        idAttribute: "id"
        initialize: function (){}
        isNew: function () {
        isValid: function () {
        manufacturer_id: 0
        name: ""
        off: function (events, callback, context) {
        on: function (events, callback, context) {
        parse: function (resp, xhr) {
        previous: function (attr) {
        previousAttributes: function () {
        save: function (key, value, options) {
        set: function (key, value, options) {
        store: Object
        toJSON: function () {
        trigger: function (events) {
        unbind: function (events, callback, context) {
        unset: function (attr, options) {
        url: function () {
        urlRoot: function () {
        __proto__: Object
        cid: "c141"
     __proto__: ctor
        constructor: function (){ parent.apply(this, arguments); }
        defaults: Object
        store: Object
        url: function () {
        urlRoot: function () {
        __proto__: ctor

我注意到第二个中的属性对象包含主干对象的所有方法，但它们不应该包含在内。它也没有 id，我也不确定为什么。希望这提供了一些见解。谢谢。

最佳答案

我不会为此使用扩展，我认为拥有一个单独的“工厂”是正确的想法。它可以让您扩展模型而不用担心副作用。

来自annotated source backbone 用 extend 做了一些奇怪的事情，我还没有完全理解它。 (另请查看 inherits )所以让我们暂时跳过它并坚持使用您的工作解决方案。

我已经修改了您生成工厂模型的方法，您应该能够像普通模型一样使用它们(例如，将它们设置在一个集合中)，除了扩展它们不起作用。他们还将像 soundcloud 示例那样处理使用新数据更新您的模型。

var makeStoreable = function(model){
  var StoreModel = function(attr, opt){
    if(!attr || !attr.id){
      // The behavior you exhibit here is up to you
      throw new Error('Cool Models always have IDs!');
    }
    if(this.store[attr.id]){
      this.store[attr.id].set(attr, opt);
    }else{
      var newModel = new model(attr, opt);
      this.store[attr.id] = newModel;
    }
    return this.store[attr.id];
  };
  StoreModel.prototype.store = {};
  return StoreModel;
};

var CoolModel = Backbone.Model.extend({});

CoolModel = makeStoreable(CoolModel);

var a = new CoolModel({
    id: 4,
    coolFactor: 'LOW'
});

var b = new CoolModel({
    id:4,
    coolFactor: 'HIGH'
});

console.log(a===b); //true!
console.log(a.get('coolFactor') === 'HIGH'); //true!

和here's a fiddle玩。

另外，我欢迎有人想出一个模型内解决方案，将“商店”保留在模型实例的原型(prototype)中。此外，为了防止内存泄漏，我们可能应该在工厂或模型本身上创建一个引用计数销毁方法。

关于javascript - 通过从构造函数返回现有实例来实现 javascript 实例存储，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/11145159/