比较对象的JavaScript数组以获得最小值/最大值

我有一个对象数组，我想在特定的对象属性上比较这些对象。这是我的阵列：

var myArray = [
    {"ID": 1, "Cost": 200},
    {"ID": 2, "Cost": 1000},
    {"ID": 3, "Cost": 50},
    {"ID": 4, "Cost": 500}
]

我想特别关注“成本”，得到一个最小值和最大值。我意识到我可以获取成本值并将其放入javascript数组中，然后运行

但是，是否有一种更简单的方法，通过绕过中间的数组步骤，直接关闭对象属性（在这种情况下是“代价”），如果不关心数组被修改，则使用

< P>使用。

myArray.sort(function (a, b) {
    return a.Cost - b.Cost
})

var min = myArray[0],
    max = myArray[myArray.length - 1]

---

一种方法是循环所有元素，并将其与最高/最低值进行比较

（创建一个数组，调用数组方法对于这个简单的操作来说是过分的）

//没有大于正无穷大的实数
var lowest=正无穷大数；
var highest=Number.NEGATIVE_无穷大；
var-tmp；
对于（var i=myArray.length-1；i>=0；i--）{
tmp=myArray[i]。成本；
如果（tmp<最低）最低=tmp；
如果（tmp>最高）最高=tmp；
}
console.log（最高、最低）；

我认为这确实是正确的选择（+1），但只是为了好玩：如果你想变得“聪明”，你可以这样做：

var myArray = 
[
    {"ID": 1, "Cost": 200},
    {"ID": 2, "Cost": 1000},
    {"ID": 3, "Cost": 50},
    {"ID": 4, "Cost": 500}
]

function finder(cmp, arr, attr) {
    var val = arr[0][attr];
    for(var i=1;i<arr.length;i++) {
        val = cmp(val, arr[i][attr])
    }
    return val;
}

alert(finder(Math.max, myArray, "Cost"));
alert(finder(Math.min, myArray, "Cost"));

var myArray=
[
{“ID”：1，“Cost”：200}，
{“ID”：2，“成本”：1000}，
{“ID”：3，“成本”：50}，
{“ID”：4，“成本”：500}
]
函数查找器（cmp、arr、attr）{
var-val=arr[0][attr]；
对于（var i=1；i另一个，类似于Kennebec的答案，但都在一行中：

maxsort = myArray.slice(0).sort(function (a, b) { return b.ID - a.ID })[0].ID; 

您可以使用内置数组对象来改为使用Math.max/Math.min：

var arr = [1,4,2,6,88,22,344];

var max = Math.max.apply(Math, arr);// return 344
var min = Math.min.apply(Math, arr);// return 1

这是更好的解决方案

    var myArray = [
    {"ID": 1, "Cost": 200},
    {"ID": 2, "Cost": 1000},
    {"ID": 3, "Cost": 50},
    {"ID": 4, "Cost": 500}
    ]
    var lowestNumber = myArray[0].Cost;
    var highestNumber = myArray[0].Cost;

    myArray.forEach(function (keyValue, index, myArray) {
      if(index > 0) {
        if(keyValue.Cost < lowestNumber){
          lowestNumber = keyValue.Cost;
        }
        if(keyValue.Cost > highestNumber) {
          highestNumber = keyValue.Cost;
        }
      }
    });
    console.log('lowest number' , lowestNumber);
    console.log('highest Number' , highestNumber);

var myArray=[
{“ID”：1，“Cost”：200}，
{“ID”：2，“成本”：1000}，
{“ID”：3，“成本”：50}，
{“ID”：4，“成本”：500}
]
var lowestNumber=myArray[0]。成本；
var highestNumber=myArray[0]。成本；
forEach（函数（键值、索引、myArray）{
如果（索引>0）{
if（keyValue.Cost<最低值）{
lowestNumber=keyValue.成本；
}
如果（keyValue.Cost>highestNumber）{
highestNumber=关键值。成本；
}
}
});
console.log（'最低编号'，最低编号）；
console.log（'最高编号'，最高编号）；
reduce适用于以下内容：对对象数组执行聚合操作（如min、max、avg等），并返回单个结果：

myArray.reduce(function(prev, curr) {
    return prev.Cost < curr.Cost ? prev : curr;
});

请注意，如果您打算使用它，它不会对每种情况都进行完全检查。如果您传入一个基元类型数组，它将失败。如果您检查一个不存在的属性，或者如果不是所有对象都包含该属性，您将得到最后一个元素。此版本稍大一些，但有这些检查：

Array.prototype.hasMin = function(attrib) {
    const checker = (o, i) => typeof(o) === 'object' && o[i]
    return (this.length && this.reduce(function(prev, curr){
        const prevOk = checker(prev, attrib);
        const currOk = checker(curr, attrib);
        if (!prevOk && !currOk) return {};
        if (!prevOk) return curr;
        if (!currOk) return prev;
        return prev[attrib] < curr[attrib] ? prev : curr; 
    })) || null;
 }

