Javascript 如何在TypeScript中重新排列数组

我有一个包含如下对象的数组

var users = [{
    id: 1,
    name: 'Swamy',
    category_id: 1,
    category_name: "Male"
  },
  {
    id: 2,
    name: 'Mahesh',
    category_id: 1,
    category_name: "Male"
  },
  {
    id: 3,
    name: 'Kajal',
    category_id: 2,
    category_name: "Female"
  },
  {
    id: 4,
    name: 'Rasi',
    category_id: 2,
    category_name: "Female"
  }
]

我想根据类别重新安排上述内容

var cat_users = [{
    category_id: 1,
    category_name: "Male",
    users: [{
      id: 1,
      name: 'Swamy'
    }, {
      id: 2,
      name: 'Mahesh'
    }]
  },
  {
    category_id: 2,
    category_name: "Female",
    users: [{
      id: 3,
      name: 'Kajal'
    }, {
      id: 4,
      name: 'Rasi'
    }]
  },
]

---

我正在寻找解决方案，但似乎找不到任何相关的解决方案。请帮助重新排列数组。

首先，根据

输入

，您可以使用

数组按
类别id
对输入进行分组。减少

从该

groupedBy

对象，您可以使用

Array.map

生成所需的结果

var用户=[{
id:1，
名字：'斯瓦米'，
类别识别号：1，
类别名称：“男性”
},
{
id:2，
姓名：“Mahesh”，
类别识别号：1，
类别名称：“男性”
},
{
id:3，
名称：“卡哈尔”，
类别识别号：2，
类别名称：“女性”
},
{
id:4，
名称：“Rasi”，
类别识别号：2，
类别名称：“女性”
}
];
const groupBy=users.reduce（（acc，cur）=>{
acc[cur.category\u id]？acc[cur.category\u id].users.push({
id:cur.id，
姓名：cur.name
})：acc[当前类别\u id]={
类别识别码：当前类别识别码，
类别名称：当前类别名称，
用户：[{
id:cur.id，
姓名：cur.name
}]
};
返回acc；
}, {});
const result=Object.entries（groupBy.map）（[category_id，rest]）=>({
类别识别码，
休息
}));
控制台日志（结果）首先，基于
输入
，您可以使用
数组按
类别id
对输入进行分组。减少

从该
groupedBy
对象，您可以使用
Array.map
生成所需的结果


var用户=[{
id:1，
名字：'斯瓦米'，
类别识别号：1，
类别名称：“男性”
},
{
id:2，
姓名：“Mahesh”，
类别识别号：1，
类别名称：“男性”
},
{
id:3，
名称：“卡哈尔”，
类别识别号：2，
类别名称：“女性”
},
{
id:4，
名称：“Rasi”，
类别识别号：2，
类别名称：“女性”
}
];
const groupBy=users.reduce（（acc，cur）=>{
acc[cur.category\u id]？acc[cur.category\u id].users.push({
id:cur.id，
姓名：cur.name
})：acc[当前类别\u id]={
类别识别码：当前类别识别码，
类别名称：当前类别名称，
用户：[{
id:cur.id，
姓名：cur.name
}]
};
返回acc；
}, {});
const result=Object.entries（groupBy.map）（[category_id，rest]）=>({
类别识别码，
休息
}));
控制台日志（结果）
您必须找到排序数组中是否存在
类别id
。如果没有，则推送一个新条目。如果是，则将用户添加到该条目的用户中

interface User {
    id: number;
    name: string;
};

interface Category {
    category_id: number;
    category_name: string;
}

interface Entry extends User, Category { }

interface SortedEntry extends Category {
    users: Array<User>;
}

var users: Array<Entry> = [
    {
        id: 1,
        name: 'Swamy',
        category_id: 1,
        category_name: "Male"
    },
    {
        id: 2,
        name: 'Mahesh',
        category_id: 1,
        category_name: "Male"
    },
    {
        id: 3,
        name: 'Kajal',
        category_id: 2,
        category_name: "Female"
    },
    {
        id: 4,
        name: 'Rasi',
        category_id: 2,
        category_name: "Female"
    }
];

const sorted: Array<SortedEntry> = [];

