如何统计javascript对象中的父对象（获取未定义错误）

我正在尝试制作一个对象，它可以表示元素的父元素的数量。 我有一个对象数组。其中有两个字段to和from。我想计算父对象的长度 这是我的密码

范例

• “node\u from”：11，没有父项。它没有to字段。因此它的长度为0，零
• “node\u from”：12，来自11。因此它有父项。因此它的父项长度为1或1，与13、14、16、18、19中的长度相同
• “node_from”：15，有两个来自13和14的父节点。因此它的长度是2

我们能找到这个吗

这是我的密码

var obj={}
for（var i=0；i假设“node_from”是当前节点的ID，“node_to”是每个节点指向的子节点。下面是一个可以计算每个节点的子节点的函数


var节点=[
{
“node_from”：11，
“儿童”：[
{
“节点到”：12
}
]
},
{
“node_from”：12，
“儿童”：[
{
“节点到”：13
},
{
“节点到”：14
}
]
},
{
“节点_from”：13，
“儿童”：[
{
“节点到”：15
}
]
},
{
“节点_from”：14，
“儿童”：[
{
“节点到”：15
}
]
},
{
“节点_from”：15，
“儿童”：[
{
“节点到”：16
},
{
“节点到”：17
},
{
“节点到”：18
}
]
},
{
“node_from”：16，
“儿童”：[
]
},
{
“node_from”：17，
“儿童”：[
]
},
{
“node_from”：18，
“儿童”：[
{
“节点到”：19
}
]
},
{
“node_from”：19，
“儿童”：[
]
}
];
函数countParents（节点，num）{
var计数=0；
for（var i=0；i假设“node_from”是当前节点的ID，“node_to”是每个节点指向的子节点。下面是一个可以计算每个节点的子节点的函数


var节点=[
{
“node_from”：11，
“儿童”：[
{
“节点到”：12
}
]
},
{
“node_from”：12，
“儿童”：[
{
“节点到”：13
},
{
“节点到”：14
}
]
},
{
“节点_from”：13，
“儿童”：[
{
“节点到”：15
}
]
},
{
“节点_from”：14，
“儿童”：[
{
“节点到”：15
}
]
},
{
“节点_from”：15，
“儿童”：[
{
“节点到”：16
},
{
“节点到”：17
},
{
“节点到”：18
}
]
},
{
“node_from”：16，
“儿童”：[
]
},
{
“node_from”：17，
“儿童”：[
]
},
{
“node_from”：18，
“儿童”：[
{
“节点到”：19
}
]
},
{
“node_from”：19，
“儿童”：[
]
}
];
函数countParents（节点，num）{
var计数=0；
对于（var i=0；i，我已经用这个JSFIDLE修复了您的代码


基本上，您在此上下文中错误地使用了
hasOwnProperty
。工作正常的是
undefined
。下面的代码获得了您要查找的确切输出。计算子节点中的
node\u to
数量，并将原始
node\u从
设置为0

var obj = {};

for (var i = 0; i < node.length; i++) {
    var new_node = node[i];
  console.log(new_node);
  if (typeof obj[new_node.node_from] === 'undefined') {
    obj[new_node.node_from] = 0;
  }
  for (var j = 0; j < new_node.children.length; j++) {
    if (typeof obj[new_node.children[j].node_to] !== 'undefined') {
        obj[new_node.children[j].node_to]++;
    }
  }
}
console.log(obj);

var obj={}；
对于（变量i=0；i
我已经用这个JSFIDLE修复了您的代码


基本上，您在此上下文中错误地使用了
hasOwnProperty
。工作正常的是
undefined
。下面的代码获得了您要查找的确切输出。计算子节点中的
node\u to
数量，并将原始
node\u从
设置为0

var obj = {};

for (var i = 0; i < node.length; i++) {
    var new_node = node[i];
  console.log(new_node);
  if (typeof obj[new_node.node_from] === 'undefined') {
    obj[new_node.node_from] = 0;
  }
  for (var j = 0; j < new_node.children.length; j++) {
    if (typeof obj[new_node.children[j].node_to] !== 'undefined') {
        obj[new_node.children[j].node_to]++;
    }
  }
}
console.log(obj);

var obj={}；
对于（变量i=0；i
此方案为父对象使用临时对象，然后返回每个父对象的长度


函数getParentCount（节点）{
var parent={}，o={}；
nodes.forEach（函数（n）{
父项[n.node_from]=父项[n.node_from]| |[]；
n、 children.forEach（函数（a）{
父[a.node_to]=父[a.node_to]| |[]；
父级[a.node\u-to]。推送（n.node\u-from）；
});
});
Object.keys（parent.forEach）（函数（k）{o[k]=parent[k].length；}）；
返回o；
}
变量nodes=[{“node_-from”：11，“children”：[{“node_-to”：12}，{“node_-from”：12，“children”：[{“node_-to”：13}，{“node_-from”：13，“children”：[{“node_-to”：15}，{“node_-from”：14，“children”：[{“node_-to”：15}，{“node_-from”：15，“children“node_from”：16，“children”：[]}，{“node_from”：17，“children”：[]}，{“node_from”：18，“children”：[{“node_to”：19}}，{“node_from”：19，“children”：[]}；
document.write（“”+JSON.stringify（getParentCount（nodes），0，4）+“”）；
此方案为父对象使用临时对象，然后返回每个父对象的长度


函数getParentCount（节点）{
var parent={}，o={}；
nodes.forEach（functi
var obj={}
node.forEach(function(object){
    if(!obj[object.node_from])
      obj[object.node_from] = 0;
    object.children.forEach(function(child){
        if(!obj[child.node_to])
          obj[child.node_to] = 0;
        obj[child.node_to]++;
    })
})
console.log(obj);