# How to count the number of certain element in an array?

If I have an array `[1, 2, 3, 5, 2, 8, 9, 2]`, I would like to check how many `2`s there are in the array. What is the most elegant way to do it in JavaScript without looping with `for` loop? Very simple:

``````var count = 0;
for(var i = 0; i < array.length; ++i){
if(array[i] == 2)
count++;
}
`````` Say hello to your friends: `map` and `filter` and `reduce` and `forEach` and `every` etc.

(I only occasionally write for-loops in javascript, because of block-level scoping is missing, so you have to use a function as the body of the loop anyway if you need to capture or clone your iteration index or value. For-loops are more efficient generally, but sometimes you need a closure.)

``````[....].filter(x => x==2).length
``````

(We could have written `.filter(function(x){return x==2}).length` instead)

The following is more space-efficient (O(1) rather than O(N)), but I'm not sure how much of a benefit/penalty you might pay in terms of time (not more than a constant factor since you visit each element exactly once):

``````[....].reduce((total,x) => (x==2 ? total+1 : total), 0)
``````

(If you need to optimize this particular piece of code, a for loop might be faster on some browsers... you can test things on jsperf.com.)

You can then be elegant and turn it into a prototype function:

``````[1, 2, 3, 5, 2, 8, 9, 2].count(2)
``````

Like this:

``````Object.defineProperties(Array.prototype, {
count: {
value: function(value) {
return this.filter(x => x==value).length;
}
}
});
``````

You can also stick the regular old for-loop technique (see other answers) inside the above property definition (again, that would likely be much faster).

2017 edit:

Whoops, this answer has gotten more popular than the correct answer. Actually, just use the accepted answer. While this answer may be cute, the js compilers probably don't (or can't due to spec) optimize such cases. So you should really write a simple for loop:

``````Object.defineProperties(Array.prototype, {
count: {
value: function(query) {
/*
Counts number of occurrences of query in array, an integer >= 0
Uses the javascript == notion of equality.
*/
var count = 0;
for(let i=0; i<this.length; i++)
if (this[i]==query)
count++;
return count;
}
}
});
``````

You could define a version `.countStrictEq(...)` which used the `===` notion of equality. The notion of equality may be important to what you're doing! (for example `[1,10,3,'10'].count(10)==2`, because numbers like '4'==4 in javascript... hence calling it `.countEq` or `.countNonstrict` stresses it uses the `==` operator.)

Also consider using your own multiset data structure (e.g. like python's '`collections.Counter`') to avoid having to do the counting in the first place.

``````class Multiset extends Map {
constructor(...args) {
super(...args);
}
if (!this.has(elem))
this.set(elem, 1);
else
this.set(elem, this.get(elem)+1);
}
remove(elem) {
var count = this.has(elem) ? this.get(elem) : 0;
if (count>1) {
this.set(elem, count-1);
} else if (count==1) {
this.delete(elem);
} else if (count==0)
throw `tried to remove element \${elem} of type \${typeof elem} from Multiset, but does not exist in Multiset (count is 0 and cannot go negative)`;
// alternatively do nothing {}
}
}
``````

Demo:

``````> counts = new Multiset([['a',1],['b',3]])
Map(2) {"a" => 1, "b" => 3}

> counts
Map(3) {"a" => 1, "b" => 3, "c" => 1}

> counts.remove('a')
> counts
Map(2) {"b" => 3, "c" => 1}

> counts.remove('a')
Uncaught tried to remove element a of type string from Multiset, but does not exist in Multiset (count is 0 and cannot go negative)
``````

sidenote: Though, if you still wanted the functional-programming way (or a throwaway one-liner without overriding Array.prototype), you could write it more tersely nowadays as `[...].filter(x => x==2).length`. If you care about performance, note that while this is asymptotically the same performance as the for-loop (O(N) time), it may require O(N) extra memory (instead of O(1) memory) because it will almost certainly generate an intermediate array and then count the elements of that intermediate array. 2017: If someone is still interested in the question, my solution is the following:

``````const arrayToCount = [1, 2, 3, 5, 2, 8, 9, 2];
const result = arrayToCount.filter(i => i === 2).length;
console.log('number of the found elements: ' + result);`````` ES6 Update to JS:

``````// Let has local scope
let array = [1, 2, 3, 5, 2, 8, 9, 2]

// Functional filter with an Arrow function
array.filter(x => x === 2).length  // -> 3
``````

The following unanimous Arrow function (lambda function) in JS:

``````(x) => {
const k = 2
return k * x
}
``````

may be simplified to this concise form for a single input:

``````x => 2 * x
``````

where the `return` is implied. Weirdest way I can think of doing this is:

``````(a.length-(' '+a.join(' ')+' ').split(' '+n+' ').join(' ').match(/ /g).length)+1
``````

Where:

• a is the array
• n is the number to count in the array

My suggestion, use a while or for loop ;-) Not using a loop usually means handing the process over to some method that does use a loop.

Here is a way our loop hating coder can satisfy his loathing, at a price:

``````var a=[1, 2, 3, 5, 2, 8, 9, 2];

/*  returned value: (Number)
3
*/
``````

You can also repeatedly call indexOf, if it is available as an array method, and move the search pointer each time.

