Bir dizi nesnem var ve bu nesneleri belirli bir nesne özelliği üzerinde karşılaştırmak istiyorum. İşte dizim:

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

Özellikle "maliyet" üzerine sıfırlamak ve bir minimum ve maksimum değer elde etmek istiyorum. Maliyet değerlerini alıp bir javascript dizisine aktarabileceğimi ve ardından Hızlı JavaScript Maks / Min'i çalıştırabileceğimi fark ettim .

Bununla birlikte, ortadaki dizi adımını atlayarak ve doğrudan nesnelerin özelliklerinden (bu durumda "Maliyet") çıkarak bunu yapmanın daha kolay bir yolu var mı?

Bunun bir yolu, tüm öğeler arasında döngü yapmak ve bunu en yüksek / en düşük değerle karşılaştırmaktır.

(Bir dizi oluşturmak, dizi yöntemlerini çağırmak bu basit işlem için aşırıdır).

 // There's no real number bigger than plus Infinity
var lowest = Number.POSITIVE_INFINITY;
var highest = Number.NEGATIVE_INFINITY;
var tmp;
for (var i=myArray.length-1; i>=0; i--) {
    tmp = myArray[i].Cost;
    if (tmp < lowest) lowest = tmp;
    if (tmp > highest) highest = tmp;
}
console.log(highest, lowest);

Azaltma, şunun gibi şeyler için iyidir: bir dizi nesne üzerinde toplu işlemler (min, maks, ortalama, vb.) Gerçekleştirmek ve tek bir sonuç döndürmek için:

myArray.reduce(function(prev, curr) {
    return prev.Cost < curr.Cost ? prev : curr;
});

... veya bu iç işlevi ES6 işlev sözdizimi ile tanımlayabilirsiniz:

(prev, curr) => prev.Cost < curr.Cost ? prev : curr

Sevimli olmak istiyorsanız, bunu diziye ekleyebilirsiniz:

Array.prototype.hasMin = function(attrib) {
    return (this.length && this.reduce(function(prev, curr){ 
        return prev[attrib] < curr[attrib] ? prev : curr; 
    })) || null;
 }

Şimdi şunu söyleyebilirsin:

myArray.hasMin('ID')  // result:  {"ID": 1, "Cost": 200}
myArray.hasMin('Cost')    // result: {"ID": 3, "Cost": 50}
myEmptyArray.hasMin('ID')   // result: null

Lütfen bunu kullanmayı planlıyorsanız, her durum için tam kontrollerin olmadığını unutmayın. Bir dizi ilkel türden geçerseniz, başarısız olur. Var olmayan bir özelliği kontrol ederseniz veya tüm nesneler bu özelliği içermiyorsa, son öğeyi alırsınız. Bu sürüm biraz daha hantal, ancak şu kontrollere sahip:

Array.prototype.hasMin = function(attrib) {
    const checker = (o, i) => typeof(o) === 'object' && o[i]
    return (this.length && this.reduce(function(prev, curr){
        const prevOk = checker(prev, attrib);
        const currOk = checker(curr, attrib);
        if (!prevOk && !currOk) return {};
        if (!prevOk) return curr;
        if (!currOk) return prev;
        return prev[attrib] < curr[attrib] ? prev : curr; 
    })) || null;
 }

sortDizinin değiştirilmesiyle ilgilenmiyorsanız kullanın .

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

var min = myArray[0],
    max = myArray[myArray.length - 1]

MathFonksiyonları kullanın ve istediğiniz değerleri çıkarın map.

İşte jsbin:

https://jsbin.com/necosu/1/edit?js,console

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

  min = Math.min.apply(null, myArray.map(function(item) {
    return item.Cost;
  })),
  max = Math.max.apply(null, myArray.map(function(item) {
    return item.Cost;
  }));

console.log('min', min);//50
console.log('max', max);//1000

GÜNCELLEME:

ES6 kullanmak istiyorsanız:

var min = Math.min.apply(null, myArray.map(item => item.Cost)),
    max = Math.max.apply(null, myArray.map(item => item.Cost));

Bence Rob W'nin cevabı gerçekten doğru cevap (+1), ama sadece eğlenmek için: "zeki" olmak istiyorsan, şöyle bir şey yapabilirsin:

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

veya derinlemesine iç içe geçmiş bir yapınız varsa, biraz daha işlevsel hale gelebilir ve aşağıdakileri yapabilirsiniz:

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

Bunlar kolaylıkla daha kullanışlı / özel biçimlere dönüştürülebilir.

Try ( adizidir, fkarşılaştırılacak alandır)

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

Max için

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

dakika için

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

Array.prototype.reduce () kullanarak , bir dizideki min, max, vb. Öğeleri belirlemek için karşılaştırma işlevlerini ekleyebilirsiniz.

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;

Kullanılması Math.minve Math.max:

var myArray = [
    { id: 1, cost: 200},
    { id: 2, cost: 1000},
    { id: 3, cost: 50},
    { id: 4, cost: 500}
]


var min = Math.min(...myArray.map(item => item.cost));
var max = Math.max(...myArray.map(item => item.cost));

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

Bu daha iyi bir çözüm

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

Tristan Reid'in cevabına (+ es6 kullanarak) ekleyerek, geri aramayı kabul eden bir işlev yaratabilirsin, bu fonksiyonun uygulanmasını istediğiniz operatörü prevve 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

O zaman bunu kullanarak arayabilirsiniz:

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

Bu, Lodash minByvemaxBy işlevlerle .

Lodash minByve maxBybelgeler

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

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

Bu yöntemler, değerin sıralandığı kriteri oluşturmak için dizideki her öğe için çağrılan bir yinelemeyi kabul eder. Yineleme, bir bağımsız değişkenle çağrılır: (değer).

Çözüm

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>

problemi iki yaklaşımla çözebiliriz, her iki yöntem de yukarıda açıklanmıştır ancak performans testi eksikti, bu yüzden onu tamamlamak

1, yerel java-script yolu
2, önce nesneyi sıralayın, ardından sıralanmış nesneden minimum maksimum elde etmek kolaydır

Ayrıca her iki çekme yaklaşımının performansını da test ediyorum

ayrıca performansı çalıştırabilir ve test edebilirsiniz ... Mutlu kodlamalar (:

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

Kısa ve modern bir çözüm için, reducemevcut minimum ve maksimum değerleri takip ederek dizi üzerinde bir işlem gerçekleştirilebilir , böylece dizi yalnızca bir kez yinelenir (en uygun olanıdır).

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

Demo:

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

Başka bir soru, Kennebec'in cevabına benzer, ancak hepsi tek satırda:

maxsort = myArray.slice(0).sort(function (a, b) { return b.ID - a.ID })[0].ID; 

Bunun yerine Math.max / Math.min'i kullanmak için yerleşik Array nesnesini kullanabilirsiniz:

var arr = [1,4,2,6,88,22,344];

var max = Math.max.apply(Math, arr);// return 344
var min = Math.min.apply(Math, arr);// return 1