在对象数组中查找属性的最大值

小开

最佳答案

要查找array中对象的最大y值：

    Math.max.apply(Math, array.map(function(o) { return o.y; }))

或者在更现代的JavaScript中：

    Math.max(...array.map(o => o.y))

小开

首先，你应该解析JSON字符串，以便你可以轻松访问它的成员：

var arr = $.parseJSON(str);

使用map方法提取值：

arr = $.map(arr, function(o){ return o.y; });

然后您可以在max方法中使用数组：

var highest = Math.max.apply(this,arr);

或者作为一个单行：

var highest = Math.max.apply(this,$.map($.parseJSON(str), function(o){ return o.y; }));

小开

var max = 0;
jQuery.map(arr, function (obj) {
if (obj.attr > max)
max = obj.attr;
});

小开

查找其属性“Y”在对象数组中具有最大值的对象

一种方法是使用数组减少。

const max = data.reduce(function(prev, current) {
return (prev.y > current.y) ? prev : current
}) //returns object

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/Reduce http://caniuse.com/#search=reduce（IE9及以上）

如果您不需要支持IE（仅限Edge），或者可以使用Babel等预编译器，您可以使用更简洁的语法。

const max = data.reduce((prev, current) => (prev.y > current.y) ? prev : current)

小开

干净简单的ES6（Babel）

const maxValueOfY = Math.max(...arrayToSearchIn.map(o => o.y), 0);

如果arrayToSearchIn为空，第二个参数应确保默认值。

小开

我想一步一步地解释简洁的回答：

var objects = [{ x: 3 }, { x: 1 }, { x: 2 }];


// array.map lets you extract an array of attribute values
var xValues = objects.map(function(o) { return o.x; });
// es6
xValues = Array.from(objects, o => o.x);


// function.apply lets you expand an array argument as individual arguments
// So the following is equivalent to Math.max(3, 1, 2)
// The first argument is "this" but since Math.max doesn't need it, null is fine
var xMax = Math.max.apply(null, xValues);
// es6
xMax = Math.max(...xValues);


// Finally, to find the object that has the maximum x value (note that result is array):
var maxXObjects = objects.filter(function(o) { return o.x === xMax; });


// Altogether
xMax = Math.max.apply(null, objects.map(function(o) { return o.x; }));
var maxXObject = objects.filter(function(o) { return o.x === xMax; })[0];
// es6
xMax = Math.max(...Array.from(objects, o => o.x));
maxXObject = objects.find(o => o.x === xMax);




document.write('<p>objects: ' + JSON.stringify(objects) + '</p>');
document.write('<p>xValues: ' + JSON.stringify(xValues) + '</p>');
document.write('<p>xMax: ' + JSON.stringify(xMax) + '</p>');
document.write('<p>maxXObjects: ' + JSON.stringify(maxXObjects) + '</p>');
document.write('<p>maxXObject: ' + JSON.stringify(maxXObject) + '</p>');

更多信息：

小开

如果您（或这里的某人）可以自由使用lodash实用程序库，它有一个maxBy函数，在您的情况下非常方便。

因此，你可以这样使用：

_.maxBy(jsonSlice, 'y');

小开

es6解决方案

Math.max(...array.map(function(o){return o.y;}))

小开

或者简单的排序！保持真实：）

array.sort((a,b)=>a.y<b.y)[0].y

小开

每个数组并使用Math获取最大值。

data.reduce((max, b) => Math.max(max, b.costo), data[0].costo);

小开

三个ONELINERS处理负数情况的比较（在a数组中输入）：

var maxA = a.reduce((a,b)=>a.y>b.y?a:b).y; // 30 chars time complexity:  O(n)


var maxB = a.sort((a,b)=>b.y-a.y)[0].y;    // 27 chars time complexity:  O(nlogn)
           

var maxC = Math.max(...a.map(o=>o.y));     // 26 chars time complexity: >O(2n)

可编辑示例这里。来自maxA、maxB和maxC的想法（maxB的副作用是数组a被更改，因为sort就位）。

var a = [
{"x":"8/11/2009","y":0.026572007},{"x":"8/12/2009","y":0.025057454},
{"x":"8/14/2009","y":0.031004457},{"x":"8/13/2009","y":0.024530916}
]


var maxA = a.reduce((a,b)=>a.y>b.y?a:b).y;
var maxC = Math.max(...a.map(o=>o.y));
var maxB = a.sort((a,b)=>b.y-a.y)[0].y;


document.body.innerHTML=`<pre>maxA: ${maxA}\nmaxB: ${maxB}\nmaxC: ${maxC}</pre>`;

对于较大的数组，Math.max...将抛出异常：超出最大调用堆栈大小（Chrome76.0.3809，Safari12.1.2，日期2019-09-13）

let a = Array(400*400).fill({"x": "8/11/2009", "y": 0.026572007 });


// Exception: Maximum call stack size exceeded


try {
let max1= Math.max.apply(Math, a.map(o => o.y));
} catch(e) { console.error('Math.max.apply:', e.message) }


