Javascript 如何按值对对象数组排序？usi

我有一个对象数组，例如

const myArrayOfColors = [
  { color: "red", number: 123 },
  { color: "red", number: 12 },
  { color: "green", number: 6 },
  { color: "blue", number: 7 },
  { color: "purple", number: 54 },
  { color: "green", number: 74 },
  { color: "blue", number: 41 },
  { color: "purple", number: 74 },
];

我有一个字符串数组，必须用作订单引用：

myOrder = ["red", "blue", "purple", "green"];

所以我必须对我的objects数组进行排序，以符合我的order引用。我应该有这样的输出：

const myArrayOfColors = [
  { color: "red", number: 123 },
  { color: "blue", number: 7 },
  { color: "purple", number: 54 },
  { color: "green", number: 6 },
  { color: "red", number: 12 },
  { color: "blue", number: 41 },
  { color: "purple", number: 74 },
  { color: "green", number: 74 },
];

---

即使对于不平等的群体，也会起作用，这是无法重复的

我已将

{color:'green'，number:74}

和

{color:'red'，number:74}

添加到

MyArrayOfColor

的末尾：

const myArrayOfColors=[{color:'red'，number:123}，{color:'red'，number:12}，{color:'green'，number:6}，{color:'blue'，number:7}，{color:'purple'，number:54}，{color:'green'，number:74}，{color:'blue'，number:41}，{color:'purple'，number:74}，{color:'red number:74}]
常量myOrder=[“红色”、“蓝色”、“紫色”、“绿色”]
常数res=[]
设maxIterations=MyArrayOfColor.length-myOrder.length
而（最大迭代次数--）{
myOrder.forEach（e=>{
常量c=myArrayOfColors.find（x=>x.color==e）？？{}
c、 颜色和分辨率推送（{…c}）
c、 color=“-”
})
}
console.log（res）

---

.as console wrapper{max height:100%！important；top:0；}

以下是一种简单的方法，可以根据颜色数组对唯一元素进行分组：

function*createdOrderedGroup（项目、颜色）{
项目=[…项目]
设colorIndex=0；
while（items.length）{
const index=items.findIndex（item=>item.color==colors[colorIndex]）
如果（索引==-1）{
抛出新错误（'每种颜色的关联项目数不相同'）；
}
收益率项目[指数]
项目.拼接（索引，1）；
colorIndex=（colorIndex+1）%colors.length
}
}
常量MyArrayOfColor=[
{颜色：'红色'，编号：123}，
{颜色：'红色'，编号：12}，
{颜色：'green'，编号：6}，
{颜色：'蓝色'，编号：7}，
{颜色：紫色，编号：54}，
{颜色：'绿色'，编号：74}，
{颜色：'blue'，编号：41}，
{颜色：'紫色'，编号：74}，
]
log（[…CreatedOrderedGroup（MyArrayOfColor，['red'、'blue'、'purple'、'green']））

不确定这是最好的方法，您可以尝试一下。因此，基本上我们运行

myArrayOfColors

，然后循环

order

，找到order元素，将其推入结果，然后从主源

（myArrayOfColors）

中删除项目。当然，在这里考虑时间复杂性（假设n³）。（它很大

• 您可以首先创建一个

  dict

  ，其中包含相应数组中的

  颜色及其
  编号，从而轻松实现此结果

• 计算相应

  颜色中的
  max
  元素数

• 现在我们知道了数组中的最大元素，因此我们可以循环到

  max

  ，从

  dict

  中获取

  color

  及其编号，并存储在

  结果

  数组中`

常量MyArrayOfColor=[
{颜色：“红色”，编号：123}，
{颜色：“红色”，编号：12}，
{颜色：“绿色”，编号：6}，
{颜色：“蓝色”，编号：7}，
{颜色：“紫色”，编号：54}，
{颜色：“绿色”，编号：74}，
{颜色：“蓝色”，编号：41}，
{颜色：“紫色”，编号：74}，
{颜色：“紫色”，编号：94}，
];
常量myOrder=[“红色”、“蓝色”、“紫色”、“绿色”]；
设max=0；
常量dict=MyArrayOfColor.reduce（（acc，curr）=>{
常数{color，number}=curr；
if（acc[color]）acc[color]。推送（number）；
else acc[颜色]=[编号]；
max=Math.max（max，acc[color].length）；
返回acc；
}, {});
常量结果=[]；
对于（设i=0；i{
常量{[i]：val}=dict[orderKey]；
if（val）result.push（{color:orderKey，number:val}）；
});
}
console.log（result）；

首先为每种颜色构建单独的条目列表，然后使用自定义比较器函数进行比较

常量MyArrayOfColor=[
{颜色：“红色”，编号：123}，
{颜色：“红色”，编号：12}，
{颜色：“绿色”，编号：6}，
{颜色：“蓝色”，编号：7}，
{颜色：“紫色”，编号：54}，
{颜色：“绿色”，编号：74}，
{颜色：“蓝色”，编号：41}，
{颜色：“紫色”，编号：74}，
];
myOrder=[“红色”、“蓝色”、“紫色”、“绿色”]；
myArraysPerColor={}；
for（myOrder的常量颜色）{
myArraysPerColor[color]=MyArrayOfColor.filter（v=>v.color==color）；
}
MyArrayOfColor.sort（（a，b）=>
myArraysPerColor[a.color].indexOf（a）-myArraysPerColor[b.color].indexOf（b）||
myOrder.indexOf（a.color）-myOrder.indexOf（b.color）
);
console.log（myArrayOfColors）；

如果没有足够的元素来“重复”它怎么办？你怎么知道哪种颜色先出现（它们有不同的数字，表示它们各自是唯一的）？我认为时间复杂度是

n³

对，有人可以确认吗？你可以执行

结果。推送（…myArrayOfColors.splice（colorIndex，1））

。