オブジェクトの配列があり、それらのオブジェクトを特定のオブジェクトプロパティで比較したい。これが私の配列です：
var myArray = [
{"ID": 1, "Cost": 200},
{"ID": 2, "Cost": 1000},
{"ID": 3, "Cost": 50},
{"ID": 4, "Cost": 500}
]
具体的には「コスト」に焦点を当てて、最小値と最大値を取得します。コストの値を取得してJavaScript配列にプッシュしてから、Fast JavaScript Max / Minを実行できることを理解しています。
しかし、途中で配列のステップをバイパスし、オブジェクトのプロパティ（この場合は「コスト」）を直接オフにすることで、これを行う簡単な方法はありますか？
回答:
この場合の最速の方法は、すべての要素をループして、それまでの最高値/最低値と比較することです。
（配列の作成、配列メソッドの呼び出しは、この単純な操作には過剰です）。
// 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);
lowest=highest=myArray[0]し、その後1でループを開始
myArray[0].Costです。ただし、最初の要素がない場合は、エラーがスローされます。そのため、追加のチェックが必要です。小さなパフォーマンスの向上を取り消す可能性があります。
var lowestObject; for (...)、if (tmp < lowest) { lowestObject = myArray[i]; lowest = tmp; }
reduceは、次のようなものに適しています。オブジェクトの配列に対して集約操作（min、max、avgなど）を実行し、単一の結果を返します。
myArray.reduce(function(prev, curr) {
return prev.Cost < curr.Cost ? prev : curr;
});
...または、ES6関数構文を使用してその内部関数を定義できます。
(prev, curr) => prev.Cost < curr.Cost ? prev : currあなたが可愛くなりたいなら、これを配列に付けることができます：
Array.prototype.hasMin = function(attrib) {
return (this.length && this.reduce(function(prev, curr){
return prev[attrib] < curr[attrib] ? prev : curr;
})) || null;
}
今、あなたはただ言うことができます：
myArray.hasMin('ID') // result: {"ID": 1, "Cost": 200}
myArray.hasMin('Cost') // result: {"ID": 3, "Cost": 50}
myEmptyArray.hasMin('ID') // result: null
これを使用する場合、すべての状況を完全にチェックできるわけではないことに注意してください。プリミティブ型の配列を渡すと、失敗します。存在しないプロパティを確認する場合、またはすべてのオブジェクトにそのプロパティが含まれていない場合は、最後の要素を取得します。このバージョンは少しかさばりますが、次の点が確認されています。
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;
}
prev.Costが未定義にならないのですか？それとも0として開始しますか？
sort変更される配列を気にしない場合は、を使用してください。
myArray.sort(function (a, b) {
return a.Cost - b.Cost
})
var min = myArray[0],
max = myArray[myArray.length - 1]
myArray予期しないことです。
O(nlog(n))、配列をトラバース：O(n)
Math関数を使用して、必要な値を取り出しますmap。
ここに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
更新：
ES6を使用する場合：
var min = Math.min.apply(null, myArray.map(item => item.Cost)),
max = Math.max.apply(null, myArray.map(item => item.Cost));
apply。単に言う- Math.min(...myArray.map(o => o.Cost))最小値 Math.max(...myArray.map(o => o.Cost))を見つけるためと最大値を見つけるため。
ロブWの答えは正解（+1）だと思いますが、楽しみのためだけです。「賢い」になりたい場合は、次のようなことを行うことができます。
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"));
または、深くネストされた構造がある場合は、もう少し機能的にして、以下を実行できます。
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; }));
これらは、より便利で特定の形式に簡単にカレー化できます。
試してください（aは配列、fは比較するフィールドです）
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);Array.prototype.reduce（）を使用すると、コンパレータ関数をプラグインして、配列内の最小、最大などの項目を決定できます。
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;使用するMath.minと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);これはより良い解決策です
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の答え（+ es6を使用）に追加して、コールバックを受け入れる関数を作成できます。これには、prevandに適用する演算子が含まれます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その後、次のようにして呼び出すだけです。
const costMin = compare(myArray, 'Cost', (a, b) => a < b);
const costMax = compare(myArray, 'Cost', (a, b) => a > b);これは、lodashのminByand maxBy関数で実現できます。
Lodash minByとmaxByドキュメント
_.minBy(array, [iteratee=_.identity])
_.maxBy(array, [iteratee=_.identity])これらのメソッドは、配列内の各要素に対して呼び出されるiterateeを受け入れ、値がランク付けされる基準を生成します。iterateeは1つの引数で呼び出されます：（値）。
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>2つのアプローチで問題を解決することができます。両方の方法はすでに上記で説明されていますが、パフォーマンステストが欠落していたため、その1つを完了します
1、ネイティブのJavaスクリプトの方法
2、最初にオブジェクトをソートしてから、ソートされたobjからmin maxを取得するのが簡単
私は両方の牽引アプローチのパフォーマンスもテストします
また、実行してパフォーマンスをテストすることもできます...ハッピーコーディング（：
//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)簡潔で最新のソリューションの場合reduce、現在の最小値と最大値を追跡しながら、配列に対して操作を実行できるため、配列は1回だけ反復されます（これが最適です）。
let [min, max] = myArray.reduce(([prevMin,prevMax], {Cost})=>
[Math.min(prevMin, Cost), Math.max(prevMax, Cost)], [Infinity, -Infinity]);デモ：