https://github.com/component/enumerable
Enumerable mixin
https://github.com/component/enumerable
Last synced: 8 months ago
JSON representation
Enumerable mixin
- Host: GitHub
- URL: https://github.com/component/enumerable
- Owner: component
- Created: 2012-10-16T16:51:20.000Z (over 13 years ago)
- Default Branch: master
- Last Pushed: 2014-04-04T02:10:55.000Z (almost 12 years ago)
- Last Synced: 2025-04-03T07:05:09.548Z (12 months ago)
- Language: JavaScript
- Size: 293 KB
- Stars: 58
- Watchers: 8
- Forks: 10
- Open Issues: 11
-
Metadata Files:
- Readme: Readme.md
- Changelog: History.md
Awesome Lists containing this project
README
# Enumerable
Enumerable mixin.
```js
users
.map('friends')
.select('age > 20')
.map('name.first')
.select(/^T/)
```
## Installation
$ component install component/enumerable
## Implementation
Nearly all methods utilize the [to-function](https://github.com/component/to-function)
component, which converts the argument passed to a function. For example
`.map('name.first')` expands to a function effectively defined as `return obj.name.first`,
likewise `.select(/^Tobi/)` expands to `return /^Tobi/.test(str)` and so on. For details
check out to-function's Readme and familiarize yourself since all of that is applicable
to Enumerable.
## API
- [mixin()](#mixin)
- [.each()](#eachfnfunction)
- [.map()](#mapfnfunction)
- [.select()](#selectfnfunctionstring)
- [.unique()](#unique)
- [.reject()](#rejectfnfunctionstringmixed)
- [.compact()](#compact)
- [.find()](#findfnfunction)
- [.findLast()](#findlastfnfunction)
- [.none()](#nonefnfunctionstring)
- [.any()](#anyfnfunction)
- [.count()](#countfnfunction)
- [.indexOf()](#indexofobjmixed)
- [.has()](#hasobjmixed)
- [.reduce()](#reducefnfunctionvalmixed)
- [.max()](#maxfnfunctionstring)
- [.sum()](#sumfnfunctionstring)
- [.first()](#firstnnumberfunction)
- [.last()](#lastnnumberfunction)
- [.inGroupsOf()](#ingroupsofnnumber)
- [.at()](#atinumber)
- [.value()](#value)
### mixin()
Mixin to `obj`.
```js
var Enumerable = require('enumerable');
Enumerable(Something.prototype);
```
### .each(fn:Function)
Iterate each value and invoke `fn(val, i)`.
```js
users.each(function(val, i){
})
```
### .map(fn:Function)
Map each return value from `fn(val, i)`.
Passing a callback function:
```js
users.map(function(user){
return user.name.first
})
```
Passing a property string:
```js
users.map('name.first')
```
### .select(fn:Function|String)
Select all values that return a truthy value of `fn(val, i)`.
```js
users.select(function(user){
return user.age > 20
})
```
With a property:
```js
items.select('complete')
```
### .unique()
Select all unique values.
```js
nums.unique()
```
### .reject(fn:Function|String|Mixed)
Reject all values that return a truthy value of `fn(val, i)`.
Rejecting using a callback:
```js
users.reject(function(user){
return user.age < 20
})
```
Rejecting with a property:
```js
items.reject('complete')
```
Rejecting values via `==`:
```js
data.reject(null)
users.reject(toni)
```
### .compact()
Reject `null` and `undefined`.
```js
[1, null, 5, undefined].compact()
// => [1,5]
```
### .find(fn:Function)
Return the first value when `fn(val, i)` is truthy,
otherwise return `undefined`.
```js
users.find(function(user){
return user.role == 'admin'
})
```
### .findLast(fn:Function)
Return the last value when `fn(val, i)` is truthy,
otherwise return `undefined`.
```js
users.findLast(function(user){
return user.role == 'admin'
})
```
### .none(fn:Function|String)
Assert that none of the invocations of `fn(val, i)` are truthy.
For example ensuring that no pets are admins:
```js
pets.none(function(p){ return p.admin })
pets.none('admin')
```
### .any(fn:Function)
Assert that at least one invocation of `fn(val, i)` is truthy.
For example checking to see if any pets are ferrets:
```js
pets.any(function(pet){
return pet.species == 'ferret'
})
```
### .count(fn:Function)
Count the number of times `fn(val, i)` returns true.
```js
var n = pets.count(function(pet){
return pet.species == 'ferret'
})
```
### .indexOf(obj:Mixed)
Determine the indexof `obj` or return `-1`.
### .has(obj:Mixed)
Check if `obj` is present in this enumerable.
### .reduce(fn:Function, [val]:Mixed)
Reduce with `fn(accumulator, val, i)` using
optional `init` value defaulting to the first
enumerable value.
### .max(fn:Function|String)
Determine the max value.
With a callback function:
```js
pets.max(function(pet){
return pet.age
})
```
With property strings:
```js
pets.max('age')
```
With immediate values:
```js
nums.max()
```
### .sum(fn:Function|String)
Determine the sum.
With a callback function:
```js
pets.sum(function(pet){
return pet.age
})
```
With property strings:
```js
pets.sum('age')
```
With immediate values:
```js
nums.sum()
```
### .first([n]:Number|Function)
Return the first value, or first `n` values.
### .last([n]:Number|Function)
Return the last value, or last `n` values.
### .inGroupsOf(n:Number)
Return values in groups of `n`.
### .at(i:Number)
Return the value at the given index.
### .value()
Return the enumerable value.
## License
MIT