Functions

compact([0, 1, false, 2, '', 3]); // [1, 2, 3]

compact

Creates an array with all falsy values removed. The values false, null, 0, "", undefined, and NaN are falsy.

Example:

concat

Creates a new array concatenating array with any additional arrays and/or values.

Example:

const array = [1];

difference([2, 1], [2, 3]); // [1]

difference

Creates an array of array values not included in the other given arrays. The order and references of result values are determined by the first array.

Example:

differenceBy([2.1, 1.2], [2.3, 3.4], Math.floor); // [1.2]

differenceBy

This method is like difference except that it accepts iteratee which is invoked for each element of array and values to generate the criterion by which they're compared.

Example:

const objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];

differenceWith

This method is like difference except that it accepts comparator which is invoked to compare elements of array to values.

Example:

drop([1, 2, 3]); // [2, 3]

drop

Creates a slice of array with n elements dropped from the beginning.

Example:

dropRight([1, 2, 3]); // [1, 2]

dropRight

Creates a slice of array with n elements dropped from the end.

Example:

dropRightWhile

Creates a slice of array excluding elements dropped from the end. Elements are dropped until predicate returns falsey.

Example:

dropWhile

Creates a slice of array excluding elements dropped from the beginning. Elements are dropped until predicate returns falsey.

Example:

const array = [1, 2, 3];

fill

Fills elements of array with value from start up to, but not including, end.

Example:

findIndex

Returns the index of the first element predicate returns truthy for instead of the element itself.

Example:

findLastIndex

This method is like findIndex except that it iterates over elements of collection from right to left.

Example:

first

Gets the first element of array.

Example:

first([1, 2, 3]); // 1

flatten([1, [2, [3, [4]], 5]]); // [1, 2, [3, [4]], 5]

flatten

Flattens array a single level deep.

Example:

flattenDeep([1, [2, [3, [4]], 5]]); // [1, 2, 3, 4, 5]

flattenDeep

Recursively flattens array.

Example:

const array = [1, [2, [3, [4]], 5]];

flattenDepth

Recursively flatten array up to depth times.

Example:

fromPairs([['a', 1], ['b', 2]]); // { 'a': 1, 'b': 2 }

fromPairs

Returns an object composed from key-value pairs.

Example:

head

Gets the first element of array.

Example:

head([1, 2, 3]); // 1

indexOf([1, 2, 1, 2], 2); // 1

indexOf

Gets the index at which the first occurrence of value is found in array.

Example:

initial([1, 2, 3]); // [1, 2]

initial

Gets all but the last element of array.

Example:

intersection([2, 1], [2, 3]); // [2]

intersection

Creates an array of unique values that are included in all given arrays.

Example:

intersectionBy([2.1, 1.2], [2.3, 3.4], Math.floor); // [2.1]

intersectionBy

This method is like intersection except that it accepts iteratee which is invoked for each element of each arrays to generate the criterion by which they're compared.

Example:

const objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];

intersectionWith

This method is like intersection except that it accepts comparator which is invoked to compare elements of arrays.

Example:

join(['a', 'b', 'c'], '~'); // 'a~b~c'

join

Converts all elements in array into a string separated by separator.

Example:

last

Gets the last element of array.

Example:

last([1, 2, 3]); // 3

lastIndexOf([1, 2, 1, 2], 2); // 3

lastIndexOf

This method is like indexOf except that it iterates over elements of array from right to left.

Example:

const array = ['a', 'b', 'c', 'd'];

nth

Gets the element at index n of array. If n is negative, the nth element from the end is returned.

Example:

const array = ['a', 'b', 'c', 'a', 'b', 'c'];

pull

Removes all given values from array.

Example:

const array = ['a', 'b', 'c', 'a', 'b', 'c'];

pullAll

This method is like pull except that it accepts an array of values to remove.

Example:

const array = [{ 'x': 1 }, { 'x': 2 }, { 'x': 3 }, { 'x': 1 }];

pullAllBy

This method is like pullAll except that it accepts iteratee which is invoked for each element of array and values to generate the criterion by which they're compared.

Example:

const array = [{ 'x': 1, 'y': 2 }, { 'x': 3, 'y': 4 }, { 'x': 5, 'y': 6 }];

pullAllWith

This method is like pullAll except that it accepts comparator which is invoked to compare elements of array to values.

Example:

const array = ['a', 'b', 'c', 'd'];

pullAt

Removes elements from array corresponding to indexes and returns an array of removed elements.

Example:

const array = [1, 2, 3, 4];

remove

Removes all elements from array that predicate returns truthy for and returns an array of the removed elements.

Example:

const array = [1, 2, 3];

reverse

Reverses array so that the first element becomes the last, the second element becomes the second to last, and so on.

Example:

const array = [1, 2, 3, 4];

slice

Creates a slice of array from start up to, but not including, end.

Example:

sortedIndex([30, 50], 40); // 1

