變換數組具有嵌套屬性的對象

Question

我有幾個陣列如下面的：

[ 'businessOpenAccount', 'accountSettings1.page.js' ] 
[ 'businessOpenAccount', 'accountSettings2.page.js' ] 
[ 'mainTest', 'test', 'test1.page.js' ] 
[ 'mainTest', 'test', 'test2.page.js' ] 

我的預期的結果是具有這樣一個目的：

{ 
    businessOpenAccount: { 
    'accountSettings1.page.js': {}, 
    'accountSettings2.page.js': {} 
    }, 
    mainTest: { 
    test: { 
     'test1.page.js': {}, 
     'test2.page.js': {} 
    } 
    } 
} 

所以實際上我想解析數組並且構建一個嵌套對象以從它們返回，但是一定要檢查一個屬性是否已經存在（因爲從前一個數組定義），我不會覆蓋它，但只需添加新的嵌套對象屬性，尊重嵌套的正確順序。

我嘗試了幾種方法使用reduce,reduceRight和簡單forEach/for循環，但我仍然不能真正實現我想要的解決方案。

請提出任何提示？

這是我迄今爲止最好的方式，但我替換的屬性騎自行車在多個陣列（具有單個陣列爲例）：

const relevantFilePath = ['businessOpenAccount', 'accountSettings.page.js']; 
 
let obj = {}; 
 
relevantFilePath.forEach((el, ind) => { 
 
    if (ind === 0) { 
 
    obj[el] = {}; 
 
    previousEl = obj[el]; 
 
    } else { 
 
    previousEl[el] = {}; 
 
    previousEl = previousEl[el]; 
 
    } 
 
}); 
 
console.log(obj);

Answer 1

你可以重複給定數據並減少對象並將最後一個項目分割爲值。

var data = [['businessOpenAccount', 'accountSettings1.page.js'], ['businessOpenAccount', 'accountSettings2.page.js'], ['mainTest', 'test', 'test1.page.js'], ['mainTest', 'test', 'test2.page.js']], 
 
    object = {}; 
 
    
 
data.forEach(function (a) { 
 
    var last = a.pop().split('.')[0]; 
 
    
 
    a.reduce(function (o, k) { 
 
     return o[k] = o[k] || {}; 
 
    }, object)[last] = ''; 
 
}); 
 

 
console.log(object);

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

ES6與沒有突變原始數據

var data = [['businessOpenAccount', 'accountSettings1.page.js'], ['businessOpenAccount', 'accountSettings2.page.js'], ['mainTest', 'test', 'test1.page.js'], ['mainTest', 'test', 'test2.page.js']], 
 
    object = {}; 
 
    
 
data.forEach(function (a) { 
 
    var temp = a.slice(), 
 
     last = temp.pop().split('.')[0]; 
 
    
 
    temp.reduce((o, k) => o[k] = o[k] || {}, object)[last] = ''; 
 
}); 
 

 
console.log(object);

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

Answer 2

遞歸解決辦法，用於anykind具有無限深度的子陣列的工作。

const a = [ 
 
    ['businessOpenAccount', 'accountSettings1.page.js'], 
 
    ['businessOpenAccount', 'accountSettings2.page.js'], 
 
    [ 'businessOpenAccount', 'test1', 
 
     [ 
 
      ['test2', 'test2.settings.page.js', 
 
       [ 
 
        ['test2', 'test2.settings.page.js'], 
 
        ['test3', 'test3.settings.page.js'], 
 
       ], 
 
       'test4', 
 
      ], 
 
      ['test3', 'test3.settings.page.js'], 
 
     ] 
 
    ], 
 
    ['mainTest', 'test', 'test1.page.js'], 
 
    ['mainTest', 'test', 'test2.page.js'], 
 
]; 
 

 
const result = {}; 
 

 
const traverse = (result, arr) => { 
 
    let firstEl = arr.shift(); 
 
    if (firstEl instanceof Array) { 
 
     if (arr.length >= 1) { 
 
      traverseTop(result, firstEl); 
 
      return traverse(result, arr); 
 
     } 
 
     return traverseTop(result, firstEl); 
 
    } 
 
    firstEl = firstEl.split('.')[0]; 
 
    result[firstEl] = arr.length >= 1 ? (result[firstEl] || {}) : ''; 
 
    if (arr.length >= 1) { 
 
     return traverse(result[firstEl], arr); 
 
    } 
 
    return; 
 
}; 
 

 
const traverseTop = (result, arr) => { 
 
    arr.forEach((subArr) => { 
 
     const firstEl = subArr.shift().split('.')[0]; 
 
     result[firstEl] = result[firstEl] || {}; 
 
     traverse(result[firstEl], subArr) 
 
    }); 
 
    return result; 
 
}; 
 

 
console.log(traverseTop(result, a));