for (const { id, name, category_name, category_id } of users) {
    const match = sorted.find((entry) => entry.category_id === category_id);
    if (!match) {
        sorted.push({
            category_id,
            category_name,
            users: [
                {
                    id,
                    name,
                }
            ]
        });
    }
    else {
        match.users.push({
            id,
            name,
        });
        const index = sorted.indexOf(match);
        sorted[index] = match;
    }
}

console.log(sorted);

用户界面{
id：编号；
名称：字符串；
};
接口类别{
类别标识：编号；
类别名称：字符串；
}
接口项扩展用户，类别{}
接口SortedEntry扩展了类别{
用户：阵列；
}
变量用户：数组=[
{
id:1，
名字：'斯瓦米'，
类别识别号：1，
类别名称：“男性”
},
{
id:2，
姓名：“Mahesh”，
类别识别号：1，
类别名称：“男性”
},
{
id:3，
名称：“卡哈尔”，
类别识别号：2，
类别名称：“女性”
},
{
id:4，
名称：“Rasi”，
类别识别号：2，
类别名称：“女性”
}
];
常量排序：数组=[]；
for（用户的常量{id，name，category_name，category_id}）{
const match=sorted.find（（条目）=>entry.category\u id===category\u id）；
如果（！匹配）{
推({
类别识别码，
类别名称，
用户：[
{
身份证件
名称
}
]
});
}
否则{
match.users.push({
身份证件
名称
});
常量索引=排序的.indexOf（匹配）；
排序[索引]=匹配；
}
}
控制台日志（已排序）；
您必须找到排序数组中是否存在
类别id
。如果没有，则推送一个新条目。如果是，则将用户添加到该条目的用户中

interface User {
    id: number;
    name: string;
};

interface Category {
    category_id: number;
    category_name: string;
}

interface Entry extends User, Category { }

interface SortedEntry extends Category {
    users: Array<User>;
}

var users: Array<Entry> = [
    {
        id: 1,
        name: 'Swamy',
        category_id: 1,
        category_name: "Male"
    },
    {
        id: 2,
        name: 'Mahesh',
        category_id: 1,
        category_name: "Male"
    },
    {
        id: 3,
        name: 'Kajal',
        category_id: 2,
        category_name: "Female"
    },
    {
        id: 4,
        name: 'Rasi',
        category_id: 2,
        category_name: "Female"
    }
];

const sorted: Array<SortedEntry> = [];

for (const { id, name, category_name, category_id } of users) {
    const match = sorted.find((entry) => entry.category_id === category_id);
    if (!match) {
        sorted.push({
            category_id,
            category_name,
            users: [
                {
                    id,
                    name,
                }
            ]
        });
    }
    else {
        match.users.push({
            id,
            name,
        });
        const index = sorted.indexOf(match);
        sorted[index] = match;
    }
}

console.log(sorted);

用户界面{
id：编号；
名称：字符串；
};
接口类别{
类别标识：编号；
类别名称：字符串；
}
接口项扩展用户，类别{}
接口SortedEntry扩展了类别{
用户：阵列；
}
变量用户：数组=[
{
id:1，
名字：'斯瓦米'，
类别识别号：1，
类别名称：“男性”
},
{
id:2，
姓名：“Mahesh”，
类别识别号：1，
类别名称：“男性”
},
{
id:3，
名称：“卡哈尔”，
类别识别号：2，
类别名称：“女性”
},
{
id:4，
名称：“Rasi”，
类别识别号：2，
类别名称：“女性”
}
];
常量排序：数组=[]；
for（用户的常量{id，name，category_name，category_id}）{
const match=sorted.find（（条目）=>entry.category\u id===category\u id）；
如果（！匹配）{
推({
类别识别码，
类别名称，
用户：[
{
身份证件
名称
}
]
});
}
否则{
match.users.push({
身份证件
名称
});
常量索引=排序的.indexOf（匹配）；
排序[索引]=匹配；
}
}
控制台日志（已排序）；
Array附带一个排序函数，您可以提供一个用于自定义比较的函数。例如，搜索“分组依据”，你会发现许多类似的问题。数组带有一个排序函数，你可以提供一个用于自定义比较的函数。搜索“分组依据”，你会发现很多类似的问题。