如何设计此架构？

Question

我有3类：

function A(data){ 
    this.data = data || []; 
}  
A.prototype.remove = function(index){ 
    // remove index from this.data; 
}; 
function B(data){ 
    this.data = data || []; 
} 
B.prototype.add = function(x){ 
    this.data.push(x); 
}; 
B.prototype.update = function(index, x){ 
    this.data[index] = x; 
}; 
function C(data){ 
    this.data = data || []; 
} 
C.prototype.add = function(x){ 
    this.data.push(x); 
}; 
var a = new A(xx); 
var b = new B(xx); 
var c = new C(xx); 

有关系：
如果我叫a.remove(i)删除一个元素，b将其添加到它data。
如果我打电话给b.update(i, x)，c会将x加到它的data。
我怎么能设计这最小的耦合？

PS：这只是为了演示的情况为例，请不要在意初始化等

Answer 1

我想补充回调到A类和B类

function A(data, callback) { 
    this.data = data || []; 
    this.callback = callback || function() {}; 
} 

A.prototype.remove = function(index) { 
    // remove index from this.data; 
    this.callback(this.data[index]); 
} 
... 
var b = new B(xx); 
var a = new A(xx, function(e) {b.add(e);}); 

Answer 2

我会用最好的松散耦合事件。作为基础，我建议使用Backbone.js（请参阅Backbone.Events部分），它的占用空间非常小，并为您提供出色的自定义事件支持。从文档简要说明：

活动是可混合的任何对象，给予对象结合并触发自定义命名的事件的能力的模块。

它看起来是这样的：

function A(data){ 
    this.data = data || []; 
}  
A.prototype.remove = function(index){ 
    // remove index from this.data; 
    // dispatch A_Remove event 
    this.trigger("A_Remove", this.data); 
}; 
function B(data){ 
    this.data = data || []; 
} 
B.prototype.add = function(x){ 
    this.data.push(x); 
}; 
B.prototype.update = function(index, x){ 
    this.data[index] = x; 
    this.trigger("B_Update", x); 
}; 
function C(data){ 
    this.data = data || []; 
} 
C.prototype.add = function(x){ 
    this.data.push(x); 
}; 
var a = new A(xx); 
var b = new B(xx); 
var c = new C(xx); 

// mixin event support to your objects 
_.extend(a, Backbone.Events); 
_.extend(b, Backbone.Events); 
_.extend(c, Backbone.Events); 

// event listener for A_Remove event 
a.bind("A_Remove", function(data) { 
    b.add(data); 
}); 
// event listener for B_Update event 
b.bind("B_Update", function(data) { 
    c.add(data); 
}); 

与此事件为基础的方法，你的类如松耦合，因为他们可以，没有必要为A，B或C，以了解各其他。同时，您可以获得最高的灵活性 - 您可以随时添加更多侦听器或事件类型。

我觉得这是最好的解决方案。