我有一个包含对象的数组：
var articles = [];
var article = {};
Simple loop that iterates x times {
article.text = "foobar";
article.color = "red";
article.number = 5;
articles.push(article);
}
我不知道我的数组中会有多少个对象，但它们的属性值都不同，这里只是举了一些例子。
问题：
我需要找到一种方法来遍历所有这些对象，并检索拥有最高article.number值的对象的索引。如何实现？我只能使用javascript、jQuery等语言，不能使用其他语言。
我猜这将涉及到使用$.grep和Math.max，但我卡住了，我以前从未使用过$.grep。
简而言之：
var highestNumber = index of object where article.number is highest
有许多方法可以做到这一点，包括Math.max()、$.grep和$.map等等，但一个易于理解的简单可读的方法是迭代对象并检查值是否大于某个变量，如果是，则将变量设置为更高的数字:
var highest = 0;
$.each(articles, function(key, article) {
if (article.number > highest) highest = article.number;
});
// highest now contains the highest number
$.each 的执行速度相对较慢。手写的 while 或 for 循环会更快。 - Alnitakfor 循环，因为我不知道它与其他方法在性能上的差异。同时，我添加了一行代码来跟踪对象的索引，这是我的主要目标。总的来说，这个答案对我帮助最大。 - RijstkoekUnderscore.js 是一个提供集合函数式操作的优秀库。下面是 Underscore 的解决方案：
var maxObj = _.max(array, function (obj) {
return obj.number;
});
var maxIndex = array.indexOf(maxObj);
虽然这个例子相当简单，但操作可以很好地扩展。假设你想要对数组中每个具有文本等于Foo和颜色等于red的对象的数字属性求和：
var customSum = _.chain(array)
.where({
text: "Foo", color: "red"
})
.map(function(obj) {
return obj.number;
})
.reduce(function(memo, num) {
return memo + num;
}, 0)
.value();
如果您关心性能，使用外部库肯定是最好的选择。外部库可以提供大量优化，这些优化很难在自己的代码中实现。话虽如此，当处理少量数据（少于几千个）时，在这里发布的任何答案之间不会有明显的性能差异。不要过分担心基准测试，使用对您来说最易理解的答案。
_.maxBy 是一个易于使用的替代 ljfranklin 方法的选择。https://lodash.com/docs#maxBy - DefiantarticleWithMaxNumber = articles.slice(0).sort(
function(x, y) { return y.number - x.number })[0]
如果你需要一个索引：
index = articles.indexOf(articleWithMaxNumber)
对于那些认为排序可能是获取最大值的过度操作的人：
articleWithMaxNumber = articles.reduce(function(max, x) {
return x.number > max.number ? x : max;
})
以下是使用map-reduce查找函数应用的最大值的通用方法：
function maxBy(array, fn) {
return array.map(function(x) {
return [x, fn(x)]
}).reduce(function(max, x) {
return x[1] > max[1] ? x : max;
})[0]
}
articleWithMaxNumber = maxBy(articles, function(x) { return x.number })
sort方法比迭代方法“慢”，与此相关的IT技术。这里有一个fiddle，使用这两种方法处理了一个包含50000个元素的数组。在我的计算机上，sort方法比迭代方法“慢”约50毫秒。视应用而定，但在大多数情况下，这不是值得谈论的事情。
var articles = [];
var len = 50000;
while (len--) {
var article = {};
article.text = "foobar";
article.color = "red";
article.number = Math.random();
articles.push(article);
}
d = performance.now();
max1 = articles.slice(0).sort(
function(x, y) {
return y.number - x.number
})[0]
time1 = performance.now() - d
d = performance.now();
max2 = articles.reduce(function(max, x) {
return x.number > max.number ? x : max;
})
time2 = performance.now() - d
document.body.innerHTML = [time1, time2].join("<br>")O(n log n)，而查找算法的复杂度为O(n)。肯定会有一个交叉点，但是Bergi是正确的，您不应该仅仅为了找到数组的最大值而对其进行排序。问题在于您无法提前知道这个交叉点在哪里，但是让一个基于排序的答案不受挑战也不是一个选项。 - Alnitakitems =>
items
.reduce(
( highest, item, index ) =>
item > highest.item
? { item, index }
: highest
, { item: Number.NEGATIVE_INFINITY }
)
.index
var articles = [],
howMany = 5,
i = 0,
article,
highest;
while (i < howMany) {
article = {};
article.text = "foobar";
article.color = "red";
article.number = i;
articles.push(article);
i += 1;
}
console.log(articles);
hownMany = articles.length;
i = 0;
while (i < howMany) {
if (typeof highest !== "number" || articles[i].number > highest) {
highest = i;
}
i += 1;
}
console.log(articles[highest]);
在jsfiddle上
这里是当前给出方法的性能测试，请随意添加答案。
hasOwnProperty进行了保护！ - Bergitypeof 测试的意义在哪里？如果输入数据正确，它永远不会失败。 - Alnitakhighest = 0 和 i = 1 开始吗？不重复这个条件会更快... - Bergiarray[array.map((o)=>o.number).indexOf(Math.max(...array.map((o)=>o.number)))]
意思是获取具有最高数字索引（i）的元素，其中（i）是索引。
我不会使用任何类似于Math或jQuery的东西，只需对结果数组进行排序并弹出最后一个元素：
var sortArticles = function (a, b)
{
return ( a.number - b.number ); // should have some type checks ? inverse order: swap a/b
}
articles.sort(sortArticles);
highestArticle = articles.pop(); // or articles[array.length-1];
// take care if srticles.length = null !
howMany = 5，任何测量都是有缺陷的。无论你选择哪种方法，计算都在亚微秒内完成。此答案值得一赞，因为它提到了排序简单而短小，但如果你有数不清的文章，排序可能会相对较慢。 - Bergi