try {
let max2= Math.max(...a.map(o=>o.y));
} catch(e) { console.error('Math.max-map:', e.message) }

4元素数组的基准

小开

// Here is very simple way to go:


// Your DataSet.


let numberArray = [
{
"x": "8/11/2009",
"y": 0.026572007
},
{
"x": "8/12/2009",
"y": 0.025057454
},
{
"x": "8/13/2009",
"y": 0.024530916
},
{
"x": "8/14/2009",
"y": 0.031004457
}
]


// 1. First create Array, containing all the value of Y
let result = numberArray.map((y) => y)
console.log(result) // >> [0.026572007,0.025057454,0.024530916,0.031004457]


// 2.
let maxValue = Math.max.apply(null, result)
console.log(maxValue) // >> 0.031004457

小开

以下是最短的解决方案（One Liner）ES6：

Math.max(...values.map(o => o.y));

小开

这很简单

     const array1 = [
{id: 1, val: 60},
{id: 2, val: 2},
{id: 3, val: 89},
{id: 4, val: 78}
];
const array2 = [1,6,8,79,45,21,65,85,32,654];
const max = array1.reduce((acc, item) => acc = acc > item.val ? acc : item.val, 0);
const max2 = array2.reduce((acc, item) => acc = acc > item ? acc : item, 0);


console.log(max);
console.log(max2);

小开

快速和肮脏：

Object.defineProperty(Array.prototype, 'min',
{
value: function(f)
{
f = f || (v => v);
return this.reduce((a, b) => (f(a) < f(b)) ? a : b);
}
});


Object.defineProperty(Array.prototype, 'max',
{
value: function(f)
{
f = f || (v => v);
return this.reduce((a, b) => (f(a) > f(b)) ? a : b);
}
});


console.log([1,2,3].max());
console.log([1,2,3].max(x => x*(4-x)));
console.log([1,2,3].min());
console.log([1,2,3].min(x => x*(4-x)));

小开

const getMaxFromListByField = (list, field) => {
return list[list.map(it => it[field]).indexOf(Math.max(...list.map(it => it[field])))]
}

小开

对可接受答案的解释和更广义的方法

如果有人在这里找到所有这些键中的最大值（一种广义的方法）：

const temp1 = [
{
"name": "Month 8 . Week 1",
"CATEGORY, Id 0": null,
"CATEGORY, Id 1": 30.666666666666668,
"CATEGORY, Id 2": 17.333333333333332,
"CATEGORY, Id 3": 12.333333333333334,
"TASK, Id 1": 30.666666666666668,
"TASK, Id 2": 12.333333333333334,
"TASK, Id 3": null,
"TASK, Id 4": 5,
"TASK, Id 5": null,
"TASK, Id 6": null,
"TASK, Id 7": null,
"TASK, Id 8": null,
"TASK, Id 9": null,
"TASK, Id 10": null,
"TASK, Id 12": null,
"TASK, Id 14": null,
"TASK, Id 16": null,
"TASK, Id 17": null,
"TASK, Id 26": 12.333333333333334
},
{
"name": "Month 8 . Week 2",
"CATEGORY, Id 0": 38,
"CATEGORY, Id 1": null,
"CATEGORY, Id 2": 12,
"CATEGORY, Id 3": null,
"TASK, Id 1": null,
"TASK, Id 2": 15,
"TASK, Id 3": null,
"TASK, Id 4": null,
"TASK, Id 5": null,
"TASK, Id 6": 5,
"TASK, Id 7": 5,
"TASK, Id 8": 5,
"TASK, Id 9": 5,
"TASK, Id 10": null,
"TASK, Id 12": null,
"TASK, Id 14": null,
"TASK, Id 16": null,
"TASK, Id 17": null,
"TASK, Id 26": 15
},
{
"name": "Month 8 . Week 3",
"CATEGORY, Id 0": 7,
"CATEGORY, Id 1": 12.333333333333334,
"CATEGORY, Id 2": null,
"CATEGORY, Id 3": null,
"TASK, Id 1": null,
"TASK, Id 2": null,
"TASK, Id 3": 12.333333333333334,
"TASK, Id 4": null,
"TASK, Id 5": null,
"TASK, Id 6": null,
"TASK, Id 7": null,
"TASK, Id 8": null,
"TASK, Id 9": null,
"TASK, Id 10": null,
"TASK, Id 12": null,
"TASK, Id 14": 7,
"TASK, Id 16": null,
"TASK, Id 17": null,
"TASK, Id 26": null
},
{
"name": "Month 8 . Week 4",
"CATEGORY, Id 0": null,
"CATEGORY, Id 1": null,
"CATEGORY, Id 2": 10,
"CATEGORY, Id 3": 5,
"TASK, Id 1": null,
"TASK, Id 2": null,
"TASK, Id 3": null,
"TASK, Id 4": null,
"TASK, Id 5": 5,
"TASK, Id 6": null,
"TASK, Id 7": null,
"TASK, Id 8": null,
"TASK, Id 9": null,
"TASK, Id 10": 5,
"TASK, Id 12": 5,
"TASK, Id 14": null,
"TASK, Id 16": null,
"TASK, Id 17": null,
"TASK, Id 26": null
},
{
"name": "Month 8 . Week 5",
"CATEGORY, Id 0": 5,
"CATEGORY, Id 1": null,
"CATEGORY, Id 2": 7,
"CATEGORY, Id 3": null,
"TASK, Id 1": null,
"TASK, Id 2": null,
"TASK, Id 3": null,
"TASK, Id 4": null,
"TASK, Id 5": null,
"TASK, Id 6": null,
"TASK, Id 7": null,
"TASK, Id 8": null,
"TASK, Id 9": null,
"TASK, Id 10": null,
"TASK, Id 12": null,
"TASK, Id 14": null,
"TASK, Id 16": 7,
"TASK, Id 17": 5,
"TASK, Id 26": null
},
{
"name": "Month 9 . Week 1",
"CATEGORY, Id 0": 13.333333333333334,
"CATEGORY, Id 1": 13.333333333333334,
"CATEGORY, Id 3": null,
"TASK, Id 11": null,
"TASK, Id 14": 6.333333333333333,
"TASK, Id 17": null,
"TASK, Id 18": 7,
"TASK, Id 19": null,
"TASK, Id 20": null,
"TASK, Id 26": 13.333333333333334
},
{
"name": "Month 9 . Week 2",
"CATEGORY, Id 0": null,
"CATEGORY, Id 1": null,
"CATEGORY, Id 3": 13.333333333333334,
"TASK, Id 11": 5,
"TASK, Id 14": null,
"TASK, Id 17": 8.333333333333334,
"TASK, Id 18": null,
"TASK, Id 19": null,
"TASK, Id 20": null,
"TASK, Id 26": null
},
{
"name": "Month 9 . Week 3",
"CATEGORY, Id 0": null,
"CATEGORY, Id 1": 14,
"CATEGORY, Id 3": null,
"TASK, Id 11": null,
"TASK, Id 14": null,
"TASK, Id 17": null,
"TASK, Id 18": null,
"TASK, Id 19": 7,
"TASK, Id 20": 7,
"TASK, Id 26": null
}
]


