查找数组中具有最高属性值的对象的索引

Question

我有一个包含对象的数组：

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

Answer 1

有很多方法可以做到这一点，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

Answer 2

Underscore.js 是一个很棒的库，为集合提供功能操作。下划线的解决方案：

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

如果您完全关心性能，那么外部库肯定是您的最佳选择。外部库可以提供大量优化，而这些优化在您自己的代码中是难以匹配的。也就是说，在处理少量项目（少于几千个）时，此处发布的任何答案之间都不会存在明显的性能差异。不要为基准测试而烦恼，并使用您最容易理解的答案。

JSFiddle

Answer 3

怎么样：

articleWithMaxNumber = 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 方法“慢”。这是一个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>")

Answer 4

这是一种可能的解决方案

Javascript

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

这是当前给定方法的performance test，请随时添加答案。

Answer 5

items => 
    items
        .reduce(
            ( highest, item, index ) => 
                item > highest.item 
                    ? { item, index }
                    : highest
        ,   { item: Number.NEGATIVE_INFINITY }
        )
        .index

Answer 6

我不会使用 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 !

只要你的记忆中没有数以万计的文章，那是最快的方法。

Answer 7

array[array.map((o)=>o.number).indexOf(Math.max(...array.map((o)=>o.number)))]

表示获取索引为 (i) 的元素，其中 (i) 是最高数字的索引。