Question

[编辑]改变了标题“JS：奇异的setter / getter收集或单项？”

关于编写混合getter / setter的能力的一些问题...对于我的国际象棋应用程序我有一个对象图更类似于图形而不是树。因此，我决定将各种类型的对象集中在一个数据结构中，同时保持对象的状态和rhem之间的关系。

类似的东西：

// in js/app/base/pools.js
var Pool = function() {
    this.items = {};
    this.relations = {};
};

/**
 * store an object into the pool
 * and augment it with relation/pooling capabilities
 * @param string key
 * @param Object obj
 */
 Pool.prototype.store = function(key, obj) {

    var self = this;

    Object.defineProperty(obj.constructor.prototype, "pool", {
        set : undefined,
        get : function() {
            return self;
        }
    });

    this.items[key] = obj;
 };

 /**
  * looks for an object in the pool
  * @param string
  */
 Pool.prototype.find = function(key) {
    return this.items[key];
 };

关系在“relations”属性中以对[obj1，obj2]的形式存储池实例。我基本上有两种关系：

一对一：像Chessman＆lt; ---＆gt;这样的一元对应物。位置或界面实现，如Chessman＆lt; ---＆gt;典当| ...... |景
一对多，如董事会[x1]＆lt; ---＆gt; [x64]平铺

这些关系被设计（通过池方式）是双向的并且必须以原子方式设置（例如事务），因为对象交叉引用需要是“ACID”，对于上面的例子，1个板包含64个Tiles ，每块瓷砖都知道它的直立板。

对于一对一的关系，也许没问题，因为我可以设置：

chessman.location = location;
// AND AT THE SAME TIME :
location.chessman = chessman;

// with two Object.defineProperty(...) combined

问题来自1-N关系，因为我可以写：

// 1st : defining relation
// ... (see below)

// 2nd setting a relation
board1.tiles.add(tile_63);
// and
tile_63.board = board1;

// 3rd getting values
board1.tiles --> a collection of tiles (array)
tile_63.board --> board1 object

在主程序中，通过传递参数对象将关系赋予Pool实例：

pool.defineRelation("board-contains-tiles", {
    tiles : { subject : boards.Board, multiple : true },
    board : { subject : tiles.Tile, multiple : false }
});

定义关系，1-side是普通的getter / setter，但是N-side更像是getter-adder，因为我们必须填充（带有tile的板）...所以这不起作用：< / p>

 Pool.prototype.defineRelation = function(alias, definition) {
    this.relations[alias] = [];

    var self = this, linker;
    var relation = self.relations[alias];
    var subject, multiple;

    // iterate through relation short names
    for(name in definition) {

        subject = definition[name].subject;
        multiple = definition[name].multiple;

        console.log("loop with name : " + name + " subject is : " + subject);

        var getter =  function() {
                var result = [];
                for(r = 0; r < relation.length; r++) {

                    // [x,y] storing
                    if(relation[r][0] == this) 
                        result.push( relation[r][1]);

                    // [y,x] storing
                    if(relation[r][1] == this) 
                        result.push( relation[r][0]);

                    return result;

                };

        var setter;

        if(multiple) {
            setter = function() {};
            setter.add = function(x) { relation.push([this, x]); };
        } else {
            setter = function(x) { relation.push([this, x]); };
        }

        Object.defineProperty(subject.prototype, name, {
            set : setter,
            get : getter
        }); 

    }
};

问题：我觉得这样做有可能，但是怎么样？或者以更好的方式，比如Delphi的TComponent，或者像DOM树一样？

还请参见：旧的，丑陋的，凌乱的代码库可以在我的网站上找到：

www.eozine.fr --> Jet d'echecs --> ColorChess

如果你想看到之前的结果（2009）

问候。

Answer 1

可以在“pooler”部分名为“colorchess”的Google代码项目下找到第一个试用版，该项目是此动态对象关系池管理器的实际名称。

使用RequireJS和Zepto的示例可以在我的网站www.eozine.fr/colorchess/javascript（示例＃3）中找到，但这不是一个例子！事情必须得到改善。

在较早的将来也许是一个JSfiddle。

2013年圣诞快乐＆amp;新年快乐2014年。

JS：动态对象交叉引用池

1 个答案: