hashish

Hashish

Hashish is a node.js library for manipulating hash data structures. It is distilled from the finest that ruby, perl, and haskell have to offer by way of hash/map interfaces.

Hashish provides a chaining interface, where you can do:

var Hash = require('hashish');

Hash({ a : 1, b : 2, c : 3, d : 4 })
    .map(function (x) { return x * 10 })
    .filter(function (x) { return x < 30 })
    .forEach(function (x, key) {
        console.log(key + ' => ' + x);
    })
;

Output:

a => 10
b => 20

Some functions and attributes in the chaining interface are terminal, like .items or .detect(). They return values of their own instead of the chain context.

Each function in the chainable interface is also attached to Hash in chainless form:

var Hash = require('hashish');
var obj = { a : 1, b : 2, c : 3, d : 4 };

var mapped = Hash.map(obj, function (x) {
    return x * 10
});

console.dir(mapped);

Output:

{ a: 10, b: 20, c: 30, d: 40 }

In either case, the 'this' context of the function calls is the same object that the chained functions return, so you can make nested chains.

Methods

forEach(cb)

For each key/value in the hash, calls cb(value, key).

map(cb)

For each key/value in the hash, calls cb(value, key). The return value of cb is the new value at key in the resulting hash.

filter(cb)

For each key/value in the hash, calls cb(value, key). The resulting hash omits key/value pairs where cb returned a falsy value.

detect(cb)

Returns the first value in the hash for which cb(value, key) is non-falsy. Order of hashes is not well-defined so watch out for that.

reduce(cb)

Returns the accumulated value of a left-fold over the key/value pairs.

some(cb)

Returns a boolean: whether or not cb(value, key) ever returned a non-falsy value.

update(obj1, [obj2, obj3, ...])

Mutate the context hash, merging the key/value pairs from the passed objects and overwriting keys from the context hash if the current obj has keys of the same name. Falsy arguments are silently ignored.

updateAll([ obj1, obj2, ... ])

Like multi-argument update() but operate on an array directly.

merge(obj1, [obj2, obj3, ...])

Merge the key/value pairs from the passed objects into the resultant hash without modifying the context hash. Falsy arguments are silently ignored.

mergeAll([ obj1, obj2, ... ])

Like multi-argument merge() but operate on an array directly.

has(key)

Return whether the hash has a key, key.

valuesAt(keys)

Return an Array with the values at the keys from keys.

tap(cb)

Call cb with the present raw hash. This function is chainable.

extract(keys)

Filter by including only those keys in keys in the resulting hash.

exclude(keys)

Filter by excluding those keys in keys in the resulting hash.

Attributes

These are attributes in the chaining interface and functions in the Hash.xxx interface.

keys

Return all the enumerable attribute keys in the hash.

values

Return all the enumerable attribute values in the hash.

compact

Filter out values which are === undefined.

clone

Make a deep copy of the hash.

copy

Make a shallow copy of the hash.

length

Return the number of key/value pairs in the hash. Note: use Hash.size() for non-chain mode.

size

Alias for length since Hash.length is masked by Function.prototype.

See Also

See also creationix's pattern/hash, which does a similar thing except with hash inputs and array outputs.

Installation

To install with npm:

npm install hashish

To run the tests with expresso:

expresso