数组和子数组上的 Javascript 递归

Question

经历了一个高级时刻，并努力让递归方法在 Javascript 中正确工作。

这里有类似的问答，但到目前为止我没有看到任何对我有帮助的东西。

话虽这么说，如果确实有重复，我将删除这个问题。

给定以下对象数组：

var collection = [
                    {
                        id: 1,
                        name: "Parent 1",
                        children: [
                            { id: 11, name: "Child 1", children: [] },
                            { id: 12, name: "Child 2", children: [] }
                        ]
                    },
                    {
                        id: 2,
                        name: "Parent 2",
                        children: [
                            {
                                id: 20,
                                name: "Child 1",
                                children: [
                                    { id: 21, name: "Grand Child 1", children: [] },
                                    { id: 22, name: "Grand Child 2", children: [] }
                                ]
                            }
                        ]
                    },
                    {
                        id: 3,
                        name: "Parent 3",
                        children: [
                            { id: 31, name: "Child 1", children: [] },
                            { id: 32, name: "Child 2", children: [] }
                        ]
                    },
                ];

我已经进行了几次尝试，但我的方法似乎只在经过一个级别后就提前返回了。

我最新的尝试是：

有人可以指出我正确的方向吗？

function findType(col, id) {


                    for (i = 0; i < col.length; i++) {

                        if (col[i].id == id) {
                            return col[i];

                        }

                        if (col[i].children.length > 0) {
                           return findType(col[i].children, id);

                        }
                    }

                    return null;

                }

我正在尝试查找给定匹配的对象id，因此查找 id1应该返回具有 name 的整个对象Parent 1。如果查找 id，则应返回具有 id和名称31的整个对象。31Child 1

这将转化为

var t = findType(collection, 1);

或者

var t = findType(collection, 31);

注意我想要有关纯 JavaScript 解决方案的帮助，而不是插件或其他库。尽管它们可能更稳定，但这对学习曲线没有帮助。谢谢。

Answer 1

你很接近，你需要一个变量来存储 find 的嵌套调用的临时结果，如果找到，则通过返回找到的对象来打破循环。

如果没有，您将返回任何找到的子级，如果第一次未找到，则无需迭代到数组末尾。

function findType(col, id) {
    var i, temp;
    for (i = 0; i < col.length; i++) {
        if (col[i].id == id) {
            return col[i];
        }
        if (col[i].children.length > 0) {
            temp = findType(col[i].children, id); // store result
            if (temp) {                           // check
                return temp;                      // return result
            }
        }
    }
    return null;
}

var collection = [{ id: 1, name: "Parent 1", children: [{ id: 11, name: "Child 1", children: [] }, { id: 12, name: "Child 2", children: [] }] }, { id: 2, name: "Parent 2", children: [{ id: 20, name: "Child 1", children: [{ id: 21, name: "Grand Child 1", children: [] }, { id: 22, name: "Grand Child 2", children: [] }] }] }, { id: 3, name: "Parent 3", children: [{ id: 31, name: "Child 1", children: [] }, { id: 32, name: "Child 2", children: [] }] }];

console.log(findType(collection, 31));
console.log(findType(collection, 1));

.as-console-wrapper { max-height: 100% !important; top: 0; }