sortedIndex

Uses a binary search to determine the lowest index at which value should be inserted into array in order to maintain its sort order.

Example:

const objects = [{ 'x': 4 }, { 'x': 5 }];

sortedIndexBy

This method is like sortedIndex except that it accepts iteratee which is invoked for value and each element of array to compute their sort ranking.

Example:

sortedIndexOf([4, 5, 5, 5, 6], 5); // 1

sortedIndexOf

This method is like indexOf except that it performs a binary search on a sorted array.

Example:

sortedLastIndex([4, 5, 5, 5, 6], 5); // 4

sortedLastIndex

This method is like sortedIndex except that it returns the highest index at which value should be inserted into array in order to maintain its sort order.

Example:

const objects = [{ 'x': 4 }, { 'x': 5 }];

sortedLastIndexBy

This method is like sortedLastIndex except that it accepts iteratee which is invoked for value and each element of array to compute their sort ranking.

Example:

sortedLastIndexOf([4, 5, 5, 5, 6], 5); // 3

sortedLastIndexOf

This method is like lastIndexOf except that it performs a binary search on a sorted array.

Example:

sortedUniq([1, 1, 2]); // [1, 2]

sortedUniq

This method is like uniq except that it's designed and optimized for sorted arrays.

Example:

sortedUniqBy([1.1, 1.2, 2.3, 2.4], Math.floor); // [1.1, 2.3]

sortedUniqBy

This method is like uniqBy except that it's designed and optimized for sorted arrays.

Example:

tail([1, 2, 3]); // [2, 3]

tail

Gets all but the first element of array.

Example:

take([1, 2, 3]); // [1]

take

Creates a slice of array with n elements taken from the beginning.

Example:

takeRight([1, 2, 3]); // [3]

takeRight

Creates a slice of array with n elements taken from the end.

Example:

takeRightWhile

Creates a slice of array with elements taken from the end. Elements are taken until predicate returns falsey.

Example:

takeWhile

Creates a slice of array with elements taken from the beginning. Elements are taken until predicate returns falsey.

Example:

union([2], [1, 2]); // [2, 1]

union

Creates an array of unique values, in order, from all given arrays.

Example:

unionBy([2.1], [1.2, 2.3], Math.floor); // [2.1, 1.2]

unionBy

This method is like union except that it accepts iteratee which is invoked for each element of each arrays to generate the criterion by which uniqueness is computed.

Example:

const objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];

unionWith

This method is like union except that it accepts comparator which is invoked to compare elements of arrays.

Example:

uniq([2, 1, 2]); // [2, 1]

uniq

Creates a duplicate-free version of an array.

Example:

uniqBy([2.1, 1.2, 2.3], Math.floor); // [2.1, 1.2]

uniqBy

This method is like uniq except that it accepts iteratee which is invoked for each element in array to generate the criterion by which uniqueness is computed.

Example:

const objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 2 }];

uniqWith

This method is like uniq except that it accepts comparator which is invoked to compare elements of array.

Example:

const zipped = zip(['a', 'b'], [1, 2], [true, false]);

unzip

This method is like zip except that it accepts an array of grouped elements and creates an array regrouping the elements to their pre-zip configuration.

Example:

const zipped = zip([1, 2], [10, 20], [100, 200]);

unzipWith

This method is like unzip except that it accepts iteratee to specify how regrouped values should be combined.

Example:

without([2, 1, 2, 3], 1, 2); // [3]

without

Creates an array excluding all given values.

Example:

xor([2, 1], [2, 3]); // [1, 3]

xor

Creates an array of unique values that is the symmetric difference of the given arrays.

Example:

xorBy([2.1, 1.2], [2.3, 3.4], Math.floor); // [1.2, 3.4]

xorBy

This method is like xor except that it accepts iteratee which is invoked for each element of each arrays to generate the criterion by which they're compared.

Example:

const objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];

xorWith

This method is like xor except that it accepts comparator which is invoked to compare elements of arrays.

Example:

zip(['a', 'b'], [1, 2], [true, false]); // [['a', 1, true], ['b', 2, false]]

zip

Creates an array of grouped elements, the first of which contains the first elements of the given arrays, the second of which contains the second elements of the given arrays, and so on.

Example:

zipObject(['a', 'b'], [1, 2]); // { 'a': 1, 'b': 2 }

zipObject

This method is like fromPairs except that it accepts two arrays, one of property identifiers and one of corresponding values.

Example:

zipObjectDeep(['a.b[0].c', 'a.b[1].d'], [1, 2]);

zipObjectDeep

This method is like zipObject except that it supports property paths.

Example:

zipWith([1, 2], [10, 20], [100, 200], (a, b, c) => a + b + c);

zipWith

This method is like zip except that it accepts iteratee to specify how grouped values should be combined.

Example:

countBy([6.1, 4.2, 6.3], Math.floor); // { '4': 1, '6': 2 }

