Contando las ocurrencias / frecuencia de los elementos del arreglo

Puede usar un objeto para contener los resultados:

var arr = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4];
var counts = {};

for (var i = 0; i < arr.length; i++) {
  var num = arr[i];
  counts[num] = counts[num] ? counts[num] + 1 : 1;
}

console.log(counts[5], counts[2], counts[9], counts[4]);

Por lo tanto, ahora su objeto counts puede decirle cuál es el conteo para un número en particular:

console.log(counts[5]); // logs '3'

Si desea obtener una matriz de miembros, simplemente use las funciones keys()

keys(counts); // returns ["5", "2", "9", "4"]

var a = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4].reduce(function (acc, curr) {
  if (typeof acc[curr] == 'undefined') {
    acc[curr] = 1;
  } else {
    acc[curr] += 1;
  }

  return acc;
}, {});

// a == {2: 5, 4: 1, 5: 3, 9: 1}

Si se usa el guion bajo o lodash, esto es lo más simple que se puede hacer:

_.countBy(array);

Tal que:

_.countBy([5, 5, 5, 2, 2, 2, 2, 2, 9, 4])
=> Object {2: 5, 4: 1, 5: 3, 9: 1}

Como han señalado otros, puede ejecutar las funciones _.keys() y _.values() en el resultado para obtener solo los números únicos y sus ocurrencias, respectivamente. Pero en mi experiencia, el objeto original es mucho más fácil de tratar.

No use dos matrices para el resultado, use un objeto:

a      = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4];
result = { };
for(var i = 0; i < a.length; ++i) {
    if(!result[a[i]])
        result[a[i]] = 0;
    ++result[a[i]];
}

Entonces result se verá como:

{
    2: 5,
    4: 1,
    5: 3,
    9: 1
}

¿Qué tal una opción ECMAScript2015?

const a = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4];

const aCount = new Map([...new Set(a)].map(
    x => [x, a.filter(y => y === x).length]
));

aCount.get(5)  // 3
aCount.get(2)  // 5
aCount.get(9)  // 1
aCount.get(4)  // 1

Este ejemplo pasa la matriz de entrada a la Set constructor creando una colección de valores únicos. La sintaxis spread luego expande estos valores en una nueva matriz para que podamos llamar a map y traducir esto en una matriz bidimensional de pares [value, count], es decir, la siguiente estructura:

Array [
   [5, 3],
   [2, 5],
   [9, 1],
   [4, 1]
]

El nuevo array se pasa entonces al Map constructor que resulta en un objeto iterable:

Map {
    5 => 3,
    2 => 5,
    9 => 1,
    4 => 1
}

Lo mejor de un objeto Map es que conserva los tipos de datos, es decir, aCount.get(5) regresará 3 pero aCount.get("5") regresará undefined. También permite que cualquier valor / tipo actúe como clave, lo que significa que esta solución también funcionará con una matriz de objetos.

function frequencies(/* {Array} */ a){
    return new Map([...new Set(a)].map(
        x => [x, a.filter(y => y === x).length]
    ));
}

let foo = { value: 'foo' },
    bar = { value: 'bar' },
    baz = { value: 'baz' };

let aNumbers = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4],
    aObjects = [foo, bar, foo, foo, baz, bar];

frequencies(aNumbers).forEach((val, key) => console.log(key + ': ' + val));
frequencies(aObjects).forEach((val, key) => console.log(key.value + ': ' + val));

Creo que esta es la forma más sencilla de contar las ocurrencias con el mismo valor en una matriz.

var a = [true, false, false, false];
a.filter(function(value){
    return value === false;
}).length

const data = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4]

function count(arr) {
  return arr.reduce((prev, curr) => (prev[curr] = ++prev[curr] || 1, prev), {})
}

console.log(count(data))

Si prefiere un solo revestimiento.

arr.reduce(function(countMap, word) {countMap[word] = ++countMap[word] || 1;return countMap}, {});

