使用JavaScript對JSON對象進行排序

Question

好的。

我有一個JSON對象，其中該對象的每個項目都是一個頂級對象...沒有嵌套關系。 有些項目是嵌套的，但所有內容都是頂級的。

嵌套關系的設置方式是通過ID值。

• 項目a = item_a
• 與a = item_a.item_b相關的項目b
• 項目c = item_c
• 與c相關的項目d = item_c.item_d
• 與d = item_c.item_d.item_e相關的項目e

我已經嘗試過拆分. 並遍歷整個json對象並對其進行排序。 我嘗試了4種或5種我可以想到的不同方式，但沒有任何工作正常。

我試圖最終得到的是一個看起來像這樣的單個對象。

Obj = [{
    item_a: {
        nestedItems: [{
            item_b: {}
        }]
    },
    item_c: {
        nestedItems: [{
            item_d: {
                nestedItems: {
                    item_e: {}
                }
            }
        }]
    }    
}];

我無法更改輸出，所以我們不要問這個問題。 這是我要解決的問題。 誰能幫助我了解整理此問題的最佳方法？

這是我目前的狀態...但還遠未完成：

function getNestedAttributes(attrs) // attrs is the JSON object
{
    var nested = [];

    for ( var i=0; i<attrs.length; i++ )
    {
        var idLevels = splitId(attrs[i].id); // split on . return array

        if ( idLevels.length == 1 )
        {
            nested[idLevels[0]] = attrs[i];
            nested[idLevels[0]]['nestedAttributes'] = [];
        }

        if ( idLevels.length > 1 )
        {
            nested[idLevels[0]]['nestedAttributes'].push(attrs[i]);
        }

    }

    console.log(nested);

}

以上工作到了一定程度。 我把所有東西都做成一個數組，這很好，但是它僅適用於嵌套了一個級別的對象。 有些項目最多嵌套4個級別。

在JS中必須有更好的方法來遍歷此過程。

JSON：

attributes: [
{
    id: "item_a",
    name: "Item A Name",
    ...
},
{
    id: "item_a.item_b",
    name: "Item B Name",
    ...
},
{
    id: "item_a.item_c",
    name: "Item C Name",
    ...
},
{
    id: "item_d",
    name: "Item D Name",
    ...
},
{
    id: "item_d.item_e",
    name: "Item E Name",
    ...
},
{
    id: "item_d.item_e.item_f",
    name: "Item F Name",
    ...
}];

上面是一個非常基本的示例，但這就是輸出的樣子。

理想情況下，我將得到以下結果：

attributes: [
{
    id: "item_a",
    name: "Item A Name",
    nestedAttributes: [{
        id: "item_a.item_b"
        name: "Item B Name"
        ...
    },
    {
        id: "item_a.item_c"
        name: "Item C Name"
        ...
    }],
    ...
},
{
    id: "item_d",
    name: "Item D Name",
    nestedAttributes: [{
        id: "item_d.item_e"
        name: "Item E Name"
        nestedAttributes: [{
            id: "item_d.item_e.item_f",
            name: "Item F Name",
            ...
        }],
        ...
    }],
    ...
}];

Answer 1

好吧，除了顯而易見的事實，整個結構都需要重新思考並與精神分裂症接壤，答案很簡單。

這是一個工作的jsfiddle 。 本質上，您只想累積對象，在每個級別檢查關鍵要素。

function build(attr) {
    var target, key, out = {},
        i = -1,
        len = attr.length;
    while (++i < len) {
        key = attr[i].id.split('.');
        target = makeOrFind(out, key);
        extend(target, attr[i]);
    }
    return out;
}

function makeOrFind(target, keyParts) {
    var key, i = -1, len = keyParts.length;
    while(++i < len) {
       key = keyParts[i];
        if( i > 0 ) {
           if( !target.nestedItems ) { target.nestedItems = {}; }
           target = target.nestedItems;
        }
       if( !target[key] ) { target[key] = {}; }
       target = target[key];
    }
    return target;
}

function extend(target, vals) {
   // this is an overly simple implementation of extend
   // it only works if your objects are exactly one level deep
   // but extend is a solved problem and not really in the scope of the question
    for( var key in vals ) {
        if( vals.hasOwnProperty(key) ) {
            target[key] = vals[key];   
        }
    }        
}

var out = build(attr);
console.log(out);