- 101 utils are made to work well with vanilla JS methods.
- 101 will only duplicate vanilla JS to provide functional programming paradigms or if the method is not available in a widely supported JS version (currently ES5).
- Underscore/lodash - duplicates a lot of ES5: forEach, map, reduce, filter, sort, and more.
- With 101, import naturally, and what you use will be bundled.
- Each util method is a module that can be required
require('101/<util>')
. - Currently node/browserify is supported, I will add other module system support on request.
- Underscore/lodash is large, and you have to manually create custom builds when if you're trying to optimize for size.
npm install 101
Functional version of &&
var and = require('101/and');
and(true, false); // false
and(true, true); // true
Functional version of function.apply
var apply = require('101/apply');
[sum].map(apply(null, [1, 2, 3])); // [6] = [sum(1,2,3)] = [1+2+3]
function sum () { /* sums all arguments */ }
apply({ prop: 'val' })(function () { return this.prop; }); // 'val'
It's clone.
var clone = require('101/clone');
var obj = {
foo: 1,
bar: 2
};
clone(obj); // { foo: 1, bar: 2 }
Functional version of str === process.env.NODE_ENV
var envIs = require('101/env-is');
// process.env.NODE_ENV = development
envIs('development'); // true
envIs('production'); // false
envIs('staging', 'production'); // false
envIs('development', 'production'); // true
Functional version of === , supports partial functionality
var equals = require('101/equals');
equals(1, 1); // true
[1,2,3].some(equals(1)); // true
equals(1, '1'); // false
Simple exists function
var exists = require('101/exists');
exists('foo'); // true
exists(null); // false
exists(undefined); // false
Just like ES6's array.find
Finds the first value in the list that passes the given function (predicate) and returns it. If list is not provided find will return a partial-function which accepts a list as the first argument.
var find = require('101/find');
var hasProps = require('101/has-properties');
var arr = [{ a: 1, b: 1 }, { b: 1 }, { c: 1 }];
var index = find(arr, hasProps({ a:1 }));
// returns { a: 1, b: 1 }
// returns null if not found
Just like ES6's array.findIndex
Finds the first value in the list that passes the given function (predicate) and returns it's index. If list is not provided findIndex will return a partial-function which accepts a list as the first argument.
var findIndex = require('101/find-index');
var arr = [1, 2, 3];
var index = findIndex(arr, function (val, i, arr) {
return val === 2;
});
// returns 1
// returns -1 if not found
Determines whether the keypaths exist and have the specified values.
var hasKeypaths = require('101/has-keypaths');
var obj = {
foo: {
bar: {
qux: 1
}
}
};
hasKeypaths(obj, ['foo.bar.qux']); // true
hasKeypaths(obj, { 'foo.bar.qux': 1 }); // true
hasKeypaths(obj, ['foo.qux']); // false
hasKeypaths(obj, { 'foo.bar': 2 }); // false
hasKeypaths(obj, { 'foo.bar': 1, 'nope': 1 }); // false
// optional 'deep' arg, defaults to true
var barObj = { bar: 1 };
hasKeypaths(obj, { 'foo.bar': barObj }); // true
hasKeypaths(obj, { 'foo.bar': barObj }, true); // true
hasKeypaths(obj, { 'foo.bar': barObj }, false); // false
hasKeypaths(obj, { 'foo.bar': obj.foo }, false); // true
hasKeypaths(obj, ['foo.bar'], false); // true, uses [hasOwnProperty vs in](http://stackoverflow.com/questions/13632999/if-key-in-object-or-ifobject-hasownpropertykey)
Determines whether the keys exist and, if specified, has the values.
var hasProperties = require('101/has-properties');
var obj = {
foo: {
bar: 1
},
qux: 1
};
hasProperties(obj, ['foo', 'qux']); // true
hasProperties(obj, { qux: 1 }) // true
// optional 'deep' arg, defaults to true
var barObj = { bar: 1 };
hasProperties(obj, { 'foo.bar': barObj }); // true
hasProperties(obj, { 'foo.bar': barObj }, true); // true
hasProperties(obj, { 'foo.bar': barObj }, false); // false
hasProperties(obj, ['foo.bar'], false); // true, uses [hasOwnProperty vs in](http://stackoverflow.com/questions/13632999/if-key-in-object-or-ifobject-hasownpropertykey)
Functional version of JavaScript's instanceof, returns a partial function which expects a value argument and returns
var instanceOf = require('101/instance-of');
['foo', 'bar', 1].map(instanceOf('string')); // [true, true, false]
Functional version of val typeof 'boolean'
var isBoolean = require('101/is-boolean');
[true, false, 1].map(isBoolean); // [true, true, false]
Functional version of val typeof 'function'
var isFunction = require('101/is-function');
[parseInt, function () {}, 'foo'].map(isFunction); // [true, true, false]
Functional strict version of val typeof 'object' (and not array or regexp)
var isObject = require('101/is-object');
[{}, { foo: 1 }, 100].map(isObject); // [true, true, false]
Functional version of val typeof 'string'
var isString = require('101/is-string');
['foo', 'bar', 1].map(isString); // [true, true, false]
Returns the last value of the item.
var last = require('101/last');
last([1, 2, 3]); // 3
last('hello'); // 'o'
last({
foo: 1,
bar: 2
}); // 2
No-op function
require('101/noop'); // function () {}
Functional version of !
var not = require('101/not');
not(isString)('hey'); // false
not(isString)(100); // true
Returns a new object without the specified keys.
var omit = require('101/omit');
var obj = {
foo: 1,
bar: 2
};
omit(obj, 'foo'); // { bar: 1 }
omit(obj, ['foo']); // { bar: 1 }
omit(obj, ['foo', 'bar']); // { }
// use it with array.map
[obj, obj, obj].map(omit('foo')); // [{ bar: 1 }, { bar: 1 }, { bar: 1 }];
Functional version of ||
var or = require('101/or');
or(true, true); // true
or(true, false); // true
or(false, false); // false
Muxes arguments across many functions and &&'s the results
var passAll = require('101/pass-all');
['', 'foo', 'bar', 100].map(passAll(isString, isTruthy)); // [false, true, true, false]
Muxes arguments across many functions and ||'s the results
var passAny = require('101/pass-any');
['', 'foo', 'bar', 100].map(passAny(isString, isNumber)); // [true, true, true, true]
Returns a new object with the specified keys (with key values from obj)
var pick = require('101/pick');
var obj = {
foo: 1,
bar: 2
};
pick(obj, 'foo'); // { foo: 1 }
pick(obj, ['foo']); // { foo: 1 }
pick(obj, ['foo', 'bar']); // { foo: 1, bar: 2 }
// use it with array.map
[obj, obj, obj].map(pick('foo')); // [{ foo: 1 }, { foo: 1 }, { foo: 1 }];
Functional version of obj[key], returns the value of the key from obj.
var pluck = require('101/pluck');
var obj = {
foo: 1,
bar: 2
};
pluck(obj, 'foo'); // 1
// use it with array.map
[obj, obj, obj].map(pluck('foo')); // [1, 1, 1]
// supports keypaths by default
var obj = {
foo: {
bar: 1
},
'foo.bar': 2
};
pluck(obj, 'foo.bar'); // 1
pluck(obj, 'foo.bar', false); // 2
Functional version of obj[key] = val, returns a new obj with the key and value set.
var set = require('101/set');
var obj = {
foo: 1,
bar: 2
};
set(obj, 'foo'); // 1
// use it with array.map
[obj, obj, obj].map(set('foo', 100)); // [{ foo: 100, bar: 2 }, {same}, {same}]
// supports keypaths by default
var obj = {
foo: 1,
bar: 2
};
set(obj, 'foo', 100); // { foo: 100, bar:2 }
MIT