Editar (6/12/2015) : La Explicación de adentro hacia afuera. countMap es un mapa que mapea una palabra con su frecuencia, de la que podemos ver la función anonymous. Lo que reduce hace es aplicar la función con argumentos como todos los elementos del array y countMap siendo pasado como el valor devuelto de la última llamada a la función. El último parámetro ({}) es el valor predeterminado de countMap para la primera llamada a la función.

Si está utilizando el guion bajo, puede ir por la ruta funcional

a = ['foo', 'foo', 'bar'];

var results = _.reduce(a,function(counts,key){ counts[key]++; return counts },
                  _.object( _.map( _.uniq(a), function(key) { return [key, 0] })))

Así que su primera matriz es

_.keys(results)

Y el segundo array es

_.values(results)

La mayor parte de esto será por defecto a las funciones nativas de javascript si están disponibles

Demo: http://jsfiddle.net/dAaUU /

Basado en respuesta de @adamse y @pmandell (que yo upvote), en ES6 usted puede hacerlo en una línea:

• 2017 editar: Uso || para reducir el tamaño del código y hacerlo más legible.

var a=[7,1,7,2,2,7,3,3,3,7,,7,7,7];
alert(JSON.stringify(

a.reduce((r,k)=>{r[k]=1+r[k]||1;return r},{})

));

Se puede usar para contar caracteres :

var s="ABRACADABRA";
alert(JSON.stringify(

s.split('').reduce((a, c)=>{a[c]++?0:a[c]=1;return a},{})

));

La versión ES6 debe ser mucho más simple (otra solución de una línea)

let arr = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4];
let acc = arr.reduce((acc, val) => acc.set(val, 1 + (acc.get(val) || 0)), new Map());

console.log(acc);
// output: Map { 5 => 3, 2 => 5, 9 => 1, 4 => 1 }

Un mapa en lugar de un objeto simple nos ayuda a distinguir diferentes tipos de elementos, o de lo contrario todos los recuentos se basan en cadenas

Podría extender el prototipo de matriz, así:

Array.prototype.frequencies = function() {
    var l = this.length, result = {all:[]};
    while (l--){
       result[this[l]] = result[this[l]] ? ++result[this[l]] : 1;
    }
    // all pairs (label, frequencies) to an array of arrays(2)
    for (var l in result){
       if (result.hasOwnProperty(l) && l !== 'all'){
          result.all.push([ l,result[l] ]);
       }
    }
    return result;
};

var freqs = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4].frequencies();
alert(freqs[2]); //=> 5
// or
var freqs = '1,1,2,one,one,2,2,22,three,four,five,three,three,five'
             .split(',')
             .frequencies();
alert(freqs.three); //=> 3

Alternativamente puede utilizar Array.map:

  Array.prototype.frequencies  = function () {
    var freqs = {sum: 0}; 
    this.map( function (a){ 
        if (!(a in this)) { this[a] = 1; } 
        else { this[a] += 1; }
        this.sum += 1;
        return a; }, freqs
    );
    return freqs;
  }

Aquí hay algo ligero y fácil para los ojos...

function count(a,i){
 var result = 0;
 for(var o in a)
  if(a[o] == i)
   result++;
 return result;
}

Editar: Y ya que desea todas las ocurrencias...

function count(a){
 var result = {};
 for(var i in a){
  if(result[a[i]] == undefined) result[a[i]] = 0;
  result[a[i]]++;
 }
 return result;
}

var array = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4];

function countDuplicates(obj, num){
  obj[num] = (++obj[num] || 1);
  return obj;
}

var answer = array.reduce(countDuplicates, {});
// answer => {2:5, 4:1, 5:3, 9:1};

Si todavía quieres dos arrays, entonces podrías usar answer así...

var uniqueNums = Object.keys(answer);
// uniqueNums => ["2", "4", "5", "9"];

var countOfNums = Object.keys(answer).map(key => answer[key]);
// countOfNums => [5, 1, 3, 1];

O si desea que los uniqueNums sean números

var uniqueNums = Object.keys(answer).map(key => +key);
// uniqueNums => [2, 4, 5, 9];

