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

C'est une meilleure solution

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

Answer 2

En complément de la réponse de Tristan Reid (+ utilisation de es6), vous pouvez créer une fonction qui accepte un callback, qui contiendra l'opérateur que vous voulez appliquer à la fonction prev y curr :

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

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

Vous pourriez alors simplement l'appeler "utiliser" :

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

Answer 3

Pour une solution concise et moderne, on peut effectuer une reduce sur le tableau, en gardant la trace des valeurs minimales et maximales actuelles, afin que le tableau ne soit itéré qu'une seule fois (ce qui est optimal).

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

Démonstration :

var myArray = [
    {"ID": 1, "Cost": 200},
    {"ID": 2, "Cost": 1000},
    {"ID": 3, "Cost": 50},
    {"ID": 4, "Cost": 500}
]
let [min, max] = myArray.reduce(([prevMin,prevMax], {Cost})=>
   [Math.min(prevMin, Cost), Math.max(prevMax, Cost)], [Infinity, -Infinity]);
console.log("Min cost:", min);
console.log("Max cost:", max);

Answer 4

nous pouvons résoudre le problème par deux approches les deux méthodes sont déjà expliquées ci-dessus, mais le test de performance était manquant, donc il faut le compléter.

1, voie native java-script.
2, d'abord trier l'objet puis il est facile d'obtenir min max de l'objet trié

Je teste également les performances des deux approches de remorquage

vous pouvez également exécuter et tester les performances... Bon codage ( :

//first approach 

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

var t1 = performance.now();;

let max=Math.max.apply(Math, myArray.map(i=>i.Cost))

let min=Math.min.apply(Math, myArray.map(i=>i.Cost))

var t2   = performance.now();;

console.log("native fuction took " + (t2 - t1) + " milliseconds.");

console.log("max Val:"+max)
console.log("min Val:"+min)

//  Second approach:

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

var s1 = performance.now();;
sortedArray=myArray.sort(sortFunc)

var minBySortArray = sortedArray[0],
    maxBySortArray = sortedArray[myArray.length - 1]

var s2   = performance.now();;
 console.log("sort funciton took  " + (s2 - s1) + " milliseconds.");  
console.log("max ValBySortArray :"+max)
console.log("min Val BySortArray:"+min)

Answer 5

max = totalAVG.reduce(function (a, b) { return Math.max(a, b)}, -Infinity);

min = totalAVG.reduce(function (a, b) {return Math.min(a, b)}, Infinity);