JavaScript：使用对象迭代数组并跟踪项目频率[关闭]

Question

我需要一个函数mostFrequentWord 来返回数组words 中最常见的字符串。我想使用一个对象来跟踪这些词频。使用 getter 和 setter 方法似乎是最可行的选择。其中 setter 函数用于更改表示单词的每个键的值。然后在我按频率值对对象进行排序后，我可以返回频率最高的单词。我是不是在想这个问题？

Answer 1

这是使用Array.prototype.reduce() 解决此问题的方法

var words = ["one", "three", "three", "three", "two", "two"];

var frequencies = words.reduce(function(memo, word) {
    //either start the count now, if this is the first encounter or increas it by 1
    memo[word] = (memo[word] + 1) || 1;
    return memo;
}, {}); // note the empty object being passed in here - that's the initial value for the variable "memo"

console.log(frequencies);

var mostFrequentWord = Object.keys(frequencies)
  .reduce(function(highest, current) {
    return frequencies[highest] > frequencies[current] ? highest : current;
  }, "");

console.log("most frequent word: " + mostFrequentWord + 
"\ncount: " + frequencies[mostFrequentWord])

然后要获得最高值，只需再次运行reduce，只是这次使用Object.keys()

编辑：发表评论：

Is there any advantage to using .reduce() over .forEach() in your first loop? You're just returning the same object every time so it seems that .forEach() would work just as well and perhaps be a little clearer

嗯，这在某种程度上取决于样式 - 这两个 可以 达到相同的结果。不过他们的做法是不同的，我认为出于这个原因reduce 至少具有微不足道的优势。原因如下：

1. reduce 和 forEach 传达不同的意图。虽然它们都可以用来实现相似的结果，但它们操作方式的不同确实使它们对某些操作有点偏颇。

   • 对于reduce，意图是“我想拿走这一系列的东西，通过它并返回一个东西”。例如，它非常适合查找最小值或最大值或总和。因此，如果您在开头有一个数组并希望以其他内容结尾（尽管有时您也可以返回一个数组），您可以使用它。
   • forEach 的意图略有不同——它是“我想浏览这个集合并对每个项目做点什么”。从本质上讲，它适用于当您想要对每个对象执行相同操作时，例如，您可能是 console.logging 它们，或者验证它们或上传它们。通常，您将拥有一些代码，该代码需要一个项目并用它做某事，您只需通过forEach 将其应用于所有项目。

2. reduce 是独立的。它可能看起来不多，并且根据上下文可能不多，但您必须认识到整个功能都包含在reduce 中。这使得在更大的范围内更容易掌握，因为你在一个地方拥有你需要的一切。让我们用forEach 重写它，我会尝试显示不同之处

var words = ["one", "three", "three", "three", "two", "two"];

var frequencies = {}; //<- instantiation needs to be separate

words.forEach(function(word) { //<- population needs to be separate
    frequencies[word] = (frequencies[word] + 1) || 1;
});

console.log(frequencies); //<- usage is separate

因此，您将函数缩短了一行（不返回），但由于变量的实例化而增加了一行。现在看起来完全没问题，因为它是孤立的，但在更大的代码库中，每个部分之间可能都有代码。这使得将所有逻辑都牢记在脑海中变得更加困难 - 如果您仅阅读 forEach 循环，则您没有完整的上下文，因为您需要了解 frequencies 何时你滚动到它，你可能看不到forEach。更重要的是，您甚至不知道frequencies 会处于什么状态，然后您会到达forEach - 它会预先填充一些值吗？它会设置为null吗？它会是一个数组而不是一个对象吗？您不仅需要找到frequencies 的初始声明，而且还必须跟踪如果它在函数被调用之前的任何时间点被更改。

现在，话虽如此，让我们重新检查一下 reduce 的作用 - 所有您需要了解的关于它如何运作的一切都在一个地方。 frequencies 的声明、所有更改和最终分配总是发生在三行代码的范围内，因此无论您有多少代码，您都不需要为上下文找到任何其他内容。是的，您可能需要知道words 包含什么，但是forEach 也是如此。