Solución ES6 con reducir (fijo):

const arr = [2, 2, 2, 3, 2]

const count = arr.reduce((pre, cur) => (cur === 2) ? ++pre : pre, 0)
console.log(count) // 4

Echa un vistazo al siguiente código.

<html>
<head>
<script>
// array with values
var ar = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4];

var Unique = []; // we'll store a list of unique values in here
var Counts = []; // we'll store the number of occurances in here

for(var i in ar)
{
    var Index = ar[i];
    Unique[Index] = ar[i];
    if(typeof(Counts[Index])=='undefined')  
        Counts[Index]=1;
    else
        Counts[Index]++;
}

// remove empty items
Unique = Unique.filter(function(){ return true});
Counts = Counts.filter(function(){ return true});

alert(ar.join(','));
alert(Unique.join(','));
alert(Counts.join(','));

var a=[];

for(var i=0; i<Unique.length; i++)
{
    a.push(Unique[i] + ':' + Counts[i] + 'x');
}
alert(a.join(', '));

</script>
</head>
<body>

</body>
</html>

Prueba esto:

Array.prototype.getItemCount = function(item) {
    var counts = {};
    for(var i = 0; i< this.length; i++) {
        var num = this[i];
        counts[num] = counts[num] ? counts[num]+1 : 1;
    }
    return counts[item] || 0;
}

Puede hacer esto mucho más fácil extendiendo sus matrices con una función count. Funciona como Rails ' Array#count, si estás familiarizado con él.

Array.prototype.count = function(obj){
    var count = this.length;
    if(typeof(obj) !== "undefined"){
        var array = this.slice(0), count = 0; // clone array and reset count
        for(i = 0; i < array.length; i++){
            if(array[i] == obj){
                count++;
            }
        }
    }
    return count;
}

Uso:

var array = ['a', 'a', 'b', 'c'];
array.count('a'); // => 2
array.count('b'); // => 1
array.count('d'); // => 0
array.count(); // => 4

Fuente (gist)

Dado array x i. e x = ['boy','man','oldman','scout','pilot']; el número de ocurrencias de un elemento 'man' es

x.length - x.toString().split(',man,').toString().split(',').length ;

Estaba resolviendo un problema similar en codewars e ideé la siguiente solución que funcionó para mí.

Esto da la cuenta más alta de un entero en una matriz y también el entero en sí. Creo que también se puede aplicar a la matriz de cadenas.

Para ordenar correctamente las cadenas, elimine function(a, b){return a-b} del interior de la porción sort()

function mostFrequentItemCount(collection) {
    collection.sort(function(a, b){return a-b});
    var i=0;
    var ans=[];
    var int_ans=[];
    while(i<collection.length)
    {
        if(collection[i]===collection[i+1])
        {
            int_ans.push(collection[i]);
        }
        else
        {
            int_ans.push(collection[i]);
            ans.push(int_ans);
            int_ans=[];
        }
        i++;
    }

    var high_count=0;
    var high_ans;

    i=0;
    while(i<ans.length)
    {
        if(ans[i].length>high_count)
        {
            high_count=ans[i].length;
            high_ans=ans[i][0];
        }
        i++;
    }
    return high_ans;
}

Hay una manera mucho mejor y más fácil de hacer esto usando ramda.js. ejemplo de Código aquí

const ary = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4]; R.countBy(r=> r)(ary) La documentación de countBy está en documentación

En lo que respecta a mi comentario preguntando @Emissary acerca de un ajuste a su solución. estoy agregando la forma en que lo manejé:

