Veo que incluso cuando la dirección del evento vinculante es de esta manera Objeto1 -> escuchar -> Objeto2 hay que quitarlo para Objeto1 perdido cualquier referencia viva.

Y viendo que escuchando a la Modelo remove evento no es una solución debido a que no se llama en un Collection.reset() llame entonces tenemos dos soluciones:

1. Sobrescribir la limpieza normal de la colección

As @dira dice aquí puedes sobrescribir Collection._removeReference para hacer una limpieza más adecuada del método.

No me gustan estas soluciones por dos razones:

• No me gusta sobrescribir un método que tiene que llamar super después de.
• No me gusta sobrescribir métodos privados.

2. Envolver demasiado su Collection.reset() llamadas

Que es lo contrario: en vez de sumar funcionalidad más profunda, Añade funcionalidad superior.

Entonces en lugar de llamar Collection.reset() directamente puede llamar a una implementación que limpiar los modelos antes han sido eliminados silenciosamente:

cleanUp: function( data ){
  this.each( function( model ) { model.unlink(); } );
  this.reset( data );
} 

Una versión clasificadora de su código puede verse así:

AppEvents = {};
_.extend(AppEvents, Backbone.Events)

var User = Backbone.Model.extend({
  initialize: function(){
    AppEvents.on('my_event', this.listen, this);
  },

  listen: function(){
    console.log("%s still listening...", this.get('name'));
  },

  unlink: function(){
   AppEvents.off( null, null, this );
  }
});

var Users = Backbone.Collection.extend({
  model: User,

  cleanUp: function( data ){
    this.each( function( model ) { model.unlink(); } );
    this.reset( data );
  }
});


// testing
var users = new Users([{name: 'John'}]);
console.log('users.size: ', users.size()); // 1
AppEvents.trigger('my_event');             // John still listening...

users.cleanUp();
console.log('users.size: ', users.size()); // 0
AppEvents.trigger('my_event');             // (nothing)

Consulta el jsFiddle.

Actualización: verificación de que el modelo se eliminó después de eliminar el enlace del evento vinculante

Lo primero que verificamos es que el Objeto1 al escuchar un evento en el Objeto2 crea un enlace en la dirección Objeto2 -> Objeto1:

En la imagen de arriba vemos como el Modelo (@314019) no solo es retenido por el users colección sino también para la AppEvents objeto que está observando. parece el vinculación de eventos para la perspectiva de un programador es Objeto que escucha -> a -> Objeto que se escucha pero en realidad es todo lo contrario: Objeto que se escucha -> a -> Objeto que se escucha.

Ahora bien, si usamos el Collection.reset() para vaciar la Colección vemos como el users El enlace ha sido eliminado pero el AppEvents queda el enlace:

La users el enlace ha desaparecido y también el enlace OurModel.collection lo que creo que es parte de la Collection._removeReference() trabajo.

Cuando usamos nuestro Collection.cleanUp() método el objeto desaparece de la memoria, no puedo hacer que el Chrome.profile herramienta para decirme explícitamente el objeto @314019 ha sido eliminado pero puedo ver eso ya no está entre los objetos de memoria.

Creo que el proceso de referencias limpias es una parte complicada de Backbone.

Cuando quitas un Model a partir de una Collection la Colección se preocupa por unbind cualquier evento en el Modelo que el Cobro en sí mismo sea vinculante. Verifique este método de colección privado.

Tal vez puedas usar una técnica similar en tu Agregador:

// ... Aggregator code
the_model.on( "remove", this.unlinkModel, this );
// ... more Aggregator code

unlinkModel: function( model ){
  model.off( null, null, this );
}

Esto es en el caso de que la dirección de la unión sea Agregador -> Modelo. Si la dirección es la contraria, no creo que tengas que hacer ninguna limpieza después de quitar el modelo.

En lugar de envolver Collection's reset con cleanUp como sugirió fguillén, prefiero extender Collection y anulando reset directamente. La razón es que cleanUp surte efecto solo en el código del cliente, pero no en la biblioteca (es decir, Columna vertebral)'s. Por ejemplo, Collection.fetch puede llamar internamente Collection.reset. A menos que se modifique el Espina dorsal código fuente, no podemos desvincular modelos de eventos (como en cleanUp) después de llamar Collection.fetch.

Básicamente, mi fragmento sugerido es el siguiente:

var MyCollection = Backbone.Collection.extend({
        reset: function(models, options) {
            this.each(function(model) {
                model.unlink(); // same as fguillen's code
            });
            Backbone.Collection.prototype.reset.apply(this, arguments);
        }
    });

Más tarde, podemos crear nuevas colecciones basadas en MyCollection.