A library of zero-dependency npm modules that do just one thing. A guilt-free alternative to those bulkier utility libraries. Ideal for PWA development or whenever bytes are precious.
We welcome contributions. Please follow our contribution guidelines.
A REPL for every utility (powered by RunKit)
- TRADEOFFS.md -- When to use Just (and when not to).
- The Zen of Dependency-Free -- Why I wrote Just.
All packages support ES module or Common JS syntax without requiring transpilation
// esm (node / bundler) import clone from 'just-clone'; // esm (native browser code) import clone from './node_modules/just-clone/index.mjs'; // cjs const clone = require('just-clone'); 
We're in the process of adding TypeScript definitions and tests to every Just utility. You're welcome to help us get there! Here's an example PR.
You can verify new TypeScript definitions by running yarn test-types (This also gets run as part of the yarn test script)
Data based on available saucelabs test browsers. It's likely Just is also fully supported by some older versions not verifiable via saucelabs.
| Chrome | Safari | Firefox | Edge | Node | Mobile Safari | Android |
|---|---|---|---|---|---|---|
| yes | yes | yes | 12 | 6+ | iOS 8+ | Android OS 5+ |
- Collections {}[]
- Objects {}
- Arrays []
- Statistics Ξ£
- Strings ""
- Numbers +-
- Functions =>
npm install just-diffyarn add just-diffReturn an object representing the difference between two other objects Pass converter to format as http://jsonpatch.com
import {diff} from 'just-diff'; const obj1 = {a: 4, b: 5}; const obj2 = {a: 3, b: 5}; const obj3 = {a: 4, c: 5}; diff(obj1, obj2); [ { "op": "replace", "path": ['a'], "value": 3 } ] diff(obj2, obj3); [ { "op": "remove", "path": ['b'] }, { "op": "replace", "path": ['a'], "value": 4 } { "op": "add", "path": ['c'], "value": 5 } ] // using converter to generate jsPatch standard paths import {diff, jsonPatchPathConverter} from 'just-diff' diff(obj1, obj2, jsonPatchPathConverter); [ { "op": "replace", "path": '/a', "value": 3 } ] diff(obj2, obj3, jsonPatchPathConverter); [ { "op": "remove", "path": '/b' }, { "op": "replace", "path": '/a', "value": 4 } { "op": "add", "path": '/c', "value": 5 } ] // arrays const obj4 = {a: 4, b: [1, 2, 3]}; const obj5 = {a: 3, b: [1, 2, 4]}; const obj6 = {a: 3, b: [1, 2, 4, 5]}; diff(obj4, obj5); [ { "op": "replace", "path": ['a'], "value": 3 } { "op": "replace", "path": ['b', 2], "value": 4 } ] diff(obj5, obj6); [ { "op": "add", "path": ['b', 3], "value": 5 } ] // nested paths const obj7 = {a: 4, b: {c: 3}}; const obj8 = {a: 4, b: {c: 4}}; const obj9 = {a: 5, b: {d: 4}}; diff(obj7, obj8); [ { "op": "replace", "path": ['b', 'c'], "value": 4 } ] diff(obj8, obj9); [ { "op": "replace", "path": ['a'], "value": 5 } { "op": "remove", "path": ['b', 'c']} { "op": "add", "path": ['b', 'd'], "value": 4 } ]npm install just-diff-applyyarn add just-diff-applyApply a diff object to an object. Pass converter to apply a http://jsonpatch.com standard patch
import diffApply from 'just-diff-apply'; const obj1 = {a: 3, b: 5}; diffApply(obj1, [ { "op": "remove", "path": ['b'] }, { "op": "replace", "path": ['a'], "value": 4 }, { "op": "add", "path": ['c'], "value": 5 } ] ); obj1; // {a: 4, c: 5} const obj2 = {a: 3, b: 5}; diffApply(obj2, [ { "op": "move", "from": ['a'], "path": ['c']}, ] ); obj2; // {b: 5, c: 3} // using converter to apply jsPatch standard paths // see http://jsonpatch.com import {diffApply, jsonPatchPathConverter} from 'just-diff-apply' const obj3 = {a: 3, b: 5}; diffApply(obj3, [ { "op": "remove", "path": '/b' }, { "op": "replace", "path": '/a', "value": 4 } { "op": "add", "path": '/c', "value": 5 } ], jsonPatchPathConverter); obj3; // {a: 4, c: 5} // arrays (array key can be string or numeric) const obj4 = {a: 4, b: [1, 2, 3]}; diffApply(obj4, [ { "op": "replace", "path": ['a'], "value": 3 } { "op": "replace", "path": ['b', 2], "value": 4 } { "op": "add", "path": ['b', 3], "value": 9 } ]); obj4; // {a: 3, b: [1, 2, 4, 9]} // nested paths const obj5 = {a: 4, b: {c: 3}}; diffApply(obj5, [ { "op": "replace", "path": ['a'], "value": 5 } { "op": "remove", "path": ['b', 'c']} { "op": "add", "path": ['b', 'd'], "value": 4 } ]); obj5; // {a: 5, b: {d: 4}}npm install just-compareyarn add just-compareCompare two collections
import compare from 'just-compare'; // primitives: value1 === value2 // functions: value1.toString == value2.toString // arrays: if length, sequence and values of properties are identical // objects: if length, names and values of properties are identical compare([1, [2, 3]], [1, [2, 3]]); // true compare([1, [2, 3], 4], [1, [2, 3]]); // false compare({a: 2, b: 3}, {a: 2, b: 3}); // true compare({a: 2, b: 3}, {b: 3, a: 2}); // true compare({a: 2, b: 3, c: 4}, {a: 2, b: 3}); // false compare({a: 2, b: 3}, {a: 2, b: 3, c: 4}); // false compare([1, [2, {a: 4}], 4], [1, [2, {a: 4}]]); // false compare([1, [2, {a: 4}], 4], [1, [2, {a: 4}], 4]); // true compare(NaN, NaN); // truenpm install just-cloneyarn add just-cloneDeep copies objects and arrays
// Deep copies objects and arrays, doesn't clone functions import clone from 'just-clone'; var arr = [1, 2, 3]; var subObj = { aa: 1 }; var obj = { a: 3, b: 5, c: arr, d: subObj }; var objClone = clone(obj); arr.push(4); objClone.d.bb = 2; obj; // {a: 3, b: 5, c: [1, 2, 3, 4], d: {aa: 1}} objClone; // {a: 3, b: 5, c: [1, 2, 3], d: {aa: 1, bb: 2}}npm install just-pluck-ityarn add just-pluck-itPluck a property from each member of a collection
import pluck from 'just-pluck-it'; pluck([{a:1, b:2}, {a:4, b:3}, {a:2, b:5}], 'a'); // [1, 4, 2] pluck({x: {a:1, b:2}, y: {a:4, b:3}, z: {a:2, b:5}}, 'a'); // {x: 1, y: 4, z: 2}npm install just-flushyarn add just-flushReturns a copy of an array or object with null/undefined members removed
import flush from 'just-flush'; flush([1, undefined, 2, null, 3, NaN, 0]); // [1, 2, 3, NaN, 0] flush([true, null, false, true, [null], undefined]); // [true, false, true, [null]] flush({a: 2, b: null, c: 4, d: undefined}); // {a: 2, c: 4} flush('something'); // undefined flush(); // undefinednpm install just-extendyarn add just-extendExtend an object
import extend from 'just-extend'; var obj = {a: 3, b: 5}; extend(obj, {a: 4, c: 8}); // {a: 4, b: 5, c: 8} obj; // {a: 4, b: 5, c: 8} var obj = {a: 3, b: 5}; extend({}, obj, {a: 4, c: 8}); // {a: 4, b: 5, c: 8} obj; // {a: 3, b: 5} var arr = [1, 2, 3]; var obj = {a: 3, b: 5}; extend(obj, {c: arr}); // {a: 3, b: 5, c: [1, 2, 3]} arr.push(4); obj; // {a: 3, b: 5, c: [1, 2, 3, 4]} var arr = [1, 2, 3]; var obj = {a: 3, b: 5}; extend(true, obj, {c: arr}); // {a: 3, b: 5, c: [1, 2, 3]} arr.push(4); obj; // {a: 3, b: 5, c: [1, 2, 3]} extend({a: 4, b: 5}); // {a: 4, b: 5} extend({a: 4, b: 5}, 3); {a: 4, b: 5} extend({a: 4, b: 5}, true); {a: 4, b: 5} extend('hello', {a: 4, b: 5}); // throws extend(3, {a: 4, b: 5}); // throwsnpm install just-mergeyarn add just-mergeShallow assign. Like just-extend but without deep copy option.
import merge from 'just-merge'; let obj = {a: 3, b: 5}; merge(obj, {a: 4, c: 8}); // {a: 4, b: 5, c: 8} obj; // {a: 4, b: 5, c: 8} let obj = {a: 3, b: 5}; merge({}, obj, {a: 4, c: 8}); // {a: 4, b: 5, c: 8} obj; // {a: 3, b: 5} let arr = [1, 2, 3]; let obj = {a: 3, b: 5}; merge(obj, {c: arr}); // {a: 3, b: 5, c: [1, 2, 3]} arr.push[4]; obj; // {a: 3, b: 5, c: [1, 2, 3, 4]} merge({a: 4, b: 5}); // {a: 4, b: 5} merge(3, {a: 4, b: 5}); // throws merge({a: 4, b: 5}, 3); // throws merge({a: 4, b: 5}, {b: 4, c: 5}, 'c'); // throwsnpm install just-valuesyarn add just-valuesReturn property values as an array
const values = require('just-values'); values({a: 4, c: 8}); // [4, 8] values({a: {aa: 2}, b: {bb: 4}}); // [{aa: 2}, {bb: 4}] values({}); // [] values([1, 2, 3]); // [1, 2, 3] values(function(a, b) {return a + b;}); // [] values(new String('hello')); // ['h', 'e', 'l', 'l', 'o'] values(1); // throws exception values(true); // throws exception values(undefined); // throws exception values(null); // throws exceptionnpm install just-entriesyarn add just-entriesReturn object entries as an array of [key, value] pairs
import entries from 'just-entries'; // Object: entries({c: 8, a: 4}); // [['c', 8], ['a', 4]] entries({b: {bb: 4}, a: {aa: 2}}); // [['b', {bb: 4}], ['a', {aa: 2}]] entries({}); // [] // Array: entries([{c: 8}, {a: 4}]); // [[0, {c: 8}], [1, {a: 4}]] entries(['Γ', 'mauvais', 'ouvrier', 'point', 'de', 'bon', 'outil']) // [[0, 'Γ'], [1, 'mauvais'] ... [6, 'outil']] entries([]); // []npm install just-pickyarn add just-pickCopy an object but with only the specified keys
import pick from 'just-pick'; var obj = { a: 3, b: 5, c: 9 }; pick(obj, ['a', 'c']); // {a: 3, c: 9} pick(obj, 'a', 'c'); // {a: 3, c: 9} pick(obj, ['a', 'b', 'd']); // {a: 3, b: 5} pick(obj, ['a', 'a']); // {a: 3}npm install just-omityarn add just-omitCopy an object but omit the specified keys
import omit from 'just-omit'; var obj = {a: 3, b: 5, c: 9}; omit(obj, ['a', 'c']); // {b: 5} omit(obj, 'a', 'c'); // {b: 5} omit(obj, ['a', 'b', 'd']); // {c: 9} omit(obj, ['a', 'a']); // {b: 5, c: 9}npm install just-is-emptyyarn add just-is-emptyReturn true if object has no enumerable key values
import isEmpty from 'just-is-empty'; isEmpty({a: 3, b: 5}) // false isEmpty([1, 2]) // false isEmpty(new Set([1, 2, 2])) // false isEmpty((new Map()).set('a', 2)) // false isEmpty({}) // true isEmpty([]) // true isEmpty(new Set()) // true isEmpty(new Map()) // true isEmpty('abc') // false isEmpty('') // true isEmpty(0) // true isEmpty(1) // true isEmpty(true) // true isEmpty(Symbol('abc')); // true isEmpty(//); // true isEmpty(new String('abc')); // false isEmpty(new String('')); // true isEmpty(new Boolean(true)); // true isEmpty(null) // true isEmpty(undefined) // truenpm install just-is-circularyarn add just-is-circularNOTE: not supported in IE or microsoft edge
import isCircular from 'just-is-circular'; const a = {}; a.b = a; isCircular(a); // true const a = {}; a.b = { c: a }; isCircular(a); // true const a = {}; a.b = { c: 4 }; isCircular(a); // false const a = []; a.push(a); isCircular(a); // true isCircular({}); // false isCircular('hi'); // false isCircular(undefined); // falsenpm install just-is-primitiveyarn add just-is-primitiveDetermine if a value is a primitive value
import isPrimitive from 'just-is-primitive'; isPrimitive('hi') // true isPrimitive(3) // true isPrimitive(true) // true isPrimitive(false) // true isPrimitive(null) // true isPrimitive(undefined) // true isPrimitive(Symbol()) // true isPrimitive({}) // false isPrimitive([]) // false isPrimitive(function() {}) // false isPrimitive(new Date()) // false isPrimitive(/a/) // falsenpm install just-filter-objectyarn add just-filter-objectFilter an object
import filter from 'just-filter'; // returns a new object containing those original properties for which the predicate returns truthy filter({a: 3, b: 5, c: 9}, (key, value) => value < 6); // {a: 3, b: 5} filter({a1: 3, b1: 5, a2: 9}, (key, value) => key[0] == 'a'); // {a1: 3, a2: 9} filter({a: 3, b: 5, c: null}, (key, value) => value); // {a: 3, b: 5}npm install just-map-objectyarn add just-map-objectMap an object, passing key and value to predicates
import map from 'just-map-object'; // DEPRECATED: use just-map-values map({a: 3, b: 5, c: 9}, (key, value) => value + 1); // {a: 4, b: 6, c: 10} map({a: 3, b: 5, c: 9}, (key, value) => key); // {a: 'a', b: 'b', c: 'c'} map({a: 3, b: 5, c: 9}, (key, value) => key + value); // {a: 'a3', b: 'b5', c: 'c9'}```npm install just-map-valuesyarn add just-map-valuesMap an object, predicate updates values, receives (value, key, object)
import map from 'just-map-values'; // predicate updates values, receives (value, key, obj) map({a: 3, b: 5, c: 9}, (value) => value + 1); // {a: 4, b: 6, c: 10} map({a: 3, b: 5, c: 9}, (value, key) => value + key); // {a: 3a, b: 5b, c: 9c} map({a: 3, b: 5, c: 9}, (value, key, obj) => obj.b); // {a: 5, b: 5, c: 5}npm install just-map-keysyarn add just-map-keysMap an object, predicate updates keys, receives (value, key, object)
import map from 'just-map-keys'; // predicate updates keys, receives (value, key, object) map({a: 'cow', b: 'sheep', c: 'pig'}, (value) => value); // {cow: 'cow', sheep: 'sheep', pig: 'pig'} map([4, 5, 6], (value, key) => key + 1); // {1: 4, 2: 5, 3: 6} map({a: 3, b: 5, c: 9}, (value, key) => key + value); // {a3: 3, b5: 5, c9: 9} map({a: 3, b: 5, c: 9}, (value, key, obj) => obj.b + value + key); // {'8a': 3, '10b': 5, '14c': 9}npm install just-deep-map-valuesyarn add just-deep-map-valuesReturns an object with values at all depths mapped according to the provided function
import deepMapValues from 'just-deep-map-values'; const squareFn = (number) => number * number; deepMapValues({ a: 1, b: { c: 2, d: { e: 3 } } }, squareFn); // => { a: 1, b: { c: 4, d: { e: 9 } } }npm install just-reduce-objectyarn add just-reduce-objectReduce an object
import reduce from 'just-reduce-object'; // applies a function against an accumulator and each key-value pairs of the object // to reduce it to a single value reduce({a: 3, b: 5, c: 9}, (acc, key, value, index, keys) => { acc[value] = key; return acc; }, {}); // {3: 'a', 5: 'b', 9: 'c'} reduce({a: 3, b: 5, c: 9}, (acc, key, value, index, keys) => { acc += value; return acc; }); // 17npm install just-safe-getyarn add just-safe-getGet value at property, don't throw if parent is undefined
import get from 'just-safe-get'; const obj = {a: {aa: {aaa: 2}}, b: 4}; get(obj, 'a.aa.aaa'); // 2 get(obj, ['a', 'aa', 'aaa']); // 2 get(obj, 'b.bb.bbb'); // undefined get(obj, ['b', 'bb', 'bbb']); // undefined get(obj.a, 'aa.aaa'); // 2 get(obj.a, ['aa', 'aaa']); // 2 get(obj.b, 'bb.bbb'); // undefined get(obj.b, ['bb', 'bbb']); // undefined get(obj.b, 'bb.bbb', 5); // 5 get(obj.b, ['bb', 'bbb'], true); // true get(null, 'a'); // undefined get(undefined, ['a']); // undefined get(null, 'a', 42); // 42 get(undefined, ['a'], 42); // 42 const obj = {a: {}}; const sym = Symbol(); obj.a[sym] = 4; get(obj.a, sym); // 4npm install just-safe-setyarn add just-safe-setSet value at property, create intermediate properties if necessary
import set from 'just-safe-set'; const obj1 = {}; set(obj1, 'a.aa.aaa', 4); // true obj1; // {a: {aa: {aaa: 4}}} const obj2 = {}; set(obj2, ['a', 'aa', 'aaa'], 4); // true obj2; // {a: {aa: {aaa: 4}}} const obj3 = {a: {aa: {aaa: 2}}}; set(obj3, 'a.aa.aaa', 3); // true obj3; // {a: {aa: {aaa: 3}}} // don't clobber existing const obj4 = {a: {aa: {aaa: 2}}}; set(obj4, 'a.aa', {bbb: 7}); // false const obj5 = {a: {}}; const sym = Symbol(); set(obj5.a, sym, 7); // true obj5; // {a: {Symbol(): 7}}npm install just-typeofyarn add just-typeofType inferer
import typeOf from 'just-typeof'; typeOf({}); // 'object' typeOf([]); // 'array' typeOf(function() {}); // 'function' typeOf(/a/); // 'regexp' typeOf(new Date()); // 'date' typeOf(null); // 'null' typeOf(undefined); // 'undefined' typeOf('a'); // 'string' typeOf(1); // 'number' typeOf(true); // 'boolean'npm install just-flip-objectyarn add just-flip-objectFlip the keys and values
import flip from 'just-flip-object'; // flip the key and value flip({a: 'x', b: 'y', c: 'z'}); // {x: 'a', y: 'b', z: 'c'} flip({a: 1, b: 2, c: 3}); // {'1': 'a', '2': 'b', '3': 'c'} flip({a: false, b: true}); // {false: 'a', true: 'b'}npm install just-hasyarn add just-hasReturn a boolen indicating the existence of a deep property, don't throw if parent is undefined
import has from 'just-has'; const obj = {a: {aa: {aaa: 2}}, b: 4}; has(obj, 'a.aa.aaa'); // true has(obj, ['a', 'aa', 'aaa']); // true has(obj, 'b.bb.bbb'); // false has(obj, ['b', 'bb', 'bbb']); // false has(obj.a, 'aa.aaa'); // true has(obj.a, ['aa', 'aaa']); // true has(obj.b, 'bb.bbb'); // false has(obj.b, ['bb', 'bbb']); // false has(null, 'a'); // false has(undefined, ['a']); // false const obj = {a: {}}; const sym = Symbol(); obj.a[sym] = 4; has(obj.a, sym); // truenpm install just-cartesian-productyarn add just-cartesian-productTakes an input of an array of arrays and returns their Cartesian product.
import cartesianProduct from 'just-cartesian-product'; cartesianProduct([[1, 2], ['a', 'b']]); // [[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b']] cartesianProduct([[1, 2], ['a', 'b', 'c']]); // [[1, 'a'], [1, 'b'], [1, 'c'], [2, 'a'], [2, 'b'], [2, 'c']] cartesianProduct([]); // [] cartesianProduct(); // throwsnpm install just-uniqueyarn add just-uniqueDedupes an array
import unique from 'just-unique'; unique([1, 2, 3, 2, 3, 4, 3, 2, 1, 3]); // [1, 2, 3, 4] var a = {a: 3}; var b = {b: 4}; var c = {c: 5}; unique([a, a, b, c, b]); // [a, b, c] unique([1, '1', 2, '2', 3, 2]); // [1, '1', 2, '2', 3] // declaring sorted array for performance unique([1, 1, '1', 2, 2, 5, '5', '5'], true); // [1, '1', 2, 5, '6'] // declaring strings array for performance unique(['a', 'c', 'b', 'c', 'a'], false, true); // ['a', 'b', 'c']npm install just-flatten-ityarn add just-flatten-itReturn a flattened array
import flatten from 'just-flatten-it'; flatten([[1, [2, 3]], [[4, 5], 6, 7, [8, 9]]]); // [1, 2, 3, 4, 5, 6, 7, 8, 9] flatten([[1, [2, 3]], [[4, 5], 6, 7, [8, 9]]], 1); // [1, [2, 3], [[4, 5], 6, 7, [8, 9]]]npm install just-indexyarn add just-indexReturn an object from an array, keyed by the value at the given id
import index from 'just-index'; index([{id: 'first', val: 1}, {id: 'second', val: 2}], 'id'); // {first: {id: 'first', val: 1}, second: {id: 'second', val: 2}} index([{id: 'first', val: 1}, null], 'id'); // {first: {id: 'first', val: 1}} index([], 'id'); // {} index([], null); // undefined index({}, 'id'); // undefinednpm install just-insertyarn add just-insertInserts a sub-array into an array starting at the given index. Returns a copy
import insert from 'just-insert'; insert([1, 2, 5, 6], ['a', 'c', 'e'], 2); // [1, 2, 'a', 'c', 'e', 5, 6] insert([1, 2, 5, 6], 'a', 2); // [1, 2, 'a', 5, 6] insert([1, 2, 5, 6], ['a', 'c', 'e'], 0); // ['a', 'c', 'e', 1, 2, 5, 6] insert([1, 2, 5, 6], ['a', 'c', 'e']); // ['a', 'c', 'e', 1, 2, 5, 6]npm install just-intersectyarn add just-intersectReturn the intersect of two arrays
import intersect from 'just-intersect'; intersect([1, 2, 5, 6], [2, 3, 5, 6]); // [2, 5, 6] intersect([1, 2, 2, 4, 5], [3, 2, 2, 5, 7]); // [2, 5] npm install just-compactyarn add just-compactReturns a copy of an array with falsey values removed
import compact from 'just-compact'; compact([1, null, 2, undefined, null, NaN, 3, 4, false, 5]); // [1, 2, 3, 4, 5] compact([1, 2, [], 4, {}]); // [1, 2, [], 4, {}] compact([]); // [] compact({}); // throwsnpm install just-lastyarn add just-lastReturn the last member of an array
import last from 'just-last'; last([1, 2, 3, 4, 5]); // 5 last([{a: 1}, {b: 1}, {c: 1}]); // {c: 1} last([true, false, [true, false]]); // [true, false] last(); // undefined last([]); // undefined last(null); // undefined last(undefined); // undefinednpm install just-tailyarn add just-tailReturn all but the first element of an array
import tail from 'just-tail'; tail([1, 2, 3, 4, 5]); // [2, 3, 4, 5] tail([{a: 1}, {b: 1}, {c: 1}]); // [{b: 1}, {c: 1}] tail([true, false, [true, false]]); // [false, [true, false]] tail([]); // [] tail(); // undefined tail(null); // undefined tail(undefined); // undefinednpm install just-randomyarn add just-randomReturn a randomly selected element in an array
import random from 'just-random'; random([1, 2, 3]); // one of [1, 2, 3], at randomnpm install just-shuffleyarn add just-shuffleReturn the elements of an array in random order
import shuffle from 'just-shuffle'; shuffle([1, 2, 3]); // array with original elements randomly sorted shuffle([1, 2, 3], {shuffleAll: true}); // array with original elements randomly sorted and all in new postions shuffle([]); // [] shuffle([1]); // [1] shuffle(); // throws shuffle(undefined); // throws shuffle(null); // throws shuffle({}); // throwsnpm install just-splityarn add just-splitSplits array into groups of n items each
import split from 'just-split'; split([]); // [] split([1, 2, 3, 4, 5]); // [[1, 2, 3, 4, 5]] split([1, 2, 3, 4, 5, 6, 7, 8, 9], 3); // [[1, 2, 3], [4, 5, 6], [7, 8, 9]] split([1, 2, 3, 4, 5, 6, 7, 8, 9], '3'); // [[1, 2, 3], [4, 5, 6], [7, 8, 9]] split(['a', 'b', 'c', 'd', 'e'], 2); // [['a', 'b'], ['c', 'd'], ['e']] split([1, 2, 3, 4, 5, 6, 7, 8], 3); // [[1, 2, 3], [4, 5, 6], [7, 8]]npm install just-split-atyarn add just-split-atSplits an array into two at a given position
import splitAt from 'just-split-at'; splitAt([1, 2, 3, 4, 5], 2); // [[1, 2], [3, 4, 5]] splitAt([{a: 1}, {b: 1}, {c: 1}], -1); // [[{a: 1}, {b: 1}], [{c: 1}]] splitAt([], 2); // [[], []] splitAt(null, 1); // throws splitAt(undefined, 1); // throwsnpm install just-sort-byyarn add just-sort-byProduces a new array, sorted in ascending order
import sortBy from 'just-array-sort-by'; sortBy([10, 1, 5, 20, 15, 35, 30, 6, 8]); // [1, 5, 6, 8, 10, 15, 20, 30, 35] sortBy([ {user: 'fabio', details: {city: "Milan", age: 34}}, {user: 'max', details: {city: "Munich", age: 29}}, {user: 'zacarias', details: {city: "Sao Paulo", age: 44}}, {user: 'robert', details: {city: "Manchester", age: 28}}, {user: 'klaus', details: {city: "Zurich", age: 38}}, ], function(o) { return o.details.age; }); /* [ {user: 'robert', age: 28}, {user: 'max', age: 29}, {user: 'fabio', age: 34}, {user: 'klaus', age: 38}, {user: 'zacarias', age: 44}, ] */ sortBy([ {user: 'fabio', age: 34}, {user: 'max', age: 29}, {user: 'zacarias', age: 44}, {user: 'robert', age: 28}, {user: 'klaus', age: 38}, ], 'user'); /* [ {user: 'fabio', age: 34}, {user: 'klaus', age: 38}, {user: 'max', age: 29}, {user: 'robert', age: 28}, {user: 'zacarias', age: 44}, ] */npm install just-partitionyarn add just-partitionElements satisfying predicate added to first array, remainder added to second
import partition from 'just-partition'; partition([1, 5, 2, 4, 3], n => n > 3); // [[5, 4],[1, 2, 3]] partition(['a', 2, 3, '3'], x => typeof x == 'string'); // [['a', '3'],[2, 3]] partition([1, 2, 3, 4], x => typeof x == 'number'); // [[1, 2, 3, 4],[]] partition([1, 2, 3, 4], x => typeof x == 'string'); // [[], [1, 2, 3, 4]] partition([], n => n > 3); // [[], []] partition({a: 1, b: 2}, n => n > 1); // throws partition(null, n => n > 1); // throws partition(undefined, n => n > 1); // throwsnpm install just-permutationsyarn add just-permutationsReturns all permutations of the length N of the elements of the given Array
import permutations from 'just-array-permutations; permutations([1, 2, 3]); // [[1, 2, 3], [2, 1, 3], [2, 3, 1], [1, 3, 2], [3, 1, 2], [3, 2, 1]] permutations([]); // [] permutations(); // throwsnpm install just-rangeyarn add just-rangeGenerate a range array for numbers
import range from 'just-range'; range(1, 5); // [1, 2, 3, 4] range(5); // [0, 1, 2, 3, 4] range(-5); // [0, -1, -2, -3, -4] range(0, 20, 5) // [0, 5, 10, 15]npm install just-removeyarn add just-removeRemoves one array from another
import remove from 'just-remove'; remove([1, 2, 3, 4, 5, 6], [1, 3, 6]); // [2, 4, 5]npm install just-unionyarn add just-unionReturns the union of two arrays
import union from 'just-union'; union([1, 2, 5, 6], [2, 3, 4, 6]); // [1, 2, 3, 4, 5, 6]npm install just-zip-ityarn add just-zip-itReturns an array of grouped elements, taking n-th element from every given array
import zip from 'just-zip-it'; zip([1, 2, 3]); // [[1], [2], [3]] zip([1, 2, 3], ['a', 'b', 'c']); // [[1, 'a'], [2, 'b'], [3, 'c']] zip([1, 2], ['a', 'b'], [true, false]); //[[1, 'a', true], [2, 'b', false]] zip(undefined, {}, false, 1, 'foo'); // [] zip([1, 2], ['a', 'b'], undefined, {}, false, 1, 'foo'); // [[1, 'a'], [2, 'b']] zip([1, 2, 3], ['a', 'b'], [true]); // [[1, 'a', true], [2, 'b', undefined], [3, undefined, undefined]]npm install just-group-byyarn add just-group-byReturn a grouped object from array
import groupBy from 'just-group-by'; groupBy([6.1, 4.2, 6.3], Math.floor); // { '4': [4.2], '6': [6.1, 6.3] } groupBy([1,2,3,4,5,6,7,8], function(i) { return i % 2}); // { '0': [2, 4, 6, 8], '1': [1, 3, 5, 7] }npm install just-meanyarn add just-meanThe mean (average) value in an array
import mean from 'just-mean'; mean([1, 2, 3, 2, 4, 1]); // 2.1666666667 mean(3, 2, 1); // 2 mean([4]); // 4 mean(['3', 2]); // throws mean(); // throwsnpm install just-medianyarn add just-medianReturn the median value of an array of numbers
import median from 'just-median'; median([1, 2, 3, 4, 5]); // 3 median([3, -1, 2]); // 2 median([9, 14, 14, 200, 15]); // 14 median(1, 2, 4, 3); // 2.5 median(['3', 2, 1]); // throws median(); // throwsnpm install just-modeyarn add just-modeReturn the most frequently occuring number(s)
import mode from 'just-mode'; mode([1, 2, 3, 2]); // 2 mode(4, 4, 1, 4); // 4 mode(100, 100, 101, 101); // [100, 101] mode(4, 3, 2, 1); // [1, 2, 3, 4] mode(['1', 2, 2, 1, 2]); // throws mode(null); // throwsnpm install just-percentileyarn add just-percentileReturn the value at the given percentile (using linear interpolation)
import percentile from 'just-percentile'; percentile([1, 2, 3], 0); // 1 percentile([1, 2, 3], 50); // 2 percentile([1, 2, 3], 100); // 3 // See https://en.wikipedia.org/wiki/Percentile (linear interpolation method) percentile([15, 20, 35, 40, 50], 5); // 15 percentile([15, 20, 35, 40, 50], 30); // 20 percentile([15, 20, 35, 40, 50], 40); // 27.5 percentile([15, 20, 35, 40, 50], 95); // 50 percentile(1, 2, 3, 50); // throws percentile(['1', 2, 3], 50); // throws percentile([], 50); // throwsnpm install just-varianceyarn add just-varianceReturn the standard deviation of an array or numeric argument list
import variance from 'just-variance'; variance([1, 2, 3, 2, 4, 1]); // 1.3666666667 variance(3, 2, 1); // 1 variance([100, 100, 100.1, 100]); // 0.0025 variance(1, 2, 3, 4, 5, -6); // 15.5 variance([4]); // throws variance(['3', 2]); // throws variance(NaN, NaN); // throws variance(); // throwsnpm install just-standard-deviationyarn add just-standard-deviationReturn the standard deviation of an array or numeric argument list
import standardDeviation from "just-standard-deviation"; standardDeviation([1, 2, 3, 2, 4, 1]); // 1.16904519 standardDeviation(3, 2, 1); // 1 standardDeviation([100, 100, 100.1, 100]); // 0.05 standardDeviation(1, 2, 3, 4, 5, -6); // 3.9370039 standardDeviation([4]); // throws standardDeviation(["3", 2]); // throws standardDeviation(NaN, NaN); // throws standardDeviation(); // throwsnpm install just-skewnessyarn add just-skewnessReturn the skewness of an array or numeric argument list using Pearson's second skewness coefficient
import skewness from "just-skewness"; // Using Pearson's second skewness coefficient skewness(3, 2, 1); // 0 skewness([1, 2, 3, 2, 4, 1]); // 0.4276994613841504 skewness(1, 2, 3, 4, 5, -6); // -0.762000762001143 skewness([1, 2, 3, 4, 9]); // 0.7705935588815224 skewness([4]); // throws skewness(["3", 2]); // throws skewness(NaN, NaN); // throws skewness(); // throwsnpm install just-templateyarn add just-templateInterpolate a string with variables
import template from 'just-template'; var data = { a: { aa: { aaa: 'apple', bbb: 'pear' }, bb: 'orange' }, b: 'plum' }; template('2 {{a.aa.aaa}}s, a {{a.aa.bbb}}, 3 {{a.bb}}s and a {{b}}. Yes 1 {{a.aa.bbb}}.', data); // '2 apples, a pear, 3 oranges and a plum. Yes 1 pear.'npm install just-truncateyarn add just-truncateTruncate a string with a custom suffix
truncate('when shall we three meet again', 9); // 'when s...' truncate('when shall we three meet again', 10, ' (etc)'); // 'when (etc)' truncate('when shall we', 15,); // 'when shall we' truncate('when shall we', 15, '(more)'); // 'when shall we' truncate('when shall we', 10, ' (etc etc etc)'); // ' (etc etc etc)'npm install just-pruneyarn add just-prunePrune a string with whole words and a custom suffix
prune('when shall we three meet again', 7); // 'when...' prune('when shall we three meet again', 7, ' (more)'; // 'when (more)' prune('when shall we', 15,); // 'when shall we' prune('when shall we', 15, ' (etc)'); // 'when shall we' prune('when shall we', 7, ' (more)'); // ' (more)'npm install just-squashyarn add just-squashRemove all spaces from a string, optionally remove escape sequences too
squash('the cat sat on the mat'); // 'thecatsatonthemat' squash(' the cat sat on the mat '); // 'thecatsatonthemat' squash('\tthe cat\n sat \fon \vthe \rmat '); // '\tthecat\nsat\fon\vthe\rmat' squash('\tthe cat\n sat \fon \vthe \rmat ', true); // 'thecatsatonthemat' squash(`the cat sat on the mat`, true); // thecatsatonthematnpm install just-left-padyarn add just-left-padAdd characters to the left of a string such that its total length is n
import leftPad from 'just-left-pad'; leftPad('hello', 9); // ' hello' leftPad('hello', 3); // 'hello' leftPad('hello', 9, '.'); // '....hello' leftPad('hello', 9, '..'); // '....hello' leftPad('hello', 10, 'ab'); // 'bababhello' leftPad('hello', 9, '\uD83D\uDC04'); // 'ππππhello' leftPad('hello', 10, '\uD83D\uDC11\uD83D\uDC04'), // 'πππππhello' leftPad('hello', 7, 'π'), // 'ππhello' leftPad(null, 7); // throws leftPad([], 4, '*'); // throws leftPad('hello', 4, true); // throws leftPad('hello', -4, true); // throws leftPad('hello', 2.3, true); // throws npm install just-right-padyarn add just-right-padAdd characters to the right of a string such that its total length is n
import rightPad from 'just-right-pad'; rightPad('hello', 9); // 'hello ' rightPad('hello', 3); // 'hello' rightPad('hello', 9, '.'); // 'hello....' rightPad('hello', 9, '..'); // 'hello....' rightPad('hello', 10, 'ab'); // 'helloababa' rightPad('hello', 9, '\uD83D\uDC04'); // 'helloππππ' rightPad('hello', 10, '\uD83D\uDC11\uD83D\uDC04'), // 'helloπππππ' rightPad('hello', 7, 'π'), // 'helloππ' rightPad(null, 7); // throws rightPad([], 4, '*'); // throws rightPad('hello', 4, true); // throws rightPad('hello', -4, true); // throws rightPad('hello', 2.3, true); // throws npm install just-camel-caseyarn add just-camel-caseConvert a string to camel case
import camelCase from 'just-camel-case'; camelCase('the quick brown fox'); // 'theQuickBrownFox' camelCase('the_quick_brown_fox'); // 'theQuickBrownFox' camelCase('the-quick-brown-fox'); // 'theQuickBrownFox' camelCase('theQuickBrownFox'); // 'theQuickBrownFox' camelCase('thequickbrownfox'); // 'thequickbrownfox' camelCase('the - quick * brown# fox'); // 'theQuickBrownFox' camelCase('behold theQuickBrownFox'); // 'beholdTheQuickBrownFox' camelCase('Behold theQuickBrownFox'); // 'beholdTheQuickBrownFox' // all caps words are camel-cased camelCase('The quick brown FOX'), 'theQuickBrownFox'); // all caps substrings >= 4 chars are camel-cased camelCase('theQUickBrownFox'); // 'theQUickBrownFox' camelCase('theQUIckBrownFox'); // 'theQUIckBrownFox' camelCase('theQUICKBrownFox'); // 'theQuickBrownFox'npm install just-kebab-caseyarn add just-kebab-caseConvert a string to kebab case
import kebabCase from 'just-kebab-case'; kebabCase('the quick brown fox'); // 'the-quick-brown-fox' kebabCase('the-quick-brown-fox'); // 'the-quick-brown-fox' kebabCase('the_quick_brown_fox'); // 'the-quick-brown-fox' kebabCase('theQuickBrownFox'); // 'the-quick-brown-fox' kebabCase('theQuickBrown Fox'); // 'the-quick-brown-fox' kebabCase('thequickbrownfox'); // 'thequickbrownfox' kebabCase('the - quick * brown# fox'); // 'the-quick-brown-fox' kebabCase('theQUICKBrownFox'); // 'the-q-u-i-c-k-brown-fox'npm install just-snake-caseyarn add just-snake-caseConvert a string to snake case
import snakeCase from 'just-snake-case'; snakeCase('the quick brown fox'); // 'the_quick_brown_fox' snakeCase('the-quick-brown-fox'); // 'the_quick_brown_fox' snakeCase('the_quick_brown_fox'); // 'the_quick_brown_fox' snakeCase('theQuickBrownFox'); // 'the_quick_brown_fox' snakeCase('thequickbrownfox'); // 'thequickbrownfox' snakeCase('the - quick * brown# fox'); // 'the_quick_brown_fox' snakeCase('theQUICKBrownFox'); // 'the_q_u_i_c_k_brown_fox'npm install just-pascal-caseyarn add just-pascal-caseConvert a string to pascal case
import pascalCase from 'just-pascal-case'; pascalCase('the quick brown fox'); // 'TheQuickBrownFox' pascalCase('the_quick_brown_fox'); // 'TheQuickBrownFox' pascalCase('the-quick-brown-fox'); // 'TheQuickBrownFox' pascalCase('theQuickBrownFox'); // 'TheQuickBrownFox' pascalCase('thequickbrownfox'); // 'Thequickbrownfox' pascalCase('the - quick * brown# fox'); // 'TheQuickBrownFox' pascalCase('theQUICKBrownFox'); // 'TheQUICKBrownFox'npm install just-capitalizeyarn add just-capitalizeCapitalize the first character of a string
import capitalize from 'just-capitalize'; /* capitalize('capitals'); // 'Capitals' capitalize('Capitals'); // 'Capitals' capitalize('many words'); // 'Many words' capitalize('!exclaim'); // '!exclaim' */npm install just-replace-allyarn add just-replace-allReplace all occurrences of a string within a string with another string
import replaceAll from 'just-replace-all'; /* replaceAll('hello, world', 'l', 'q'); // 'heqqo, worqd' replaceAll('hello, world', 'l', 'qq'); // 'heqqqqo, worqqd' replaceAll('hello, world', 'll', 'q'); // 'heqo, world' replaceAll('hello, world', '', 'q'); // 'hello, world' replaceAll('hello, world', 'l', ''); // 'heo, word' replaceAll('hello, world', null, 'q'); // 'hello, world' replaceAll('hello, world', 'l'); // throw replaceAll('hello, world'); // throw replaceAll(); // throw replaceAll(null, 'l', 'q'); // throw replaceAll('hello, world', null, 'q'); // throw replaceAll('hello, world', 'l', null); // throw */npm install just-clampyarn add just-clampRestrict a number within a range
import clamp from 'just-clamp'; var n = 5; clamp(1, n, 12); // 5 clamp(3, n, 1); // 3 clamp(8, n, 9); // 8 clamp(0, n, 0); // 0 var n = -5; clamp(1, n, 12); // 1 clamp(-7, n, -8); // -7 clamp(NaN, n, 8); // NaN clamp(3, n, NaN); // NaN clamp(3, NaN, 8); // NaN clamp(undefined, n, 8); // throws clamp(3, n, 'h'); // throws clamp(3, false, 8); // throws npm install just-is-primeyarn add just-is-primeCheck if number is prime
import isPrime from 'just-is-prime; /* isPrime(1); // false isPrime(2); // true isPrime(17); // true isPrime(10); // false isPrime(); // throws isPrime(null); // throws isPrime("js"); // throws isPrime({}); // throws isPrime(function() {}); // throws isPrime([]); // throws */npm install just-moduloyarn add just-moduloModulo of a number and a divisor
import modulo from 'just-modulo'; modulo(7, 5); // 2 modulo(17, 23); // 17 modulo(16.2, 3.8); // 1 modulo(5.8, 3.4); //2.4 modulo(4, 0); // 4 modulo(-7, 5); // 3 modulo(-2, 15); // 13 modulo(-5.8, 3.4); // 1 modulo(12, -1); // NaN modulo(-3, -8); // NaN modulo(12, 'apple'); // NaN modulo('bee', 9); // NaN modulo(null, undefined); // NaNnpm install just-random-integeryarn add just-random-integerProduces a random integer within a given range
import random from 'just-random-integer'; random(); // Returns either 0 or 1 random(5); // Returns a random integer between 0 and 5 (inclusively) random(3, 10); // Returns a random integer between 3 and 10 (inclusively) random(-5.8, 10.4); // Returns a random integer between -5 and 10 (inclusively)npm install just-composeyarn add just-composeReturn a function composed of 2 or more functions
import compose from 'just-compose'; const sqRootBiggest = compose(Math.max, Math.sqrt, Math.trunc); sqRootBiggest(10, 5); // 3 sqRootBiggest(7, 0, 16); // 4npm install just-curry-ityarn add just-curry-itReturn a curried function
import curry from 'just-curry-it'; function add(a, b, c) { return a + b + c; } curry(add)(1)(2)(3); // 6 curry(add)(1)(2)(2); // 5 curry(add)(2)(4, 3); // 9 function add(...args) { return args.reduce((sum, n) => sum + n, 0) } var curryAdd4 = curry(add, 4) curryAdd4(1)(2, 3)(4); // 10 function converter(ratio, input) { return (input*ratio).toFixed(1); } const curriedConverter = curry(converter) const milesToKm = curriedConverter(1.62); milesToKm(35); // 56.7 milesToKm(10); // 16.2npm install just-demethodizeyarn add just-demethodizeTurn a method into a standalone function; the first arg becomes this
import demethodize from 'just-demethodize'; const trimFn = demethodize(''.trim); ['hello ', ' goodbye', 'hello again'].map(trimFn); // ['hello', 'goodbye', 'hello again']npm install just-flipyarn add just-flipFlip first two arguments of a function
import flip from 'just-flip'; flip(console.log)(1, 2, 3) // 2, 1, 3 import map from 'just-map-object'; import partial from 'just-partial'; const numbers = {x: 5, y: 10}; const flippedMap = flip(map); const double = partial(flippedMap, (undefined, number) => number * 2); double(numbers) // {x: 10, y: 20];npm install just-partial-ityarn add just-partial-itReturn a partial function
import partial from 'just-partial-it'; const cubedRoot = partial(Math.pow, _, 1/3); cubedRoot(64); // 4 const getRoot = partial(Math.pow, 64); getRoot(1/2); // 8npm install just-debounce-ityarn add just-debounce-itReturn a debounced function
import debounce from "just-debounce-it"; const fn1 = debounce(() => console.log("Hello"), 500); fn1(); fn1(); fn1(); // 500ms later logs 'hello' once const fn2 = debounce(() => console.log("Hello"), 500, true); fn2(); // logs hello immediately fn2(); fn2(); // 500ms later logs 'hello' once const fn3 = debounce(() => console.log("Hello"), 500); fn3(); fn3(); fn3(); fn3.cancel(); // function cancelled before 'hello' is logged const fn4 = debounce(() => console.log("Hello"), 500); fn4(); fn4(); fn4(); fn4.flush(); // immediately invoke the debounced functionnpm install just-memoizeyarn add just-memoizeAn implementation of the memoize technique
import memoize from 'just-memoize'; const sumByOne = memoize(function(value) { return value + 1; }); sumByOne(10); // Returns value returned by the function sumByOne(10); // Cache hit! sumByOne(20); // Returns value returned by the function sumByOne(20); // Cache hit! // Custom cache key (key defaults to JSON stringified arguments) var sum = memoize(function(a, b) { return a + b; }, function(a, b) { return `${a}-${b}`; }); sum(10, 10); // Returns value returned by the function sum(10, 20); // Returns value returned by the function sum(10, 20); // Cache hit!npm install just-memoize-lastyarn add just-memoize-lastA memoize implementation that only caches the most recent evaluation
const memoizeLast = require('just-memoize-last') const compare = require('just-compare') const maxValue = memoizeLast(function(arr) { return Math.max(...arr) }, function(a, b) { return compare(a, b) }); maxValue([1,2,3]) // 3 maxValue([1,2,3]) // cache hit! maxValue([1,3,4]) // 4 maxValue([1,2,3]) // 3npm install just-randomyarn add just-randomReturn a randomly selected element in an array
import random from 'just-random'; random([1, 2, 3]); // one of [1, 2, 3], at randomnpm install just-throttleyarn add just-throttleReturn a throttled function
import throttle from 'just-throttle'; // no matter how many times the function is called, only invoke once within the given interval // options: // `leading`: invoke before interval // `trailing`: invoke afer interval const fn1 = throttle(() => console.log('hello'), 500, {leading: true}); setInterval(fn1, 400); // logs 'hello' immediately and then every 500ms const fn2 = throttle(() => console.log('hello'), 500, {trailing: true}); setInterval(fn2, 400); // logs 'hello' after 500ms and then every 500ms const fn3 = throttle(() => console.log('hello'), 500, {leading: true, trailing: true}); // forces trailing to false const fn4 = throttle(() => console.log('hello'), 500, { leading: false }); fn4(); fn4(); fn4(); fn4.cancel(); // function cancelled before 'hello' is logged const fn5 = throttle(() => console.log("Hello"), 500); fn5(); fn5(); fn5(); fn5.flush(); // immediately invoke the throttled functionnpm install just-onceyarn add just-onceCreate a function that can only be invoked once
import once from 'just-once'; const fn = once(() => console.log('hello')); fn(); // logs 'hello' fn(); // does nothingRun all tests as a single test suite with
npm run test
Cross browser tests (via saucelabs) are in the sauce branch