Javascript 在保留键的同时，按值的属性对映射进行排序

我有一个声明为

var cars=newmap（）的映射

，其中

字符串

是汽车的型号，

对象

包含

年份

和

价格

等信息

因此，

Map

将如下所示：

Map = [
        'BMW' => {
            id: 123,
            price: 2000,
            models: {...}
        },
        'Opel' => {
            id: 1234,
            price: 3500,
            models: {...}
        },
        ....
    ]

const values = Array.from(this.cars.values());
values.sort((a, b) => {
    return (a.price < b.price) ? -1 : 1;
});

我想按

price

字段（asc或desc）对所有实体进行排序

我找不出任何解决方案，因为迭代

值

会丢失钥匙，而像我用

阅读的解决方案…cars.entries（）

不适用，因为这些值不可迭代

另外，我目前正在使用TypeScript，但是JS的解决方案应该仍然适用

编辑：我尝试将地图转换为数组，如下所示：

Map = [
        'BMW' => {
            id: 123,
            price: 2000,
            models: {...}
        },
        'Opel' => {
            id: 1234,
            price: 3500,
            models: {...}
        },
        ....
    ]

const values = Array.from(this.cars.values());
values.sort((a, b) => {
    return (a.price < b.price) ? -1 : 1;
});

const values=Array.from（this.cars.values（））；
值。排序（（a，b）=>{
回报率（a.价格

---

但是我在重建地图时遇到了一些问题，无法保持

键

。

地图在插入时间后进行排序。事情就是这样。如果要对其进行不同的排序，可以构建一个数组，该数组指向与贴图相同的对象，但顺序不同。为了获得映射键，直接将其存储在对象中是有意义的。要设置数组，可以使用插入排序：

const sorted: object[] = [];

for(const [key, car] of cars){
  car.name = key;
  const insertAt = sorted.findIndex(other => other.price < car.price) + 1;
  sorted.splice(insertAt, 0, car);
}

请注意，如果您只是退回到本机类型，那么使用typescript毫无意义。您可以改为实现汽车接口，例如：

interface ICar {
  price: number;
  models: IModel[];
  id: number;
  name: string;
}

---

Map

对象迭代并保持其元素的插入顺序。因此，创建新的

地图

是唯一的解决方案。我认为最简单的方法是将旧映射转换为数组，对其进行排序，然后转换为新映射。像这样：

let newMap = new Map([...map].sort(([k, v], [k2, v2])=> {
  if (v.price > v2.price) {
    return 1;
  }
  if (v.price < v2.price) {
    return -1;
  }
  return 0; 
}));

let newMap=newMap（[…Map].sort（[k，v]，[k2，v2]）=>{
如果（v.价格>v2.价格）{
返回1；
}
如果（v.价格

利用和的想法，我得到了这个解决方案。虽然不完美，但似乎很管用

private sortCars(cars): Map<string, iCar> {

    // Convert the map to array first and sort it by "price"
    const carList = Array.from(cars)
        .map(([brand, car]) => ({brand, ...car}))
        .sort((a, b) => {
            if (a.price === b.price) {
                return 0;
            } else {
                return a.price < b.price ? -1 : 1;
            }
        }
    );

    // Rebuild the map after sorting it.
    const carsMap = new Map();
    carList.forEach((car) => carsMap.set(car.name, car));

    return carsMap;
}

私人分拣车（汽车）：地图{
//首先将映射转换为数组并按“价格”对其排序
常量carList=数组。从（车）
.map（（[brand，car]）=>（{brand，…car}））
.排序（（a，b）=>{
如果（a.价格===b.价格）{
返回0；
}否则{
返回a.价格carsMap.set（car.name，car））；
返回carsMap；
}

---

为了重新构建最终地图，我选择将品牌名称添加到汽车对象中。相反，我可以在原始地图中搜索对象并返回键。

可能重复的@Nope不是真的，因为这只是对对象的排序。我的问题是当重新构造映射以保留每个值的原始键时