Finden Sie idiomatisch die Anzahl der Vorkommen, die ein bestimmter Wert in einem Array hat

Neuere Browser nur wegen der Verwendung von Array.filter

var dataset = [2,2,4,2,6,4,7,8];
var search = 2;
var occurrences = dataset.filter(function(val) {
    return val === search;
}).length;
console.log(occurrences); // 3

array.filter(c => c === searchvalue).length;

Hier ist eine Möglichkeit,ALLEauf einmal anzuzeigen:

var dataset = [2, 2, 4, 2, 6, 4, 7, 8];
var counts = {}, i, value;
for (i = 0; i < dataset.length; i++) {
    value = dataset[i];
    if (typeof counts[value] === "undefined") {
        counts[value] = 1;
    } else {
        counts[value]++;
    }
}
console.log(counts);
// Object {
//    2: 3,
//    4: 2,
//    6: 1,
//    7: 1,
//    8: 1
//}

Mit einer normalen Schleife können Sie die Vorkommen konsistent und zuverlässig finden:

const dataset = [2,2,4,2,6,4,7,8];

function getNumMatches(array, valToFind) {
    let numMatches = 0;
    for (let i = 0, j = array.length; i < j; i += 1) {
        if (array[i] === valToFind) {
            numMatches += 1;
        }
    }
    return numMatches;
}

alert(getNumMatches(dataset, 2)); // should alert 3

DEMO:https://jsfiddle.net/a7q9k4uu/

Um es allgemeiner zu machen, könnte die Funktion eine Prädikatsfunktion mit benutzerdefinierter Logik akzeptieren (truefalse), die die endgültige Anzahl bestimmt. Zum Beispiel:

const dataset = [2,2,4,2,6,4,7,8];

function getNumMatches(array, predicate) {
    let numMatches = 0;
    for (let i = 0, j = array.length; i < j; i += 1) {
        const current = array[i];
        if (predicate(current) === true) {
            numMatches += 1;
        }
    }
    return numMatches;
}

const numFound = getNumMatches(dataset, (item) => {
    return item === 2;
});

alert(numFound); // should alert 3

_/DEMO:https://jsfiddle.net/57en9nar/1/

var dataset = [2,2,4,2,6,4,7,8], count = {}

dataset.forEach(function(el){
    count[el] = count[el] + 1 || 1
});

console.log(count)

//  {
//    2: 3,
//    4: 2,
//    6: 1,
//    7: 1,
//    8: 1
//  }

Sie können die array.reduce(callback[, initialValue])-Methode in JavaScript 1.8 verwenden. 

var dataset = [2,2,4,2,6,4,7,8],
    dataWithCount = dataset.reduce( function( o , v ) {

        if ( ! o[ v ] ) {
            o[ v ] = 1 ;  
        }  else {
            o[ v ] = o[ v ] + 1;
        }      

        return o ;    

    }, {} );

// print data with count.
for( var i in  dataWithCount ){
     console.log( i + 'occured ' + dataWithCount[i] + 'times ' ); 
}

// find one number
var search = 2,
    count = dataWithCount[ search ] || 0;

Sie können alle Elemente in einem Array in einer einzigen Zeile zählen, indem Sie verkleinern. 

[].reduce((a,b) => (a[b] = a[b] + 1 || 1) && a, {})

Dies ergibt ein Objekt, dessen Schlüssel die verschiedenen Elemente im Array sind, und die Werte die Anzahl der Vorkommen von Elementen im Array. Sie können dann auf eine oder mehrere der Zählungen zugreifen, indem Sie auf einen entsprechenden Schlüssel des Objekts zugreifen.

Zum Beispiel, wenn Sie das Obige in eine Funktion namens count() einschließen würden:

function count(arr) {
  return arr.reduce((a,b) => (a[b] = a[b] + 1 || 1) && a, {})
}

count(['example'])          // { example: 1 }
count([2,2,4,2,6,4,7,8])[2] // 3

Ich fand es sinnvoller, eine Liste von Objekten mit einem Schlüssel für das, was gezählt wird, und einem Schlüssel für die Zählung zu erhalten:

const data = [2,2,4,2,6,4,7,8]
let counted = []
for (var c of data) {
  const alreadyCounted = counted.map(c => c.name)
  if (alreadyCounted.includes(c)) {
    counted[alreadyCounted.indexOf(c)].count += 1
  } else {
    counted.Push({ 'name': c, 'count': 1})
  }
}
console.log(counted)

was gibt zurück: 

[ { name: 2, count: 3 },
  { name: 4, count: 2 },
  { name: 6, count: 1 },
  { name: 7, count: 1 },
  { name: 8, count: 1 } ]

Es ist nicht die sauberste Methode, und wenn jemand weiß, wie man mit reduce dasselbe Ergebnis erzielt, lass es mich wissen. Es führt jedoch zu einem Ergebnis, mit dem man relativ leicht arbeiten kann.

Erstens können Sie mit Brute Force Solution arbeiten, indem Sie mit der linearen Suche fortfahren.

public int LinearSearchcount(int[] A, int data){
  int count=0;
  for(int i=0;i<A.length;i++) {
    if(A[i]==data) count++;
  }
  return count;
}

Um dies zu bewerkstelligen, erhalten wir die Zeitkomplexität als O (n). Aber durch die binäre Suche können wir unsere Komplexität verbessern.