let distinctArr = yourArray.filter((curElement, index, array) => array.findIndex(t =>    t.prop1=== curElement.prop1 && t.prop2 === curElement.prop2 && t.prop3=== curElement.prop3) === index);
let distinctWithCount = [...new Set(distinctArr)].map(function(element){element.prop4 = yourArray.filter(t =>    t.prop1=== element.prop1 && t.prop2 === element.prop2 && t.prop2=== element.prop2).length;

Lo que estoy haciendo aquí es, 1st eliminando los duplicados y guardando el array (distinctArr) luego estoy contando con el array original (yourArray) la cantidad de tiempo que el objeto se duplicó y agregando una 4th propiedad con el valor de las ocurrencias

Espero que ayude a alguien que necesita esta solución específica Ofc se hace con ES6

Aquí hay una manera de contar las ocurrencias dentro de un array de objetos. También coloca el contenido de la primera matriz dentro de una nueva matriz para ordenar los valores de modo que el orden en la matriz original no se interrumpa. Luego se usa una función recursiva para pasar por cada elemento y contar la propiedad quantity de cada objeto dentro del array.

var big_array = [
  { name: "Pineapples", quantity: 3 },
  { name: "Pineapples", quantity: 1 },
  { name: "Bananas", quantity: 1 },
  { name: "Limes", quantity: 1 },
  { name: "Bananas", quantity: 1 },
  { name: "Pineapples", quantity: 2 },
  { name: "Pineapples", quantity: 1 },
  { name: "Bananas", quantity: 1 },
  { name: "Bananas", quantity: 1 },
  { name: "Bananas", quantity: 5 },
  { name: "Coconuts", quantity: 1 },
  { name: "Lemons", quantity: 2 },
  { name: "Oranges", quantity: 1 },
  { name: "Lemons", quantity: 1 },
  { name: "Limes", quantity: 1 },
  { name: "Grapefruit", quantity: 1 },
  { name: "Coconuts", quantity: 5 },
  { name: "Oranges", quantity: 6 }
];

function countThem() {
  var names_array = [];
  for (var i = 0; i < big_array.length; i++) {
    names_array.push( Object.assign({}, big_array[i]) );
  }

  function outerHolder(item_array) {
    if (item_array.length > 0) {
      var occurrences = [];
      var counter = 0;
      var bgarlen = item_array.length;
      item_array.sort(function(a, b) { return (a.name > b.name) ? 1 : ((b.name > a.name) ? -1 : 0); });

      function recursiveCounter() {
        occurrences.push(item_array[0]);
        item_array.splice(0, 1);
        var last_occurrence_element = occurrences.length - 1;
        var last_occurrence_entry = occurrences[last_occurrence_element].name;
        var occur_counter = 0;
        var quantity_counter = 0;
        for (var i = 0; i < occurrences.length; i++) {
          if (occurrences[i].name === last_occurrence_entry) {
            occur_counter = occur_counter + 1;
            if (occur_counter === 1) {
              quantity_counter = occurrences[i].quantity;
            } else {
              quantity_counter = quantity_counter + occurrences[i].quantity;
            }
          }
        }

        if (occur_counter > 1) {
          var current_match = occurrences.length - 2;
          occurrences[current_match].quantity = quantity_counter;
          occurrences.splice(last_occurrence_element, 1);
        }

        counter = counter + 1;

        if (counter < bgarlen) {
          recursiveCounter();
        }
      }

      recursiveCounter();

      return occurrences;
    }
  }
  alert(JSON.stringify(outerHolder(names_array)));
}

function countOcurrences(arr){
    return arr.reduce((aggregator, value, index, array) => {
      if(!aggregator[value]){
        return aggregator = {...aggregator, [value]: 1};  
      }else{
        return aggregator = {...aggregator, [value]:++aggregator[value]};
      }
    }, {})
}

Aquí hay un método clásico de la vieja escuela para contar matrices.

var arr = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4];
var counted = [], count = [];
var i = 0, j = 0, k = 0;
while (k < arr.length) {
    if (counted.indexOf(arr[k]) < 0) {
        counted[i] = arr[k];
        count[i] = 0;
        for (j = 0; j < arr.length; j++) {
            if (counted[i] == arr[j]) {
                count[i]++;
            }
        }
        i++;
    } else {
        k++;
    }
}

Puede ordenarlo primero si desea un resultado alfabético, pero si desea preservar el orden en el que se ingresaron los datos, pruebe esto. Los bucles anidados pueden ser un poco más lentos que algunos de los otros métodos en esta página.