动态添加嵌套对象，分配给定值并使用具有键值对的对象添加更多对象答案

【问题标题】：Dynamically add nested object, allocate given value and add further object using object with key-value pairs动态添加嵌套对象，分配给定值并使用具有键值对的对象添加更多对象
【发布时间】：2020-10-12 20:39:31
【问题描述】：

我是 JavaScript 新手，很难在给定对象中嵌套键值对的一些值，例如通过获取键（例如“a”）并添加嵌套键（例如“ e") 如下所示，并将相关值从基础分配给添加的嵌套键。对于每一个，都应在同一层次结构中添加一个新对象，以将其包装在一个数组中。

例子

// Basis could look like this
{ a: '1', b: '2', c: '3', d: '4' }

// Map through basis and add new nested keys 
{ a: 'e', b: 'f', c: 'g', d: 'h', e: 'i', f: 'j', g: 'k' }

// Objective    
{ a: [{e: '1', date: Date.now()}], b: [{f: '2', date: Date.now()}], c: [{g: '3', date: Date.now()}], d: [{h: '4', date: Date.now()}] }

这很难。我不知道。甚至以下来源也没有帮助我，因为我必须使用键值对遍历给定对象。 Javascript: how to dynamically create nested objects using object names given by an array

【问题讨论】：

标签： javascript node.js arrays object nested

【解决方案1】：

遍历basis 的元素。使用键在nested 中找到对应的元素，并将其用作正在创建的新对象中的键。

const basis = { a: '1', b: '2', c: '3', d: '4' };
const nested = { a: 'e', b: 'f', c: 'g', d: 'h', e: 'i', f: 'j', g: 'k' };

const result = Object.entries(basis).reduce((obj, [key, value]) => {
  obj[key] = [{
    [nested[key]]: value,
    date: Date.now()
  }];
  return obj;
}, {});

console.log(result);

[nested[key]]: 表示在新对象中使用nested[key] 的值作为属性名。

【讨论】：

[nested[key]]: value

【解决方案2】：

类似这样的：

// Basis could look like this
const basis = { a: '1', b: '2', c: '3', d: '4' }

// Map through basis and add new nested keys 
const map = { a: 'e', b: 'f', c: 'g', d: 'h', e: 'i', f: 'j', g: 'k' }

const objective = {};
for (let [key, value] of Object.entries(map)) {
  if(basis[key]) {
    let item = { 
      date: Date.now()
    };
    item[value] = basis[key];
    objective[value] = [item];
  }
}
console.log(objective);
// Objective    
//{ a: [{e: '1', date: Date.now()}], b: [{f: '2', date: Date.now()}], c: [{g: '3', date: Date.now()}], d: [{h: '4', date: Date.now()}] }

【讨论】：

【解决方案3】：

您可以使用两个嵌套的reduce 方法来创建任何深度级别的嵌套值。

const a = { a: '1', b: '2', c: '3', d: '4' }
const b = { a: 'e.c.f', b: 'a', c: 'g', d: 'h', e: 'i', f: 'j', g: 'k' }

const result = Object.entries(a).reduce((r, [k, v]) => {
  if (k in b) {
    const value = [];

    b[k].split('.').reduce((a, e, i, arr) => {
      const value = arr[i + 1] ? [] : v
      const object = { [e]: value }

      if (!arr[i + 1]) {
        object.date = Date.now()
      }

      a.push(object)
      return arr[i + 1] ? value : a
    }, value)

    r[k] = value
  } else {
    r[k] = v
  }

  return r
}, {})

console.log(result)

【讨论】：

【解决方案4】：

与上述答案类似，但对于提出问题的用户来说可能更容易阅读。

假设您使用的是 ES6，您可以使用 Object.keys() 函数和 .forEach 循环遍历一个对象。

Object.keys() 将返回一个对象的键数组，您可以在该数组上调用 forEach()。

var basis = { a: '1', b: '2', c: '3', d: '4' }

var nestedKeys = { a: 'e', b: 'f', c: 'g', d: 'h', e: 'i', f: 'j', g: 'k' }

Object.keys(basis).forEach(function (basisKey) {
  Object.keys(nestedKeys).forEach(function (matchedKey) {
    if (basisKey == matchedKey) {
      basis[basisKey] = [{
        [nestedKeys[matchedKey]] : basis[basisKey],
        'date' : Date.now(),
      }];
    }
  });
});

console.log(JSON.stringify(basis, null, 4));

【讨论】：