_.count method

[justin808]

Would it make sense for lodash to have a _.count method?

Like this: http://ruby-doc.org/core-2.1.2/Enumerable.html#method-i-count
I'd be happy to implement one and submit a PR if this is appropriate.

[jdalton]

Thanks for asking. This looks like a combo of a couple of existing methods.
There's _.filter & _.size which can be used to come to similar results.

We'll keep an eye on the popularity of the request.

[nickperkinslondon]

👍 for _.count ( and _.countWhere)

I was surprised to find that these don't already exist! Wouldn't it be nice, when you just want to count something, to simply reach for the _.count() function?

Of course you can do it with "filter/length" but that seems a tiny bit awkward, and counting is such a simple and fundamental concept -- it deserves it's own function. ( plus, there's the performance thing -- you could implement it without creating a new array ).

[c-dante]

My only conflict is how count is useful in applications -- I'm trying to think of times where I want how many satisfy a predicate and not which -- I keep coming to UI concerns only.

Is there a meaningful algorithm or use case you can come up with that just wants to know how many and not which? Or rather, one such that you do not want the filtered set (either side)?

Edit:
Oh. We get _.sumBy. So here's your count:

_.sumBy(collection, (x) => pred(x) ? 1 : 0)

[jdalton]

@c-dante Oh neat!

_.sumBy(collection, _.flow(pred, Boolean));

[lindem]

Just stumbled across this (because I need to count predicate-satisfying values); I'd like to add that _.count(seq, predicate) is also self-documenting code. I think _.countBy() just doesn't achieve the same degree of simplicity, its return value always being an object. I am really surprised that there's opposition to this particular concept of just returning a number.
EDIT: That's 👍 for a simple _.count() returning a number.

[c-dante]

I'm for a mixin of:

_.count = _.sumBy(collection, _.flow(pred, Boolean));

Whether its implemented that way or not. It's pretty clear what would be expected from:

_.count(myNumbers, x => x > 5);  // I read this is, "how many of myNumbers are > 5

_.count(name.split(''), x => x === 'a'); // How many "a" are in name?

_.count(resturants, x => distanceFromMe(x) > 10mi); // How many resturants are within 10mi of my location

[mologie]

There also is an argument of efficiency to make here.

Most combined functions which achieve the behavior described in this ticket will build some kind of temporary object, which is then further evaluated for deriving the final count. Obvious examples are the filter+length and the map+sum approaches described above.

A more efficient implementation would only require a single integer for counting. This ticket therefore has my vote, because bits are precious.

[SmedbergM]

I'd upvote this too. _.sumBy(collection, predicate) works but is unidiomatic.

[gunar]

The predicate needs to return a number not a boolean, hence

_.sumBy(collection, _.flow(pred, Number));

[SmedbergM]

The predicate needs to return a number not a boolean

In a type-safe world, sure. But + coerces booleans into numbers, which is why I said it works.

[lock]

This thread has been automatically locked since there has not been any recent activity after it was closed. Please open a new issue for related bugs.