Trovare il valore massimo di un attributo in una matrice di oggetti

Sto cercando un modo davvero rapido, pulito ed efficiente per ottenere il massimo valore "y" nella seguente sezione JSON:

[
  {
    "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
  }
]

Un for-loop è l'unico modo per farlo? Sono appassionato di usare in qualche modo Math.max.

Per trovare il yvalore massimo degli oggetti in array:

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

Trova l'oggetto la cui proprietà "Y" ha il massimo valore in una matrice di oggetti

Un modo sarebbe quello di utilizzare Array ridurre ..

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 e versioni successive)

Se non è necessario supportare IE (solo Edge) o è possibile utilizzare un pre-compilatore come Babel, è possibile utilizzare la sintassi più concisa.

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

ES6 pulito e semplice (Babele)

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

Il secondo parametro dovrebbe garantire un valore predefinito se arrayToSearchInè vuoto.

Confronto di ONELINERS dell'albero che gestiscono il caso meno numeri (input in aarray):

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)

esempio modificabile qui . Idee da: maxA , maxB e maxC (l'effetto collaterale di maxB è che l'array aè cambiato perché sortè sul posto).

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>`;

Per array più grandi Math.max...verrà generata un'eccezione: dimensione massima dello stack di chiamate superata (Chrome 76.0.3809, Safari 12.1.2, data 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) }

Vorrei spiegare passo dopo passo la risposta accettata concisa :

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>');

Ulteriori informazioni:

• Math.max.apply()
• Array.prototype.map()
• Array.from()
• Function.prototype.apply()
• Array.prototype.filter()
• Array.prototype.find()

Bene, prima dovresti analizzare la stringa JSON, in modo da poter accedere facilmente ai suoi membri:

var arr = $.parseJSON(str);

Utilizzare il mapmetodo per estrarre i valori:

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

Quindi è possibile utilizzare l'array nel maxmetodo:

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

O come one-liner:

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

var data = [
  { 'name': 'Vins', 'age': 27 },
  { 'name': 'Jan', 'age': 38 },
  { 'name': 'Alex', 'age': 80 },
  { 'name': 'Carl', 'age': 25 },
  { 'name': 'Digi', 'age': 40 }
];
var max = data.reduce(function (prev, current) {
   return (prev.age > current.age) ? prev : current
});
//output = {'name': 'Alex', 'age': 80}

se tu (o qualcuno qui) sei libero di usare la lodashlibreria di utility, ha una funzione maxBy che sarebbe molto utile nel tuo caso.

quindi puoi usare come tale:

_.maxBy(jsonSlice, 'y');

O un tipo semplice! Mantenerlo reale :)

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

Ogni array e ottiene il massimo valore con la matematica.

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

Ecco la soluzione più breve (One Liner) ES6 :

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

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

Soluzione ES6

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

Per maggiori dettagli consultare https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/max

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