Javascript 按键对对象数组进行分组_Javascript_Arrays_Object_Grouping

Javascript 按键对对象数组进行分组

javascript arrays object

Javascript 按键对对象数组进行分组,javascript,arrays,object,grouping,Javascript,Arrays,Object,Grouping,我有这个对象数组，我希望它们按照特定的键进行分组，在本例中是标记 var items = [ {id: 0, tags: ["a"], name: "foo"}, {id: 1, tags: [], name: "bar"}, {id: 2, tags: ["a"], name: "bazz"}, {id: 3, tags: ["b"], name: "wah"}, {id: 4, tags: ["c"], name: "ikr"}, {id: 5

我有这个对象数组，我希望它们按照特定的键进行分组，在本例中是

标记

var items = [
    {id: 0, tags: ["a"], name: "foo"},
    {id: 1, tags: [], name: "bar"},
    {id: 2, tags: ["a"], name: "bazz"},
    {id: 3, tags: ["b"], name: "wah"},
    {id: 4, tags: ["c"], name: "ikr"},
    {id: 5, tags: ["a"], name: "wtf"},
    {id: 6, tags: ["a","b"], name: "gtg"},
    {id: 7, tags: ["c"], name: "afk"}
]

所以我用下划线，像这样：

var groupItems = _.groupBy(items, function(obj) {
  return obj.tags;
});

问题在于：

{
"a": [
        {"id": 0,"tags": ["a"],"name": "foo"},
        {"id": 2,"tags": ["a"],"name": "bazz"},
        {"id": 5,"tags": ["a"],"name": "wtf"}
     ],
"":  [
        {"id": 1,"tags": [],"name": "bar"}
     ],
"b": [
         {"id": 3,"tags": ["b"],"name": "wah"}
     ],
"c": [
         {"id": 4,"tags": ["c"],"name": "ikr"},
         {"id": 7,"tags": ["c"],"name": "afk"}
     ],
"a,b": [
         {"id": 6,"tags": ["a","b"],"name": "gtg"}
     ]

}

如果您还注意到，那些有多个标记的人从数组

标记

创建了一个

连接的

键，这是一个非常不理想的结果。如果一个项目有多个标签时，您希望每个标签下都有重复的条目，那么如何按标签对它们进行分组，并在它们有多个标签时复制数据

var items = [
    {id: 0, tags: ["a"], name: "foo"},
    {id: 1, tags: [], name: "bar"},
    {id: 2, tags: ["a"], name: "bazz"},
    {id: 3, tags: ["b"], name: "wah"},
    {id: 4, tags: ["c"], name: "ikr"},
    {id: 5, tags: ["a"], name: "wtf"},
    {id: 6, tags: ["a","b"], name: "gtg"},
    {id: 7, tags: ["c"], name: "afk"}
]

相反，您需要手动循环您的项目，然后是每个项目的标签，并为您建立列表（如果需要，您可以使用

。每个：
这将给你：
{
  "a": [
    {"id": 0,"tags": ["a"],"name": "foo"},
    {"id": 2,"tags": ["a"],"name": "bazz"},
    {"id": 5,"tags": ["a"],"name": "wtf"},
    {"id": 6,"tags": ["a","b"],"name": "gtg"}
  ],
  "b": [
    {"id": 3,"tags": ["b"],"name": "wah"},
    {"id": 6,"tags": ["a","b"],"name": "gtg"}
  ],
  "c": [
    {"id": 4,"tags": ["c"],"name": "ikr"},
    {"id": 7,"tags": ["c"],"name": "afk"}
  ]
}

假设当一个项目有多个标记时，您希望每个标记下都有重复的条目。。
不会做您想做的事情，因为它只是将集合拆分（不会重复条目）
相反，您需要手动循环您的项目，然后是每个项目的标签，并为您建立列表（如果需要，您可以使用。每个：
这将给你：
{
  "a": [
    {"id": 0,"tags": ["a"],"name": "foo"},
    {"id": 2,"tags": ["a"],"name": "bazz"},
    {"id": 5,"tags": ["a"],"name": "wtf"},
    {"id": 6,"tags": ["a","b"],"name": "gtg"}
  ],
  "b": [
    {"id": 3,"tags": ["b"],"name": "wah"},
    {"id": 6,"tags": ["a","b"],"name": "gtg"}
  ],
  "c": [
    {"id": 4,"tags": ["c"],"name": "ikr"},
    {"id": 7,"tags": ["c"],"name": "afk"}
  ]
}

假设当一个项目有多个标记时，您希望每个标记下都有重复的条目。。
不会做您想做的事情，因为它只是将集合拆分（不会重复条目）
相反，您需要手动循环您的项目，然后是每个项目的标签，并为您建立列表（如果需要，您可以使用。每个：
这将给你：
{
  "a": [
    {"id": 0,"tags": ["a"],"name": "foo"},
    {"id": 2,"tags": ["a"],"name": "bazz"},
    {"id": 5,"tags": ["a"],"name": "wtf"},
    {"id": 6,"tags": ["a","b"],"name": "gtg"}
  ],
  "b": [
    {"id": 3,"tags": ["b"],"name": "wah"},
    {"id": 6,"tags": ["a","b"],"name": "gtg"}
  ],
  "c": [
    {"id": 4,"tags": ["c"],"name": "ikr"},
    {"id": 7,"tags": ["c"],"name": "afk"}
  ]
}

假设当一个项目有多个标记时，您希望每个标记下都有重复的条目。。
不会做您想做的事情，因为它只是将集合拆分（不会重复条目）
相反，您需要手动循环您的项目，然后是每个项目的标签，并为您建立列表（如果需要，您可以使用。每个：
这将给你：
{
  "a": [
    {"id": 0,"tags": ["a"],"name": "foo"},
    {"id": 2,"tags": ["a"],"name": "bazz"},
    {"id": 5,"tags": ["a"],"name": "wtf"},
    {"id": 6,"tags": ["a","b"],"name": "gtg"}
  ],
  "b": [
    {"id": 3,"tags": ["b"],"name": "wah"},
    {"id": 6,"tags": ["a","b"],"name": "gtg"}
  ],
  "c": [
    {"id": 4,"tags": ["c"],"name": "ikr"},
    {"id": 7,"tags": ["c"],"name": "afk"}
  ]
}

我根据您的需要创建了一个解决方案，重视可读性和维护性

我根据您的需要创建了一个解决方案，重视可读性和维护性

我根据您的需要创建了一个解决方案，重视可读性和维护性

我根据您的需要创建了一个解决方案，重视可读性和维护性

下面是一个小函数，它可以正确处理标记的空数组。您可能希望将forEach
替换为for
循环，以获得更好的性能，并添加一些类型检查，使此函数更通用，更不容易出错
function groupBy(arr, propName) {
    var grouped = {};

    arr.forEach(function (thing) {
        var values = thing[propName];

        if (!values.length) {
            grouped[''] = grouped[''] || [];
            grouped[''].push(thing);

            return;
        }

        values.forEach(function (value) {
            grouped[value] = grouped[value] || [];
            grouped[value].push(thing)
        });
    });

    return grouped;
}

这里有一个小函数，可以正确处理标记的空数组。您可能希望将forEach
替换为for
循环，以获得更好的性能，并添加一些类型检查，使此函数更通用，更不容易出错
function groupBy(arr, propName) {
    var grouped = {};

    arr.forEach(function (thing) {
        var values = thing[propName];

        if (!values.length) {
            grouped[''] = grouped[''] || [];
            grouped[''].push(thing);

            return;
        }

        values.forEach(function (value) {
            grouped[value] = grouped[value] || [];
            grouped[value].push(thing)
        });
    });

    return grouped;
}

这里有一个小函数，可以正确处理标记的空数组。您可能希望将forEach
替换为for
循环，以获得更好的性能，并添加一些类型检查，使此函数更通用，更不容易出错
function groupBy(arr, propName) {
    var grouped = {};

    arr.forEach(function (thing) {
        var values = thing[propName];

        if (!values.length) {
            grouped[''] = grouped[''] || [];
            grouped[''].push(thing);

            return;
        }

        values.forEach(function (value) {
            grouped[value] = grouped[value] || [];
            grouped[value].push(thing)
        });
    });

    return grouped;
}

这里有一个小函数，可以正确处理标记的空数组。您可能希望将forEach
替换为for
循环，以获得更好的性能，并添加一些类型检查，使此函数更通用，更不容易出错
function groupBy(arr, propName) {
    var grouped = {};

    arr.forEach(function (thing) {
        var values = thing[propName];

        if (!values.length) {
            grouped[''] = grouped[''] || [];
            grouped[''].push(thing);

            return;
        }

        values.forEach(function (value) {
            grouped[value] = grouped[value] || [];
            grouped[value].push(thing)
        });
    });

    return grouped;
}

另一个带有

var项目=[{
id:0，
标签：[“a”]，
姓名：“富”
}, {
id:1，
标签：[]，
名称：“酒吧”
}, {
id:2，
标签：[“a”]，
名称：“巴兹”
}, {
id:3，
标签：[“b”]，
姓名：“华”
}, {
id:4，
标签：[“c”]，
名称：“ikr”
}, {
id:5，
标签：[“a”]，
名称：“wtf”
}, {
id:6，
标签：[“a”、“b”]，
名称：“gtg”
}, {
id:7，
标签：[“c”]，
名称：“afk”
}]
var结果=项目减少（功能（acc、el）{
（el.tags.length==0？[“”]：el.tags.forEach（函数（el2）{
如果（！acc[el2]）acc[el2]=[]；
acc[el2]。推力（el）；
});
返回acc；
}, {});
document.getElementById（'res'）.innerHTML=JSON.stringify（结果，null，2）
另一个具有

