Javascript 优化嵌套对象漫游

我有一个嵌套的对象结构，对每个对象执行一系列操作，然后将其推送到数组中。我当前的代码如下所示：

var item;
var final_data = [];

function walk (items, level) {
    for (var i = 0; i < items.length; i++) {
        item = items[i];

        var final_item = Object.assign({}, item); // <-- required step, object's proper key/values must be cloned, but not recursively.
        delete final_item.children; // final_item shouldn't have children

        final_item.foo = level;

        final_data.push(final_item);

        if ("children" in item) walk(item.children, level + 1);
    }

}

walk(my_data, 0);

my_data = [
    {a: 1, b: 2},
    {a: 3, b: 8},
    {a: 9, b: 3, children: [
        {...}, {...}, {...}
    ]},
    {...},
    {..., children: [{}, {}, {}...]}
];

---

我能立即看到的唯一一件事是通过给变量赋值.length来优化循环

i、 e:

for（变量i=0，j=items.length；i

而不是

for (var i = 0; i < items.length; i++)

for（变量i=0；i

以下是另一篇文章的答案，以获得更多见解：

---

如果你想提高性能，是的，它肯定会得到改进。不需要Object.assign，在javascript中创建和销毁对象的效率极低。与删除该变量相比，分配长度变量的收益可以忽略不计。

要删除递归，我使用数组作为堆栈，访问“my_data”的所有节点，找出是否有子级，并推送堆栈上的所有子级。 然后，移除子节点并在最终结果中推送所访问的节点

var item;
var final_data = [];

function walk(items, level) {
    var stack = items;

    while (stack.length > 0) {
        item = stack.shift();
        if ("children" in item) {
            var x = Object.assign({}, item)
            var children = item.children;
            // console.log(children);
            for (var z = 0; z < children.length; z++) {
                stack.push(children[z]);
            }
        }
        delete item.children;
        final_data.push(item);
    }
}

walk(my_data, 0);
for (var i = 0; i < final_data.length; i++) {
    //console.log(final_data[i].a);
}

var项目；
var最终数据=[]；
功能行走（项目、级别）{
var堆栈=项目；
while（stack.length>0）{
item=stack.shift（）；
如果（项目中的“子项”）{
var x=Object.assign（{}，item）
var children=item.children；
//console.log（儿童）；
对于（var z=0；z

您是否遇到了缩放问题，或者您只是想证明这一点？@mederomuraliev实际上两者都没有。我只是想压缩我能获得的所有性能，因为这个代码路径非常昂贵。删除递归始终是增强的第一步。您应该给我们一个计时器，以便我们可以尝试使其更快，并与您轻松共享结果。现在，你要求付出相当多的努力来帮助你完成一些已经成功的事情……我认为这应该迁移到CodeReview，与其他所有东西相比，这将是一个微不足道的微优化，而现在JS引擎无论如何都会对其进行优化。上次我检查时，这个“优化”与“未优化”一样快在Chrome上编写代码，在Firefox上甚至要慢一点。所以我不再推荐它了。长度缓冲在IE上帮助很大，它已经非常慢了，所以如果它是一个清洗其他地方，它仍然应该做。很多穴居人仍然在那里，优化是无痛的$0.02无论需要什么样的OP启动克隆，都会创建对象，不是吗？如果他修改原始对象，就不会。原始对象不应该以任何方式修改。啊，好吧，那么，我刚刚想到了这个。执行

JSON.stringify

，然后想出一些解析字符串的方法。然后调用

JSON.parse

。或者您可以对原始对象调用

JSON.parse（JSON.stringify（obj））

来复制它。然后，继续解析，而不必担心修改原始对象，也不必创建新对象。代码段中的最后一个循环用于测试结果JSFIDLE：这不会处理超过1级的嵌套对象。我尝试了2级，它可以工作，您检查了我的JSFIDLE了吗？

var item;
var final_data = [];

function walk(items, level) {
    var stack = items;

    while (stack.length > 0) {
        item = stack.shift();
        if ("children" in item) {
            var x = Object.assign({}, item)
            var children = item.children;
            // console.log(children);
            for (var z = 0; z < children.length; z++) {
                stack.push(children[z]);
            }
        }
        delete item.children;
        final_data.push(item);
    }
}

walk(my_data, 0);
for (var i = 0; i < final_data.length; i++) {
    //console.log(final_data[i].a);
}