Recherche de la valeur maximale d'un attribut dans un tableau d'objets

Je cherche un moyen très rapide, propre et efficace pour obtenir la valeur maximale "y" dans la tranche JSON suivante:

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

Une boucle for est-elle la seule façon de procéder? Je tiens à utiliser en quelque sorte Math.max.

Pour trouver la yvaleur maximale des objets dans array:

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

Rechercher l'objet dont la propriété "Y" a la plus grande valeur dans un tableau d'objets

Une façon serait d'utiliser la réduction de tableau ..

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 et supérieur)

Si vous n'avez pas besoin de prendre en charge IE (uniquement Edge), ou si vous pouvez utiliser un précompilateur tel que Babel, vous pouvez utiliser la syntaxe la plus laconique.

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

ES6 propre et simple (Babel)

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

Le deuxième paramètre doit garantir une valeur par défaut si arrayToSearchInest vide.

Comparaison des ONELINERS d' arbre qui gèrent le cas des nombres négatifs (entrée dans le atableau):

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)

exemple modifiable ici . Idées de: maxA , maxB et maxC (l'effet secondaire de maxB est que le tableau aest modifié parce qu'il sortest en place).

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

Pour les baies plus grandes, l' Math.max...exception lancera: la taille maximale de la pile d'appels est dépassée (Chrome 76.0.3809, Safari 12.1.2, date 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) }

Je voudrais expliquer la réponse concise acceptée étape par étape:

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

Plus d'informations:

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

Eh bien, vous devez d'abord analyser la chaîne JSON, afin que vous puissiez facilement accéder à ses membres:

var arr = $.parseJSON(str);

Utilisez la mapméthode pour extraire les valeurs:

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

Ensuite, vous pouvez utiliser le tableau dans la maxméthode:

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

Ou en monoplace:

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}

si vous (ou quelqu'un ici) êtes libre d'utiliser la lodashbibliothèque d'utilitaires, elle a une fonction maxBy qui serait très pratique dans votre cas.

vous pouvez donc utiliser comme tel:

_.maxBy(jsonSlice, 'y');

Ou une sorte simple! Garder les choses réelles :)

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

Chaque tableau et obtenez la valeur maximale avec Math.

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

Voici la solution la plus courte (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;
});

Solution ES6

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

Pour plus de détails, voir 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