使用javascript将平面数组转换为嵌套数组

我希望将这个平面数组转换为嵌套数组，但它始终返回为空。不知道如何解决这个问题，或者我遗漏了什么，但这让我发疯

平面阵列：

var names =[
{ name: 'b', parent: 'Brown' },
{ name: 'a', parent: 'Brown' },
{ name: 'h', parent: 'Green' },
{ name: 'c', parent: 'Green' },
];

阵列的期望输出：

[{
    name: 'Brown',
    children: [{
            name: 'a',
            children: []
        },
        {
            name: 'b',
            children: []
        }
    ]
}, {
    name: 'Green',
        children: [{
                name: 'h',
                children: []
            },
            {
                name: 'c',
                children: []
            }
        ]
    }
}]

Js:

函数getNestedChildren（arr，父级）{ var children=[]； 对于（变量i=0；i您可以创建一个新对象，为每个项分配一个数组给具有父项名称的键，并将该项连接到该数组

var名称=[
{name:'b'，parent:'Brown'}，
{name:'a'，parent:'Brown'}，
{name:'h'，parent:'Green'}，
{name:'c'，parent:'Green'}，
];
const getGroup=（组，父级）=>{
让group=groups.find（g=>g.parent==parent）；
如果（！组）{
组=（{父，子：[]}）；
组。推（组）；
}
返回组；
}
让分组=[]
names.forEach（item=>getGroup（分组，item.parent）.children.push（item））
log（分组）

您可以为每个项创建一个新对象，为具有父项名称的键分配一个数组，并将该项连接到该数组

var名称=[
{name:'b'，parent:'Brown'}，
{name:'a'，parent:'Brown'}，
{name:'h'，parent:'Green'}，
{name:'c'，parent:'Green'}，
];
const getGroup=（组，父级）=>{
让group=groups.find（g=>g.parent==parent）；
如果（！组）{
组=（{父，子：[]}）；
组。推（组）；
}
返回组；
}
让分组=[]
names.forEach（item=>getGroup（分组，item.parent）.children.push（item））
console.log（分组）

var名称=[
{name:'b'，parent:'Brown'}，
{name:'a'，parent:'Brown'}，
{name:'h'，parent:'Green'}，
{name:'c'，parent:'Green'}，
{name:'j'，parent:'Brown'}
];
功能分组依据（arr，f）{
返回arr.reduce（（r，v，i，a，k=f（v））=>（（r[k]|（r[k]=[]））.push（v，r），{}）；
}
函数嵌套数组（数组）{
var newArray=[]，
resultGrouped=groupBy（名称，函数（c）{
返回c.parent
});
for（ResultGroup中的变量键）{
var item=resultgroup[key]；
newArray.push({
姓名:key,，
子项：item.map（函数（map）{
删除map.parent；
map.children=[]；
返回图；
})
});
}
返回新数组；
}
log（nestArray（names））
var名称=[
{name:'b'，parent:'Brown'}，
{name:'a'，parent:'Brown'}，
{name:'h'，parent:'Green'}，
{name:'c'，parent:'Green'}，
{name:'j'，parent:'Brown'}
];
功能分组依据（arr，f）{
返回arr.reduce（（r，v，i，a，k=f（v））=>（（r[k]|（r[k]=[]））.push（v，r），{}）；
}
函数嵌套数组（数组）{
var newArray=[]，
resultGrouped=groupBy（名称，函数（c）{
返回c.parent
});
for（ResultGroup中的变量键）{
var item=resultgroup[key]；
newArray.push({
姓名:key,，
子项：item.map（函数（map）{
删除map.parent；
map.children=[]；
返回图；
})
});
}
返回新数组；
}
log（nestArray（names））因此，对于初学者，需要循环遍历名称并将每个父级发送到getNestedChildren（）函数

var names =[
    { name: 'b', parent: 'Brown' },
    { name: 'a', parent: 'Brown' },
    { name: 'h', parent: 'Green' },
    { name: 'c', parent: 'Green' },
];

var nest = [];

for (var i = 0; i < names.length; i++) {
    nest.push(getNestedChildren(names, names[i].parent));
} 

var名称=[
{name:'b'，parent:'Brown'}，
{name:'a'，parent:'Brown'}，
{name:'h'，parent:'Green'}，
{name:'c'，parent:'Green'}，
];
var-nest=[]；
对于（var i=0；i

此外，getNestedChildren（）当前正在尝试修改并发回旧名称数组。我建议改为创建一个新对象，并将包含子对象的对象发回

function getNestedChildren(arr, parent) {
    var children = [];
    var parentObj = {};
    parentObj.name = parent;
    for(var i =0; i < arr.length; ++i) {
        if(arr[i].parent == parent) {
            children.push(getNestedChildren(arr, arr[i].name));
        }
    }
    parentObj.children = children;
    return parentObj;
}

函数getNestedChildren（arr，父级）{
var children=[]；
var parentObj={}；
parentObj.name=父对象；
对于（变量i=0；i
因此，对于初学者，您需要循环遍历名称，并将每个父级发送到getNestedChildren（）函数

var names =[
    { name: 'b', parent: 'Brown' },
    { name: 'a', parent: 'Brown' },
    { name: 'h', parent: 'Green' },
    { name: 'c', parent: 'Green' },
];

var nest = [];

for (var i = 0; i < names.length; i++) {
    nest.push(getNestedChildren(names, names[i].parent));
} 

var名称=[
{name:'b'，parent:'Brown'}，
{name:'a'，parent:'Brown'}，
{name:'h'，parent:'Green'}，
{name:'c'，parent:'Green'}，
];
var-nest=[]；
对于（var i=0；i

此外，getNestedChildren（）当前正在尝试修改并发回旧名称数组。我建议改为创建一个新对象，并将包含子对象的对象发回

function getNestedChildren(arr, parent) {
    var children = [];
    var parentObj = {};
    parentObj.name = parent;
    for(var i =0; i < arr.length; ++i) {
        if(arr[i].parent == parent) {
            children.push(getNestedChildren(arr, arr[i].name));
        }
    }
    parentObj.children = children;
    return parentObj;
}

函数getNestedChildren（arr，父级）{
var children=[]；
var parentObj={}；
parentObj.name=父对象；
对于（变量i=0；i

var nest=getNestedChildren（name，names.parent）什么是
名称。父项
undefined
？您必须遍历名称并为每个名称调用parent[0]。parent（否则未定义）我正在尝试访问数组的根级别。有什么想法吗？@user992731使用0获得根级别。下面是我的答案。所以，这可能会让您感兴趣：（首先复制了错误的链接，经过编辑）
var nest=getNestedChildren（names，names.parent）什么是
名称。父项
<代码>未定义
？您必须循环遍历名称，并为每个名称调用父项[0]。父项（oth