Comparez un tableau d'objets JavaScript pour obtenir le minimum et le maximum.

Question

J'ai un tableau d'objets et je veux comparer ces objets sur une propriété spécifique de l'objet. Voici mon tableau :

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

Je voudrais me concentrer sur le "coût" spécifiquement et obtenir une valeur minimale et maximale. Je me rends compte que je peux simplement récupérer les valeurs de coût et les placer dans un tableau javascript, puis exécuter la fonction JavaScript rapide Max/Min .

Cependant, existe-t-il un moyen plus simple de le faire en contournant l'étape du tableau au milieu et en utilisant directement les propriétés de l'objet (dans ce cas, "Coût") ?

Answer 1

Je pense La réponse de Rob W est vraiment la bonne (+1), mais juste pour le plaisir : si vous vouliez être "intelligent", vous pourrait faire quelque chose comme ça :

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

ou si vous aviez une structure profondément imbriquée, vous pourriez être un peu plus fonctionnel et faire ce qui suit :

var myArray = 
[
    {"ID": 1, "Cost": { "Wholesale":200, Retail: 250 }},
    {"ID": 2, "Cost": { "Wholesale":1000, Retail: 1010 }},
    {"ID": 3, "Cost": { "Wholesale":50, Retail: 300 }},
    {"ID": 4, "Cost": { "Wholesale":500, Retail: 1050 }}
]

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

alert(finder(Math.max, myArray, function(x) { return x.Cost.Wholesale; }));
alert(finder(Math.min, myArray, function(x) { return x.Cost.Retail; }));

Elles pourraient facilement être transformées en formes plus utiles/spécifiques.

Answer 2

Essayez ( a est un tableau, f est le champ à comparer)

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

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

// TEST

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

console.log('Max Cost', max(myArray, 'Cost'));
console.log('Min Cost', min(myArray, 'Cost'));

console.log('Max ID', max(myArray, 'ID'));
console.log('Min ID', min(myArray, 'ID'));

Answer 3

Pour Max

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

pour min

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

Answer 4

Ceci peut être réalisé avec la fonction minBy y maxBy fonctions.

Lodash's minBy y maxBy documentation

_.minBy(array, [iteratee=_.identity])

_.maxBy(array, [iteratee=_.identity])

Ces méthodes acceptent une itération qui est invoquée pour chaque élément de la liste. tableau pour générer le critère par lequel la valeur est classée. L'itération est invoquée avec un argument : (valeur).

Solution

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

const minimumCostItem = _.minBy(myArray, "Cost");

console.log("Minimum cost item: ", minimumCostItem);

// Getting the maximum using a functional iteratee
const maximumCostItem = _.maxBy(myArray, function(entry) {
  return entry["Cost"];
});

console.log("Maximum cost item: ", maximumCostItem);

<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.15/lodash.js"></script>

Answer 5

Utilisation de Array.prototype.reduce() vous pouvez insérer des fonctions de comparaison pour déterminer l'élément minimum, maximum, etc. d'un tableau.

var items = [
  { name : 'Apple',  count : 3  },
  { name : 'Banana', count : 10 },
  { name : 'Orange', count : 2  },
  { name : 'Mango',  count : 8  }
];

function findBy(arr, key, comparatorFn) {
  return arr.reduce(function(prev, curr, index, arr) { 
    return comparatorFn.call(arr, prev[key], curr[key]) ? prev : curr; 
  });
}

function minComp(prev, curr) {
  return prev < curr;
}

function maxComp(prev, curr) {
  return prev > curr;
}

document.body.innerHTML  = 'Min: ' + findBy(items, 'count', minComp).name + '<br />';
document.body.innerHTML += 'Max: ' + findBy(items, 'count', maxComp).name;