Function

Passes each element of the array to the given function, and checks if all of the items make the given function return a truthy value, or if all of the items are truthy values.

Example:

 all([1, 'string', true], Boolean); // true

 rbjs([1, 'string', true]).all(Boolean); // true

Passes each element of the array to the given function, and checks if any of the items makes the given function return a truthy value, or if any of the items is a truthy value.

Example:

 any([null, undefined, true], Boolean); // true

 rbjs([null, undefined, true]).any(Boolean); // true

Appends the given object(s) on to the end of the given array.

Example:

 append([1, 2], 3); // => [1, 2, 3]
 append([1, 2], 3, 4, 5); // => [1, 2, 3, 4, 5]

 rbjs([1, 2]).append(3); // => [1, 2, 3]
 rbjs([1, 2]).append(3, 4, 5); // => [1, 2, 3, 4, 5]

Searches through an array whose elements are also arrays comparing obj with the first element of each contained array.

Example:

 assoc([
     ['colors', 'red', 'blue', 'green'],
     ['letters', 'a', 'b', 'c'],
     'foo'
 ], 'letters');
 // => ['letters', 'a', 'b', 'c']

 rbjs([
     ['colors', 'red', 'blue', 'green'],
     ['letters', 'a', 'b', 'c'],
     'foo'
 ]).assoc('letters');
 // => ['letters', 'a', 'b', 'c']

Returns the element at the given index. A negative index counts from the end of the array. Returns null if the index is out of range.

Example:

 at([1, 2, 3], 1); // 2
 at([1, 2, 3], -1); // 3

 rbjs([1, 2, 3]).at(1); // 2
 rbjs([1, 2, 3]).at(-1); // 3

By using binary search, finds an a value from this array which meets the given condition in O(log n) where n is the length of the array.

You can use this method in two modes: a find-minimum mode and a find-any mode. In either case, the elements of the array must be monotone (or sorted) with respect to the given callback.

In find-minimum mode (this is a good choice for typical use cases), the callback must always return true or false, and there must be an index i (0 <= i <= array.length) so that:

• the callback returns false for any element whose index is less than i, and

• the callback returns true for any element whose index is greater than or equal to i.

  This method returns the i-th element. If i is equal to array.length, it returns null.

  In find-any mode, the callback must always return a number, and there must be two indices i and j (0 <= i <= j <= array.length) so that:

• the callback returns a positive number if 0 <= k < i,
• the callback returns zero if i <= k < j, and

• the callback returns a negative number if j <= k < array.length.

  Under this condition, this method returns any element whose index is within i...j. If i is equal to j (i.e., there is no element that satisfies the callback), this method returns null.

  You must not mix the two modes at a time; the block must always return either true/false, or always return a number. It is undefined which value is actually picked up at each iteration.

Example:

 bsearch([0, 4, 7, 10, 12], x => x >= 4); // => 4
 bsearch([1, 2, 3, 4, 5], x => 2 - x); // => 2

 rbjs([0, 4, 7, 10, 12]).bsearch(x => x >= 4); // => 4
 rbjs([1, 2, 3, 4, 5]).bsearch(x => 2 - x); // => 2

By using binary search, finds an index of a value from this array which meets the given condition in O(log n) where n is the length of the array.

You can use this method in two modes: a find-minimum mode and a find-any mode. In either case, the elements of the array must be monotone (or sorted) with respect to the given callback.

In find-minimum mode (this is a good choice for typical use cases), the callback must always return true or false, and there must be an index i (0 <= i <= array.length) so that:

• the callback returns false for any element whose index is less than i, and

• the callback returns true for any element whose index is greater than or equal to i.

  This method returns the index i. If i is equal to array.length, it returns null.

  In find-any mode, the callback must always return a number, and there must be two indices i and j (0 <= i <= j <= array.length) so that:

• the callback returns a positive number if 0 <= k < i,
• the callback returns zero if i <= k < j, and

• the callback returns a negative number if j <= k < array.length.

  Under this condition, this method returns any index within i...j. If i is equal to j (i.e., there is no element that satisfies the callback), this method returns null.

  You must not mix the two modes at a time; the block must always return either true/false, or always return a number. It is undefined which value is actually picked up at each iteration.

Example:

 bsearchIndex([0, 4, 7, 10, 12], x => x >= 4); // => 1
 bsearchIndex([1, 2, 3, 4, 5], x => 2 - x); // => 1

 rbjs([0, 4, 7, 10, 12]).bsearchIndex(x => x >= 4); // => 1
 rbjs([1, 2, 3, 4, 5]).bsearchIndex(x => 2 - x); // => 1

Removes all elements from the array.

Example:

 clear([1, 2, 3]); // => []

 rbjs([1, 2, 3]).clear(); // => []

Invokes the given function once for each element of the array. Returns an array containing the values returned by the given function.

If the callback function is not given, this returns the original array.

Example:

 collect([1, 2, 3], x => x * 2); // => [2, 4, 6]
 collect(['a', 'b', 'c'], x => `${x}!`); // => ['a!', 'b!', 'c!']

 rbjs([1, 2, 3]).collect(x => x * 2); // => [2, 4, 6]
 rbjs(['a', 'b', 'c']).collect(x => `${x}!`); // => ['a!', 'b!', 'c!']

