Javascript 将数组转换为包含对象

如何将这样的简单数组：

['foo'、'bar'、'baz']

转换为这样的对象：

{ 'foo': {
    'bar': {
      'baz' : {}
    }
  }
}

---

看起来很简单，但我想不出来。

我想这就是你想要的：

function arrayToNestedObject(arr) {
    var obj = {},
        current = obj;

    for(var i = 0; i < arr.length; i++) {
        var key = arr[i];
        current = current[key] = {};
    }

    return obj;
}

console.log(arrayToNestedObject(['foo', 'bar', 'baz']));

函数数组嵌套对象（arr）{
var obj={}，
电流=obj；
对于（变量i=0；i

我想这就是你想要的：

function arrayToNestedObject(arr) {
    var obj = {},
        current = obj;

    for(var i = 0; i < arr.length; i++) {
        var key = arr[i];
        current = current[key] = {};
    }

    return obj;
}

console.log(arrayToNestedObject(['foo', 'bar', 'baz']));

函数数组嵌套对象（arr）{
var obj={}，
电流=obj；
对于（变量i=0；i

我想这就是你想要的：

function arrayToNestedObject(arr) {
    var obj = {},
        current = obj;

    for(var i = 0; i < arr.length; i++) {
        var key = arr[i];
        current = current[key] = {};
    }

    return obj;
}

console.log(arrayToNestedObject(['foo', 'bar', 'baz']));

函数数组嵌套对象（arr）{
var obj={}，
电流=obj；
对于（变量i=0；i

我想这就是你想要的：

function arrayToNestedObject(arr) {
    var obj = {},
        current = obj;

    for(var i = 0; i < arr.length; i++) {
        var key = arr[i];
        current = current[key] = {};
    }

    return obj;
}

console.log(arrayToNestedObject(['foo', 'bar', 'baz']));

函数数组嵌套对象（arr）{
var obj={}，
电流=obj；
对于（变量i=0；i

您应该使用

数组#reduceRight

：

function arrayToNestedObject(arr) {

    // Proceeding from the end of the array back towards the beginning...
    return arr.reduceRight(function(prev, cur) { 

        // Create a new object with a property named by the array element,
        // whose value is what we have got so far
        return Object.defineProperty({}, cur, {value: prev});

    }, {});
}

测试：

请注意，

Object.defineProperty（{}，prop，{value:val}）

是一种方便的单行缩写

var x = {};
x[prop] = val;
return x;

在ES6中，使用“计算属性”，上述内容将简单地

arrayToNestedObject = (arr) => arr.reduceRight((prev, cur) => ({[cur]: prev}));

如果您更喜欢递归解决方案，也最好从右侧开始，使用

pop

：

function arrayToNestedObject(arr) {
    return (function _(arr, obj) {
      var val = arr.pop();
      return val ? _(arr, Object.defineProperty({}, val, {value: obj})) : obj;
    }(arr, {}));
}

arrayToNestedObject(['foo', 'bar'])
> { foo: { bar: { } } } 

您应该使用

Array#reduceRight

：

function arrayToNestedObject(arr) {

    // Proceeding from the end of the array back towards the beginning...
    return arr.reduceRight(function(prev, cur) { 

        // Create a new object with a property named by the array element,
        // whose value is what we have got so far
        return Object.defineProperty({}, cur, {value: prev});

    }, {});
}

测试：

请注意，

Object.defineProperty（{}，prop，{value:val}）

是一种方便的单行缩写

var x = {};
x[prop] = val;
return x;

在ES6中，使用“计算属性”，上述内容将简单地

arrayToNestedObject = (arr) => arr.reduceRight((prev, cur) => ({[cur]: prev}));

如果您更喜欢递归解决方案，也最好从右侧开始，使用

pop

：

function arrayToNestedObject(arr) {
    return (function _(arr, obj) {
      var val = arr.pop();
      return val ? _(arr, Object.defineProperty({}, val, {value: obj})) : obj;
    }(arr, {}));
}

arrayToNestedObject(['foo', 'bar'])
> { foo: { bar: { } } } 

您应该使用

Array#reduceRight

：

function arrayToNestedObject(arr) {

    // Proceeding from the end of the array back towards the beginning...
    return arr.reduceRight(function(prev, cur) { 

        // Create a new object with a property named by the array element,
        // whose value is what we have got so far
        return Object.defineProperty({}, cur, {value: prev});

    }, {});
}

测试：

请注意，

Object.defineProperty（{}，prop，{value:val}）

是一种方便的单行缩写

var x = {};
x[prop] = val;
return x;

在ES6中，使用“计算属性”，上述内容将简单地

arrayToNestedObject = (arr) => arr.reduceRight((prev, cur) => ({[cur]: prev}));

如果您更喜欢递归解决方案，也最好从右侧开始，使用

pop

：

function arrayToNestedObject(arr) {
    return (function _(arr, obj) {
      var val = arr.pop();
      return val ? _(arr, Object.defineProperty({}, val, {value: obj})) : obj;
    }(arr, {}));
}

arrayToNestedObject(['foo', 'bar'])
> { foo: { bar: { } } } 

您应该使用

Array#reduceRight

：

function arrayToNestedObject(arr) {

    // Proceeding from the end of the array back towards the beginning...
    return arr.reduceRight(function(prev, cur) { 

        // Create a new object with a property named by the array element,
        // whose value is what we have got so far
        return Object.defineProperty({}, cur, {value: prev});

    }, {});
}

测试：

请注意，

Object.defineProperty（{}，prop，{value:val}）

是一种方便的单行缩写

var x = {};
x[prop] = val;
return x;

在ES6中，使用“计算属性”，上述内容将简单地

arrayToNestedObject = (arr) => arr.reduceRight((prev, cur) => ({[cur]: prev}));

如果您更喜欢递归解决方案，也最好从右侧开始，使用

pop

：

function arrayToNestedObject(arr) {
    return (function _(arr, obj) {
      var val = arr.pop();
      return val ? _(arr, Object.defineProperty({}, val, {value: obj})) : obj;
    }(arr, {}));
}

arrayToNestedObject(['foo', 'bar'])
> { foo: { bar: { } } } 

---

你试过什么？让我们看看你的尝试。它确实应该是一个简单的递归函数或反向循环。您尝试过什么？让我们看看你的尝试。它确实应该是一个简单的递归函数或反向循环。您尝试过什么？让我们看看你的尝试。它确实应该是一个简单的递归函数或反向循环。您尝试过什么？让我们看看你的尝试。它应该是一个简单的递归函数或反向循环。比我早30秒到达。可能需要注意的是，这不适用于嵌套数组，fe

['foo'、'bar'、['baz'、'buzz']]

。尽管老实说，最初的转换是不寻常的，如果您有嵌套数组，可能应该重新考虑。@iabw：嵌套数组是从哪里来的？OP没有提到它们。除了终端位置，嵌套数组的含义还不清楚。如果

['foo'，'bar'，['baz'，'buzz'，'garb']

，那么

garb

去哪里了？比我早30秒到达那里。可能需要注意的是，这不适用于嵌套数组，fe

['foo'、'bar'、['baz'、'buzz']]

。尽管老实说，最初的转换是不寻常的，如果您有嵌套数组，可能应该重新考虑。@iabw：嵌套数组是从哪里来的？OP没有提到它们。除了终端位置，嵌套数组的含义还不清楚。如果

['foo'，'bar'，['baz'，'buzz'，'garb']

，那么

garb

去哪里了？比我早30秒到达那里。可能需要注意的是，这不适用于嵌套数组，fe

['foo'、'bar'、['baz'、'buzz']]

。尽管老实说，最初的转换是不寻常的，如果您有嵌套数组，可能应该重新考虑。@iabw：嵌套数组是从哪里来的？OP没有提到它们。除了终端位置，嵌套数组的含义还不清楚。如果

['foo'，'bar'，['baz'，'buzz'，'garb']

，那么

garb

去哪里了？比我早30秒到达那里。可能需要注意的是，这不适用于嵌套数组，fe

['foo'、'bar'、['baz'、'buzz']]

。尽管老实说，最初的转换是不寻常的，如果您有嵌套数组，可能应该重新考虑。@iabw：嵌套数组是从哪里来的？OP没有提到它们。除了终端位置，嵌套数组的含义还不清楚。如果

['foo'，'bar'，['baz'，'buzz'，'garb']

，那么

garb

去哪里？