树结构-Javascript-父级？

简而言之

我有一个由对象组成的树结构

是否可以构建该树并向每个对象添加对其父对象的引用

我知道引用适用于对象，但我不确定在这种情况下是否适用

我希望能写出这样的东西

currentLevel = this.getParent();

另一个例子是

this.getChildList().addChild({name: test,parent: this}) 

没有副本，也不需要从第一个副本创建多个树

第二个问题

引用如何处理数组？它们被视为对象还是取决于它们的内容

3个问题

通过字符串JSON序列化将树保存在浏览器缓存中会破坏引用吗？

您可以通过创建“TreeNode”类来实现这一点：

然后你可以从中展开

示例代码：

var node_a = new TreeNode();
var node_b = new TreeNode(node_a);
var node_c = new TreeNode(node_a);

console.log(node_a.getParent(), node_c.get_parent()); //null , node_a        
console.log(node_a.getChildren()); //[node_b, node_c]

---

这只是一个开始，它需要更多的扩展：-）

您可以通过创建“TreeNode”类来实现：

然后你可以从中展开

示例代码：

var node_a = new TreeNode();
var node_b = new TreeNode(node_a);
var node_c = new TreeNode(node_a);

console.log(node_a.getParent(), node_c.get_parent()); //null , node_a        
console.log(node_a.getChildren()); //[node_b, node_c]

---

---

这只是一个开始，它需要更多的扩展：-）

您可以遍历对象并将父属性添加到每个子对象：

function addParents(obj) {
    var name;
    for (name in obj) {
        if (typeof obj[name] === "object") {
            addParents(obj[name]);
            obj[name].parent = obj;
        }
    }
}

var obj = {
    g: {
        k: [
            {
                r : 1
            },
            {
                r : 1
            }
        ],
        j: {
            h: 1
        }
    }
};

addParents(obj);

console.log(obj.g.parent === obj); //true
console.log(obj.g.k.parent === obj.g); //true
console.log(obj.g.k[1].parent === obj.g.k); //true
console.log(obj.g.j.parent === obj.g); //true

如果以后要添加对象，可以使用以下方法：

function addChild(obj, child, name){
    obj[name] = child;
    child.parent = obj;
}

addChild(obj.g, {t:1}, "xy");

console.log(obj.g.xy.parent === obj.g); //true

---

您可以遍历对象并将父属性添加到每个子对象：

function addParents(obj) {
    var name;
    for (name in obj) {
        if (typeof obj[name] === "object") {
            addParents(obj[name]);
            obj[name].parent = obj;
        }
    }
}

var obj = {
    g: {
        k: [
            {
                r : 1
            },
            {
                r : 1
            }
        ],
        j: {
            h: 1
        }
    }
};

addParents(obj);

console.log(obj.g.parent === obj); //true
console.log(obj.g.k.parent === obj.g); //true
console.log(obj.g.k[1].parent === obj.g.k); //true
console.log(obj.g.j.parent === obj.g); //true

如果以后要添加对象，可以使用以下方法：

function addChild(obj, child, name){
    obj[name] = child;
    child.parent = obj;
}

addChild(obj.g, {t:1}, "xy");

console.log(obj.g.xy.parent === obj.g); //true

---

好吧，很有可能会有框架，但我写了一篇支持JSON序列化和相反的东西（通过它自己的方法）。我从他的回答中得到了基本的灵感。范例

var a = new MyTreeNode('a'), // make some nodes
    b = new MyTreeNode('b'),
    c = new MyTreeNode('c');

a.addChild(b).addChild(c); // a parent of b parent of c

c.getParent() === b; // true

var str = a.toJSON(); // "{"nodeName":"a","childNodes":[{"nodeName":"b","childNodes":[{"nodeName":"c","childNodes":[]}]}]}"

MyTreeNode.parseJSON(str); // MyTreeNode (same structure as before)

完整代码