var项目=[{
id:0，
标签：[“a”]，
姓名：“富”
}, {
id:1，
标签：[]，
名称：“酒吧”
}, {
id:2，
标签：[“a”]，
名称：“巴兹”
}, {
id:3，
标签：[“b”]，
姓名：“华”
}, {
id:4，
标签：[“c”]，
名称：“ikr”
}, {
id:5，
标签：[“a”]，
名称：“wtf”
}, {
id:6，
标签：[“a”、“b”]，
名称：“gtg”
}, {
id:7，
标签：[“c”]，
名称：“afk”
}]
var结果=项目减少（功能（acc、el）{
（el.tags.length==0？[“”]：el.tags.forEach（函数（el2）{
如果（！acc[el2]）acc[el2]=[]；
acc[el2]。推力（el）；
});
返回acc；
}, {});
document.getElementById（'res'）.innerHTML=JSON.stringify（结果，null，2）
另一个具有

var项目=[{
id:0，
标签：[“a”]，
姓名：“富”
}, {
id:1，
标签：[]，
名称：“酒吧”
}, {
id:2，
标签：[“a”]，
名称：“巴兹”
}, {
id:3，
标签：[“b”]，
姓名：“华”
}, {
id:4，
标签：[“c”]，
名称：“ikr”
}, {
id:5，
标签：[“a”]，
名称：“wtf”
}, {
id:6，
标签：[“a”、“b”]，
名称：“gtg”
}, {
id:7，
标签：[“c”]，
名称：“afk”
}]
var结果=项目减少（功能（acc、el）{
（el.tags.length==0？[“”]：el.tags.forEach（函数（el2）{
如果（！acc[el2]）acc[el2]=[]；
acc[el2]。推力（el）；
});
返回acc；
}, {});
document.getElementById（'res'）.innerHTML=JSON.stringify（结果，null，2）
另一个具有

var项目=[{
id:0，
标签：[“a”]，
姓名：“富”
}, {
id:1，
标签：[]，
名称：“酒吧”
}, {
id:2，
标签：[“a”]，
名称：“巴兹”
}, {
id:3，
标签：[“b”]，
姓名：“华”
}, {
id:4，
标签：[“c”]，
名称：“ikr”
}, {
id:5，
标签：[“a”]，
名称：“wtf”
}, {
id:6，
标签：[“a”、“b”