Cleans the given array of empty values

• TypeError: When the passed array is not actually an array.

const sourceArray = [undefined, null, true, '', {}];
arrayClean(sourceArray); // Returns: [true, {}]

arrayClean() // throws: Cannot read property 'length' of undefined

Check if an array contains a specified item

• TypeError: When filter can not be found on array . This generally happens when the array is null or undefined

const a = [1, 2];
const b = [1, 3];
difference(a, b) // returns: [2]
difference(a, b, true) // returns: [2, 3]

Create an array from a value

Insert a value into an array

const sourceArray = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
sourceArray, undefined, ['a', 'b', 'c']); // Returns: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 'a', 'b', 'c']

Return the highest value (number) in the given array

• TypeError: When the passed array is not actually an array.

const sourceArray = [1,3,2];
arrayMax(sourceArray); // Returns: 3

arrayClean() // throws: Cannot read property 'length' of undefined

Return the lowest value (number) in the given array

• TypeError: When the passed array is not actually an array.

const sourceArray = [3,1,2];
arrayMax(sourceArray); // Returns: 1

arrayClean() // throws: Cannot read property 'length' of undefined

• TypeError: When the propertyName can not be found on an item in the array . This generally happens when a value in the array is null or undefined

const values = [{name: 'John'}, {name: 'James'}];
arrayPluck(values, 'name') // returns: ['John', 'James']

const values = [{name: 'John'}, {}, {name: 'James'}];
arrayPluck(values, 'name') // returns: ['John', undefined, 'James']

const values = [undefined, {name: 'James'}];
arrayPluck(values, 'name') // throws: Cannot read property 'name' of undefined

Repeats content of array by structure or by index, returns flattened array.

const values = [1, 2, 3];
arrayRepeat(values, 3) // returns: [1, 2, 3, 1, 2, 3, 1, 2, 3]

const values = [1, 2, 3];
arrayRepeat(values, 3, true) // returns: [1, 1, 1, 2, 2, 2, 3, 3, 3]

Replace values in an array with given values or remove values from an array.

const sourceArray = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
arrayReplace(sourceArray, 0, 5, ['a', 'b', 'c', 'd']); // Returns: ['a', 'b', 'c', 'd', 6, 7, 8, 9, 10]

Create an array from the passed param. (When the value is an object only takes the iterable properties from the object (not its prototypes))

arrayTo('myData') // Returns: ['myData']

const sourceObject = {
    name: 'ANC First Visit',
    shortName: 'ANC1',
    level: 1,
};
arrayTo(sourceObject); // Returns: ['ANC First Visit', 'ANC1', 1]

arrayTo(null); // Returns: []

Creates an array of unique values from the array passed. This function does not do a deep compare. Objects with the same values will therefore not be filtered.

• TypeError: Is thrown when the argument passed is not an array

const sourceArray = [1, 1, 2, 3, 2, 4, 4, 3];
arrayUnique(sourceArray); // returns: [1, 2, 3, 4]

const A = {name: 'A'};
const B = {name: 'B'};
arrayUnique([A, A, B, B]); // Returns: [{name: 'A'}, {name: 'B'}]

const sourceArray = [{name: 'A'}, {name: 'B'}, {name: 'B'}];
arrayUnique(sourceArray); // Returns: [{name: 'A'}, {name: 'B'}, {name: 'B'}]

Convert a camelCase word to its underscore_case equivalent

const word = 'HelloMyAmazingWorld';
camelCaseToUnderscores(word); // Returns: 'hello_my_amazing_world'

Create a clone a value

const person1 = {name: 'John'};
const person2 = clone(person1); // Returns {name: 'John'}
// but
person1 !== person2 // Returns:  true

Check if the value is an Array

isArray([]); // Returns: true
isArray({}); // Returns: false
isArray('Hello'); // Returns: false

Check if an array consists of strings

isArrayOfStrings(['Mark', 'John']) // Returns: true
isArrayOfStrings([{name: 'Mark'}, {name: 'John'}]) // Returns: false

Check if a value is a boolean value true or false

Check if param is defined.

Check if a value is concidered empty. An empty value is an empty Set, Map or Array. Depending on if the allowEmptyString flag, empty strings are also considered empty

isEmpty(''); // Returns: true
isEmpty('', true); // Returns: false
isEmpty(null); // Returns: true
isEmpty(new Map()); // Returns: true

Check if the value is a Function

Check if the users browser is a version of Internet Explorer

// When using IE10
isIE(); // Returns: 10

// When using FireFox
isIE(); // Returns: false

TODO: It is not very good practice to return two different types of values from a function. Perhaps we can return `true` on IE and have a secondary function to get the version?

Check if a value is an integer

isInteger(17); // Returns: true

isInteger(0xFF); // Returns: true

isInteger(-17); // Returns: true

isInteger(2e-3); // Returns: false

isIterable('My value'); // Returns:  true

isIterable([1, 2, 3]); // Returns: true

isIterable({}); // Returns: false

let iterableObject = {
    [Symbol.iterator]: () => {}
};
isIterable(iterableObject); // Returns: true

Check if a value is a number

Check if a value is numeric

Check if the value is an Object

Check if a value is a primitive (string, number, boolean)

Check if the value is a String

Constrains the value between the passed min and max

Returns the number of decimal places in a number

Check if a number is finite

Fixes the number to a certain amount of decimals

Applies properties from "config" if they are undefined in "object.

let object = {id: 1}
const config = {id: 2, name: 'Name'}
objectApplyIf(object, config); // returns: {id: 1, name: 'Name'}

Applies properties from "config" if they are undefined in "object.

let object = {id: 1, name: undefined}
objectClean(object); // returns: {id: 1}

Replace all occurrences of the matchValue within the str parameter.

Removes all spaces before first after last text char.

Generates a universally unique identifier