console.log(Math.max(...[].concat([], ...temp1.map(i => Object.values(i))).filter(v => typeof v === 'number')))

需要注意的是Math.max(1, 2, 3)返回3。 Math.max(...[1, 2, 3])也是如此，因为当对象或数组中的所有元素都需要包含在某种列表中时，可以使用扩展语法。

我们将利用这一点！

让我们假设一个数组如下所示：

var a = [{a: 1, b: 2}, {foo: 12, bar: 141}]

目标是找到最大值（在任何属性中），（这里是bar（141））

所以要使用Math.max()，我们需要一个数组中的值（所以我们可以做...arr）

首先让我们把所有的数字分开我们可以确定数组a的每个项目都是一个对象。在遍历每个数组时，Object.values(item)将以数组形式为我们提供该项目的所有值，我们可以使用map生成一个只有值的新数组

所以，

var p = a.map(item => Object.values(item)) // [ [1, 2], [12, 141] ]

此外，使用conat，

[].concat([], ...arr)，或者只是[].concat(...arr) on arr，[ [1, 2], [12, 141] ]将其展平为[1, 2, 12, 141]

所以，

var f = [].concat(...p) // [1, 2, 12, 141]

因为我们现在有一个数组，我们Math.max（… f）：

var m = Math.max(...f) // 141

小开

感谢我在这里找到的答案，希望能对某人有用。可以调用此打字稿函数来搜索数组对象字段中可能存在的最大值：

function getHighestField(objArray: any[], fieldName: string) {
return Number(
Math.max.apply(
Math,
objArray?.map(o => o[fieldName] || 0),
) || 0,
);
}

以此值为例：

const scoreBoard = [
{ name: 'player1', score: 4 },
{ name: 'player2', score: 9 },
{ name: 'player3', score: 7 }
]

您可以通过以下方式调用函数：

const myHighestVariable = `This is the highest: ${getHighestField(scoreBoard, "score")}`;

结果将是这样的：

console.log(myHighestVariable);

这是最高的：9

小开

它返回对象简化@andy polhill answare

var data=[
{
y:90
},
{
y:9
},
{
y:8
}
]




const max = data.reduce((prev, current)=> ( (prev.y > current.y) ? prev : current),0) //returns object
console.log(max)

小开

let List= [{votes:4},{votes:8},{votes:7}]


let objMax = List.reduce((max, curren) => max.votes > curren.votes ? max : curren);


console.log(objMax)

小开

小心null和空以及属性不在数组和空数组中

if ((value && value.length > 0)) {
var maxObj = (value && value.length > 0) value.reduce(function (prev, current) {
return ((parseInt(prev["y"]) || 0) > (parseInt(current["y"]) || 0)) ? prev : current
})
}
{
// else logic here
}