This does not create a new array, and the loop is faster than a forEach or filter.

It could make a difference if you have a million members to look at.

``````function countItems(arr, what){
var count= 0, i;
while((i= arr.indexOf(what, i))!= -1){
++count;
++i;
}
return count
}

countItems(a,2)

/*  returned value: (Number)
3
*/
`````` Really, why would you need `map` or `filter` for this? `reduce` was "born" for these kind of operations:

`[1, 2, 3, 5, 2, 8, 9, 2].reduce( (count,2)=>count+(item==val), 0);`

that's it! (if `item==val` in each iteration, then 1 will be added to the accumulator `count`, as `true` will resolve to `1`).

As a function:

``````function countInArray(arr, val) {
return arr.reduce((count,item)=>count+(item==val),0)
}
``````

``````Array.prototype.count = function(val) {
return this.reduce((count,item)=>count+(item==val),0)
}
`````` Most of the posted solutions using array functions such as filter are incomplete because they aren't parameterized.

Here goes a solution with which the element to count can be set at run time.

``````function elementsCount(elementToFind, total, number){
}

var ar = [1, 2, 3, 5, 2, 8, 9, 2];
var elementToFind=2;
var result = ar.reduce(elementsCount.bind(this, elementToFind), 0);
``````

The advantage of this approach is that could easily change the function to count for instance the number of elements greater than X.

You may also declare the reduce function inline

``````var ar = [1, 2, 3, 5, 2, 8, 9, 2];
var elementToFind=2;
var result = ar.reduce(function (elementToFind, total, number){
}.bind(this, elementToFind), 0);
`````` I'm a begin fan of js array's reduce function.

``````const myArray =[1, 2, 3, 5, 2, 8, 9, 2];
const count = myArray.reduce((count, num) => num === 2 ? count + 1 : count, 0)
``````

In fact if you really want to get fancy you can create a count function on the Array prototype. Then you can reuse it.

``````Array.prototype.count = function(filterMethod) {
return this.reduce((count, item) => filterMethod(item)? count + 1 : count, 0);
}
``````

Then do

``````const myArray =[1, 2, 3, 5, 2, 8, 9, 2]
const count = myArray.count(x => x==2)
`````` Solution by recursion

``````function count(arr, value) {
if (arr.length === 1)    {
return arr === value ? 1 : 0;
} else {
return (arr.shift() === value ? 1 : 0) + count(arr, value);
}
}

count([1,2,2,3,4,5,2], 2); // 3
`````` Create a new method for Array class in core level file and use it all over your project.

``````// say in app.js
Array.prototype.occurrence = function(val) {
return this.filter(e => e === val).length;
}
``````

Use this anywhere in your project -

``````[1, 2, 4, 5, 2, 7, 2, 9].occurrence(2);
// above line returns 3
`````` You can use length property in JavaScript array:

``````var myarray = [];
var count = myarray.length;//return 0

myarray = [1,2];
count = myarray.length;//return 2
`````` If you are using lodash or underscore the _.countBy method will provide an object of aggregate totals keyed by each value in the array. You can turn this into a one-liner if you only need to count one value:

``````_.countBy(['foo', 'foo', 'bar'])['foo']; // 2
``````

This also works fine on arrays of numbers. The one-liner for your example would be:

``````_.countBy([1, 2, 3, 5, 2, 8, 9, 2]); // 3
`````` ``````var arrayCount = [1,2,3,2,5,6,2,8];
var co = 0;
function findElement(){
arrayCount.find(function(value, index) {
if(value == 2)
co++;
});
console.log( 'found' + ' ' + co + ' element with value 2');
}``````

I would do something like that:

``````var arrayCount = [1,2,3,4,5,6,7,8];

function countarr(){
var dd = 0;
arrayCount.forEach( function(s){
dd++;
});

console.log(dd);
}`````` Here is a one liner in javascript.

1. Use map. Find the matching values `(v === 2)` in the array, returning an array of ones and zeros.
2. Use Reduce. Add all the values of the array for the total number found.
``````[1, 2, 3, 5, 2, 8, 9, 2]
.map(function(v) {
return v === 2 ? 1 : 0;
})
.reduce((a, b) => a + b, 0);
``````

The result is `3`. I believe what you are looking for is functional approach

``````    const arr = ['a', 'a', 'b', 'g', 'a', 'e'];
const count = arr.filter(elem => elem === 'a').length;
console.log(count); // Prints 3
``````

elem === 'a' is the condition, replace it with your own. It is better to wrap it into function:

``````let countNumber = (array,specificNumber) => {
return array.filter(n => n == specificNumber).length
}

countNumber([1,2,3,4,5],3) // returns 1
`````` Here is an ES2017+ way to get the counts for all array items in O(N):

``````const arr = [1, 2, 3, 5, 2, 8, 9, 2];
const counts = {};

arr.forEach((el) => {
counts[el] = counts[el] ? (counts[el] += 1) : 1;
});
``````

You can also optionally sort the output:

``````const countsSorted = Object.entries(counts).sort(([_, a], [__, b]) => a - b);
``````

``````[
[ '2', 3 ],
[ '1', 1 ],
[ '3', 1 ],
[ '5', 1 ],
[ '8', 1 ],
[ '9', 1 ]
]
``````