/* MyTreeNode(String nodeName)
Instance Properties
 - nodeName,   String
 - childNodes, Array of MyTreeNodes
 - parentNode, MyTreeNode
Instance Methods
 - addChild(MyTreeNode node),    child MyTreeNode
 - removeChild(MyTreeNode node), child MyTreeNode
 - getParent,                    parent MyTreeNode
 - getChildList,                 Array of MyTreeNodes
 - serialise,                    JSON-safe Object
 - toJSON,                       String
Constructor Methods
 - deserialise(Object serialised), MyTreeNode
 - parseJSON(String JSONString),   MyTreeNode
*/
var MyTreeNode = (function () {
    function MyTreeNode(nodeName) {
        nodeName && (this.nodeName = nodeName);
        this.childNodes = [];
    }

    MyTreeNode.prototype.parentNode = null;
    MyTreeNode.prototype.childNodes = [];
    MyTreeNode.prototype.nodeName = '';

    // getters
    MyTreeNode.prototype.getChildList = function () {
        return this.childNodes = [];
    };
    MyTreeNode.prototype.getParent = function () {
        return this.parentNode;
    };

    // add/remove
    MyTreeNode.prototype.removeChild = function (node) {
        var i = this.childNodes.indexOf(node);
        if (node.parentNode !== this || i == -1)
            throw new ReferenceError('node is not a child of this');
        this.childNodes.splice(i, 1);
        node.parentNode = null;
        return node;
    };
    MyTreeNode.prototype.addChild = function (node) {
        if (node.parentNode) node.parentNode.removeChild(node);
        node.parentNode = this;
        this.childNodes.push(node);
        return node;
    };

    // JSON
    MyTreeNode.prototype.serialise = function () {
        var o = {
            nodeName: this.nodeName,
            childNodes: []
        }, i;
        for (i = 0; i < this.childNodes.length; ++i) {
            o.childNodes.push(this.childNodes[i].serialise());
        }
        return o;
    };
    MyTreeNode.prototype.toJSON = function () {
        return JSON.stringify(this.serialise());
    };
    MyTreeNode.deserialise = function (o) {
        var p = new MyTreeNode(o.nodeName), i;
        for (i = 0; i < o.childNodes.length; ++i) {
            p.addChild(MyTreeNode.deserialise(o.childNodes[i]));
        }
        return p;
    };
    MyTreeNode.parseJSON = function (str) {
        var o = JSON.parse(str);
        return MyTreeNode.deserialise(o);
    };
    return MyTreeNode;
}());