Returns a copy of the given array, with all the null and undefined items removed.

Example:

 compact([1, 2, undefined, 3, null, 4, 5]); // [1, 2, 3, 4, 5]

 rbjs([1, 2, undefined, 3, null, 4, 5]).compact(); // [1, 2, 3, 4, 5]

Appends the elements of otherArrays into the given array.

Example:

concat([1, 2, 3], [4, 5, 6]); // => [1, 2, 3, 4, 5, 6]
concat(['a', 'b'], ['c'], ['d', 'e']) // => ['a', 'b', 'c', 'd', 'e']

rbjs([1, 2]).concat([3, 4]); // => [1, 2, 3, 4]
rbjs(['a', 'b']).concat(['c', 'd'], ['e'])  // => ['a', 'b', 'c', 'd', 'e']

Returns the number of elements.

If an argument is given, counts the number of elements for which the object or predicate holds true

Example:

count(['a', 'b', 'c'])  // => 3
count(['a', 'b', 'c'], e => e === 'b')  // => 1

rbjs([1, 2, 3, 4]).count() // => 4
rbjs([1, 2, 3, 4]).count(e => e % 2 === 0) // => 2

Calls the given callback for each item count times, or forever if count is not given.

Does nothing if a non-positive number is given or the array is empty.

Returns undefined if the loop has finished without getting interrupted.

Example:

 const callback = item => console.log(item);
 cycle([1, 2, 3], callback); // prints: 1, 2, 3, 1, 2, 3,... forever
 cycle([1, 2, 3], callback, 2); // prints: 1, 2, 3, 1, 2, 3

 const callback = item => console.log(item);
 rbjs([1, 2, 3]).cycle(callback); // prints: 1, 2, 3, 1, 2, 3,... forever
 rbjs([1, 2, 3]).cycle(callback, 2); // prints: 1, 2, 3, 1, 2, 3

Deletes the element at the specified index, returning the removed element, or null if the index is out of range.

Example:

 deleteAt([1, 2, 3], 1); // => 2
 deleteAt([1, 2, 3], -5); // => null

 rbjs([1, 2, 3]).deleteAt(1); // => 2
 rbjs([1, 2, 3]).deleteAt(-5); // => null

Deletes every item of the array for which the given callback returns true.

Example:

 deleteIf([1, 2, 3, 4, 5], x => x < 4); // => [4, 5]

 rbjs([1, 2, 3, 4, 5]).deleteIf(x => x < 4); // => [4, 5]

Returns a new array that is a copy of the receiver, removing any items that also appear in any of the arrays given as arguments. The order is preserved from the original array.

Example:

difference([1, 1, 2, 2, 3, 3, 4, 5], [1, 2, 4]); // => [ 3, 3, 5 ]
difference([1, 'c', 'yep'], [1], [ 'a', 'c' ]);  // => ["yep"]

rbjs([1, 'c', 'yep']).difference([1], ['a', 'c']) // => ["yep"]

Retrieves the value object corresponding to each index objects repeatedly.

Example:

dig([[1, [2, 3]]], 0, 1, 1); // => 2

rbjs([[1, [2, 3]]]).dig(0, 1, 1); // => 2

Drops first n elements from array and returns the rest of the elements in an array.

If a negative number is given, raises a TypeError: Invalid arguments.

Example:

drop([1, 2, 3, 4, 5], 2);  // => [3, 4, 5]
drop([1, 2], 3); // => []

rbjs([1, 2, 3, 4, 5]).drop(2); // => [3, 4, 5]
rbjs([1, 2]).drop(3); // => []

Drops elements up to, but not including, the first element for which the predicate returns null or false and returns an array containing the remaining elements.

If no predicate is given, the array is returned instead.

Example:

dropWhile([1, 2, 3, 4, 5, 0], x => x < 3); // => [3, 4, 5, 0]

rbjs([1, 2, 3, false, 5].dropWhile(x => x < 3);  // => [false, 5]

Calls the given callback once for each item in the array, passing that item to the callback.

Example:

 each([1, 2, 3], callback); // calls `callback` with 1, 2, then 3

 rbjs([1, 2, 3]).each(callback); // calls `callback` with 1, 2, then 3

Iterates the items of the array and passes their index to the callback.

Example:

 eachIndex(['a', 'b', 'c'], i => console.log(i)); // prints: 0 1 2

 rbjs(['a', 'b', 'c']).eachIndex(i => console.log(i)); // prints: 0 1 2

Delets all items from the array that are equal to a given object.

Note that since delete is a reserved keyword in JavaScript, you must use a different identifier when importing this method, e.g. rbjsDelete.

Example:

 rbjsDelete([1, 2, 2, 3], 2); // => [1, 3]
 rbjsDelete([1, 2, 2, 3], 4, () => 'hello'); // => 'hello'

 rbjs([1, 2, 2, 3]).delete(2); // => [1, 3]
 rbjs([1, 2, 2, 3]).delete(4, () => 'hello'); // => 'hello'