Javascript 获取基于另一个数组的内容排序的数组

如何对allGames数组进行排序，以便首先安装视频？

const allGames = [
    { id: 2, name: 'game2' },
    { id: 1, name: 'game1' },
    { id: 4, name: 'game4' },
    { id: 3, name: 'game3' },
]
const installedGames = [
    { id: 2, name: 'game2' },
    { id: 3, name: 'game3' }
]

const sorted = allGames.sort((a, b) => {
    return a.id - b.id // but this just sorts by id
});

基本上我想得到这个订单：

{ id: 2, name: 'game2' },
{ id: 3, name: 'game3' },
{ id: 1, name: 'game1' },
{ id: 4, name: 'game4' }

---

你可以试试下面的

首先，为了提高性能，在

installedGames

数组中创建一个映射，其中

键作为
id
，而
值作为其
索引。然后根据map中存储的索引对第一个数组进行排序

映射第二个数组并创建一个ID数组。现在，根据


const allGames=[{id:2，名称：'game2'}，{id:1，名称：'game1'}，{id:4，名称：'game4'}，{id:3，名称：'game3'}]；
const installedGames=[{id:2，名称：'game2'}，{id:3，名称：'game3'}]；
const obj=installedGames.reduce（（a，c，i）=>Object.assign（a，{[c.id]：i}），{}）；
allGames.sort（（a，b）=>{
设aIndex=obj[a.id]，bIndex=obj[b.id]；
返回aIndex！=未定义？bIndex！=未定义？aIndex-bIndex:-1:1；
});
控制台日志（所有游戏）
让所有游戏=[
{id:2，名称：'game2'}，
{id:1，名称：'game1'}，
{id:4，名称：'game4'}，
{id:3，名称：'game3'}，
]
让installedGames=[
{id:3，名称：'game3'}，
{id:2，名称：'game2'}，
]
//第一步。对两个数组进行排序
allGames=allGames.sort（（a，b）=>a.id-b.id）
installedGames=installedGames.sort（（a，b）=>a.id-b.id）
//第二步。从所有游戏中删除installedGames
const remainingGames=allGames.filter（game=>！installedGames.find（g=>g.name==game.name））
//第三步。连接两者
const sortedGames=installedGames.concat（剩余游戏）
console.log（sortedGames）
您可以使用
排序
方法和内部
查找索引
，然后检查索引是否为
-1
并按结果排序


const allGames=[{id:2，名称：'game2'}，{id:1，名称：'game1'}，{id:4，名称：'game4'}，{id:3，名称：'game3'}，]
const installedGames=[{id:2，名称：'game2'}，{id:3，名称：'game3'}]
allGames.sort（（a，b）=>{
const ai=installedGames.findIndex（（{id}）=>id==a.id）；
const bi=installedGames.findIndex（（{id}）=>id==b.id）
返回（bi！=-1）-（ai！=-1）| ai-bi
});
console.log（所有游戏）
以下是我的尝试：


const allGames=[
{id:2，名称：'game2'}，
{id:1，名称：'game1'}，
{id:4，名称：'game4'}，
{id:3，名称：'game3'}，
]
常量installedGames=[
{id:2，名称：'game2'}，
{id:3，名称：'game3'}
];
var id=installedGames.map（x=>x.id）；
const sorted=allGames.slice（）.sort（（a，b）=>{
var pos_a=id.indexOf（a.id）；
var pos_b=id.indexOf（b.id）；
//比较两个已安装的
如果（位置a！=-1和位置b！=-1）{
返回位置a-位置b；
}
//比较已安装和未安装
如果（位置a！=-1）{
返回-1；
}
//把其余的分类
返回1；
});
控制台日志（已排序）您可以试试这个

const allGames = [
    { id: 2, name: 'game2' },
    { id: 1, name: 'game1' },
    { id: 4, name: 'game4' },
    { id: 3, name: 'game3' },
]
const installedGames = [
    { id: 2, name: 'game2' },
    { id: 3, name: 'game3' }
]

const sorted = ((a, b) => {
    return a.id - b.id //this just sorts by id
});
var out  = [...installedGames.sort(sorted), ...allGames.filter(o=> !(installedGames.map(i => i.id).indexOf(o.id) > -1)).sort(sorted)]

console.log(out)

我认为这是解决这个问题的最快方法

 const allGames = [
    { id: 2, name: 'game2' },
    { id: 1, name: 'game1' },
    { id: 4, name: 'game4' },
    { id: 3, name: 'game3' },
]
const installedGames = [
    { id: 2, name: 'game2' },
    { id: 3, name: 'game3' }
]

const output = [
    ...installedGames,
    ...allGames.filter( io => installedGames.findIndex(il => io.id === il.id) === -1 )
];

比较
a
和
b
的标准如下：


如果两个项目均已安装或未安装，则首先安装id较小的项目
否则（保证一个已安装，另一个未安装）首先安装项目


const allGames=[
{id:2，名称：'game2'}，
{id:1，名称：'game1'}，
{id:4，名称：'game4'}，
{id:3，名称：'game3'}，
]
常量installedGames=[
{id:2，名称：'game2'}，
{id:3，名称：'game3'}
];
allGames.sort（函数a，b）{
//findIndex返回速度比筛选器快
var ai=installedGames.findIndex（game=>game.id==a.id）>=0；
var bi=installedGames.findIndex（game=>game.id==b.id）>=0；
//ai===bi->两项均已安装或两项均未安装
//a.id-b.id->首先是id较小的项目
//ai-bi->如果1-0则返回-1，如果0-1则返回+1
返回ai==bi？（a.id-b.id）：-（ai-bi）；
});
控制台日志（所有游戏）这些对象引用的是同一个对象还是只有相同的id？这些对象略有不同，如果可能的话，我不想加入数组。