将对象父键附加到孩子

发布于 2025-02-11 05:45:23 字数 470 浏览 2 评论 0原文

我有以下对象:

{
  "groupA": [
    {data: 'foo'},
    {data: 'bar'}
  ],
  "groupB": [
    {data: 'hi'},
    {data: 'mom'}
  ]
}

我想将父对象键添加到其所有数组项目中:

{
  "groupA": [
    {data: 'foo', set: 'groupA'},
    {data: 'bar', set: 'groupA'}
  ],
  "groupB": [
    {data: 'hi', set: 'groupB'},
    {data: 'mom', set: 'groupB'}
  ]
}

如何实现?

I have the following object given:

{
  "groupA": [
    {data: 'foo'},
    {data: 'bar'}
  ],
  "groupB": [
    {data: 'hi'},
    {data: 'mom'}
  ]
}

I would like to append the parent object keys to all its array items like so:

{
  "groupA": [
    {data: 'foo', set: 'groupA'},
    {data: 'bar', set: 'groupA'}
  ],
  "groupB": [
    {data: 'hi', set: 'groupB'},
    {data: 'mom', set: 'groupB'}
  ]
}

How can I achieve this?

如果你对这篇内容有疑问,欢迎到本站社区发帖提问 参与讨论,获取更多帮助,或者扫码二维码加入 Web 技术交流群。

扫码二维码加入Web技术交流群

发布评论

需要 登录 才能够评论, 你可以免费 注册 一个本站的账号。

评论(5

深居我梦 2025-02-18 05:45:23

这是一个不变的版本,它可以使用object.fromentries Object.entriesmap为您提供新对象。

const data = {
  "groupA": [{
      data: 'foo'
    },
    {
      data: 'bar'
    }
  ],
  "groupB": [{
      data: 'hi'
    },
    {
      data: 'mom'
    }
  ]
}

const withGroup = Object.fromEntries(
     Object.entries(data).map(([set, items]) => [set, items.map(i => ({ ...i,set}))])
)

console.log(withGroup)

This is a immutable version that give you a new object using Object.fromEntries Object.entries and map

const data = {
  "groupA": [{
      data: 'foo'
    },
    {
      data: 'bar'
    }
  ],
  "groupB": [{
      data: 'hi'
    },
    {
      data: 'mom'
    }
  ]
}

const withGroup = Object.fromEntries(
     Object.entries(data).map(([set, items]) => [set, items.map(i => ({ ...i,set}))])
)

console.log(withGroup)

兮颜 2025-02-18 05:45:23

您可以循环并设置每个项目

const obj = {
  "groupA": [
    {data: 'foo'},
    {data: 'bar'}
  ],
  "groupB": [
    {data: 'hi'},
    {data: 'mom'}
  ]
};
Object.entries(obj).forEach(([key,val]) => val.forEach(item => item.set=key))
console.log(obj)

You can loop and set each item

const obj = {
  "groupA": [
    {data: 'foo'},
    {data: 'bar'}
  ],
  "groupB": [
    {data: 'hi'},
    {data: 'mom'}
  ]
};
Object.entries(obj).forEach(([key,val]) => val.forEach(item => item.set=key))
console.log(obj)

并安 2025-02-18 05:45:23

您可以通过在对象上循环并映射数组来做到这一点,例如:

const data = {
  "groupA": [
    {data: 'foo'},
    {data: 'bar'}
  ],
  "groupB": [
    {data: 'hi'},
    {data: 'mom'}
  ]
};

Object.keys(data).forEach(key => {
    data[key] = data[key].map(rec => ({...rec, set: key}));
})

console.log(data);

You can do it simply by looping over the object and mapping the arrays, like this:

const data = {
  "groupA": [
    {data: 'foo'},
    {data: 'bar'}
  ],
  "groupB": [
    {data: 'hi'},
    {data: 'mom'}
  ]
};

Object.keys(data).forEach(key => {
    data[key] = data[key].map(rec => ({...rec, set: key}));
})

console.log(data);
清音悠歌 2025-02-18 05:45:23

您也可以在中使用

let data = {
  "groupA": [
    {data: 'foo'},
    {data: 'bar'}
  ],
  "groupB": [
    {data: 'hi'},
    {data: 'mom'}
  ]
}

for (const key in data) {
  data[key] = data[key].map(item => ({...item, set: key}))
}

console.log(data);

You can use for...in as well

let data = {
  "groupA": [
    {data: 'foo'},
    {data: 'bar'}
  ],
  "groupB": [
    {data: 'hi'},
    {data: 'mom'}
  ]
}

for (const key in data) {
  data[key] = data[key].map(item => ({...item, set: key}))
}

console.log(data);

诗笺 2025-02-18 05:45:23

您可以尝试object.keys(arr)获取所有密钥名称:

let before = {
  "groupA": [
    {data: 'foo'},
    {data: 'bar'}
  ],
  "groupB": [
    {data: 'hi'},
    {data: 'mom'}
  ]
}

let after = {}
Object.keys(before).map((key) => {
    let data = before[key].map((x) => { 
        x.set = key
        return x
    })
    after[key] = data 
})
console.log(before)
console.log(after)

============

[update] 在之后创建 之前:

    let before = {
    "groupA": [
        {data: 'foo'},
        {data: 'bar'}
    ],
    "groupB": [
        {data: 'hi'},
        {data: 'mom'}
    ]
}

let after = {}
Object.entries(before).forEach(([key, data]) => {
    after[key] = data.map((before_value) => { 
        return { 
            ...before_value, 
            set: key
          }
    })
})
console.log(before)
console.log(after)

You can try Object.keys(arr) to get all key name:

let before = {
  "groupA": [
    {data: 'foo'},
    {data: 'bar'}
  ],
  "groupB": [
    {data: 'hi'},
    {data: 'mom'}
  ]
}

let after = {}
Object.keys(before).map((key) => {
    let data = before[key].map((x) => { 
        x.set = key
        return x
    })
    after[key] = data 
})
console.log(before)
console.log(after)

==========

[UPDATE] Create after without changed before:

    let before = {
    "groupA": [
        {data: 'foo'},
        {data: 'bar'}
    ],
    "groupB": [
        {data: 'hi'},
        {data: 'mom'}
    ]
}

let after = {}
Object.entries(before).forEach(([key, data]) => {
    after[key] = data.map((before_value) => { 
        return { 
            ...before_value, 
            set: key
          }
    })
})
console.log(before)
console.log(after)

~没有更多了~
我们使用 Cookies 和其他技术来定制您的体验包括您的登录状态等。通过阅读我们的 隐私政策 了解更多相关信息。 单击 接受 或继续使用网站,即表示您同意使用 Cookies 和您的相关数据。
原文