Javascript 如何从键列表和值创建嵌套对象？

我正试图想出一个脚本，它将接受一个键数组和一个值并返回一个对象：

keys = ['a', 'b', 'c'];
value = 'hello';

我正努力做到这一点：

{'a': {'b': {'c': 'hello'}}}

我的代码：

var data = {};
for (var i=0; i < keys.length; i++) {
  var key = keys[i];
  if (i < keys.length -1) {
     if (data[key] === undefined) {
       data[key] = {};
    }
  } else {
    data[key] = value;
  }
  data = data[key];
}

var data={}；
对于（变量i=0；i

此外，我希望确保

data

值中已经包含的任何数据在使用其他键时不会被擦除

你可以这样使用

var keys = ['a', 'b', 'c'];
var value = 'hello';

console.log(keys.reduceRight(function (pastResult, currentKey) {
    var obj = {};
    obj[currentKey] = pastResult;
    return obj;
}, value));
// { a: { b: { c: 'hello' } } }

var keys = ['a', 'b', 'c'],
    value = 'hello',
    data = {},
    temp = data;

for (var i = 0; i < keys.length; i++) {
    var key = keys[i];
    if (i < keys.length - 1) {
        if (temp[key] === undefined) {
            temp[key] = {};
        }
    } else {
        temp[key] = value;
    }
    temp = temp[key];
}

console.log(data)
// { a: { b: { c: 'hello' } } }

for (var i = 0; i < keys.length - 1; i++) {
    temp = (temp[keys[i]] = {});
}
temp[keys[keys.length - 1]] = value;

reduceRight

将从右向左处理数组。每次我们创建一个新对象，并根据当前键名存储旧对象。因此，当我们一个接一个地迭代时，我们正在增加对象的嵌套。我们传递

值

作为最后一个参数，它将第一次用作

passresult

---

如果要修复原始代码，只需停止将新对象分配给

数据

，并使用另一个变量，如下所示

var keys = ['a', 'b', 'c'];
var value = 'hello';

console.log(keys.reduceRight(function (pastResult, currentKey) {
    var obj = {};
    obj[currentKey] = pastResult;
    return obj;
}, value));
// { a: { b: { c: 'hello' } } }

var keys = ['a', 'b', 'c'],
    value = 'hello',
    data = {},
    temp = data;

for (var i = 0; i < keys.length; i++) {
    var key = keys[i];
    if (i < keys.length - 1) {
        if (temp[key] === undefined) {
            temp[key] = {};
        }
    } else {
        temp[key] = value;
    }
    temp = temp[key];
}

console.log(data)
// { a: { b: { c: 'hello' } } }

for (var i = 0; i < keys.length - 1; i++) {
    temp = (temp[keys[i]] = {});
}
temp[keys[keys.length - 1]] = value;

var key=['a'，'b'，'c']，
value='hello'，
数据={}，
温度=数据；
对于（变量i=0；i

即使这样也可以写得很简洁，像这样

var keys = ['a', 'b', 'c'];
var value = 'hello';

console.log(keys.reduceRight(function (pastResult, currentKey) {
    var obj = {};
    obj[currentKey] = pastResult;
    return obj;
}, value));
// { a: { b: { c: 'hello' } } }

var keys = ['a', 'b', 'c'],
    value = 'hello',
    data = {},
    temp = data;

for (var i = 0; i < keys.length; i++) {
    var key = keys[i];
    if (i < keys.length - 1) {
        if (temp[key] === undefined) {
            temp[key] = {};
        }
    } else {
        temp[key] = value;
    }
    temp = temp[key];
}

console.log(data)
// { a: { b: { c: 'hello' } } }

for (var i = 0; i < keys.length - 1; i++) {
    temp = (temp[keys[i]] = {});
}
temp[keys[keys.length - 1]] = value;

for（变量i=0；i

我们迭代所有

键

，除了最后一个键，每次都为当前键分配一个新对象，因为我们将其分配回

temp

，在下一次迭代中

temp

将引用新创建的对象。最后，我们将

值

分配给

键

的最后一个元素