关于这两点，我想说reduce 更容易理解。 forEach 看起来像更简单的解决方案的唯一原因是，如果您只使用常规的 for 循环来做事情，并且您需要功能替换。然而，声明式方法与命令式方法不同 - forEach 和 for 是不同的。两者都不是天生的更好，但根据情况，它们确实有优点和缺点。在这种情况下，reduce 操作是更好的功能方法。

Answer 2

是这样的：

function inArrayToIndex(value, array){
  for(var i=0,l=array.length; i<l; i++){
    if(array[i] === value){
      return i;
    }
  }
  return false;
}
function mostFrequentWord(wordsArray){
  var h = [], w, a, c = [], m;
  for(var i=0,l=wordsArray.length; i<l; i++){
    w = wordsArray[i]; a = inArrayToIndex(w, h)
    if(a !== false){
      c[a]++;
    }
    else{
      h.push(w); c.push(1);
    }
  }
  return h[inArrayToIndex(Math.max.apply(null, c), c)];
}
var mostest = mostFrequentWord(yourWordsArray);

Answer 3

感谢所有输入的家伙和女孩。以下是我解决它的方法。

首先我从一个辅助函数开始：

function getTokens(rawString) {
  // returns an alphabetically sorted list of words, removing punctuation
  // characters
  return rawString.toLowerCase().split(/[ ,!.";:-]+/).filter(Boolean).sort();
}

然后我的主要功能如下：

function mostFrequentWord(words) { 
  var wordsArray = getTokens(words);           // setup array for strings to live
  var wordsObject = {};                        // Setup object literal for words + count

  for (var i=0; i<wordsArray.length; i++) {
    var wordToCheck = wordsArray[i];
    if (wordsObject[wordToCheck] == undefined) {
      // word doesn't exist, let's add it as a key and set value pair to 1
      console.log(wordToCheck + " not found. Adding to object.");
      wordsObject[wordToCheck] = 1;
    } else {
      // word does exist, let's increment the value pair by 1
      console.log(wordToCheck + " has been found. Incrementing.");
      wordsObject[wordToCheck] += 1;
    }
  }

console.log(wordsObject);
var mostFrequent;

  for (var key in wordsObject) {
    if (mostFrequent == undefined) {
      mostFrequent = key;
    } else if (wordsObject[key] > wordsObject[mostFrequent]) {
       mostFrequent = key;
    }
  }

console.log("Most frequent word is: " + mostFrequent);
return mostFrequent;

}

Answer 4

这是另一个解决方案，它使用lodash

var words = ["bob", "bill", "jimmy", "jack", "bob", "bob", "jimmy"];
    freq = {};

_.forEach(words, function (word) {
  freq[word] = freq[word]++ || 1;
});

var max = 0,
    mostFreq = undefined;

_.forEach(freq, function (count, word) {
  if (count > max) {
    max = count;
    mostFreq = word;
  }
});

console.log(mostFreq);

<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.15.0/lodash.min.js"></script>

for each 函数在 javascript 中是原生的，但仅适用于数组。使用 lodash，您可以遍历数组的每个元素，或对象的每个键值对。将 _.forEach 与对象一起使用时，传递给回调的第一个参数是值，第二个参数是对象中每一对的键。你应该看看 lodash 文档。它们提供了一些非常有用的工具。

Answer 5

您可以使用一个对象来保存一个单词索引计数，然后遍历计数以获得最高的计数。这是一个有效的 sn-p 说明：

function findMostFrequent(array) {
    var map = {};
    
    array.forEach(function(item) {
        map[item] = (map[item] || 0) + 1;
    });

    // find highest word count
    var highWord = Object.keys(map).reduce(function(highestWord, currentWord) {
        return map[currentWord] > map[highestWord] ? currentWord : highestWord;
    });
    return {word: highWord, count: map[highWord]};
}

var words = ["hello", "goodbye", "hello", "hello", "whatever", "something", "goodbye"];

var result = findMostFrequent(words);
console.log("highest count word is " + result.word + ", count = " + result.count);

在 ES6 中，您可以使用 Map 对象而不是普通的 JS 对象来保存计数，尽管这两种方式的实现几乎没有区别。