Zählen der vorkommen / Häufigkeit von array-Elementen

Hier gehen Sie:

function foo(arr) {
    var a = [], b = [], prev;

    arr.sort();
    for ( var i = 0; i < arr.length; i++ ) {
        if ( arr[i] !== prev ) {
            a.push(arr[i]);
            b.push(1);
        } else {
            b[b.length-1]++;
        }
        prev = arr[i];
    }

    return [a, b];
}

Live-demo: http://jsfiddle.net/simevidas/bnACW/

InformationsquelleAutor der Antwort Šime Vidas

Wenn mit Unterstrich oder lodash, das ist die einfachste Sache zu tun:

_.countBy(array);

Mit:

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

Als von anderen darauf hingewiesen wird, können Sie dann führen Sie die _.keys() und _.values() Funktionen auf das Ergebnis, um nur die eindeutigen zahlen, und Ihre vorkommen, beziehungsweise. Aber in meiner Erfahrung, das original ist viel einfacher zu handhaben.

InformationsquelleAutor der Antwort radicand

Ich denke, dies ist der einfachste Weg, wie zählen der vorkommen mit gleichem Wert in der Reihe.

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

InformationsquelleAutor der Antwort Dmytro Kozlovskyi

Wenn Sie Unterstrich, Sie können gehen der funktionale route

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

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

so dass Ihre erste array ist

_.keys(results)

und das zweite array ist

_.values(results)

meisten dieser wird standardmäßig auf native javascript-Funktionen, wenn Sie verfügbar sind

demo : http://jsfiddle.net/dAaUU/

InformationsquelleAutor der Antwort jhnstn

Könnte man erweitern der Array-Prototyp, wie diese:

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

Alternativ können Sie nutzen 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;
  }

InformationsquelleAutor der Antwort KooiInc

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};

Wenn Sie wollen immer noch zwei arrays, dann können Sie Antwort so...

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

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

Oder wenn Sie wollen, uniqueNums zu zahlen

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

InformationsquelleAutor der Antwort SoEzPz

Versuchen Sie dies:

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;
}

InformationsquelleAutor der Antwort Aamir Afridi

Gegebenes array x
ich.e x = ['boy','man','oldman','scout','pilot'];
Anzahl der vorkommen eines Elements 'man' ist

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

InformationsquelleAutor der Antwort Shashank Reddy Arrabothu

Es ist eine viel bessere und einfache Möglichkeit, wir können dies tun, indem ramda.js.
Code-Beispiel hier

const ary = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4];
R.countBy(r=> r)(ary)

countBy Dokumentation ist bei Dokumentation

InformationsquelleAutor der Antwort Eshwar Prasad Yaddanapudi

Hier ist eine Möglichkeit zum zählen der vorkommen innerhalb eines Arrays von Objekten. Es stellt auch das erste array die Inhalte in ein neues array, das Sortieren der Werte, so dass die Reihenfolge, in der die ursprüngliche array wird nicht gestört. Dann eine rekursive Funktion verwendet, um zu gehen durch jedes element und zählen Sie die Menge-Eigenschaft für jedes Objekt im 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)));
}

InformationsquelleAutor der Antwort nate_js

Hier ist eine klassische old-school-Methode für die Zählung von arrays.

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++;
    }
}

Können Sie Sortieren Sie zuerst, wenn Sie möchten, eine alphabetische Ergebnis, aber wenn Sie wollen, um die Erhaltung der Reihenfolge, in der die Daten eingegeben wurde, dann geben Sie dieses einen Versuch. Nested loops-vielleicht ein wenig langsamer als einige der anderen Methoden auf dieser Seite.

InformationsquelleAutor der Antwort MangoPapa7