/*MyTreeNode（字符串节点名）
实例属性
-nodeName，字符串
-子节点，MyTreeNodes数组
-父节点，MyTreeNode
实例方法
-addChild（MyTreeNode节点），子MyTreeNode
-removeChild（MyTreeNode节点），子MyTreeNode
-getParent，父MyTreeNode
-getChildList，MyTreeNodes数组
-序列化，JSON安全对象
-toJSON，字符串
构造函数方法
-反序列化（对象序列化），MyTreeNode
-parseJSON（字符串JSONString），MyTreeNode
*/
var MyTreeNode=（函数（）{
函数MyTreeNode（节点名称）{
nodeName&（this.nodeName=nodeName）；
this.childNodes=[]；
}
MyTreeNode.prototype.parentNode=null；
MyTreeNode.prototype.childNodes=[]；
MyTreeNode.prototype.nodeName=''；
//吸气剂
MyTreeNode.prototype.getChildList=函数（）{
返回this.childNodes=[]；
};
MyTreeNode.prototype.getParent=函数（）{
返回此.parentNode；
};
//添加/删除
MyTreeNode.prototype.removeChild=函数（节点）{
var i=this.childNodes.indexOf（节点）；
if（node.parentNode！==this | | i==-1）
抛出新引用错误（'节点不是此节点的子节点'）；
这个.childNodes.splice（i，1）；
node.parentNode=null；
返回节点；
};
MyTreeNode.prototype.addChild=函数（节点）{
if（node.parentNode）node.parentNode.removeChild（node）；
node.parentNode=这个；
this.childNodes.push（节点）；
返回节点；
};
//JSON
MyTreeNode.prototype.serialise=函数（）{
变量o={
nodeName:this.nodeName，
子节点：[]
}，i；
对于（i=0；i

好的，很有可能存在框架，但是我写了一个快速的东西，它支持JSON序列化和相反的方式（通过它自己的方法）。我从他的回答中得到了基本的灵感。范例

var a = new MyTreeNode('a'), // make some nodes
    b = new MyTreeNode('b'),
    c = new MyTreeNode('c');

a.addChild(b).addChild(c); // a parent of b parent of c

c.getParent() === b; // true

var str = a.toJSON(); // "{"nodeName":"a","childNodes":[{"nodeName":"b","childNodes":[{"nodeName":"c","childNodes":[]}]}]}"

MyTreeNode.parseJSON(str); // MyTreeNode (same structure as before)

完整代码

/* MyTreeNode(String nodeName)
Instance Properties
 - nodeName,   String
 - childNodes, Array of MyTreeNodes
 - parentNode, MyTreeNode
Instance Methods
 - addChild(MyTreeNode node),    child MyTreeNode
 - removeChild(MyTreeNode node), child MyTreeNode
 - getParent,                    parent MyTreeNode
 - getChildList,                 Array of MyTreeNodes
 - serialise,                    JSON-safe Object
 - toJSON,                       String
Constructor Methods
 - deserialise(Object serialised), MyTreeNode
 - parseJSON(String JSONString),   MyTreeNode
*/
var MyTreeNode = (function () {
    function MyTreeNode(nodeName) {
        nodeName && (this.nodeName = nodeName);
        this.childNodes = [];
    }

    MyTreeNode.prototype.parentNode = null;
    MyTreeNode.prototype.childNodes = [];
    MyTreeNode.prototype.nodeName = '';

    // getters
    MyTreeNode.prototype.getChildList = function () {
        return this.childNodes = [];
    };
    MyTreeNode.prototype.getParent = function () {
        return this.parentNode;
    };

    // add/remove
    MyTreeNode.prototype.removeChild = function (node) {
        var i = this.childNodes.indexOf(node);
        if (node.parentNode !== this || i == -1)
            throw new ReferenceError('node is not a child of this');
        this.childNodes.splice(i, 1);
        node.parentNode = null;
        return node;
    };
    MyTreeNode.prototype.addChild = function (node) {
        if (node.parentNode) node.parentNode.removeChild(node);
        node.parentNode = this;
        this.childNodes.push(node);
        return node;
    };

    // JSON
    MyTreeNode.prototype.serialise = function () {
        var o = {
            nodeName: this.nodeName,
            childNodes: []
        }, i;
        for (i = 0; i < this.childNodes.length; ++i) {
            o.childNodes.push(this.childNodes[i].serialise());
        }
        return o;
    };
    MyTreeNode.prototype.toJSON = function () {
        return JSON.stringify(this.serialise());
    };
    MyTreeNode.deserialise = function (o) {
        var p = new MyTreeNode(o.nodeName), i;
        for (i = 0; i < o.childNodes.length; ++i) {
            p.addChild(MyTreeNode.deserialise(o.childNodes[i]));
        }
        return p;
    };
    MyTreeNode.parseJSON = function (str) {
        var o = JSON.parse(str);
        return MyTreeNode.deserialise(o);
    };
    return MyTreeNode;
}());

/*MyTreeNode（字符串节点名）
实例属性
-nodeName，字符串
-子节点，MyTreeNodes数组
-父节点，MyTreeNode
实例方法
-addChild（MyTreeNode节点），子MyTreeNode
-removeChild（MyTreeNode节点），子MyTreeNode
-getParent，父MyTreeNode
-getChildList，MyTreeNodes数组
-序列化，JSON安全对象
-toJSON，字符串
构造函数方法
-反序列化（对象序列化），MyTreeNode
-parseJSON（字符串JSONString），MyTreeNode
*/
var MyTreeNode=（函数（）{
函数MyTreeNode（节点名称）{
nodeName&（this.nodeName=nodeName）；
this.childNodes=[]；
}
MyTreeNode.prototype.parentNode=null；
MyTreeNode.prototype.childNodes=[]；
MyTreeNode.prototype.nodeName=''；
//吸气剂
MyTreeNode.prototype.getChildList=函数（）{
返回this.childNodes=[]；
};
MyTreeNode.prototype.getParent=函数（）{
返回此.parentNode；
};
//添加/删除
MyTreeNode.prototype.removeChild=函数（节点）{
var i=this.childNodes.indexOf（节点）；
if（node.parentNode！==this | | i==-1）
抛出新引用错误（'节点不是此节点的子节点'）；
这个.childNodes.splice（i，1）；
node.parentNode=null；
返回节点；
};
MyTreeNode.prototype.addChild=函数（节点）{
if（node.parentNode）node.parentNode.removeChild（node）；
node.parentNode=这个；
this.childNodes.push（节点）；