An array function that returns an array containing all elements appearing a certain number of times

Question

Array.prototype.itemsWithQuantity = function(n) {
    var counts = {};
    var result = [];
    var i = this.length;
    while(i--){
        counts[this[i]] = counts[this[i]] == undefined ? 1 : counts[this[i]] + 1;       
    }
    i = this.length;
    var alreadyPushed = {};
    while(i--){
        if(counts[this[i]] == n && !alreadyPushed[this[i]]){
            alreadyPushed[this[i]] = true;
            result.push(this[i]);
        }       
    }
    return result;
};

Above is my function that returns all the items in an array with a certain quantity. E.g., [1,2,3,2,3,4].itemsWithQuantity(2) == [2,3].

Not only is the code kinda ugly, but I also have a feeling there's a more efficient way to do it that I'm not spotting.

Answer 1

I guess you could use Array.forEach() to do the counting and laterArray.filter() to get the elements with the desired number of occurences.

It reduces the bookkeeping to the minimum of counts, goodbye alreadyPushed. It also reduces the boilerplateness a little, by giving you local variables implicitely:

• You have this[i] everywhere, which can look a little cryptic. You could store it in a local var element = this[i]; which could be considered more readable.
• in my suggested code, you get those local variables as a result of using functions that receive the value as a parameter which you can of course name however you want.

I think it depends on how much you are used to seeing certain patterns show up in code. After doing it for a while, you know that

var i = this.length;
while(i--){ //...}

will iterate over all the elements. Array.forEach() calls it by its name, which can improve readability.

I had my first ever go at the built in scripting thingy here on stackexchange, take a look and try the code:

Array.prototype.itemsWithQuantity = function(n) {
  var counts = {};

  // count
  this.forEach(function(element) {
    counts[element] = counts[element] == undefined ? 1 : counts[element] + 1
  });

  // return those elements (which are the keys(=property names) of the object) occuring n times
  return Object.keys(counts).filter(function(element) {
    return counts[element] == n;
  });
};

var input = [1, 2, 3, 3, 4, 1, 2, 5];
var output = input.itemsWithQuantity(2);

document.getElementById("output").innerHTML = output.toString();

<p id="output"></p>

Answer 2

You can (ab-)use the short-circuit logic of Javascript to make the last line a little more readable:

counts[this[i]] = (counts[this[i]] || 0) + 1;

Answer 3

I would use Javascripts ability to reduce Arrays (see MDN).

function itemByFrequency(arr, freq){
    function countFrequencies(o,n){
      o[n] = o[n] || 0;
      o[n] += 1;
      return o;
    };
    var fr = arr.reduce(countFrequencies, {});
    function filterFrequencies(o,n){
        if (fr[n]==freq) o.push(n);
        return o;
    }
    return Object.keys(fr).reduce(filterFrequencies, []);
}

Here is an example glot.io

Answer 4

One could combine string-methods with array-methods. So that the used loops are reduced.

function getElementsWithCount(arr, requiredCount) {
  var arrAsString = arr.join(', ');
  var ret = [];
  var alreadyChecked = [];

  for (var i = 0; i < arr.length; i++) {
    // If the element is already in one of the two
    //   collector-arrays then continue.
    if ( ret.indexOf(arr[i]) !== -1 || 
         alreadyChecked.indexOf(arr[i]) !== -1 ) {
      continue;
    }

    var regExp =
        new RegExp('(^|\\s)' + arr[i] + '($|,)', 'g');

    // Compare the occurences within the string with 
    // demanded count.
    arrAsString.match(regExp).length === requiredCount ? 
      ret.push(arr[i]) : 
      alreadyChecked.push(arr[i]);
  }

  return ret;
}

var field = [1,2,3,2,3,4];

console.log( getElementsWithCount(field, 2) );

The for-loop is necessary because I want to use continue. Which isn't possible with forEach.