Creates an object composed of keys generated from the results of running each element of collection thru iteratee. The corresponding value of each key is the number of times the key was returned by iteratee.

Example:

each([1, 2], (value) => console.log(value)); // Logs `1` then `2`

each

Iterates over elements of collection and invokes iteratee for each element. The iteratee is invoked with three arguments: (value, index|key, collection).

Example:

eachRight([1, 2], (value) => console.log(value)); // Logs `2` then `1`

eachRight

This method is like each except that it iterates over elements of collection from right to left.

Example:

every([true, 1, null, 'yes'], Boolean); // false

every

Checks if predicate returns truthy for all elements of collection.

Example:

filter

Iterates over elements of collection, returning an array of all elements predicate returns truthy for.

Example:

find

Iterates over elements of collection, returning the first element predicate returns truthy for.

Example:

findLast([1, 2, 3, 4], (n) => n % 2 === 1); // 3

findLast

This method is like find except that it iterates over elements of collection from right to left.

Example:

function duplicate(n: number) {

flatMap

Creates a flattened array of values by running each element in collection thru iteratee and flattening the mapped results.

Example:

function duplicate(n: number) {

flatMapDeep

This method is like flatMap except that it recursively flattens the mapped results.

Example:

function duplicate(n: number) {

flatMapDepth

This method is like flatMap except that it recursively flattens the mapped results up to depth times.

Example:

forEach([1, 2], (value) => console.log(value)); // Logs `1` then `2`

forEach

Iterates over elements of collection and invokes iteratee for each element.

Example:

forEachRight([1, 2], (value) => console.log(value)); // Logs `2` then `1`

forEachRight

This method is like forEach except that it iterates over elements of collection from right to left.

Example:

groupBy([6.1, 4.2, 6.3], Math.floor); // { '4': [4.2], '6': [6.1, 6.3] }

groupBy

Creates an object composed of keys generated from the results of running each element of collection thru iteratee. The order of grouped values is determined by the order they occur in collection.

Example:

includes([1, 2, 3], 1); // true

includes

Checks if value is in collection.

Example:

invokeMap([[5, 1, 7], [3, 2, 1]], 'sort'); // [[1, 5, 7], [1, 2, 3]]

invokeMap

Invokes the method at path of each element in collection, returning an array of the results of each invoked method.

Example:

keyBy

Creates an object composed of keys generated from the results of running each element of collection thru iteratee. The corresponding value of each key is the last element responsible for generating the key.

Example:

const array = [

function square(n: number) {

map

Creates an array of values by running each element in collection thru iteratee.

Example:

orderBy

This method is like sortBy except that it allows specifying the sort orders of the iteratees to sort by.

Example:

partition

Creates an array of elements split into two groups, the first of which contains elements predicate returns truthy for, the second of which contains elements predicate returns falsey for.

Example:

reduce([1, 2], (sum, n) => sum + n, 0); // 3

reduce

Reduces collection to a value which is the accumulated result of running each element in collection thru iteratee.

Example:

const array = [[0, 1], [2, 3], [4, 5]];

reduceRight

This method is like reduce except that it iterates over elements of collection from right to left.

Example:

reject

The opposite of filter; this method returns the elements of collection that predicate does not return truthy for.

Example:

sample([1, 2, 3, 4]); // 2 (random)

sample

Gets a random element from collection.

Example:

sampleSize([1, 2, 3], 2); // [3, 1] (random)

sampleSize

Gets n random elements at unique keys from collection up to the size of collection.

Example:

shuffle([1, 2, 3, 4]); // [4, 1, 3, 2] (random)

shuffle

Creates an array of shuffled values, using a version of the Fisher-Yates shuffle.

Example:

size

Gets the size of collection by returning its length for array-like values or the number of own enumerable string keyed properties for objects.

Example:

size([1, 2, 3]); // 3

some([null, 0, 'yes', false], Boolean); // true

some

Checks if predicate returns truthy for any element of collection.

Example:

sortBy

Creates an array of elements, sorted in ascending order by the results of running each element in a collection thru each iteratee.

Example:

const timestamp = now(); // e.g., 1699123456789

date

now

Gets the timestamp of the number of milliseconds that have elapsed since the Unix epoch.

Example:

const saves = ['profile', 'settings'];

after

The opposite of before; this method creates a function that invokes func once it's called n or more times.

Example:

map(['6', '8', '10'], ary(parseInt, 1)); // [6, 8, 10]

ary

Creates a function that invokes func, with up to n arguments, ignoring any additional arguments.

Example:

jQuery(element).on('click', before(5, addContactToList));

before

Creates a function that invokes func, with the this binding and arguments of the created function, while it's called less than n times.

Example:

const greet = function(greeting: string, punctuation: string) {

bind

Creates a function that invokes func with the this binding of thisArg and partials prepended to the arguments it receives.

Example:

bindKey

Creates a function that invokes the method at object[key] with partials prepended to the arguments it receives.

Example:

const object = {

const abc = (a: string, b: string, c: string) => [a, b, c];

curry

Creates a function that accepts arguments of func and either invokes func returning its result, or returns a function that accepts the remaining arguments.

Example:

const abc = (a: string, b: string, c: string) => [a, b, c];

curryRight

This method is like curry except that arguments are applied to func in the manner of partialRight instead of partial.

Example:

const debounced = debounce(() => console.log('hello'), 1000);

debounce

Creates a debounced function that delays invoking func until after wait milliseconds have elapsed since the last time the debounced function was invoked.

Example:

defer((text: string) => console.log(text), 'deferred'); // Logs 'deferred' after one millisecond.

defer

Defers invoking the func until the current call stack has cleared.

Example:

delay((text: string) => console.log(text), 1000, 'later'); // Logs 'later' after one second.

delay

Invokes func after wait milliseconds.

Example:

const flipped = flip((...args: unknown[]) => args);

flip

Creates a function that invokes func with arguments reversed.

Example:

const object = { 'a': 1, 'b': 2 };

memoize

Creates a function that memoizes the result of func.

Example:

const isEven = (n: number) => n % 2 === 0;

negate

Creates a function that negates the result of the predicate func.

Example:

const initialize = once(() => console.log('initialized'));

once

Creates a function that is restricted to invoking func once.

Example:

function doubled(n: number) {

overArgs

Creates a function that invokes func with its arguments transformed.

Example:

function greet(greeting: string, name: string) {

partial

Creates a function that invokes func with partials prepended to the arguments it receives.

Example:

function greet(greeting: string, name: string) {

partialRight

This method is like partial except that partials are appended to the arguments it receives.

Example:

const rearged = rearg((a: string, b: string, c: string) => [a, b, c], [2, 0, 1]);

rearg

Creates a function that invokes func with arguments arranged according to the specified indexes.

Example:

const say = rest((what: string, names: string[]) => what + ' ' + names.join(', '));

rest

Creates a function that invokes func with the this binding of the created function and arguments from start and beyond provided as an array.

Example:

const say = spread((who: string, what: string) => who + ' says ' + what);

spread

Creates a function that invokes func with the array of arguments provided to the created function.

Example:

const throttled = throttle(() => console.log('hello'), 1000);

throttle

Creates a throttled function that only invokes func at most once per every wait milliseconds.

Example:

map(['6', '8', '10'], unary(parseInt)); // [6, 8, 10]

unary

Creates a function that accepts up to one argument, ignoring any additional arguments.

Example:

const p = wrap(escape, (func: typeof escape, text: string) => '<p>' + func(text) + '</p>');

wrap

Creates a function that provides value to wrapper as its first argument.

Example:

castArray

Casts value as an array if it's not one.

Example:

castArray(1); // [1]

const objects = [{ 'a': 1 }, { 'b': 2 }];

clone

Creates a shallow clone of value.

Example:

const objects = [{ 'a': 1 }, { 'b': 2 }];

cloneDeep

This method is like clone except that it recursively clones value.

Example:

function customizer(value: unknown) {

cloneDeepWith

This method is like cloneDeep except that it accepts customizer which is invoked to produce the cloned value.

Example:

function customizer(value: unknown) {

cloneWith

This method is like clone except that it accepts customizer which is invoked to produce the cloned value.

Example:

const object = { 'a': 1, 'b': 2 };

conformsTo

Checks if object conforms to source by invoking the predicate properties of source with the corresponding property values of object.

Example:

const object = { 'a': 1 };

eq

Performs a SameValueZero comparison between two values to determine if they are equivalent.

Example:

gt

Checks if value is greater than other.

Example:

gt(3, 1); // true

gte

Checks if value is greater than or equal to other.

Example:

gte(3, 1); // true

isArguments(function() { return arguments; }()); // true

isArguments

Checks if value is likely an arguments object.

Example:

isArray([1, 2, 3]); // true

isArray

Checks if value is classified as an Array object.

Example:

isArrayBuffer(new ArrayBuffer(2)); // true

isArrayBuffer

Checks if value is classified as an ArrayBuffer object.

Example:

isArrayLike([1, 2, 3]); // true

isArrayLike

Checks if value is array-like.

Example:

isArrayLikeObject([1, 2, 3]); // true

isArrayLikeObject

This method is like isArrayLike except that it also checks if value is an object.

Example:

isBoolean(false); // true

isBoolean

Checks if value is classified as a Boolean primitive or object.

Example:

isBuffer(Buffer.alloc(2)); // true (Node.js)

isBuffer

Checks if value is a Buffer. Note: This method returns false in browser environments.

Example:

isDate(new Date); // true

isDate

Checks if value is classified as a Date object.

Example:

isElement(document.body); // true

isElement

Checks if value is likely a DOM element.

Example:

isEmpty

Checks if value is an empty object, collection, map, or set.

Example:

isEmpty(null); // true

const object = { 'a': 1 };

isEqual

Performs a deep comparison between two values to determine if they are equivalent.

Example:

function isGreeting(value: unknown) {

isEqualWith

This method is like isEqual except that it accepts customizer which is invoked to compare values.

Example:

isError(new Error); // true

isError

Checks if value is an Error, EvalError, RangeError, ReferenceError, SyntaxError, TypeError, or URIError object.

Example:

isFinite

Checks if value is a finite primitive number.

Example:

isFinite(3); // true

isFunction(() => {}); // true

isFunction

Checks if value is classified as a Function object.

Example:

isInteger

Checks if value is an integer.

Example:

isInteger(3); // true

isLength

Checks if value is a valid array-like length.

Example:

isLength(3); // true

isMap(new Map); // true

isMap

Checks if value is classified as a Map object.

Example:

const object = { 'a': 1, 'b': 2 };

isMatch

Performs a partial deep comparison between object and source to determine if object contains equivalent property values.

Example:

function isGreeting(value: unknown) {

isMatchWith

This method is like isMatch except that it accepts customizer which is invoked to compare values.

Example:

isNaN

Checks if value is NaN.

Example:

isNaN(NaN); // true

isNative(Array.prototype.push); // true

isNative

Checks if value is a native function.

Example:

isNil

Checks if value is null or undefined.

Example:

isNil(null); // true

isNull

Checks if value is null.

Example:

isNull(null); // true

isNumber

Checks if value is classified as a Number primitive or object.

Example:

isNumber(3); // true

isObject

Checks if value is the language type of Object.

Example:

isObject({}); // true

isObjectLike({}); // true

isObjectLike

Checks if value is object-like.

Example:

isPlainObject

Checks if value is a plain object.

Example:

isRegExp(/abc/); // true

isRegExp

Checks if value is classified as a RegExp object.

Example:

isSafeInteger(3); // true

isSafeInteger

Checks if value is a safe integer.

Example:

isSet(new Set); // true

isSet

Checks if value is classified as a Set object.

Example:

isString('abc'); // true

isString

Checks if value is classified as a String primitive or object.

Example:

isSymbol(Symbol.iterator); // true

isSymbol

Checks if value is classified as a Symbol primitive or object.

Example:

isTypedArray(new Uint8Array); // true

isTypedArray

Checks if value is classified as a typed array.

Example:

isUndefined(void 0); // true

isUndefined

Checks if value is undefined.

Example:

isWeakMap(new WeakMap); // true

isWeakMap

Checks if value is classified as a WeakMap object.

Example:

isWeakSet(new WeakSet); // true

isWeakSet

Checks if value is classified as a WeakSet object.

Example:

lt

Checks if value is less than other.

Example:

lt(1, 3); // true

lte

Checks if value is less than or equal to other.

Example:

lte(1, 3); // true

toArray({ 'a': 1, 'b': 2 }); // [1, 2]

toArray

Converts value to an array.

Example:

toFinite

Converts value to a finite number.

Example:

toFinite(3.2); // 3.2

toInteger

Converts value to an integer.

Example:

toInteger(3.2); // 3

toLength

Converts value to an integer suitable for use as the length of an array-like object.

Example:

toLength(3.2); // 3

toNumber

Converts value to a number.

Example:

toNumber(3.2); // 3.2

toPlainObject

Converts value to a plain object flattening inherited enumerable string keyed properties of value to own properties of the plain object.

Example:

toSafeInteger(3.2); // 3

toSafeInteger

Converts value to a safe integer.

Example:

toString

Converts value to a string.

Example:

toString(null); // ''

add

Adds two numbers.

Example:

add(6, 4); // 10

ceil

Computes number rounded up to precision.

Example:

ceil(4.006); // 5

divide

Divide two numbers.

Example:

divide(6, 4); // 1.5

floor

Computes number rounded down to precision.

Example:

floor(4.006); // 4

max([4, 2, 8, 6]); // 8

max

Computes the maximum value of array.

Example:

const objects = [{ 'n': 1 }, { 'n': 2 }];

maxBy

This method is like max except that it accepts iteratee which is invoked for each element in array to generate the criterion by which the value is ranked.

Example:

mean([4, 2, 8, 6]); // 5

mean

Computes the mean of the values in array.

Example:

const objects = [{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }];

meanBy

This method is like mean except that it accepts iteratee which is invoked for each element in array to generate the value to be averaged.

Example:

min([4, 2, 8, 6]); // 2

min

Computes the minimum value of array.

Example:

const objects = [{ 'n': 1 }, { 'n': 2 }];

minBy

This method is like min except that it accepts iteratee which is invoked for each element in array to generate the criterion by which the value is ranked.

Example:

multiply

Multiply two numbers.

Example:

multiply(6, 4); // 24

round

Computes number rounded to precision.

Example:

round(4.006); // 4

subtract

Subtract two numbers.

Example:

subtract(6, 4); // 2

sum([4, 2, 8, 6]); // 20

sum

Computes the sum of the values in array.

Example:

const objects = [{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }];

sumBy

This method is like sum except that it accepts iteratee which is invoked for each element in array to generate the value to be summed.

Example:

number

clamp

Clamps a number between a lower and upper bound.

Example:

clamp(-10, -5, 5); // -5

number

inRange

Checks if a number is between start and up to, but not including, end. If end is not specified, it's set to start with start then 0.

Example:

inRange(3, 2, 4); // true

number

random

Produces a random number between the inclusive lower and upper bounds. If only one argument is provided, a number between 0 and the given number is returned. If floating is true, or either lower or upper are floats, a floating-point number is returned instead of an integer.

Example:

random(0, 5); // an integer between 0 and 5

assign

Assigns own enumerable string keyed properties of source objects to the destination object.

Example:

assignIn

This method is like assign except that it iterates over own and inherited source properties.

Example:

function customizer(objValue: unknown, srcValue: unknown) {

assignInWith

This method is like assignIn except that it accepts customizer which is invoked to produce the assigned values.

Example:

function customizer(objValue: unknown, srcValue: unknown) {

assignWith

This method is like assign except that it accepts customizer which is invoked to produce the assigned values.

Example:

const object = { 'a': [{ 'b': { 'c': 3 } }, 4] };

at

Creates an array of values corresponding to paths of object.

Example:

create

Creates an object that inherits from the prototype object.

Example:

function Shape() {

defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 }); // { 'a': 1, 'b': 2 }

defaults

Assigns own enumerable string keyed properties of source objects to the destination object for all destination properties that resolve to undefined.

Example:

defaultsDeep({ 'a': { 'b': 2 } }, { 'a': { 'b': 1, 'c': 3 } }); // { 'a': { 'b': 2, 'c': 3 } }

defaultsDeep

This method is like defaults except that it recursively assigns default properties.

Example:

entries

Creates an array of own enumerable string keyed-value pairs for object.

Example:

entriesIn

Creates an array of own and inherited enumerable string keyed-value pairs for object.

Example:

extend({ 'a': 1 }, { 'b': 2 }); // { 'a': 1, 'b': 2 }

extend

Assigns own enumerable string keyed properties of source objects to the destination object. This is an alias for assignIn.

Example:

function customizer(objValue: unknown, srcValue: unknown) {

extendWith

This method is like extend except that it accepts customizer which is invoked to produce the assigned values.

Example:

findKey

This method is like find except that it returns the key of the first element predicate returns truthy for instead of the element itself.

Example:

const users = {

findLastKey

This method is like findKey except that it iterates over elements of a collection in the opposite order.

Example:

const users = {

forIn

Iterates over own and inherited enumerable string keyed properties of an object and invokes iteratee for each property.

Example:

forInRight

This method is like forIn except that it iterates over properties of object in the opposite order.

Example:

forOwn

Iterates over own enumerable string keyed properties of an object and invokes iteratee for each property.

Example:

forOwnRight

This method is like forOwn except that it iterates over properties of object in the opposite order.

Example:

functions

Creates an array of function property names from own enumerable properties of object.

Example:

functionsIn

Creates an array of function property names from own and inherited enumerable properties of object.

Example:

const object = { 'a': [{ 'b': { 'c': 3 } }] };

get

Gets the value at path of object.

Example:

const object = { 'a': { 'b': 2 } };

has

Checks if path is a direct property of object.

Example:

const object = Object.create({ 'a': Object.create({ 'b': 2 }) });

hasIn

Checks if path is a direct or inherited property of object.

Example:

const object = { 'a': 1, 'b': 2, 'c': 1 };

invert

Creates an object composed of the inverted keys and values of object.

Example:

const object = { 'a': 1, 'b': 2, 'c': 1 };

invertBy

This method is like invert except that the inverted object is generated from the results of running each element of object thru iteratee.

Example:

const object = { 'a': [{ 'b': { 'c': [1, 2, 3, 4] } }] };

invoke

Invokes the method at path of object.

Example:

keys

Creates an array of the own enumerable property names of object.

Example:

keysIn

Creates an array of the own and inherited enumerable property names of object.

Example:

mapKeys({ 'a': 1, 'b': 2 }, (value, key) => key + value); // { 'a1': 1, 'b2': 2 }

mapKeys

Creates an object with the same values as object and keys generated by running each own enumerable string keyed property of object thru iteratee.

Example:

mapValues

Creates an object with the same keys as object and values generated by running each own enumerable string keyed property of object thru iteratee.

Example:

const users = {

merge

Recursively merges own and inherited enumerable string keyed properties of source objects into the destination object.

Example:

const object = {

function customizer(objValue: unknown, srcValue: unknown) {

mergeWith

This method is like merge except that it accepts customizer which is invoked to produce the merged values of the destination and source properties.

Example:

omit

Creates an object composed of the own and inherited enumerable property paths of object that are not omitted.

Example:

omitBy

Creates an object composed of the own and inherited enumerable string keyed properties of object that predicate doesn't return truthy for.

Example:

pick

Creates an object composed of the picked object properties.

Example:

pickBy

Creates an object composed of the object properties predicate returns truthy for.

Example:

const object = { 'a': [{ 'b': { 'c1': 3, 'c2': () => 4 } }] };

result

This method is like get except that if the resolved value is a function it's invoked with the this binding of its parent object and its result is returned.

Example:

const object = { 'a': [{ 'b': { 'c': 3 } }] };

set

Sets the value at path of object.

Example:

setWith

This method is like set except that it accepts customizer which is invoked to produce the objects of path.

Example:

const object = {};

toPairs

Creates an array of own enumerable string keyed-value pairs for object. This is an alias for entries.

Example:

toPairsIn

Creates an array of own and inherited enumerable string keyed-value pairs for object. This is an alias for entriesIn.

Example:

transform([2, 3, 4], (result, n) => {

transform

An alternative to reduce; this method transforms object to a new accumulator object which is the result of running each of its own enumerable string keyed properties thru iteratee.

Example:

const object = { 'a': [{ 'b': { 'c': 7 } }] };

unset

Removes the property at path of object.

Example:

const object = { 'a': [{ 'b': { 'c': 3 } }] };

update

This method is like set except that it accepts updater to produce the value to set.

Example:

updateWith

This method is like update except that it accepts customizer which is invoked to produce the objects of path.

Example:

const object = {};

values

Creates an array of the own enumerable string keyed property values of object.

Example:

valuesIn

Creates an array of the own and inherited enumerable string keyed property values of object.

Example:

seq

chain

Creates a lodash wrapper instance that wraps value with explicit method chain sequences enabled.

Example:

tap([1, 2, 3], (array) => array.pop()); // [1, 2]

seq

tap

This method invokes interceptor and returns value.

Example:

seq

thru

This method is like tap except that it returns the result of interceptor.

Example:

thru([1, 2, 3], (array) => array.reverse()); // [3, 2, 1]

camelCase('Foo Bar'); // 'fooBar'

camelCase

Converts string to camel case.

Example:

capitalize('FRED'); // 'Fred'

capitalize

Converts the first character of string to upper case and the remaining to lower case.

Example:

deburr('déjà vu'); // 'deja vu'

deburr

Deburrs string by converting Latin-1 Supplement and Latin Extended-A letters to basic Latin letters and removing combining diacritical marks.

Example:

endsWith('abc', 'c'); // true

endsWith

Checks if string ends with the given target string.

Example:

escape('fred, barney, & pebbles'); // 'fred, barney, & pebbles'

escape

Converts the characters "&", "<", ">", '"', and "'" in string to their corresponding HTML entities.

Example:

escapeRegExp('[lodash](https://lodash.com/)'); // '\\[lodash\\]\$https://lodash\\.com/\$'

escapeRegExp

Escapes the RegExp special characters "^", "$", "\", ".", "*", "+", "?", "(", ")", "[", "]", "{", "}", and "|" in string.

Example:

kebabCase('Foo Bar'); // 'foo-bar'

kebabCase

Converts string to kebab case.

Example:

lowerCase('--Foo-Bar--'); // 'foo bar'

lowerCase

Converts string, as space separated words, to lower case.

Example:

lowerFirst('Fred'); // 'fred'

lowerFirst

Converts the first character of string to lower case.

Example:

pad('abc', 8); // ' abc '

pad

Pads string on the left and right sides if it's shorter than length. Padding characters are truncated if they can't be evenly divided by length.

Example:

padEnd('abc', 6); // 'abc '

padEnd

Pads string on the right side if it's shorter than length. Padding characters are truncated if they exceed length.

Example:

padStart('abc', 6); // ' abc'

padStart

Pads string on the left side if it's shorter than length. Padding characters are truncated if they exceed length.

Example:

parseInt

Converts string to an integer of the specified radix.

Example:

parseInt('08'); // 8

repeat('*', 3); // '***'

repeat

Repeats the given string n times.

Example:

replace('Hi Fred', 'Fred', 'Barney'); // 'Hi Barney'

replace

Replaces matches for pattern in string with replacement.

Example:

snakeCase('Foo Bar'); // 'foo_bar'

snakeCase

Converts string to snake case.

Example:

split('a-b-c', '-', 2); // ['a', 'b']

split

Splits string by separator.

Example:

startCase('--foo-bar--'); // 'Foo Bar'

startCase

Converts string to start case.

Example:

startsWith('abc', 'a'); // true

startsWith

Checks if string starts with the given target string.

Example:

toLower('--Foo-Bar--'); // '--foo-bar--'

toLower

Converts string, as a whole, to lower case.

Example:

toUpper('--foo-bar--'); // '--FOO-BAR--'

toUpper

Converts string, as a whole, to upper case.

Example:

trim(' abc '); // 'abc'

trim

Removes leading and trailing whitespace or specified characters from string.

Example:

trimEnd(' abc '); // ' abc'

trimEnd

Removes trailing whitespace or specified characters from string.

Example:

trimStart(' abc '); // 'abc '

trimStart

Removes leading whitespace or specified characters from string.

Example:

truncate('hi-diddly-ho there, neighborino'); // 'hi-diddly-ho there, neighbo...'

truncate

Truncates string if it's longer than the given maximum string length. The last characters of the truncated string are replaced with the omission string which defaults to "...".

Example:

unescape('fred, barney, & pebbles'); // 'fred, barney, & pebbles'

unescape

The inverse of escape; this method converts the HTML entities &, <, >, ", and ' in string to their corresponding characters.

Example:

upperCase('--foo-bar--'); // 'FOO BAR'

upperCase

Converts string, as space separated words, to upper case.

Example:

upperFirst('fred'); // 'Fred'

upperFirst

Converts the first character of string to upper case.

Example:

words('fred, barney, & pebbles'); // ['fred', 'barney', 'pebbles']

words

Splits string into an array of its words.

Example:

const elements = attempt((selector: string) => document.querySelectorAll(selector), '>_>');

attempt

Attempts to invoke func, returning either the result or the caught error object.

Example:

bindAll

Binds methods of an object to the object itself, overwriting the existing method.

Example:

const view = {

cond

Creates a function that iterates over pairs and invokes the corresponding function of the first predicate to return truthy.

Example:

const func = cond([

conforms

Creates a function that invokes the predicate properties of source with the corresponding property values of a given object.

Example:

const objects = times(2, constant({ 'a': 1 }));

constant

Creates a function that returns value.

Example:

defaultTo

Checks value to determine whether a default value should be returned in its place.

Example:

defaultTo(1, 10); // 1

function square(n: number) {

flow

Creates a function that returns the result of invoking the given functions with the this binding of the created function.

Example:

function square(n: number) {

flowRight

This method is like flow except that it creates a function that invokes the given functions from right to left.

Example:

const object = { 'a': 1 };

identity

This method returns the first argument it receives.

Example:

iteratee

Creates a function that invokes the predicate at the path of a given object.

Example:

matches

Creates a function that performs a partial deep comparison between a given object and source.

Example:

matchesProperty

Creates a function that performs a partial deep comparison between the value at path of a given object and srcValue.

Example:

method

Creates a function that invokes the method at path of a given object.

Example:

methodOf

The opposite of method; this method creates a function that invokes the method at a given path of object.

Example:

const array = [

function vowels(string) {

mixin

Adds all own enumerable string keyed function properties of a source object to the destination object.

Example:

const tulx = noConflict();

noConflict

Reverts the _ variable to its previous value and returns a reference to the tulx object.

Example:

const object = { 'user': 'fred' };

noop

A no-operation function that returns undefined regardless of the arguments it receives.

Example:

const func = nthArg(1);

nthArg

Creates a function that gets the argument at index n.

Example:

const func = over([Math.max, Math.min]);

over

Creates a function that invokes iteratees with the arguments it receives and returns their results.

Example:

const func = overEvery([Boolean, isFinite]);

overEvery

Creates a function that checks if all of the predicates return truthy when invoked with the arguments it receives.

Example:

const func = overSome([Boolean, isFinite]);

overSome

Creates a function that checks if any of the predicates return truthy when invoked with the arguments it receives.

Example:

property

Creates a function that returns the value at path of a given object.

Example:

const array = [0, 1, 2];

propertyOf

The opposite of property; this method creates a function that returns the value at a given path of object.

Example:

range(4); // [0, 1, 2, 3]

range

Creates an array of numbers (positive and/or negative) progressing from start up to, but not including, end.

Example:

rangeRight(4); // [3, 2, 1, 0]

rangeRight

This method is like range except that it populates values in descending order.

Example:

const _ = runInContext();

runInContext

Create a new pristine lodash function using the given context object.

Example:

const arrays = times(2, stubArray);

stubArray

This method returns a new empty array.

Example:

times(2, stubFalse); // [false, false]

stubFalse

This method returns false.

Example:

const objects = times(2, stubObject);

stubObject

This method returns a new empty object.

Example:

times(2, stubString); // ['', '']

stubString

This method returns an empty string.

Example:

times(2, stubTrue); // [true, true]

stubTrue

This method returns true.

Example:

times(3, String); // ['0', '1', '2']

times

Invokes the iteratee n times, returning an array of the results of each invocation.

Example:

toPath('a.b.c'); // ['a', 'b', 'c']

toPath

Converts value to a property path array.

Example: