javascript - 如何按数组中更多嵌套对象对 JavaScript 数组进行排序并获取顶部###？

Question

这是一个虚拟的例子。我有一个对象数组:

var cars = [
  { 
    name: "Hyundai",
    plans: [
      {
        name: "Something",
        add-ons: [
            {
               cost: 100
            },
            {
               cost: 75
            }
        ] 
      }, { ... }
    ]
  },
  { 
    name: "Jeep",
    plans: [
      {
        name: "Something",
        add-ons: [
            {
               cost: 50
            },
            {
               cost: 75
            }
        ] 
      }, { ... }
    ]
  },
  { 
    name: "Buick",
    plans: [
      {
        name: "Something",
        add-ons: [
            {
               cost: 35
            },
            {
               cost: 50
            }
        ] 
      }, {...}
    ]
  }
]

我想要做的是找到附加组件最便宜的前 2 辆汽车，并通过另一个变量引用它们。

像这样:

var top2 = findTopTwo(cars);

findTopTwo(arr) {
  return arr.sort(function(a, b) {
    // My trouble spot
  }).slice(0, 2);
}

在我的简单示例中，top2 的结果将是:

1. 别克(最便宜的附加组件是 35 美元，用于比较的值(value))
2. Jeep(最便宜的附加组件是 50 美元，用于比较的值(value))

Answer 1

所以我要做的是将它们全部放入一个数组中，然后根据成本对其进行排序。那将是我天真的做法。更理想的解决方案是在给定时间只存储 2 个对象，而不是所有项目的列表。

天真的方法很简单:

var items = [];
for ( var i in cars ){
  var car = cars[i];
  for (var i in car["plans"]){
    for (var j = 0; j < car["plans"][i]["add-ons"]){
      items.push({"name": car.name, "cost": car["plans"][i]["add-ons"][j]["cost"]});
    }
  }
}
return items.sort(function(a,b){ return a.cost < b.cost }).slice(0,2);

这将返回一个包含 2 个对象的列表，该对象包含汽车名称和费用。更有效的做法是做这样的事情:

var biggest = function(arr){
  if (arr.length < 2 ) return -1;
  return arr[0].cost > arr[1].cost ? 0 : 1;
}
var items = [];
for ( var i in cars ){
  var car = cars[i];
  for (var i in car["plans"]){
    for (var j = 0; j < car["plans"][i]["add-ons"]){
      var obj = {"name": car.name, "cost": car["plans"][i]["add-ons"][j]["cost"]};
    }

    var index = biggest(items)
    if (index < 0){
      items.push(obj);
    }else{
      if (items[index].cost > obj.cost)
        items[index] = obj;
    }

  }
}
return items;

这个更有趣的设计会将前 2 个插入列表，但随后它会找到 2 个成本中最大的一个，然后检查新的成本是否小于它。如果新的小于 item[index]，它将被替换。

这永远不会有大于 2 的数组，因此它占用的内存更少