Javascript 具有某些权重年龄值的对象数组值的顺序不正确

我有一个对象数组，如下所示：

let messageScoreData = {
  messagescore: [
    {
      userid: "5bacc8c6563a882a1ca7756a",
      score: 2605.4
    },
    {
      userid: "5bacc98431481e0520856df8",
      score: 1013.2
    },
    {
      userid: "5bc6d0bb26f1bb1b44a790c6",
      score: 41
    },
    {
      userid: "5bc6d0bb26f1bb1b44a790c9",
      score: 29
    }
  ],
  messagescorebefore: [
    {
      userid: "5bacc8c6563a882a1ca7756a",
      score: 3754
    },
    {
      userid: "5bacc98431481e0520856df8",
      score: 1259.8
    },
    {
      userid: "5bc6d0bb26f1bb1b44a790c6",
      score: 98
    },
    {
      userid: "5bced078d62b321d08f012af",
      score: 22
    },
    {
      userid: "5bcec1ad11302529f452b31e",
      score: 6
    },
    {
      userid: "5c10afec8c587d2fac8c356e",
      score: 6
    },
    {
      userid: "5c07b7f199848528e86e9359",
      score: 3
    },
    {
      userid: "5bed1373f94b611de4425259",
      score: 2
    },
    {
      userid: "5c21ccff833a5006fc5a98af",
      score: 2
    },
    {
      userid: "5c21ccff82e32c05c4043410",
      score: 1
    }
  ]
};

[     { name: '5bacc8c6563a882a1ca7756a', value: 1 },
      { name: '5bacc98431481e0520856df8', value: 1 },
      { name: '5bc6d0bb26f1bb1b44a790c6', value: 1 },
      { name: '5bc6d0bb26f1bb1b44a790c9', value: 0.6 },
      { name: '5bced078d62b321d08f012af', value: 0.4 },
      { name: '5bcec1ad11302529f452b31e', value: 0.4 },
      { name: '5c10afec8c587d2fac8c356e', value: 0.4 },
      { name: '5c07b7f199848528e86e9359', value: 0.4 },
      { name: '5bed1373f94b611de4425259', value: 0.4 },
      { name: '5c21ccff833a5006fc5a98af', value: 0.4 },
]

现在我们将提供权重年龄值，即messagescorebefore数组的值为0.4，messagescore的值为0.6； 为此，我有一个算法，它将值与权重年龄值排序。i、 e

var result = messageScoreData;

var columns = [
  {
    name: "messagescorebefore",
    value: 0.4
  },
  {
    name: "messagescore",
    value: 0.6
  }
];

var total = {};

for (let column of columns) {
  for (let userid of result[column.name]) {
    var alphabet = userid.userid;
    if (total[alphabet]) {
      total[alphabet] += column.value;
    } else {
      total[alphabet] = column.value;
    }
  }
}
const valueholder = Object.keys(total)
  .map(key => ({ name: key, value: total[key] }))
  .sort((f, s) => s.value - f.value);
console.log(valueholder); 

通过该算法，输出为：

[ { name: '5bacc8c6563a882a1ca7756a', value: 1 },
  { name: '5bc6d0bb26f1bb1b44a790c6', value: 1 },
  { name: '5bacc98431481e0520856df8', value: 1 },
  { name: '5bc6d0bb26f1bb1b44a790c9', value: 0.6 },
  { name: '5bcec1ad11302529f452b31e', value: 0.4 },
  { name: '5bced078d62b321d08f012af', value: 0.4 },
  { name: '5c07b7f199848528e86e9359', value: 0.4 },
  { name: '5bed1373f94b611de4425259', value: 0.4 },
  { name: '5c21ccff833a5006fc5a98af', value: 0.4 },
  { name: '5c21ccff82e32c05c4043410', value: 0.4 },
  { name: '5c10afec8c587d2fac8c356e', value: 0.4 } ]

问题是userid：“5bacc98431481e0520856df8”将出现在两个数组的第二个位置，但在最终计算之后，它将出现在第三个位置，这是错误的。 预期输出如下所示：

let messageScoreData = {
  messagescore: [
    {
      userid: "5bacc8c6563a882a1ca7756a",
      score: 2605.4
    },
    {
      userid: "5bacc98431481e0520856df8",
      score: 1013.2
    },
    {
      userid: "5bc6d0bb26f1bb1b44a790c6",
      score: 41
    },
    {
      userid: "5bc6d0bb26f1bb1b44a790c9",
      score: 29
    }
  ],
  messagescorebefore: [
    {
      userid: "5bacc8c6563a882a1ca7756a",
      score: 3754
    },
    {
      userid: "5bacc98431481e0520856df8",
      score: 1259.8
    },
    {
      userid: "5bc6d0bb26f1bb1b44a790c6",
      score: 98
    },
    {
      userid: "5bced078d62b321d08f012af",
      score: 22
    },
    {
      userid: "5bcec1ad11302529f452b31e",
      score: 6
    },
    {
      userid: "5c10afec8c587d2fac8c356e",
      score: 6
    },
    {
      userid: "5c07b7f199848528e86e9359",
      score: 3
    },
    {
      userid: "5bed1373f94b611de4425259",
      score: 2
    },
    {
      userid: "5c21ccff833a5006fc5a98af",
      score: 2
    },
    {
      userid: "5c21ccff82e32c05c4043410",
      score: 1
    }
  ]
};