Array.prototype.hasMin=函数（attrib）{
常量检查器=（o，i）=>typeof（o）=='object'&&o[i]
return（this.length&&this.reduce（函数（prev，curr））{
const prevOk=检查器（prev，attrib）；
const currOk=检查程序（curr，attrib）；
如果（！prevOk&&！currOk）返回{}；
如果（！prevOk）返回当前值；
如果（！currOk）返回上一个；
返回上一个[attrib]
使用
数学
函数，并使用
映射
提取所需的值

以下是jsbin：


更新：

如果要使用ES6：

var min = Math.min.apply(null, myArray.map(item => item.Cost)),
    max = Math.max.apply(null, myArray.map(item => item.Cost));

使用，可以插入比较器函数以确定数组中的最小值、最大值等项


var项目=[
{姓名：'苹果'，计数：3}，
{姓名：'香蕉'，计数：10}，
{name:'Orange'，计数：2}，
{姓名：'芒果'，计数：8}
];
通过（arr、key、comparatorFn）查找函数{
返回arr.reduce（函数（prev，curr，index，arr）{
返回比较器fn.调用（arr，prev[key]，curr[key]）？prev:curr；
});
}
函数minComp（上一个，当前）{
返回上一次<当前；
}
函数maxComp（上一个，当前）{
返回上一个>当前；
}
document.body.innerHTML='Min:'+findBy（items'count'，minComp.name+'
'；
document.body.innerHTML+=“Max:”+findBy（items，'count'，maxComp）.name；
添加到Tristan Reid的答案（+使用es6），您可以创建一个接受回调的函数，该函数将包含要应用于
上一个
和
当前
的运算符：

const compare = (arr, key, callback) => arr.reduce((prev, curr) =>
    (callback(prev[key], curr[key]) ? prev : curr), {})[key];

    // remove `[key]` to return the whole object

然后，您可以简单地使用以下方法调用它：

const costMin = compare(myArray, 'Cost', (a, b) => a < b);
const costMax = compare(myArray, 'Cost', (a, b) => a > b);

const costMin=compare（myArray，'Cost'，（a，b）=>aa>b）；
这可以通过lodash的
minBy
和
maxBy
功能实现

Lodash的
minBy
和
maxBy
文档

\.minBy（数组，[iteratee=\.identity]）

\.maxBy（数组，[iteratee=\.identity]）

这些方法接受一个iteratee，该iteratee为中的每个元素调用
数组以生成值的排序标准
iteratee通过一个参数（value）调用

解决方案

var myArray=[
{“ID”：1，“Cost”：200}，
{“ID”：2，“成本”：1000}，
{“ID”：3，“成本”：50}，
{“ID”：4，“成本”：500}
]
const minimumCostItem=uu.minBy（myArray，“成本”）；
控制台日志（“最低成本项目：”，最低成本项目）；
//使用函数迭代器获取最大值
const maximumCostItem=u2;.maxBy（myArray，函数（条目）{
退货分录[“成本”]；
});
console.log（“最大成本项目：”，最大成本项目）；
试试（
a
是数组，
f
是要比较的字段）

max=（a，f）=>a.reduce（（m，x）=>m[f]>x[f]？m:x）；
设min=（a，f）=>a.reduce（（m，x）=>m[f]a.reduce（（m，x）=>m[f]>x[f]？m:x）；
设min=（a，f）=>a.reduce（（m，x）=>m[f]表示最大值

Math.max.apply(Math, myArray.map(a => a.Cost));

至少

Math.min.apply(Math, myArray.map(a => a.Cost));

我们可以用两种方法解决这个问题
上面已经解释了这两种方法，但是缺少性能测试，因此无法完成该方法

1、本机java脚本方式

2、首先对对象进行排序，然后很容易得到最小值
已排序对象的最大值

我也测试体育
var myArray = [{
    "ID": 1,
    "Cost": 200
  }, {
    "ID": 2,
    "Cost": 1000
  }, {
    "ID": 3,
    "Cost": 50
  }, {
    "ID": 4,
    "Cost": 500
  }],

  min = Math.min.apply(null, myArray.map(function(item) {
    return item.Cost;
  })),
  max = Math.max.apply(null, myArray.map(function(item) {
    return item.Cost;
  }));

console.log('min', min);//50
console.log('max', max);//1000

var min = Math.min.apply(null, myArray.map(item => item.Cost)),
    max = Math.max.apply(null, myArray.map(item => item.Cost));

const compare = (arr, key, callback) => arr.reduce((prev, curr) =>
    (callback(prev[key], curr[key]) ? prev : curr), {})[key];

    // remove `[key]` to return the whole object

const costMin = compare(myArray, 'Cost', (a, b) => a < b);
const costMax = compare(myArray, 'Cost', (a, b) => a > b);

let max= (a,f)=> a.reduce((m,x)=> m[f]>x[f] ? m:x);
let min= (a,f)=> a.reduce((m,x)=> m[f]<x[f] ? m:x);

Math.max.apply(Math, myArray.map(a => a.Cost));

Math.min.apply(Math, myArray.map(a => a.Cost));

let [min, max] = myArray.reduce(([prevMin,prevMax], {Cost})=>
   [Math.min(prevMin, Cost), Math.max(prevMax, Cost)], [Infinity, -Infinity]);