[     { name: '5bacc8c6563a882a1ca7756a', value: 1 },
      { name: '5bacc98431481e0520856df8', value: 1 },
      { name: '5bc6d0bb26f1bb1b44a790c6', value: 1 },
      { name: '5bc6d0bb26f1bb1b44a790c9', value: 0.6 },
      { name: '5bced078d62b321d08f012af', value: 0.4 },
      { name: '5bcec1ad11302529f452b31e', value: 0.4 },
      { name: '5c10afec8c587d2fac8c356e', value: 0.4 },
      { name: '5c07b7f199848528e86e9359', value: 0.4 },
      { name: '5bed1373f94b611de4425259', value: 0.4 },
      { name: '5c21ccff833a5006fc5a98af', value: 0.4 },
]

---

我们非常感谢您的帮助。提前感谢

由于您以降序方式对值进行排序，因此预期会出现观察到的行为：

.sort（（f，s）=>s.value-f.value）。从您的示例来看，您似乎希望按名称按字典顺序对条目进行排序。在这种情况下，应根据名称进行排序：

const valueholder = Object.keys(total)
  .map(key => ({ name: key, value: total[key] }))
  .sort((f, s) => f.name.localeCompare(s.name));

如果要主要按值（降序）排序，其次按名称（升序）排序，请执行以下操作：

在这种情况下，如果两个条目具有相同的值，则差值
s.value-f.value
将为0。由于这是一个错误的值，
f.name.localeCompare（s.name）
将被计算，有效地按照名称对值进行字典排序

如果要根据条目的值对条目进行排序，但保留相同值条目的原始顺序，可以执行以下操作：

const entries = Object.keys(total)
      .map(key => ({ name: key, value: total[key] }))
const valueholder = entries.sort((f, s) => s.value - f.value || arr.indexOf(f) - arr.indexOf(s));

我们需要按照原始顺序显式排序的原因是，内置排序算法（保证）不稳定。注意，上面的排序不是很有效，因为我们使用了
indexOf
。我把它作为一个练习，首先循环遍历数组，并在将名称映射到索引的映射中累积所有索引。因此，在排序时，您可以查找索引而不是计算它们。
实际上，您希望保留元素的相对顺序。正常排序函数不能保证保持相对顺序。所以我们需要一些技巧来保持相对秩序，如下所示


让messageScoreData={
messagescore：[
{
用户标识：“5bacc8c6563a882a1ca7756a”，
得分：2605.4
},
{
用户标识：“5bacc98431481e0520856df8”，
分数：1013.2
},
{
用户标识：“5bc6d0bb26f1bb1b44a790c6”，
分数：41
},
{
用户标识：“5bc6d0bb26f1bb1b44a790c9”，
分数：29
}
],
messagescorebefore：[
{
用户标识：“5bacc8c6563a882a1ca7756a”，
分数：3754
},
{
用户标识：“5bacc98431481e0520856df8”，
分数：1259.8
},
{
用户标识：“5bc6d0bb26f1bb1b44a790c6”，
分数：98
},
{
用户标识：“5bced078d62b321d08f012af”，
分数：22
},
{
用户标识：“5bcec1ad11302529f452b31e”，
得分：6分
},
{
用户标识：“5C10FEC8C587D2FAC8C356E”，
得分：6分
},
{
用户标识：“5c07b7f199848528e86e9359”，
得分：3分
},
{
用户标识：“5bed1373f94b611de4425259”，
分数：2
},
{
用户标识：“5C21CFF833A5006FC5A98AF”，
分数：2
},
{
用户标识：“5C21CFF82E32C05C4043410”，
分数：1
}
]
};
var结果=messageScoreData；
变量列=[
{
名称：“messagescorebefore”，
数值：0.4
},
{
名称：“messagescore”，
数值：0.6
}
];
风险价值总额=[]；
for（列中的列）{
for（让结果的userid[column.name]）{
var alphabet=userid.userid；
if（总计[字母表]）{
总计[字母表]+=列值；
}否则{
总计[字母表]=列值；
}
}
}
设res=Object.keys（总计）.map（（k，idx）=>{
返回{
姓名:k,，
值：总计[k]，
索引：idx
}
})
变量输出=res.sort（（f，s）=>{
如果（s.valuef.value）返回1；
返回f.index-s.index
})
console.log（“output:，output）
如果您正在寻找稳定的排序，即保持数组元素的原始顺序为等值，则必须添加键数组索引的比较（假设这具有正确的顺序）：

const keys=Object.keys（总计）；
常量值持有者=键
.map（key=>（{name:key，value:total[key]}））
.sort（（f，s）=>s.value-f.value | | keys.indexOf（f.name）
您可以将此解决方案简化为：
var output=res.sort（（f，s）=>s.value-f.value | | f.index-s.index）
@Kevin是的，我们可以这样做。