| [ Index ] |
PHP Cross Reference of WordPress Trunk (Updated Daily) |
[Source view] [Print] [Project Stats]
(no description)
| License: | |
| File Size: | 17209 lines (544 kb) |
| Included or required: | 0 times |
| Referenced: | 0 times |
| Includes or requires: | 0 files |
| apply(func, thisArg, args) X-Ref |
| A faster alternative to `Function#apply`, this function invokes `func` with the `this` binding of `thisArg` and the arguments of `args`. param: {Function} func The function to invoke. param: {*} thisArg The `this` binding of `func`. param: {Array} args The arguments to invoke `func` with. returns: {*} Returns the result of `func`. |
| arrayAggregator(array, setter, iteratee, accumulator) X-Ref |
| A specialized version of `baseAggregator` for arrays. param: {Array} [array] The array to iterate over. param: {Function} setter The function to set `accumulator` values. param: {Function} iteratee The iteratee to transform keys. param: {Object} accumulator The initial aggregated object. returns: {Function} Returns `accumulator`. |
| arrayEach(array, iteratee) X-Ref |
| A specialized version of `_.forEach` for arrays without support for iteratee shorthands. param: {Array} [array] The array to iterate over. param: {Function} iteratee The function invoked per iteration. returns: {Array} Returns `array`. |
| arrayEachRight(array, iteratee) X-Ref |
| A specialized version of `_.forEachRight` for arrays without support for iteratee shorthands. param: {Array} [array] The array to iterate over. param: {Function} iteratee The function invoked per iteration. returns: {Array} Returns `array`. |
| arrayEvery(array, predicate) X-Ref |
| A specialized version of `_.every` for arrays without support for iteratee shorthands. param: {Array} [array] The array to iterate over. param: {Function} predicate The function invoked per iteration. returns: {boolean} Returns `true` if all elements pass the predicate check, |
| arrayFilter(array, predicate) X-Ref |
| A specialized version of `_.filter` for arrays without support for iteratee shorthands. param: {Array} [array] The array to iterate over. param: {Function} predicate The function invoked per iteration. returns: {Array} Returns the new filtered array. |
| arrayIncludes(array, value) X-Ref |
| A specialized version of `_.includes` for arrays without support for specifying an index to search from. param: {Array} [array] The array to inspect. param: {*} target The value to search for. returns: {boolean} Returns `true` if `target` is found, else `false`. |
| arrayIncludesWith(array, value, comparator) X-Ref |
| This function is like `arrayIncludes` except that it accepts a comparator. param: {Array} [array] The array to inspect. param: {*} target The value to search for. param: {Function} comparator The comparator invoked per element. returns: {boolean} Returns `true` if `target` is found, else `false`. |
| arrayMap(array, iteratee) X-Ref |
| A specialized version of `_.map` for arrays without support for iteratee shorthands. param: {Array} [array] The array to iterate over. param: {Function} iteratee The function invoked per iteration. returns: {Array} Returns the new mapped array. |
| arrayPush(array, values) X-Ref |
| Appends the elements of `values` to `array`. param: {Array} array The array to modify. param: {Array} values The values to append. returns: {Array} Returns `array`. |
| arrayReduce(array, iteratee, accumulator, initAccum) X-Ref |
| A specialized version of `_.reduce` for arrays without support for iteratee shorthands. param: {Array} [array] The array to iterate over. param: {Function} iteratee The function invoked per iteration. param: {*} [accumulator] The initial value. param: {boolean} [initAccum] Specify using the first element of `array` as returns: {*} Returns the accumulated value. |
| arrayReduceRight(array, iteratee, accumulator, initAccum) X-Ref |
| A specialized version of `_.reduceRight` for arrays without support for iteratee shorthands. param: {Array} [array] The array to iterate over. param: {Function} iteratee The function invoked per iteration. param: {*} [accumulator] The initial value. param: {boolean} [initAccum] Specify using the last element of `array` as returns: {*} Returns the accumulated value. |
| arraySome(array, predicate) X-Ref |
| A specialized version of `_.some` for arrays without support for iteratee shorthands. param: {Array} [array] The array to iterate over. param: {Function} predicate The function invoked per iteration. returns: {boolean} Returns `true` if any element passes the predicate check, |
| asciiToArray(string) X-Ref |
| Converts an ASCII `string` to an array. param: {string} string The string to convert. returns: {Array} Returns the converted array. |
| asciiWords(string) X-Ref |
| Splits an ASCII `string` into an array of its words. param: {string} The string to inspect. returns: {Array} Returns the words of `string`. |
| baseFindKey(collection, predicate, eachFunc) X-Ref |
| The base implementation of methods like `_.findKey` and `_.findLastKey`, without support for iteratee shorthands, which iterates over `collection` using `eachFunc`. param: {Array|Object} collection The collection to inspect. param: {Function} predicate The function invoked per iteration. param: {Function} eachFunc The function to iterate over `collection`. returns: {*} Returns the found element or its key, else `undefined`. |
| baseFindIndex(array, predicate, fromIndex, fromRight) X-Ref |
| The base implementation of `_.findIndex` and `_.findLastIndex` without support for iteratee shorthands. param: {Array} array The array to inspect. param: {Function} predicate The function invoked per iteration. param: {number} fromIndex The index to search from. param: {boolean} [fromRight] Specify iterating from right to left. returns: {number} Returns the index of the matched value, else `-1`. |
| baseIndexOf(array, value, fromIndex) X-Ref |
| The base implementation of `_.indexOf` without `fromIndex` bounds checks. param: {Array} array The array to inspect. param: {*} value The value to search for. param: {number} fromIndex The index to search from. returns: {number} Returns the index of the matched value, else `-1`. |
| baseIndexOfWith(array, value, fromIndex, comparator) X-Ref |
| This function is like `baseIndexOf` except that it accepts a comparator. param: {Array} array The array to inspect. param: {*} value The value to search for. param: {number} fromIndex The index to search from. param: {Function} comparator The comparator invoked per element. returns: {number} Returns the index of the matched value, else `-1`. |
| baseIsNaN(value) X-Ref |
| The base implementation of `_.isNaN` without support for number objects. param: {*} value The value to check. returns: {boolean} Returns `true` if `value` is `NaN`, else `false`. |
| baseMean(array, iteratee) X-Ref |
| The base implementation of `_.mean` and `_.meanBy` without support for iteratee shorthands. param: {Array} array The array to iterate over. param: {Function} iteratee The function invoked per iteration. returns: {number} Returns the mean. |
| baseProperty(key) X-Ref |
| The base implementation of `_.property` without support for deep paths. param: {string} key The key of the property to get. returns: {Function} Returns the new accessor function. |
| basePropertyOf(object) X-Ref |
| The base implementation of `_.propertyOf` without support for deep paths. param: {Object} object The object to query. returns: {Function} Returns the new accessor function. |
| baseReduce(collection, iteratee, accumulator, initAccum, eachFunc) X-Ref |
| The base implementation of `_.reduce` and `_.reduceRight`, without support for iteratee shorthands, which iterates over `collection` using `eachFunc`. param: {Array|Object} collection The collection to iterate over. param: {Function} iteratee The function invoked per iteration. param: {*} accumulator The initial value. param: {boolean} initAccum Specify using the first or last element of param: {Function} eachFunc The function to iterate over `collection`. returns: {*} Returns the accumulated value. |
| baseSortBy(array, comparer) X-Ref |
| The base implementation of `_.sortBy` which uses `comparer` to define the sort order of `array` and replaces criteria objects with their corresponding values. param: {Array} array The array to sort. param: {Function} comparer The function to define sort order. returns: {Array} Returns `array`. |
| baseSum(array, iteratee) X-Ref |
| The base implementation of `_.sum` and `_.sumBy` without support for iteratee shorthands. param: {Array} array The array to iterate over. param: {Function} iteratee The function invoked per iteration. returns: {number} Returns the sum. |
| baseTimes(n, iteratee) X-Ref |
| The base implementation of `_.times` without support for iteratee shorthands or max array length checks. param: {number} n The number of times to invoke `iteratee`. param: {Function} iteratee The function invoked per iteration. returns: {Array} Returns the array of results. |
| baseToPairs(object, props) X-Ref |
| The base implementation of `_.toPairs` and `_.toPairsIn` which creates an array of key-value pairs for `object` corresponding to the property names of `props`. param: {Object} object The object to query. param: {Array} props The property names to get values for. returns: {Object} Returns the key-value pairs. |
| baseTrim(string) X-Ref |
| The base implementation of `_.trim`. param: {string} string The string to trim. returns: {string} Returns the trimmed string. |
| baseUnary(func) X-Ref |
| The base implementation of `_.unary` without support for storing metadata. param: {Function} func The function to cap arguments for. returns: {Function} Returns the new capped function. |
| baseValues(object, props) X-Ref |
| The base implementation of `_.values` and `_.valuesIn` which creates an array of `object` property values corresponding to the property names of `props`. param: {Object} object The object to query. param: {Array} props The property names to get values for. returns: {Object} Returns the array of property values. |
| cacheHas(cache, key) X-Ref |
| Checks if a `cache` value for `key` exists. param: {Object} cache The cache to query. param: {string} key The key of the entry to check. returns: {boolean} Returns `true` if an entry for `key` exists, else `false`. |
| charsStartIndex(strSymbols, chrSymbols) X-Ref |
| Used by `_.trim` and `_.trimStart` to get the index of the first string symbol that is not found in the character symbols. param: {Array} strSymbols The string symbols to inspect. param: {Array} chrSymbols The character symbols to find. returns: {number} Returns the index of the first unmatched string symbol. |
| charsEndIndex(strSymbols, chrSymbols) X-Ref |
| Used by `_.trim` and `_.trimEnd` to get the index of the last string symbol that is not found in the character symbols. param: {Array} strSymbols The string symbols to inspect. param: {Array} chrSymbols The character symbols to find. returns: {number} Returns the index of the last unmatched string symbol. |
| countHolders(array, placeholder) X-Ref |
| Gets the number of `placeholder` occurrences in `array`. param: {Array} array The array to inspect. param: {*} placeholder The placeholder to search for. returns: {number} Returns the placeholder count. |
| escapeStringChar(chr) X-Ref |
| Used by `_.template` to escape characters for inclusion in compiled string literals. param: {string} chr The matched character to escape. returns: {string} Returns the escaped character. |
| getValue(object, key) X-Ref |
| Gets the value at `key` of `object`. param: {Object} [object] The object to query. param: {string} key The key of the property to get. returns: {*} Returns the property value. |
| hasUnicode(string) X-Ref |
| Checks if `string` contains Unicode symbols. param: {string} string The string to inspect. returns: {boolean} Returns `true` if a symbol is found, else `false`. |
| hasUnicodeWord(string) X-Ref |
| Checks if `string` contains a word composed of Unicode symbols. param: {string} string The string to inspect. returns: {boolean} Returns `true` if a word is found, else `false`. |
| iteratorToArray(iterator) X-Ref |
| Converts `iterator` to an array. param: {Object} iterator The iterator to convert. returns: {Array} Returns the converted array. |
| mapToArray(map) X-Ref |
| Converts `map` to its key-value pairs. param: {Object} map The map to convert. returns: {Array} Returns the key-value pairs. |
| overArg(func, transform) X-Ref |
| Creates a unary function that invokes `func` with its argument transformed. param: {Function} func The function to wrap. param: {Function} transform The argument transform. returns: {Function} Returns the new function. |
| replaceHolders(array, placeholder) X-Ref |
| Replaces all `placeholder` elements in `array` with an internal placeholder and returns an array of their indexes. param: {Array} array The array to modify. param: {*} placeholder The placeholder to replace. returns: {Array} Returns the new array of placeholder indexes. |
| setToArray(set) X-Ref |
| Converts `set` to an array of its values. param: {Object} set The set to convert. returns: {Array} Returns the values. |
| setToPairs(set) X-Ref |
| Converts `set` to its value-value pairs. param: {Object} set The set to convert. returns: {Array} Returns the value-value pairs. |
| strictIndexOf(array, value, fromIndex) X-Ref |
| A specialized version of `_.indexOf` which performs strict equality comparisons of values, i.e. `===`. param: {Array} array The array to inspect. param: {*} value The value to search for. param: {number} fromIndex The index to search from. returns: {number} Returns the index of the matched value, else `-1`. |
| strictLastIndexOf(array, value, fromIndex) X-Ref |
| A specialized version of `_.lastIndexOf` which performs strict equality comparisons of values, i.e. `===`. param: {Array} array The array to inspect. param: {*} value The value to search for. param: {number} fromIndex The index to search from. returns: {number} Returns the index of the matched value, else `-1`. |
| stringSize(string) X-Ref |
| Gets the number of symbols in `string`. param: {string} string The string to inspect. returns: {number} Returns the string size. |
| stringToArray(string) X-Ref |
| Converts `string` to an array. param: {string} string The string to convert. returns: {Array} Returns the converted array. |
| trimmedEndIndex(string) X-Ref |
| Used by `_.trim` and `_.trimEnd` to get the index of the last non-whitespace character of `string`. param: {string} string The string to inspect. returns: {number} Returns the index of the last non-whitespace character. |
| unicodeSize(string) X-Ref |
| Gets the size of a Unicode `string`. param: {string} string The string inspect. returns: {number} Returns the string size. |
| unicodeToArray(string) X-Ref |
| Converts a Unicode `string` to an array. param: {string} string The string to convert. returns: {Array} Returns the converted array. |
| unicodeWords(string) X-Ref |
| Splits a Unicode `string` into an array of its words. param: {string} The string to inspect. returns: {Array} Returns the words of `string`. |
| lodash(value) X-Ref |
| No description |
| object() X-Ref |
| The base implementation of `_.create` without support for assigning properties to the created object. param: {Object} proto The object to inherit from. returns: {Object} Returns the new object. |
| baseLodash() X-Ref |
| The function whose prototype chain sequence wrappers inherit from. |
| LodashWrapper(value, chainAll) X-Ref |
| The base constructor for creating `lodash` wrapper objects. param: {*} value The value to wrap. param: {boolean} [chainAll] Enable explicit method chain sequences. |
| LazyWrapper(value) X-Ref |
| Creates a lazy wrapper object which wraps `value` to enable lazy evaluation. param: {*} value The value to wrap. |
| lazyClone() X-Ref |
| Creates a clone of the lazy wrapper object. returns: {Object} Returns the cloned `LazyWrapper` object. |
| lazyReverse() X-Ref |
| Reverses the direction of lazy iteration. returns: {Object} Returns the new reversed `LazyWrapper` object. |
| lazyValue() X-Ref |
| Extracts the unwrapped value from its lazy wrapper. returns: {*} Returns the unwrapped value. |
| Hash(entries) X-Ref |
| Creates a hash object. param: {Array} [entries] The key-value pairs to cache. |
| hashClear() X-Ref |
| Removes all key-value entries from the hash. |
| hashDelete(key) X-Ref |
| Removes `key` and its value from the hash. param: {Object} hash The hash to modify. param: {string} key The key of the value to remove. returns: {boolean} Returns `true` if the entry was removed, else `false`. |
| hashGet(key) X-Ref |
| Gets the hash value for `key`. param: {string} key The key of the value to get. returns: {*} Returns the entry value. |
| hashHas(key) X-Ref |
| Checks if a hash value for `key` exists. param: {string} key The key of the entry to check. returns: {boolean} Returns `true` if an entry for `key` exists, else `false`. |
| hashSet(key, value) X-Ref |
| Sets the hash `key` to `value`. param: {string} key The key of the value to set. param: {*} value The value to set. returns: {Object} Returns the hash instance. |
| ListCache(entries) X-Ref |
| Creates an list cache object. param: {Array} [entries] The key-value pairs to cache. |
| listCacheClear() X-Ref |
| Removes all key-value entries from the list cache. |
| listCacheDelete(key) X-Ref |
| Removes `key` and its value from the list cache. param: {string} key The key of the value to remove. returns: {boolean} Returns `true` if the entry was removed, else `false`. |
| listCacheGet(key) X-Ref |
| Gets the list cache value for `key`. param: {string} key The key of the value to get. returns: {*} Returns the entry value. |
| listCacheHas(key) X-Ref |
| Checks if a list cache value for `key` exists. param: {string} key The key of the entry to check. returns: {boolean} Returns `true` if an entry for `key` exists, else `false`. |
| listCacheSet(key, value) X-Ref |
| Sets the list cache `key` to `value`. param: {string} key The key of the value to set. param: {*} value The value to set. returns: {Object} Returns the list cache instance. |
| MapCache(entries) X-Ref |
| Creates a map cache object to store key-value pairs. param: {Array} [entries] The key-value pairs to cache. |
| mapCacheClear() X-Ref |
| Removes all key-value entries from the map. |
| mapCacheDelete(key) X-Ref |
| Removes `key` and its value from the map. param: {string} key The key of the value to remove. returns: {boolean} Returns `true` if the entry was removed, else `false`. |
| mapCacheGet(key) X-Ref |
| Gets the map value for `key`. param: {string} key The key of the value to get. returns: {*} Returns the entry value. |
| mapCacheHas(key) X-Ref |
| Checks if a map value for `key` exists. param: {string} key The key of the entry to check. returns: {boolean} Returns `true` if an entry for `key` exists, else `false`. |
| mapCacheSet(key, value) X-Ref |
| Sets the map `key` to `value`. param: {string} key The key of the value to set. param: {*} value The value to set. returns: {Object} Returns the map cache instance. |
| SetCache(values) X-Ref |
| Creates an array cache object to store unique values. param: {Array} [values] The values to cache. |
| setCacheAdd(value) X-Ref |
| Adds `value` to the array cache. param: {*} value The value to cache. returns: {Object} Returns the cache instance. |
| setCacheHas(value) X-Ref |
| Checks if `value` is in the array cache. param: {*} value The value to search for. returns: {number} Returns `true` if `value` is found, else `false`. |
| Stack(entries) X-Ref |
| Creates a stack cache object to store key-value pairs. param: {Array} [entries] The key-value pairs to cache. |
| stackClear() X-Ref |
| Removes all key-value entries from the stack. |
| stackDelete(key) X-Ref |
| Removes `key` and its value from the stack. param: {string} key The key of the value to remove. returns: {boolean} Returns `true` if the entry was removed, else `false`. |
| stackGet(key) X-Ref |
| Gets the stack value for `key`. param: {string} key The key of the value to get. returns: {*} Returns the entry value. |
| stackHas(key) X-Ref |
| Checks if a stack value for `key` exists. param: {string} key The key of the entry to check. returns: {boolean} Returns `true` if an entry for `key` exists, else `false`. |
| stackSet(key, value) X-Ref |
| Sets the stack `key` to `value`. param: {string} key The key of the value to set. param: {*} value The value to set. returns: {Object} Returns the stack cache instance. |
| arrayLikeKeys(value, inherited) X-Ref |
| Creates an array of the enumerable property names of the array-like `value`. param: {*} value The value to query. param: {boolean} inherited Specify returning inherited property names. returns: {Array} Returns the array of property names. |
| arraySample(array) X-Ref |
| A specialized version of `_.sample` for arrays. param: {Array} array The array to sample. returns: {*} Returns the random element. |
| arraySampleSize(array, n) X-Ref |
| A specialized version of `_.sampleSize` for arrays. param: {Array} array The array to sample. param: {number} n The number of elements to sample. returns: {Array} Returns the random elements. |
| arrayShuffle(array) X-Ref |
| A specialized version of `_.shuffle` for arrays. param: {Array} array The array to shuffle. returns: {Array} Returns the new shuffled array. |
| assignMergeValue(object, key, value) X-Ref |
| This function is like `assignValue` except that it doesn't assign `undefined` values. param: {Object} object The object to modify. param: {string} key The key of the property to assign. param: {*} value The value to assign. |
| assignValue(object, key, value) X-Ref |
| Assigns `value` to `key` of `object` if the existing value is not equivalent using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) for equality comparisons. param: {Object} object The object to modify. param: {string} key The key of the property to assign. param: {*} value The value to assign. |
| assocIndexOf(array, key) X-Ref |
| Gets the index at which the `key` is found in `array` of key-value pairs. param: {Array} array The array to inspect. param: {*} key The key to search for. returns: {number} Returns the index of the matched value, else `-1`. |
| baseAggregator(collection, setter, iteratee, accumulator) X-Ref |
| Aggregates elements of `collection` on `accumulator` with keys transformed by `iteratee` and values set by `setter`. param: {Array|Object} collection The collection to iterate over. param: {Function} setter The function to set `accumulator` values. param: {Function} iteratee The iteratee to transform keys. param: {Object} accumulator The initial aggregated object. returns: {Function} Returns `accumulator`. |
| baseAssign(object, source) X-Ref |
| The base implementation of `_.assign` without support for multiple sources or `customizer` functions. param: {Object} object The destination object. param: {Object} source The source object. returns: {Object} Returns `object`. |
| baseAssignIn(object, source) X-Ref |
| The base implementation of `_.assignIn` without support for multiple sources or `customizer` functions. param: {Object} object The destination object. param: {Object} source The source object. returns: {Object} Returns `object`. |
| baseAssignValue(object, key, value) X-Ref |
| The base implementation of `assignValue` and `assignMergeValue` without value checks. param: {Object} object The object to modify. param: {string} key The key of the property to assign. param: {*} value The value to assign. |
| baseAt(object, paths) X-Ref |
| The base implementation of `_.at` without support for individual paths. param: {Object} object The object to iterate over. param: {string[]} paths The property paths to pick. returns: {Array} Returns the picked elements. |
| baseClamp(number, lower, upper) X-Ref |
| The base implementation of `_.clamp` which doesn't coerce arguments. param: {number} number The number to clamp. param: {number} [lower] The lower bound. param: {number} upper The upper bound. returns: {number} Returns the clamped number. |
| baseClone(value, bitmask, customizer, key, object, stack) X-Ref |
| The base implementation of `_.clone` and `_.cloneDeep` which tracks traversed objects. param: {*} value The value to clone. param: {boolean} bitmask The bitmask flags. param: {Function} [customizer] The function to customize cloning. param: {string} [key] The key of `value`. param: {Object} [object] The parent object of `value`. param: {Object} [stack] Tracks traversed objects and their clone counterparts. returns: {*} Returns the cloned value. |
| baseConforms(source) X-Ref |
| The base implementation of `_.conforms` which doesn't clone `source`. param: {Object} source The object of property predicates to conform to. returns: {Function} Returns the new spec function. |
| baseConformsTo(object, source, props) X-Ref |
| The base implementation of `_.conformsTo` which accepts `props` to check. param: {Object} object The object to inspect. param: {Object} source The object of property predicates to conform to. returns: {boolean} Returns `true` if `object` conforms, else `false`. |
| baseDelay(func, wait, args) X-Ref |
| The base implementation of `_.delay` and `_.defer` which accepts `args` to provide to `func`. param: {Function} func The function to delay. param: {number} wait The number of milliseconds to delay invocation. param: {Array} args The arguments to provide to `func`. returns: {number|Object} Returns the timer id or timeout object. |
| baseDifference(array, values, iteratee, comparator) X-Ref |
| The base implementation of methods like `_.difference` without support for excluding multiple arrays or iteratee shorthands. param: {Array} array The array to inspect. param: {Array} values The values to exclude. param: {Function} [iteratee] The iteratee invoked per element. param: {Function} [comparator] The comparator invoked per element. returns: {Array} Returns the new array of filtered values. |
| baseEvery(collection, predicate) X-Ref |
| The base implementation of `_.every` without support for iteratee shorthands. param: {Array|Object} collection The collection to iterate over. param: {Function} predicate The function invoked per iteration. returns: {boolean} Returns `true` if all elements pass the predicate check, |
| baseExtremum(array, iteratee, comparator) X-Ref |
| The base implementation of methods like `_.max` and `_.min` which accepts a `comparator` to determine the extremum value. param: {Array} array The array to iterate over. param: {Function} iteratee The iteratee invoked per iteration. param: {Function} comparator The comparator used to compare values. returns: {*} Returns the extremum value. |
| baseFill(array, value, start, end) X-Ref |
| The base implementation of `_.fill` without an iteratee call guard. param: {Array} array The array to fill. param: {*} value The value to fill `array` with. param: {number} [start=0] The start position. param: {number} [end=array.length] The end position. returns: {Array} Returns `array`. |
| baseFilter(collection, predicate) X-Ref |
| The base implementation of `_.filter` without support for iteratee shorthands. param: {Array|Object} collection The collection to iterate over. param: {Function} predicate The function invoked per iteration. returns: {Array} Returns the new filtered array. |
| baseFlatten(array, depth, predicate, isStrict, result) X-Ref |
| The base implementation of `_.flatten` with support for restricting flattening. param: {Array} array The array to flatten. param: {number} depth The maximum recursion depth. param: {boolean} [predicate=isFlattenable] The function invoked per iteration. param: {boolean} [isStrict] Restrict to values that pass `predicate` checks. param: {Array} [result=[]] The initial result value. returns: {Array} Returns the new flattened array. |
| baseForOwn(object, iteratee) X-Ref |
| The base implementation of `_.forOwn` without support for iteratee shorthands. param: {Object} object The object to iterate over. param: {Function} iteratee The function invoked per iteration. returns: {Object} Returns `object`. |
| baseForOwnRight(object, iteratee) X-Ref |
| The base implementation of `_.forOwnRight` without support for iteratee shorthands. param: {Object} object The object to iterate over. param: {Function} iteratee The function invoked per iteration. returns: {Object} Returns `object`. |
| baseFunctions(object, props) X-Ref |
| The base implementation of `_.functions` which creates an array of `object` function property names filtered from `props`. param: {Object} object The object to inspect. param: {Array} props The property names to filter. returns: {Array} Returns the function names. |
| baseGet(object, path) X-Ref |
| The base implementation of `_.get` without support for default values. param: {Object} object The object to query. param: {Array|string} path The path of the property to get. returns: {*} Returns the resolved value. |
| baseGetAllKeys(object, keysFunc, symbolsFunc) X-Ref |
| The base implementation of `getAllKeys` and `getAllKeysIn` which uses `keysFunc` and `symbolsFunc` to get the enumerable property names and symbols of `object`. param: {Object} object The object to query. param: {Function} keysFunc The function to get the keys of `object`. param: {Function} symbolsFunc The function to get the symbols of `object`. returns: {Array} Returns the array of property names and symbols. |
| baseGetTag(value) X-Ref |
| The base implementation of `getTag` without fallbacks for buggy environments. param: {*} value The value to query. returns: {string} Returns the `toStringTag`. |
| baseGt(value, other) X-Ref |
| The base implementation of `_.gt` which doesn't coerce arguments. param: {*} value The value to compare. param: {*} other The other value to compare. returns: {boolean} Returns `true` if `value` is greater than `other`, |
| baseHas(object, key) X-Ref |
| The base implementation of `_.has` without support for deep paths. param: {Object} [object] The object to query. param: {Array|string} key The key to check. returns: {boolean} Returns `true` if `key` exists, else `false`. |
| baseHasIn(object, key) X-Ref |
| The base implementation of `_.hasIn` without support for deep paths. param: {Object} [object] The object to query. param: {Array|string} key The key to check. returns: {boolean} Returns `true` if `key` exists, else `false`. |
| baseInRange(number, start, end) X-Ref |
| The base implementation of `_.inRange` which doesn't coerce arguments. param: {number} number The number to check. param: {number} start The start of the range. param: {number} end The end of the range. returns: {boolean} Returns `true` if `number` is in the range, else `false`. |
| baseIntersection(arrays, iteratee, comparator) X-Ref |
| The base implementation of methods like `_.intersection`, without support for iteratee shorthands, that accepts an array of arrays to inspect. param: {Array} arrays The arrays to inspect. param: {Function} [iteratee] The iteratee invoked per element. param: {Function} [comparator] The comparator invoked per element. returns: {Array} Returns the new array of shared values. |
| baseInverter(object, setter, iteratee, accumulator) X-Ref |
| The base implementation of `_.invert` and `_.invertBy` which inverts `object` with values transformed by `iteratee` and set by `setter`. param: {Object} object The object to iterate over. param: {Function} setter The function to set `accumulator` values. param: {Function} iteratee The iteratee to transform values. param: {Object} accumulator The initial inverted object. returns: {Function} Returns `accumulator`. |
| baseInvoke(object, path, args) X-Ref |
| The base implementation of `_.invoke` without support for individual method arguments. param: {Object} object The object to query. param: {Array|string} path The path of the method to invoke. param: {Array} args The arguments to invoke the method with. returns: {*} Returns the result of the invoked method. |
| baseIsArguments(value) X-Ref |
| The base implementation of `_.isArguments`. param: {*} value The value to check. returns: {boolean} Returns `true` if `value` is an `arguments` object, |
| baseIsArrayBuffer(value) X-Ref |
| The base implementation of `_.isArrayBuffer` without Node.js optimizations. param: {*} value The value to check. returns: {boolean} Returns `true` if `value` is an array buffer, else `false`. |
| baseIsDate(value) X-Ref |
| The base implementation of `_.isDate` without Node.js optimizations. param: {*} value The value to check. returns: {boolean} Returns `true` if `value` is a date object, else `false`. |
| baseIsEqual(value, other, bitmask, customizer, stack) X-Ref |
| The base implementation of `_.isEqual` which supports partial comparisons and tracks traversed objects. param: {*} value The value to compare. param: {*} other The other value to compare. param: {boolean} bitmask The bitmask flags. param: {Function} [customizer] The function to customize comparisons. param: {Object} [stack] Tracks traversed `value` and `other` objects. returns: {boolean} Returns `true` if the values are equivalent, else `false`. |
| baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) X-Ref |
| A specialized version of `baseIsEqual` for arrays and objects which performs deep comparisons and tracks traversed objects enabling objects with circular references to be compared. param: {Object} object The object to compare. param: {Object} other The other object to compare. param: {number} bitmask The bitmask flags. See `baseIsEqual` for more details. param: {Function} customizer The function to customize comparisons. param: {Function} equalFunc The function to determine equivalents of values. param: {Object} [stack] Tracks traversed `object` and `other` objects. returns: {boolean} Returns `true` if the objects are equivalent, else `false`. |
| baseIsMap(value) X-Ref |
| The base implementation of `_.isMap` without Node.js optimizations. param: {*} value The value to check. returns: {boolean} Returns `true` if `value` is a map, else `false`. |
| baseIsMatch(object, source, matchData, customizer) X-Ref |
| The base implementation of `_.isMatch` without support for iteratee shorthands. param: {Object} object The object to inspect. param: {Object} source The object of property values to match. param: {Array} matchData The property names, values, and compare flags to match. param: {Function} [customizer] The function to customize comparisons. returns: {boolean} Returns `true` if `object` is a match, else `false`. |
| baseIsNative(value) X-Ref |
| The base implementation of `_.isNative` without bad shim checks. param: {*} value The value to check. returns: {boolean} Returns `true` if `value` is a native function, |
| baseIsRegExp(value) X-Ref |
| The base implementation of `_.isRegExp` without Node.js optimizations. param: {*} value The value to check. returns: {boolean} Returns `true` if `value` is a regexp, else `false`. |
| baseIsSet(value) X-Ref |
| The base implementation of `_.isSet` without Node.js optimizations. param: {*} value The value to check. returns: {boolean} Returns `true` if `value` is a set, else `false`. |
| baseIsTypedArray(value) X-Ref |
| The base implementation of `_.isTypedArray` without Node.js optimizations. param: {*} value The value to check. returns: {boolean} Returns `true` if `value` is a typed array, else `false`. |
| baseIteratee(value) X-Ref |
| The base implementation of `_.iteratee`. param: {*} [value=_.identity] The value to convert to an iteratee. returns: {Function} Returns the iteratee. |
| baseKeys(object) X-Ref |
| The base implementation of `_.keys` which doesn't treat sparse arrays as dense. param: {Object} object The object to query. returns: {Array} Returns the array of property names. |
| baseKeysIn(object) X-Ref |
| The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense. param: {Object} object The object to query. returns: {Array} Returns the array of property names. |
| baseLt(value, other) X-Ref |
| The base implementation of `_.lt` which doesn't coerce arguments. param: {*} value The value to compare. param: {*} other The other value to compare. returns: {boolean} Returns `true` if `value` is less than `other`, |
| baseMap(collection, iteratee) X-Ref |
| The base implementation of `_.map` without support for iteratee shorthands. param: {Array|Object} collection The collection to iterate over. param: {Function} iteratee The function invoked per iteration. returns: {Array} Returns the new mapped array. |
| baseMatches(source) X-Ref |
| The base implementation of `_.matches` which doesn't clone `source`. param: {Object} source The object of property values to match. returns: {Function} Returns the new spec function. |
| baseMatchesProperty(path, srcValue) X-Ref |
| The base implementation of `_.matchesProperty` which doesn't clone `srcValue`. param: {string} path The path of the property to get. param: {*} srcValue The value to match. returns: {Function} Returns the new spec function. |
| baseMerge(object, source, srcIndex, customizer, stack) X-Ref |
| The base implementation of `_.merge` without support for multiple sources. param: {Object} object The destination object. param: {Object} source The source object. param: {number} srcIndex The index of `source`. param: {Function} [customizer] The function to customize merged values. param: {Object} [stack] Tracks traversed source values and their merged |
| baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) X-Ref |
| A specialized version of `baseMerge` for arrays and objects which performs deep merges and tracks traversed objects enabling objects with circular references to be merged. param: {Object} object The destination object. param: {Object} source The source object. param: {string} key The key of the value to merge. param: {number} srcIndex The index of `source`. param: {Function} mergeFunc The function to merge values. param: {Function} [customizer] The function to customize assigned values. param: {Object} [stack] Tracks traversed source values and their merged |
| baseNth(array, n) X-Ref |
| The base implementation of `_.nth` which doesn't coerce arguments. param: {Array} array The array to query. param: {number} n The index of the element to return. returns: {*} Returns the nth element of `array`. |
| baseOrderBy(collection, iteratees, orders) X-Ref |
| The base implementation of `_.orderBy` without param guards. param: {Array|Object} collection The collection to iterate over. param: {Function[]|Object[]|string[]} iteratees The iteratees to sort by. param: {string[]} orders The sort orders of `iteratees`. returns: {Array} Returns the new sorted array. |
| basePick(object, paths) X-Ref |
| The base implementation of `_.pick` without support for individual property identifiers. param: {Object} object The source object. param: {string[]} paths The property paths to pick. returns: {Object} Returns the new object. |
| basePickBy(object, paths, predicate) X-Ref |
| The base implementation of `_.pickBy` without support for iteratee shorthands. param: {Object} object The source object. param: {string[]} paths The property paths to pick. param: {Function} predicate The function invoked per property. returns: {Object} Returns the new object. |
| basePropertyDeep(path) X-Ref |
| A specialized version of `baseProperty` which supports deep paths. param: {Array|string} path The path of the property to get. returns: {Function} Returns the new accessor function. |
| basePullAll(array, values, iteratee, comparator) X-Ref |
| The base implementation of `_.pullAllBy` without support for iteratee shorthands. param: {Array} array The array to modify. param: {Array} values The values to remove. param: {Function} [iteratee] The iteratee invoked per element. param: {Function} [comparator] The comparator invoked per element. returns: {Array} Returns `array`. |
| basePullAt(array, indexes) X-Ref |
| The base implementation of `_.pullAt` without support for individual indexes or capturing the removed elements. param: {Array} array The array to modify. param: {number[]} indexes The indexes of elements to remove. returns: {Array} Returns `array`. |
| baseRandom(lower, upper) X-Ref |
| The base implementation of `_.random` without support for returning floating-point numbers. param: {number} lower The lower bound. param: {number} upper The upper bound. returns: {number} Returns the random number. |
| baseRange(start, end, step, fromRight) X-Ref |
| The base implementation of `_.range` and `_.rangeRight` which doesn't coerce arguments. param: {number} start The start of the range. param: {number} end The end of the range. param: {number} step The value to increment or decrement by. param: {boolean} [fromRight] Specify iterating from right to left. returns: {Array} Returns the range of numbers. |
| baseRepeat(string, n) X-Ref |
| The base implementation of `_.repeat` which doesn't coerce arguments. param: {string} string The string to repeat. param: {number} n The number of times to repeat the string. returns: {string} Returns the repeated string. |
| baseRest(func, start) X-Ref |
| The base implementation of `_.rest` which doesn't validate or coerce arguments. param: {Function} func The function to apply a rest parameter to. param: {number} [start=func.length-1] The start position of the rest parameter. returns: {Function} Returns the new function. |
| baseSample(collection) X-Ref |
| The base implementation of `_.sample`. param: {Array|Object} collection The collection to sample. returns: {*} Returns the random element. |
| baseSampleSize(collection, n) X-Ref |
| The base implementation of `_.sampleSize` without param guards. param: {Array|Object} collection The collection to sample. param: {number} n The number of elements to sample. returns: {Array} Returns the random elements. |
| baseSet(object, path, value, customizer) X-Ref |
| The base implementation of `_.set`. param: {Object} object The object to modify. param: {Array|string} path The path of the property to set. param: {*} value The value to set. param: {Function} [customizer] The function to customize path creation. returns: {Object} Returns `object`. |
| baseShuffle(collection) X-Ref |
| The base implementation of `_.shuffle`. param: {Array|Object} collection The collection to shuffle. returns: {Array} Returns the new shuffled array. |
| baseSlice(array, start, end) X-Ref |
| The base implementation of `_.slice` without an iteratee call guard. param: {Array} array The array to slice. param: {number} [start=0] The start position. param: {number} [end=array.length] The end position. returns: {Array} Returns the slice of `array`. |
| baseSome(collection, predicate) X-Ref |
| The base implementation of `_.some` without support for iteratee shorthands. param: {Array|Object} collection The collection to iterate over. param: {Function} predicate The function invoked per iteration. returns: {boolean} Returns `true` if any element passes the predicate check, |
| baseSortedIndex(array, value, retHighest) X-Ref |
| The base implementation of `_.sortedIndex` and `_.sortedLastIndex` which performs a binary search of `array` to determine the index at which `value` should be inserted into `array` in order to maintain its sort order. param: {Array} array The sorted array to inspect. param: {*} value The value to evaluate. param: {boolean} [retHighest] Specify returning the highest qualified index. returns: {number} Returns the index at which `value` should be inserted |
| baseSortedIndexBy(array, value, iteratee, retHighest) X-Ref |
| The base implementation of `_.sortedIndexBy` and `_.sortedLastIndexBy` which invokes `iteratee` for `value` and each element of `array` to compute their sort ranking. The iteratee is invoked with one argument; (value). param: {Array} array The sorted array to inspect. param: {*} value The value to evaluate. param: {Function} iteratee The iteratee invoked per element. param: {boolean} [retHighest] Specify returning the highest qualified index. returns: {number} Returns the index at which `value` should be inserted |
| baseSortedUniq(array, iteratee) X-Ref |
| The base implementation of `_.sortedUniq` and `_.sortedUniqBy` without support for iteratee shorthands. param: {Array} array The array to inspect. param: {Function} [iteratee] The iteratee invoked per element. returns: {Array} Returns the new duplicate free array. |
| baseToNumber(value) X-Ref |
| The base implementation of `_.toNumber` which doesn't ensure correct conversions of binary, hexadecimal, or octal string values. param: {*} value The value to process. returns: {number} Returns the number. |
| baseToString(value) X-Ref |
| The base implementation of `_.toString` which doesn't convert nullish values to empty strings. param: {*} value The value to process. returns: {string} Returns the string. |
| baseUniq(array, iteratee, comparator) X-Ref |
| The base implementation of `_.uniqBy` without support for iteratee shorthands. param: {Array} array The array to inspect. param: {Function} [iteratee] The iteratee invoked per element. param: {Function} [comparator] The comparator invoked per element. returns: {Array} Returns the new duplicate free array. |
| baseUnset(object, path) X-Ref |
| The base implementation of `_.unset`. param: {Object} object The object to modify. param: {Array|string} path The property path to unset. returns: {boolean} Returns `true` if the property is deleted, else `false`. |
| baseUpdate(object, path, updater, customizer) X-Ref |
| The base implementation of `_.update`. param: {Object} object The object to modify. param: {Array|string} path The path of the property to update. param: {Function} updater The function to produce the updated value. param: {Function} [customizer] The function to customize path creation. returns: {Object} Returns `object`. |
| baseWhile(array, predicate, isDrop, fromRight) X-Ref |
| The base implementation of methods like `_.dropWhile` and `_.takeWhile` without support for iteratee shorthands. param: {Array} array The array to query. param: {Function} predicate The function invoked per iteration. param: {boolean} [isDrop] Specify dropping elements instead of taking them. param: {boolean} [fromRight] Specify iterating from right to left. returns: {Array} Returns the slice of `array`. |
| baseWrapperValue(value, actions) X-Ref |
| The base implementation of `wrapperValue` which returns the result of performing a sequence of actions on the unwrapped `value`, where each successive action is supplied the return value of the previous. param: {*} value The unwrapped value. param: {Array} actions Actions to perform to resolve the unwrapped value. returns: {*} Returns the resolved value. |
| baseXor(arrays, iteratee, comparator) X-Ref |
| The base implementation of methods like `_.xor`, without support for iteratee shorthands, that accepts an array of arrays to inspect. param: {Array} arrays The arrays to inspect. param: {Function} [iteratee] The iteratee invoked per element. param: {Function} [comparator] The comparator invoked per element. returns: {Array} Returns the new array of values. |
| baseZipObject(props, values, assignFunc) X-Ref |
| This base implementation of `_.zipObject` which assigns values using `assignFunc`. param: {Array} props The property identifiers. param: {Array} values The property values. param: {Function} assignFunc The function to assign values. returns: {Object} Returns the new object. |
| castArrayLikeObject(value) X-Ref |
| Casts `value` to an empty array if it's not an array like object. param: {*} value The value to inspect. returns: {Array|Object} Returns the cast array-like object. |
| castFunction(value) X-Ref |
| Casts `value` to `identity` if it's not a function. param: {*} value The value to inspect. returns: {Function} Returns cast function. |
| castPath(value, object) X-Ref |
| Casts `value` to a path array if it's not one. param: {*} value The value to inspect. param: {Object} [object] The object to query keys on. returns: {Array} Returns the cast property path array. |
| castSlice(array, start, end) X-Ref |
| Casts `array` to a slice if it's needed. param: {Array} array The array to inspect. param: {number} start The start position. param: {number} [end=array.length] The end position. returns: {Array} Returns the cast slice. |
| cloneBuffer(buffer, isDeep) X-Ref |
| Creates a clone of `buffer`. param: {Buffer} buffer The buffer to clone. param: {boolean} [isDeep] Specify a deep clone. returns: {Buffer} Returns the cloned buffer. |
| cloneArrayBuffer(arrayBuffer) X-Ref |
| Creates a clone of `arrayBuffer`. param: {ArrayBuffer} arrayBuffer The array buffer to clone. returns: {ArrayBuffer} Returns the cloned array buffer. |
| cloneDataView(dataView, isDeep) X-Ref |
| Creates a clone of `dataView`. param: {Object} dataView The data view to clone. param: {boolean} [isDeep] Specify a deep clone. returns: {Object} Returns the cloned data view. |
| cloneRegExp(regexp) X-Ref |
| Creates a clone of `regexp`. param: {Object} regexp The regexp to clone. returns: {Object} Returns the cloned regexp. |
| cloneSymbol(symbol) X-Ref |
| Creates a clone of the `symbol` object. param: {Object} symbol The symbol object to clone. returns: {Object} Returns the cloned symbol object. |
| cloneTypedArray(typedArray, isDeep) X-Ref |
| Creates a clone of `typedArray`. param: {Object} typedArray The typed array to clone. param: {boolean} [isDeep] Specify a deep clone. returns: {Object} Returns the cloned typed array. |
| compareAscending(value, other) X-Ref |
| Compares values to sort them in ascending order. param: {*} value The value to compare. param: {*} other The other value to compare. returns: {number} Returns the sort order indicator for `value`. |
| compareMultiple(object, other, orders) X-Ref |
| Used by `_.orderBy` to compare multiple properties of a value to another and stable sort them. If `orders` is unspecified, all values are sorted in ascending order. Otherwise, specify an order of "desc" for descending or "asc" for ascending sort order of corresponding values. param: {Object} object The object to compare. param: {Object} other The other object to compare. param: {boolean[]|string[]} orders The order to sort by for each property. returns: {number} Returns the sort order indicator for `object`. |
| composeArgs(args, partials, holders, isCurried) X-Ref |
| Creates an array that is the composition of partially applied arguments, placeholders, and provided arguments into a single array of arguments. param: {Array} args The provided arguments. param: {Array} partials The arguments to prepend to those provided. param: {Array} holders The `partials` placeholder indexes. returns: {Array} Returns the new array of composed arguments. |
| composeArgsRight(args, partials, holders, isCurried) X-Ref |
| This function is like `composeArgs` except that the arguments composition is tailored for `_.partialRight`. param: {Array} args The provided arguments. param: {Array} partials The arguments to append to those provided. param: {Array} holders The `partials` placeholder indexes. returns: {Array} Returns the new array of composed arguments. |
| copyArray(source, array) X-Ref |
| Copies the values of `source` to `array`. param: {Array} source The array to copy values from. param: {Array} [array=[]] The array to copy values to. returns: {Array} Returns `array`. |
| copyObject(source, props, object, customizer) X-Ref |
| Copies properties of `source` to `object`. param: {Object} source The object to copy properties from. param: {Array} props The property identifiers to copy. param: {Object} [object={}] The object to copy properties to. param: {Function} [customizer] The function to customize copied values. returns: {Object} Returns `object`. |
| copySymbols(source, object) X-Ref |
| Copies own symbols of `source` to `object`. param: {Object} source The object to copy symbols from. param: {Object} [object={}] The object to copy symbols to. returns: {Object} Returns `object`. |
| copySymbolsIn(source, object) X-Ref |
| Copies own and inherited symbols of `source` to `object`. param: {Object} source The object to copy symbols from. param: {Object} [object={}] The object to copy symbols to. returns: {Object} Returns `object`. |
| createAggregator(setter, initializer) X-Ref |
| Creates a function like `_.groupBy`. param: {Function} setter The function to set accumulator values. param: {Function} [initializer] The accumulator object initializer. returns: {Function} Returns the new aggregator function. |
| createAssigner(assigner) X-Ref |
| Creates a function like `_.assign`. param: {Function} assigner The function to assign values. returns: {Function} Returns the new assigner function. |
| createBaseEach(eachFunc, fromRight) X-Ref |
| Creates a `baseEach` or `baseEachRight` function. param: {Function} eachFunc The function to iterate over a collection. param: {boolean} [fromRight] Specify iterating from right to left. returns: {Function} Returns the new base function. |
| createBaseFor(fromRight) X-Ref |
| Creates a base function for methods like `_.forIn` and `_.forOwn`. param: {boolean} [fromRight] Specify iterating from right to left. returns: {Function} Returns the new base function. |
| createBind(func, bitmask, thisArg) X-Ref |
| Creates a function that wraps `func` to invoke it with the optional `this` binding of `thisArg`. param: {Function} func The function to wrap. param: {number} bitmask The bitmask flags. See `createWrap` for more details. param: {*} [thisArg] The `this` binding of `func`. returns: {Function} Returns the new wrapped function. |
| wrapper() X-Ref |
| No description |
| createCaseFirst(methodName) X-Ref |
| Creates a function like `_.lowerFirst`. param: {string} methodName The name of the `String` case method to use. returns: {Function} Returns the new case function. |
| createCompounder(callback) X-Ref |
| Creates a function like `_.camelCase`. param: {Function} callback The function to combine each word. returns: {Function} Returns the new compounder function. |
| createCtor(Ctor) X-Ref |
| Creates a function that produces an instance of `Ctor` regardless of whether it was invoked as part of a `new` expression or by `call` or `apply`. param: {Function} Ctor The constructor to wrap. returns: {Function} Returns the new wrapped function. |
| createCurry(func, bitmask, arity) X-Ref |
| Creates a function that wraps `func` to enable currying. param: {Function} func The function to wrap. param: {number} bitmask The bitmask flags. See `createWrap` for more details. param: {number} arity The arity of `func`. returns: {Function} Returns the new wrapped function. |
| wrapper() X-Ref |
| No description |
| createFind(findIndexFunc) X-Ref |
| Creates a `_.find` or `_.findLast` function. param: {Function} findIndexFunc The function to find the collection index. returns: {Function} Returns the new find function. |
| createFlow(fromRight) X-Ref |
| Creates a `_.flow` or `_.flowRight` function. param: {boolean} [fromRight] Specify iterating from right to left. returns: {Function} Returns the new flow function. |
| createHybrid(func, bitmask, thisArg, partials, holders, partialsRight, holdersRight, argPos, ary, arity) X-Ref |
| Creates a function that wraps `func` to invoke it with optional `this` binding of `thisArg`, partial application, and currying. param: {Function|string} func The function or method name to wrap. param: {number} bitmask The bitmask flags. See `createWrap` for more details. param: {*} [thisArg] The `this` binding of `func`. param: {Array} [partials] The arguments to prepend to those provided to param: {Array} [holders] The `partials` placeholder indexes. param: {Array} [partialsRight] The arguments to append to those provided param: {Array} [holdersRight] The `partialsRight` placeholder indexes. param: {Array} [argPos] The argument positions of the new function. param: {number} [ary] The arity cap of `func`. param: {number} [arity] The arity of `func`. returns: {Function} Returns the new wrapped function. |
| wrapper() X-Ref |
| No description |
| createInverter(setter, toIteratee) X-Ref |
| Creates a function like `_.invertBy`. param: {Function} setter The function to set accumulator values. param: {Function} toIteratee The function to resolve iteratees. returns: {Function} Returns the new inverter function. |
| createMathOperation(operator, defaultValue) X-Ref |
| Creates a function that performs a mathematical operation on two values. param: {Function} operator The function to perform the operation. param: {number} [defaultValue] The value used for `undefined` arguments. returns: {Function} Returns the new mathematical operation function. |
| createOver(arrayFunc) X-Ref |
| Creates a function like `_.over`. param: {Function} arrayFunc The function to iterate over iteratees. returns: {Function} Returns the new over function. |
| createPadding(length, chars) X-Ref |
| Creates the padding for `string` based on `length`. The `chars` string is truncated if the number of characters exceeds `length`. param: {number} length The padding length. param: {string} [chars=' '] The string used as padding. returns: {string} Returns the padding for `string`. |
| createPartial(func, bitmask, thisArg, partials) X-Ref |
| Creates a function that wraps `func` to invoke it with the `this` binding of `thisArg` and `partials` prepended to the arguments it receives. param: {Function} func The function to wrap. param: {number} bitmask The bitmask flags. See `createWrap` for more details. param: {*} thisArg The `this` binding of `func`. param: {Array} partials The arguments to prepend to those provided to returns: {Function} Returns the new wrapped function. |
| wrapper() X-Ref |
| No description |
| createRange(fromRight) X-Ref |
| Creates a `_.range` or `_.rangeRight` function. param: {boolean} [fromRight] Specify iterating from right to left. returns: {Function} Returns the new range function. |
| createRelationalOperation(operator) X-Ref |
| Creates a function that performs a relational operation on two values. param: {Function} operator The function to perform the operation. returns: {Function} Returns the new relational operation function. |
| createRecurry(func, bitmask, wrapFunc, placeholder, thisArg, partials, holders, argPos, ary, arity) X-Ref |
| Creates a function that wraps `func` to continue currying. param: {Function} func The function to wrap. param: {number} bitmask The bitmask flags. See `createWrap` for more details. param: {Function} wrapFunc The function to create the `func` wrapper. param: {*} placeholder The placeholder value. param: {*} [thisArg] The `this` binding of `func`. param: {Array} [partials] The arguments to prepend to those provided to param: {Array} [holders] The `partials` placeholder indexes. param: {Array} [argPos] The argument positions of the new function. param: {number} [ary] The arity cap of `func`. param: {number} [arity] The arity of `func`. returns: {Function} Returns the new wrapped function. |
| createRound(methodName) X-Ref |
| Creates a function like `_.round`. param: {string} methodName The name of the `Math` method to use when rounding. returns: {Function} Returns the new round function. |
| createToPairs(keysFunc) X-Ref |
| Creates a `_.toPairs` or `_.toPairsIn` function. param: {Function} keysFunc The function to get the keys of a given object. returns: {Function} Returns the new pairs function. |
| createWrap(func, bitmask, thisArg, partials, holders, argPos, ary, arity) X-Ref |
| Creates a function that either curries or invokes `func` with optional `this` binding and partially applied arguments. param: {Function|string} func The function or method name to wrap. param: {number} bitmask The bitmask flags. param: {*} [thisArg] The `this` binding of `func`. param: {Array} [partials] The arguments to be partially applied. param: {Array} [holders] The `partials` placeholder indexes. param: {Array} [argPos] The argument positions of the new function. param: {number} [ary] The arity cap of `func`. param: {number} [arity] The arity of `func`. returns: {Function} Returns the new wrapped function. |
| customDefaultsAssignIn(objValue, srcValue, key, object) X-Ref |
| Used by `_.defaults` to customize its `_.assignIn` use to assign properties of source objects to the destination object for all destination properties that resolve to `undefined`. param: {*} objValue The destination value. param: {*} srcValue The source value. param: {string} key The key of the property to assign. param: {Object} object The parent object of `objValue`. returns: {*} Returns the value to assign. |
| customDefaultsMerge(objValue, srcValue, key, object, source, stack) X-Ref |
| Used by `_.defaultsDeep` to customize its `_.merge` use to merge source objects into destination objects that are passed thru. param: {*} objValue The destination value. param: {*} srcValue The source value. param: {string} key The key of the property to merge. param: {Object} object The parent object of `objValue`. param: {Object} source The parent object of `srcValue`. param: {Object} [stack] Tracks traversed source values and their merged returns: {*} Returns the value to assign. |
| customOmitClone(value) X-Ref |
| Used by `_.omit` to customize its `_.cloneDeep` use to only clone plain objects. param: {*} value The value to inspect. param: {string} key The key of the property to inspect. returns: {*} Returns the uncloned value or `undefined` to defer cloning to `_.cloneDeep`. |
| equalArrays(array, other, bitmask, customizer, equalFunc, stack) X-Ref |
| A specialized version of `baseIsEqualDeep` for arrays with support for partial deep comparisons. param: {Array} array The array to compare. param: {Array} other The other array to compare. param: {number} bitmask The bitmask flags. See `baseIsEqual` for more details. param: {Function} customizer The function to customize comparisons. param: {Function} equalFunc The function to determine equivalents of values. param: {Object} stack Tracks traversed `array` and `other` objects. returns: {boolean} Returns `true` if the arrays are equivalent, else `false`. |
| equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) X-Ref |
| A specialized version of `baseIsEqualDeep` for comparing objects of the same `toStringTag`. **Note:** This function only supports comparing values with tags of `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`. param: {Object} object The object to compare. param: {Object} other The other object to compare. param: {string} tag The `toStringTag` of the objects to compare. param: {number} bitmask The bitmask flags. See `baseIsEqual` for more details. param: {Function} customizer The function to customize comparisons. param: {Function} equalFunc The function to determine equivalents of values. param: {Object} stack Tracks traversed `object` and `other` objects. returns: {boolean} Returns `true` if the objects are equivalent, else `false`. |
| equalObjects(object, other, bitmask, customizer, equalFunc, stack) X-Ref |
| A specialized version of `baseIsEqualDeep` for objects with support for partial deep comparisons. param: {Object} object The object to compare. param: {Object} other The other object to compare. param: {number} bitmask The bitmask flags. See `baseIsEqual` for more details. param: {Function} customizer The function to customize comparisons. param: {Function} equalFunc The function to determine equivalents of values. param: {Object} stack Tracks traversed `object` and `other` objects. returns: {boolean} Returns `true` if the objects are equivalent, else `false`. |
| flatRest(func) X-Ref |
| A specialized version of `baseRest` which flattens the rest array. param: {Function} func The function to apply a rest parameter to. returns: {Function} Returns the new function. |
| getAllKeys(object) X-Ref |
| Creates an array of own enumerable property names and symbols of `object`. param: {Object} object The object to query. returns: {Array} Returns the array of property names and symbols. |
| getAllKeysIn(object) X-Ref |
| Creates an array of own and inherited enumerable property names and symbols of `object`. param: {Object} object The object to query. returns: {Array} Returns the array of property names and symbols. |
| getFuncName(func) X-Ref |
| Gets the name of `func`. param: {Function} func The function to query. returns: {string} Returns the function name. |
| getHolder(func) X-Ref |
| Gets the argument placeholder value for `func`. param: {Function} func The function to inspect. returns: {*} Returns the placeholder value. |
| getIteratee() X-Ref |
| Gets the appropriate "iteratee" function. If `_.iteratee` is customized, this function returns the custom method, otherwise it returns `baseIteratee`. If arguments are provided, the chosen function is invoked with them and its result is returned. param: {*} [value] The value to convert to an iteratee. param: {number} [arity] The arity of the created iteratee. returns: {Function} Returns the chosen function or its result. |
| getMapData(map, key) X-Ref |
| Gets the data for `map`. param: {Object} map The map to query. param: {string} key The reference key. returns: {*} Returns the map data. |
| getMatchData(object) X-Ref |
| Gets the property names, values, and compare flags of `object`. param: {Object} object The object to query. returns: {Array} Returns the match data of `object`. |
| getNative(object, key) X-Ref |
| Gets the native function at `key` of `object`. param: {Object} object The object to query. param: {string} key The key of the method to get. returns: {*} Returns the function if it's native, else `undefined`. |
| getRawTag(value) X-Ref |
| A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values. param: {*} value The value to query. returns: {string} Returns the raw `toStringTag`. |
| getView(start, end, transforms) X-Ref |
| Gets the view, applying any `transforms` to the `start` and `end` positions. param: {number} start The start of the view. param: {number} end The end of the view. param: {Array} transforms The transformations to apply to the view. returns: {Object} Returns an object containing the `start` and `end` |
| getWrapDetails(source) X-Ref |
| Extracts wrapper details from the `source` body comment. param: {string} source The source to inspect. returns: {Array} Returns the wrapper details. |
| hasPath(object, path, hasFunc) X-Ref |
| Checks if `path` exists on `object`. param: {Object} object The object to query. param: {Array|string} path The path to check. param: {Function} hasFunc The function to check properties. returns: {boolean} Returns `true` if `path` exists, else `false`. |
| initCloneArray(array) X-Ref |
| Initializes an array clone. param: {Array} array The array to clone. returns: {Array} Returns the initialized clone. |
| initCloneObject(object) X-Ref |
| Initializes an object clone. param: {Object} object The object to clone. returns: {Object} Returns the initialized clone. |
| initCloneByTag(object, tag, isDeep) X-Ref |
| Initializes an object clone based on its `toStringTag`. **Note:** This function only supports cloning values with tags of `Boolean`, `Date`, `Error`, `Map`, `Number`, `RegExp`, `Set`, or `String`. param: {Object} object The object to clone. param: {string} tag The `toStringTag` of the object to clone. param: {boolean} [isDeep] Specify a deep clone. returns: {Object} Returns the initialized clone. |
| insertWrapDetails(source, details) X-Ref |
| Inserts wrapper `details` in a comment at the top of the `source` body. param: {string} source The source to modify. returns: {Array} details The details to insert. returns: {string} Returns the modified source. |
| isFlattenable(value) X-Ref |
| Checks if `value` is a flattenable `arguments` object or array. param: {*} value The value to check. returns: {boolean} Returns `true` if `value` is flattenable, else `false`. |
| isIndex(value, length) X-Ref |
| Checks if `value` is a valid array-like index. param: {*} value The value to check. param: {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index. returns: {boolean} Returns `true` if `value` is a valid index, else `false`. |
| isIterateeCall(value, index, object) X-Ref |
| Checks if the given arguments are from an iteratee call. param: {*} value The potential iteratee value argument. param: {*} index The potential iteratee index or key argument. param: {*} object The potential iteratee object argument. returns: {boolean} Returns `true` if the arguments are from an iteratee call, |
| isKey(value, object) X-Ref |
| Checks if `value` is a property name and not a property path. param: {*} value The value to check. param: {Object} [object] The object to query keys on. returns: {boolean} Returns `true` if `value` is a property name, else `false`. |
| isKeyable(value) X-Ref |
| Checks if `value` is suitable for use as unique object key. param: {*} value The value to check. returns: {boolean} Returns `true` if `value` is suitable, else `false`. |
| isLaziable(func) X-Ref |
| Checks if `func` has a lazy counterpart. param: {Function} func The function to check. returns: {boolean} Returns `true` if `func` has a lazy counterpart, |
| isMasked(func) X-Ref |
| Checks if `func` has its source masked. param: {Function} func The function to check. returns: {boolean} Returns `true` if `func` is masked, else `false`. |
| isPrototype(value) X-Ref |
| Checks if `value` is likely a prototype object. param: {*} value The value to check. returns: {boolean} Returns `true` if `value` is a prototype, else `false`. |
| isStrictComparable(value) X-Ref |
| Checks if `value` is suitable for strict equality comparisons, i.e. `===`. param: {*} value The value to check. returns: {boolean} Returns `true` if `value` if suitable for strict |
| matchesStrictComparable(key, srcValue) X-Ref |
| A specialized version of `matchesProperty` for source values suitable for strict equality comparisons, i.e. `===`. param: {string} key The key of the property to get. param: {*} srcValue The value to match. returns: {Function} Returns the new spec function. |
| memoizeCapped(func) X-Ref |
| A specialized version of `_.memoize` which clears the memoized function's cache when it exceeds `MAX_MEMOIZE_SIZE`. param: {Function} func The function to have its output memoized. returns: {Function} Returns the new memoized function. |
| mergeData(data, source) X-Ref |
| Merges the function metadata of `source` into `data`. Merging metadata reduces the number of wrappers used to invoke a function. This is possible because methods like `_.bind`, `_.curry`, and `_.partial` may be applied regardless of execution order. Methods like `_.ary` and `_.rearg` modify function arguments, making the order in which they are executed important, preventing the merging of metadata. However, we make an exception for a safe combined case where curried functions have `_.ary` and or `_.rearg` applied. param: {Array} data The destination metadata. param: {Array} source The source metadata. returns: {Array} Returns `data`. |
| nativeKeysIn(object) X-Ref |
| This function is like [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys) except that it includes inherited enumerable properties. param: {Object} object The object to query. returns: {Array} Returns the array of property names. |
| objectToString(value) X-Ref |
| Converts `value` to a string using `Object.prototype.toString`. param: {*} value The value to convert. returns: {string} Returns the converted string. |
| overRest(func, start, transform) X-Ref |
| A specialized version of `baseRest` which transforms the rest array. param: {Function} func The function to apply a rest parameter to. param: {number} [start=func.length-1] The start position of the rest parameter. param: {Function} transform The rest array transform. returns: {Function} Returns the new function. |
| parent(object, path) X-Ref |
| Gets the parent value at `path` of `object`. param: {Object} object The object to query. param: {Array} path The path to get the parent value of. returns: {*} Returns the parent value. |
| reorder(array, indexes) X-Ref |
| Reorder `array` according to the specified indexes where the element at the first index is assigned as the first element, the element at the second index is assigned as the second element, and so on. param: {Array} array The array to reorder. param: {Array} indexes The arranged array indexes. returns: {Array} Returns `array`. |
| safeGet(object, key) X-Ref |
| Gets the value at `key`, unless `key` is "__proto__" or "constructor". param: {Object} object The object to query. param: {string} key The key of the property to get. returns: {*} Returns the property value. |
| setWrapToString(wrapper, reference, bitmask) X-Ref |
| Sets the `toString` method of `wrapper` to mimic the source of `reference` with wrapper details in a comment at the top of the source body. param: {Function} wrapper The function to modify. param: {Function} reference The reference function. param: {number} bitmask The bitmask flags. See `createWrap` for more details. returns: {Function} Returns `wrapper`. |
| shortOut(func) X-Ref |
| Creates a function that'll short out and invoke `identity` instead of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN` milliseconds. param: {Function} func The function to restrict. returns: {Function} Returns the new shortable function. |
| shuffleSelf(array, size) X-Ref |
| A specialized version of `_.shuffle` which mutates and sets the size of `array`. param: {Array} array The array to shuffle. param: {number} [size=array.length] The size of `array`. returns: {Array} Returns `array`. |
| toKey(value) X-Ref |
| Converts `value` to a string key if it's not a string or symbol. param: {*} value The value to inspect. returns: {string|symbol} Returns the key. |
| toSource(func) X-Ref |
| Converts `func` to its source code. param: {Function} func The function to convert. returns: {string} Returns the source code. |
| updateWrapDetails(details, bitmask) X-Ref |
| Updates wrapper `details` based on `bitmask` flags. param: {number} bitmask The bitmask flags. See `createWrap` for more details. returns: {Array} details The details to modify. returns: {Array} Returns `details`. |
| wrapperClone(wrapper) X-Ref |
| Creates a clone of `wrapper`. param: {Object} wrapper The wrapper to clone. returns: {Object} Returns the cloned wrapper. |
| chunk(array, size, guard) X-Ref |
| Creates an array of elements split into groups the length of `size`. If `array` can't be split evenly, the final chunk will be the remaining elements. param: {Array} array The array to process. param: {number} [size=1] The length of each chunk param: - {Object} [guard] Enables use as an iteratee for methods like `_.map`. returns: {Array} Returns the new array of chunks. |
| compact(array) X-Ref |
| Creates an array with all falsey values removed. The values `false`, `null`, `0`, `""`, `undefined`, and `NaN` are falsey. param: {Array} array The array to compact. returns: {Array} Returns the new array of filtered values. |
| concat() X-Ref |
| Creates a new array concatenating `array` with any additional arrays and/or values. param: {Array} array The array to concatenate. param: {...*} [values] The values to concatenate. returns: {Array} Returns the new concatenated array. |
| drop(array, n, guard) X-Ref |
| Creates a slice of `array` with `n` elements dropped from the beginning. param: {Array} array The array to query. param: {number} [n=1] The number of elements to drop. param: - {Object} [guard] Enables use as an iteratee for methods like `_.map`. returns: {Array} Returns the slice of `array`. |
| dropRight(array, n, guard) X-Ref |
| Creates a slice of `array` with `n` elements dropped from the end. param: {Array} array The array to query. param: {number} [n=1] The number of elements to drop. param: - {Object} [guard] Enables use as an iteratee for methods like `_.map`. returns: {Array} Returns the slice of `array`. |
| dropRightWhile(array, predicate) X-Ref |
| Creates a slice of `array` excluding elements dropped from the end. Elements are dropped until `predicate` returns falsey. The predicate is invoked with three arguments: (value, index, array). param: {Array} array The array to query. param: {Function} [predicate=_.identity] The function invoked per iteration. returns: {Array} Returns the slice of `array`. |
| dropWhile(array, predicate) X-Ref |
| Creates a slice of `array` excluding elements dropped from the beginning. Elements are dropped until `predicate` returns falsey. The predicate is invoked with three arguments: (value, index, array). param: {Array} array The array to query. param: {Function} [predicate=_.identity] The function invoked per iteration. returns: {Array} Returns the slice of `array`. |
| fill(array, value, start, end) X-Ref |
| Fills elements of `array` with `value` from `start` up to, but not including, `end`. **Note:** This method mutates `array`. param: {Array} array The array to fill. param: {*} value The value to fill `array` with. param: {number} [start=0] The start position. param: {number} [end=array.length] The end position. returns: {Array} Returns `array`. |
| findIndex(array, predicate, fromIndex) X-Ref |
| This method is like `_.find` except that it returns the index of the first element `predicate` returns truthy for instead of the element itself. param: {Array} array The array to inspect. param: {Function} [predicate=_.identity] The function invoked per iteration. param: {number} [fromIndex=0] The index to search from. returns: {number} Returns the index of the found element, else `-1`. |
| findLastIndex(array, predicate, fromIndex) X-Ref |
| This method is like `_.findIndex` except that it iterates over elements of `collection` from right to left. param: {Array} array The array to inspect. param: {Function} [predicate=_.identity] The function invoked per iteration. param: {number} [fromIndex=array.length-1] The index to search from. returns: {number} Returns the index of the found element, else `-1`. |
| flatten(array) X-Ref |
| Flattens `array` a single level deep. param: {Array} array The array to flatten. returns: {Array} Returns the new flattened array. |
| flattenDeep(array) X-Ref |
| Recursively flattens `array`. param: {Array} array The array to flatten. returns: {Array} Returns the new flattened array. |
| flattenDepth(array, depth) X-Ref |
| Recursively flatten `array` up to `depth` times. param: {Array} array The array to flatten. param: {number} [depth=1] The maximum recursion depth. returns: {Array} Returns the new flattened array. |
| fromPairs(pairs) X-Ref |
| The inverse of `_.toPairs`; this method returns an object composed from key-value `pairs`. param: {Array} pairs The key-value pairs. returns: {Object} Returns the new object. |
| head(array) X-Ref |
| Gets the first element of `array`. param: {Array} array The array to query. returns: {*} Returns the first element of `array`. |
| indexOf(array, value, fromIndex) X-Ref |
| Gets the index at which the first occurrence of `value` is found in `array` using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) for equality comparisons. If `fromIndex` is negative, it's used as the offset from the end of `array`. param: {Array} array The array to inspect. param: {*} value The value to search for. param: {number} [fromIndex=0] The index to search from. returns: {number} Returns the index of the matched value, else `-1`. |
| initial(array) X-Ref |
| Gets all but the last element of `array`. param: {Array} array The array to query. returns: {Array} Returns the slice of `array`. |
| join(array, separator) X-Ref |
| Converts all elements in `array` into a string separated by `separator`. param: {Array} array The array to convert. param: {string} [separator=','] The element separator. returns: {string} Returns the joined string. |
| last(array) X-Ref |
| Gets the last element of `array`. param: {Array} array The array to query. returns: {*} Returns the last element of `array`. |
| lastIndexOf(array, value, fromIndex) X-Ref |
| This method is like `_.indexOf` except that it iterates over elements of `array` from right to left. param: {Array} array The array to inspect. param: {*} value The value to search for. param: {number} [fromIndex=array.length-1] The index to search from. returns: {number} Returns the index of the matched value, else `-1`. |
| nth(array, n) X-Ref |
| Gets the element at index `n` of `array`. If `n` is negative, the nth element from the end is returned. param: {Array} array The array to query. param: {number} [n=0] The index of the element to return. returns: {*} Returns the nth element of `array`. |
| pullAll(array, values) X-Ref |
| This method is like `_.pull` except that it accepts an array of values to remove. **Note:** Unlike `_.difference`, this method mutates `array`. param: {Array} array The array to modify. param: {Array} values The values to remove. returns: {Array} Returns `array`. |
| pullAllBy(array, values, iteratee) X-Ref |
| 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. The iteratee is invoked with one argument: (value). **Note:** Unlike `_.differenceBy`, this method mutates `array`. param: {Array} array The array to modify. param: {Array} values The values to remove. param: {Function} [iteratee=_.identity] The iteratee invoked per element. returns: {Array} Returns `array`. |
| pullAllWith(array, values, comparator) X-Ref |
| This method is like `_.pullAll` except that it accepts `comparator` which is invoked to compare elements of `array` to `values`. The comparator is invoked with two arguments: (arrVal, othVal). **Note:** Unlike `_.differenceWith`, this method mutates `array`. param: {Array} array The array to modify. param: {Array} values The values to remove. param: {Function} [comparator] The comparator invoked per element. returns: {Array} Returns `array`. |
| remove(array, predicate) X-Ref |
| Removes all elements from `array` that `predicate` returns truthy for and returns an array of the removed elements. The predicate is invoked with three arguments: (value, index, array). **Note:** Unlike `_.filter`, this method mutates `array`. Use `_.pull` to pull elements from an array by value. param: {Array} array The array to modify. param: {Function} [predicate=_.identity] The function invoked per iteration. returns: {Array} Returns the new array of removed elements. |
| reverse(array) X-Ref |
| Reverses `array` so that the first element becomes the last, the second element becomes the second to last, and so on. **Note:** This method mutates `array` and is based on [`Array#reverse`](https://mdn.io/Array/reverse). param: {Array} array The array to modify. returns: {Array} Returns `array`. |
| slice(array, start, end) X-Ref |
| Creates a slice of `array` from `start` up to, but not including, `end`. **Note:** This method is used instead of [`Array#slice`](https://mdn.io/Array/slice) to ensure dense arrays are returned. param: {Array} array The array to slice. param: {number} [start=0] The start position. param: {number} [end=array.length] The end position. returns: {Array} Returns the slice of `array`. |
| sortedIndex(array, value) X-Ref |
| Uses a binary search to determine the lowest index at which `value` should be inserted into `array` in order to maintain its sort order. param: {Array} array The sorted array to inspect. param: {*} value The value to evaluate. returns: {number} Returns the index at which `value` should be inserted |
| sortedIndexBy(array, value, iteratee) X-Ref |
| 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. The iteratee is invoked with one argument: (value). param: {Array} array The sorted array to inspect. param: {*} value The value to evaluate. param: {Function} [iteratee=_.identity] The iteratee invoked per element. returns: {number} Returns the index at which `value` should be inserted |
| sortedIndexOf(array, value) X-Ref |
| This method is like `_.indexOf` except that it performs a binary search on a sorted `array`. param: {Array} array The array to inspect. param: {*} value The value to search for. returns: {number} Returns the index of the matched value, else `-1`. |
| sortedLastIndex(array, value) X-Ref |
| 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. param: {Array} array The sorted array to inspect. param: {*} value The value to evaluate. returns: {number} Returns the index at which `value` should be inserted |
| sortedLastIndexBy(array, value, iteratee) X-Ref |
| 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. The iteratee is invoked with one argument: (value). param: {Array} array The sorted array to inspect. param: {*} value The value to evaluate. param: {Function} [iteratee=_.identity] The iteratee invoked per element. returns: {number} Returns the index at which `value` should be inserted |
| sortedLastIndexOf(array, value) X-Ref |
| This method is like `_.lastIndexOf` except that it performs a binary search on a sorted `array`. param: {Array} array The array to inspect. param: {*} value The value to search for. returns: {number} Returns the index of the matched value, else `-1`. |
| sortedUniq(array) X-Ref |
| This method is like `_.uniq` except that it's designed and optimized for sorted arrays. param: {Array} array The array to inspect. returns: {Array} Returns the new duplicate free array. |
| sortedUniqBy(array, iteratee) X-Ref |
| This method is like `_.uniqBy` except that it's designed and optimized for sorted arrays. param: {Array} array The array to inspect. param: {Function} [iteratee] The iteratee invoked per element. returns: {Array} Returns the new duplicate free array. |
| tail(array) X-Ref |
| Gets all but the first element of `array`. param: {Array} array The array to query. returns: {Array} Returns the slice of `array`. |
| take(array, n, guard) X-Ref |
| Creates a slice of `array` with `n` elements taken from the beginning. param: {Array} array The array to query. param: {number} [n=1] The number of elements to take. param: - {Object} [guard] Enables use as an iteratee for methods like `_.map`. returns: {Array} Returns the slice of `array`. |
| takeRight(array, n, guard) X-Ref |
| Creates a slice of `array` with `n` elements taken from the end. param: {Array} array The array to query. param: {number} [n=1] The number of elements to take. param: - {Object} [guard] Enables use as an iteratee for methods like `_.map`. returns: {Array} Returns the slice of `array`. |
| takeRightWhile(array, predicate) X-Ref |
| Creates a slice of `array` with elements taken from the end. Elements are taken until `predicate` returns falsey. The predicate is invoked with three arguments: (value, index, array). param: {Array} array The array to query. param: {Function} [predicate=_.identity] The function invoked per iteration. returns: {Array} Returns the slice of `array`. |
| takeWhile(array, predicate) X-Ref |
| Creates a slice of `array` with elements taken from the beginning. Elements are taken until `predicate` returns falsey. The predicate is invoked with three arguments: (value, index, array). param: {Array} array The array to query. param: {Function} [predicate=_.identity] The function invoked per iteration. returns: {Array} Returns the slice of `array`. |
| uniq(array) X-Ref |
| Creates a duplicate-free version of an array, using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) for equality comparisons, in which only the first occurrence of each element is kept. The order of result values is determined by the order they occur in the array. param: {Array} array The array to inspect. returns: {Array} Returns the new duplicate free array. |
| uniqBy(array, iteratee) X-Ref |
| 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. The order of result values is determined by the order they occur in the array. The iteratee is invoked with one argument: (value). param: {Array} array The array to inspect. param: {Function} [iteratee=_.identity] The iteratee invoked per element. returns: {Array} Returns the new duplicate free array. |
| uniqWith(array, comparator) X-Ref |
| This method is like `_.uniq` except that it accepts `comparator` which is invoked to compare elements of `array`. The order of result values is determined by the order they occur in the array.The comparator is invoked with two arguments: (arrVal, othVal). param: {Array} array The array to inspect. param: {Function} [comparator] The comparator invoked per element. returns: {Array} Returns the new duplicate free array. |
| unzip(array) X-Ref |
| 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. param: {Array} array The array of grouped elements to process. returns: {Array} Returns the new array of regrouped elements. |
| unzipWith(array, iteratee) X-Ref |
| This method is like `_.unzip` except that it accepts `iteratee` to specify how regrouped values should be combined. The iteratee is invoked with the elements of each group: (...group). param: {Array} array The array of grouped elements to process. param: {Function} [iteratee=_.identity] The function to combine returns: {Array} Returns the new array of regrouped elements. |
| zipObject(props, values) X-Ref |
| This method is like `_.fromPairs` except that it accepts two arrays, one of property identifiers and one of corresponding values. param: {Array} [props=[]] The property identifiers. param: {Array} [values=[]] The property values. returns: {Object} Returns the new object. |
| zipObjectDeep(props, values) X-Ref |
| This method is like `_.zipObject` except that it supports property paths. param: {Array} [props=[]] The property identifiers. param: {Array} [values=[]] The property values. returns: {Object} Returns the new object. |
| chain(value) X-Ref |
| Creates a `lodash` wrapper instance that wraps `value` with explicit method chain sequences enabled. The result of such sequences must be unwrapped with `_#value`. param: {*} value The value to wrap. returns: {Object} Returns the new `lodash` wrapper instance. |
| tap(value, interceptor) X-Ref |
| This method invokes `interceptor` and returns `value`. The interceptor is invoked with one argument; (value). The purpose of this method is to "tap into" a method chain sequence in order to modify intermediate results. param: {*} value The value to provide to `interceptor`. param: {Function} interceptor The function to invoke. returns: {*} Returns `value`. |
| thru(value, interceptor) X-Ref |
| This method is like `_.tap` except that it returns the result of `interceptor`. The purpose of this method is to "pass thru" values replacing intermediate results in a method chain sequence. param: {*} value The value to provide to `interceptor`. param: {Function} interceptor The function to invoke. returns: {*} Returns the result of `interceptor`. |
| wrapperChain() X-Ref |
| Creates a `lodash` wrapper instance with explicit method chain sequences enabled. returns: {Object} Returns the new `lodash` wrapper instance. |
| wrapperCommit() X-Ref |
| Executes the chain sequence and returns the wrapped result. returns: {Object} Returns the new `lodash` wrapper instance. |
| wrapperNext() X-Ref |
| Gets the next value on a wrapped object following the [iterator protocol](https://mdn.io/iteration_protocols#iterator). returns: {Object} Returns the next iterator value. |
| wrapperToIterator() X-Ref |
| Enables the wrapper to be iterable. returns: {Object} Returns the wrapper object. |
| wrapperPlant(value) X-Ref |
| Creates a clone of the chain sequence planting `value` as the wrapped value. param: {*} value The value to plant. returns: {Object} Returns the new `lodash` wrapper instance. |
| wrapperReverse() X-Ref |
| This method is the wrapper version of `_.reverse`. **Note:** This method mutates the wrapped array. returns: {Object} Returns the new `lodash` wrapper instance. |
| wrapperValue() X-Ref |
| Executes the chain sequence to resolve the unwrapped value. returns: {*} Returns the resolved unwrapped value. |
| every(collection, predicate, guard) X-Ref |
| Checks if `predicate` returns truthy for **all** elements of `collection`. Iteration is stopped once `predicate` returns falsey. The predicate is invoked with three arguments: (value, index|key, collection). **Note:** This method returns `true` for [empty collections](https://en.wikipedia.org/wiki/Empty_set) because [everything is true](https://en.wikipedia.org/wiki/Vacuous_truth) of elements of empty collections. param: {Array|Object} collection The collection to iterate over. param: {Function} [predicate=_.identity] The function invoked per iteration. param: - {Object} [guard] Enables use as an iteratee for methods like `_.map`. returns: {boolean} Returns `true` if all elements pass the predicate check, |
| filter(collection, predicate) X-Ref |
| Iterates over elements of `collection`, returning an array of all elements `predicate` returns truthy for. The predicate is invoked with three arguments: (value, index|key, collection). **Note:** Unlike `_.remove`, this method returns a new array. param: {Array|Object} collection The collection to iterate over. param: {Function} [predicate=_.identity] The function invoked per iteration. returns: {Array} Returns the new filtered array. |
| flatMap(collection, iteratee) X-Ref |
| Creates a flattened array of values by running each element in `collection` thru `iteratee` and flattening the mapped results. The iteratee is invoked with three arguments: (value, index|key, collection). param: {Array|Object} collection The collection to iterate over. param: {Function} [iteratee=_.identity] The function invoked per iteration. returns: {Array} Returns the new flattened array. |
| flatMapDeep(collection, iteratee) X-Ref |
| This method is like `_.flatMap` except that it recursively flattens the mapped results. param: {Array|Object} collection The collection to iterate over. param: {Function} [iteratee=_.identity] The function invoked per iteration. returns: {Array} Returns the new flattened array. |
| flatMapDepth(collection, iteratee, depth) X-Ref |
| This method is like `_.flatMap` except that it recursively flattens the mapped results up to `depth` times. param: {Array|Object} collection The collection to iterate over. param: {Function} [iteratee=_.identity] The function invoked per iteration. param: {number} [depth=1] The maximum recursion depth. returns: {Array} Returns the new flattened array. |
| forEach(collection, iteratee) X-Ref |
| Iterates over elements of `collection` and invokes `iteratee` for each element. The iteratee is invoked with three arguments: (value, index|key, collection). Iteratee functions may exit iteration early by explicitly returning `false`. **Note:** As with other "Collections" methods, objects with a "length" property are iterated like arrays. To avoid this behavior use `_.forIn` or `_.forOwn` for object iteration. param: {Array|Object} collection The collection to iterate over. param: {Function} [iteratee=_.identity] The function invoked per iteration. returns: {Array|Object} Returns `collection`. |
| forEachRight(collection, iteratee) X-Ref |
| This method is like `_.forEach` except that it iterates over elements of `collection` from right to left. param: {Array|Object} collection The collection to iterate over. param: {Function} [iteratee=_.identity] The function invoked per iteration. returns: {Array|Object} Returns `collection`. |
| includes(collection, value, fromIndex, guard) X-Ref |
| Checks if `value` is in `collection`. If `collection` is a string, it's checked for a substring of `value`, otherwise [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) is used for equality comparisons. If `fromIndex` is negative, it's used as the offset from the end of `collection`. param: {Array|Object|string} collection The collection to inspect. param: {*} value The value to search for. param: {number} [fromIndex=0] The index to search from. param: - {Object} [guard] Enables use as an iteratee for methods like `_.reduce`. returns: {boolean} Returns `true` if `value` is found, else `false`. |
| map(collection, iteratee) X-Ref |
| Creates an array of values by running each element in `collection` thru `iteratee`. The iteratee is invoked with three arguments: (value, index|key, collection). Many lodash methods are guarded to work as iteratees for methods like `_.every`, `_.filter`, `_.map`, `_.mapValues`, `_.reject`, and `_.some`. The guarded methods are: `ary`, `chunk`, `curry`, `curryRight`, `drop`, `dropRight`, `every`, `fill`, `invert`, `parseInt`, `random`, `range`, `rangeRight`, `repeat`, `sampleSize`, `slice`, `some`, `sortBy`, `split`, `take`, `takeRight`, `template`, `trim`, `trimEnd`, `trimStart`, and `words` param: {Array|Object} collection The collection to iterate over. param: {Function} [iteratee=_.identity] The function invoked per iteration. returns: {Array} Returns the new mapped array. |
| orderBy(collection, iteratees, orders, guard) X-Ref |
| This method is like `_.sortBy` except that it allows specifying the sort orders of the iteratees to sort by. If `orders` is unspecified, all values are sorted in ascending order. Otherwise, specify an order of "desc" for descending or "asc" for ascending sort order of corresponding values. param: {Array|Object} collection The collection to iterate over. param: {Array[]|Function[]|Object[]|string[]} [iteratees=[_.identity]] param: {string[]} [orders] The sort orders of `iteratees`. param: - {Object} [guard] Enables use as an iteratee for methods like `_.reduce`. returns: {Array} Returns the new sorted array. |
| reduce(collection, iteratee, accumulator) X-Ref |
| Reduces `collection` to a value which is the accumulated result of running each element in `collection` thru `iteratee`, where each successive invocation is supplied the return value of the previous. If `accumulator` is not given, the first element of `collection` is used as the initial value. The iteratee is invoked with four arguments: (accumulator, value, index|key, collection). Many lodash methods are guarded to work as iteratees for methods like `_.reduce`, `_.reduceRight`, and `_.transform`. The guarded methods are: `assign`, `defaults`, `defaultsDeep`, `includes`, `merge`, `orderBy`, and `sortBy` param: {Array|Object} collection The collection to iterate over. param: {Function} [iteratee=_.identity] The function invoked per iteration. param: {*} [accumulator] The initial value. returns: {*} Returns the accumulated value. |
| reduceRight(collection, iteratee, accumulator) X-Ref |
| This method is like `_.reduce` except that it iterates over elements of `collection` from right to left. param: {Array|Object} collection The collection to iterate over. param: {Function} [iteratee=_.identity] The function invoked per iteration. param: {*} [accumulator] The initial value. returns: {*} Returns the accumulated value. |
| reject(collection, predicate) X-Ref |
| The opposite of `_.filter`; this method returns the elements of `collection` that `predicate` does **not** return truthy for. param: {Array|Object} collection The collection to iterate over. param: {Function} [predicate=_.identity] The function invoked per iteration. returns: {Array} Returns the new filtered array. |
| sample(collection) X-Ref |
| Gets a random element from `collection`. param: {Array|Object} collection The collection to sample. returns: {*} Returns the random element. |
| sampleSize(collection, n, guard) X-Ref |
| Gets `n` random elements at unique keys from `collection` up to the size of `collection`. param: {Array|Object} collection The collection to sample. param: {number} [n=1] The number of elements to sample. param: - {Object} [guard] Enables use as an iteratee for methods like `_.map`. returns: {Array} Returns the random elements. |
| shuffle(collection) X-Ref |
| Creates an array of shuffled values, using a version of the [Fisher-Yates shuffle](https://en.wikipedia.org/wiki/Fisher-Yates_shuffle). param: {Array|Object} collection The collection to shuffle. returns: {Array} Returns the new shuffled array. |
| size(collection) X-Ref |
| Gets the size of `collection` by returning its length for array-like values or the number of own enumerable string keyed properties for objects. param: {Array|Object|string} collection The collection to inspect. returns: {number} Returns the collection size. |
| some(collection, predicate, guard) X-Ref |
| Checks if `predicate` returns truthy for **any** element of `collection`. Iteration is stopped once `predicate` returns truthy. The predicate is invoked with three arguments: (value, index|key, collection). param: {Array|Object} collection The collection to iterate over. param: {Function} [predicate=_.identity] The function invoked per iteration. param: - {Object} [guard] Enables use as an iteratee for methods like `_.map`. returns: {boolean} Returns `true` if any element passes the predicate check, |
| after(n, func) X-Ref |
| The opposite of `_.before`; this method creates a function that invokes `func` once it's called `n` or more times. param: {number} n The number of calls before `func` is invoked. param: {Function} func The function to restrict. returns: {Function} Returns the new restricted function. |
| ary(func, n, guard) X-Ref |
| Creates a function that invokes `func`, with up to `n` arguments, ignoring any additional arguments. param: {Function} func The function to cap arguments for. param: {number} [n=func.length] The arity cap. param: - {Object} [guard] Enables use as an iteratee for methods like `_.map`. returns: {Function} Returns the new capped function. |
| before(n, func) X-Ref |
| Creates a function that invokes `func`, with the `this` binding and arguments of the created function, while it's called less than `n` times. Subsequent calls to the created function return the result of the last `func` invocation. param: {number} n The number of calls at which `func` is no longer invoked. param: {Function} func The function to restrict. returns: {Function} Returns the new restricted function. |
| curry(func, arity, guard) X-Ref |
| Creates a function that accepts arguments of `func` and either invokes `func` returning its result, if at least `arity` number of arguments have been provided, or returns a function that accepts the remaining `func` arguments, and so on. The arity of `func` may be specified if `func.length` is not sufficient. The `_.curry.placeholder` value, which defaults to `_` in monolithic builds, may be used as a placeholder for provided arguments. **Note:** This method doesn't set the "length" property of curried functions. param: {Function} func The function to curry. param: {number} [arity=func.length] The arity of `func`. param: - {Object} [guard] Enables use as an iteratee for methods like `_.map`. returns: {Function} Returns the new curried function. |
| curryRight(func, arity, guard) X-Ref |
| This method is like `_.curry` except that arguments are applied to `func` in the manner of `_.partialRight` instead of `_.partial`. The `_.curryRight.placeholder` value, which defaults to `_` in monolithic builds, may be used as a placeholder for provided arguments. **Note:** This method doesn't set the "length" property of curried functions. param: {Function} func The function to curry. param: {number} [arity=func.length] The arity of `func`. param: - {Object} [guard] Enables use as an iteratee for methods like `_.map`. returns: {Function} Returns the new curried function. |
| debounce(func, wait, options) X-Ref |
| Creates a debounced function that delays invoking `func` until after `wait` milliseconds have elapsed since the last time the debounced function was invoked. The debounced function comes with a `cancel` method to cancel delayed `func` invocations and a `flush` method to immediately invoke them. Provide `options` to indicate whether `func` should be invoked on the leading and/or trailing edge of the `wait` timeout. The `func` is invoked with the last arguments provided to the debounced function. Subsequent calls to the debounced function return the result of the last `func` invocation. **Note:** If `leading` and `trailing` options are `true`, `func` is invoked on the trailing edge of the timeout only if the debounced function is invoked more than once during the `wait` timeout. If `wait` is `0` and `leading` is `false`, `func` invocation is deferred until to the next tick, similar to `setTimeout` with a timeout of `0`. See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/) for details over the differences between `_.debounce` and `_.throttle`. param: {Function} func The function to debounce. param: {number} [wait=0] The number of milliseconds to delay. param: {Object} [options={}] The options object. param: {boolean} [options.leading=false] param: {number} [options.maxWait] param: {boolean} [options.trailing=true] returns: {Function} Returns the new debounced function. |
| invokeFunc(time) X-Ref |
| No description |
| leadingEdge(time) X-Ref |
| No description |
| remainingWait(time) X-Ref |
| No description |
| shouldInvoke(time) X-Ref |
| No description |
| timerExpired() X-Ref |
| No description |
| trailingEdge(time) X-Ref |
| No description |
| cancel() X-Ref |
| No description |
| flush() X-Ref |
| No description |
| debounced() X-Ref |
| No description |
| flip(func) X-Ref |
| Creates a function that invokes `func` with arguments reversed. param: {Function} func The function to flip arguments for. returns: {Function} Returns the new flipped function. |
| memoize(func, resolver) X-Ref |
| Creates a function that memoizes the result of `func`. If `resolver` is provided, it determines the cache key for storing the result based on the arguments provided to the memoized function. By default, the first argument provided to the memoized function is used as the map cache key. The `func` is invoked with the `this` binding of the memoized function. **Note:** The cache is exposed as the `cache` property on the memoized function. Its creation may be customized by replacing the `_.memoize.Cache` constructor with one whose instances implement the [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object) method interface of `clear`, `delete`, `get`, `has`, and `set`. param: {Function} func The function to have its output memoized. param: {Function} [resolver] The function to resolve the cache key. returns: {Function} Returns the new memoized function. |
| negate(predicate) X-Ref |
| Creates a function that negates the result of the predicate `func`. The `func` predicate is invoked with the `this` binding and arguments of the created function. param: {Function} predicate The predicate to negate. returns: {Function} Returns the new negated function. |
| once(func) X-Ref |
| Creates a function that is restricted to invoking `func` once. Repeat calls to the function return the value of the first invocation. The `func` is invoked with the `this` binding and arguments of the created function. param: {Function} func The function to restrict. returns: {Function} Returns the new restricted function. |
| rest(func, start) X-Ref |
| Creates a function that invokes `func` with the `this` binding of the created function and arguments from `start` and beyond provided as an array. **Note:** This method is based on the [rest parameter](https://mdn.io/rest_parameters). param: {Function} func The function to apply a rest parameter to. param: {number} [start=func.length-1] The start position of the rest parameter. returns: {Function} Returns the new function. |
| spread(func, start) X-Ref |
| Creates a function that invokes `func` with the `this` binding of the create function and an array of arguments much like [`Function#apply`](http://www.ecma-international.org/ecma-262/7.0/#sec-function.prototype.apply). **Note:** This method is based on the [spread operator](https://mdn.io/spread_operator). param: {Function} func The function to spread arguments over. param: {number} [start=0] The start position of the spread. returns: {Function} Returns the new function. |
| throttle(func, wait, options) X-Ref |
| Creates a throttled function that only invokes `func` at most once per every `wait` milliseconds. The throttled function comes with a `cancel` method to cancel delayed `func` invocations and a `flush` method to immediately invoke them. Provide `options` to indicate whether `func` should be invoked on the leading and/or trailing edge of the `wait` timeout. The `func` is invoked with the last arguments provided to the throttled function. Subsequent calls to the throttled function return the result of the last `func` invocation. **Note:** If `leading` and `trailing` options are `true`, `func` is invoked on the trailing edge of the timeout only if the throttled function is invoked more than once during the `wait` timeout. If `wait` is `0` and `leading` is `false`, `func` invocation is deferred until to the next tick, similar to `setTimeout` with a timeout of `0`. See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/) for details over the differences between `_.throttle` and `_.debounce`. param: {Function} func The function to throttle. param: {number} [wait=0] The number of milliseconds to throttle invocations to. param: {Object} [options={}] The options object. param: {boolean} [options.leading=true] param: {boolean} [options.trailing=true] returns: {Function} Returns the new throttled function. |
| unary(func) X-Ref |
| Creates a function that accepts up to one argument, ignoring any additional arguments. param: {Function} func The function to cap arguments for. returns: {Function} Returns the new capped function. |
| wrap(value, wrapper) X-Ref |
| Creates a function that provides `value` to `wrapper` as its first argument. Any additional arguments provided to the function are appended to those provided to the `wrapper`. The wrapper is invoked with the `this` binding of the created function. param: {*} value The value to wrap. param: {Function} [wrapper=identity] The wrapper function. returns: {Function} Returns the new function. |
| castArray() X-Ref |
| Casts `value` as an array if it's not one. param: {*} value The value to inspect. returns: {Array} Returns the cast array. |
| clone(value) X-Ref |
| Creates a shallow clone of `value`. **Note:** This method is loosely based on the [structured clone algorithm](https://mdn.io/Structured_clone_algorithm) and supports cloning arrays, array buffers, booleans, date objects, maps, numbers, `Object` objects, regexes, sets, strings, symbols, and typed arrays. The own enumerable properties of `arguments` objects are cloned as plain objects. An empty object is returned for uncloneable values such as error objects, functions, DOM nodes, and WeakMaps. param: {*} value The value to clone. returns: {*} Returns the cloned value. |
| cloneWith(value, customizer) X-Ref |
| This method is like `_.clone` except that it accepts `customizer` which is invoked to produce the cloned value. If `customizer` returns `undefined`, cloning is handled by the method instead. The `customizer` is invoked with up to four arguments; (value [, index|key, object, stack]). param: {*} value The value to clone. param: {Function} [customizer] The function to customize cloning. returns: {*} Returns the cloned value. |
| cloneDeep(value) X-Ref |
| This method is like `_.clone` except that it recursively clones `value`. param: {*} value The value to recursively clone. returns: {*} Returns the deep cloned value. |
| cloneDeepWith(value, customizer) X-Ref |
| This method is like `_.cloneWith` except that it recursively clones `value`. param: {*} value The value to recursively clone. param: {Function} [customizer] The function to customize cloning. returns: {*} Returns the deep cloned value. |
| conformsTo(object, source) X-Ref |
| Checks if `object` conforms to `source` by invoking the predicate properties of `source` with the corresponding property values of `object`. **Note:** This method is equivalent to `_.conforms` when `source` is partially applied. param: {Object} object The object to inspect. param: {Object} source The object of property predicates to conform to. returns: {boolean} Returns `true` if `object` conforms, else `false`. |
| eq(value, other) X-Ref |
| Performs a [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) comparison between two values to determine if they are equivalent. param: {*} value The value to compare. param: {*} other The other value to compare. returns: {boolean} Returns `true` if the values are equivalent, else `false`. |
| isArrayLike(value) X-Ref |
| Checks if `value` is array-like. A value is considered array-like if it's not a function and has a `value.length` that's an integer greater than or equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`. param: {*} value The value to check. returns: {boolean} Returns `true` if `value` is array-like, else `false`. |
| isArrayLikeObject(value) X-Ref |
| This method is like `_.isArrayLike` except that it also checks if `value` is an object. param: {*} value The value to check. returns: {boolean} Returns `true` if `value` is an array-like object, |
| isBoolean(value) X-Ref |
| Checks if `value` is classified as a boolean primitive or object. param: {*} value The value to check. returns: {boolean} Returns `true` if `value` is a boolean, else `false`. |
| isElement(value) X-Ref |
| Checks if `value` is likely a DOM element. param: {*} value The value to check. returns: {boolean} Returns `true` if `value` is a DOM element, else `false`. |
| isEmpty(value) X-Ref |
| Checks if `value` is an empty object, collection, map, or set. Objects are considered empty if they have no own enumerable string keyed properties. Array-like values such as `arguments` objects, arrays, buffers, strings, or jQuery-like collections are considered empty if they have a `length` of `0`. Similarly, maps and sets are considered empty if they have a `size` of `0`. param: {*} value The value to check. returns: {boolean} Returns `true` if `value` is empty, else `false`. |
| isEqual(value, other) X-Ref |
| Performs a deep comparison between two values to determine if they are equivalent. **Note:** This method supports comparing arrays, array buffers, booleans, date objects, error objects, maps, numbers, `Object` objects, regexes, sets, strings, symbols, and typed arrays. `Object` objects are compared by their own, not inherited, enumerable properties. Functions and DOM nodes are compared by strict equality, i.e. `===`. param: {*} value The value to compare. param: {*} other The other value to compare. returns: {boolean} Returns `true` if the values are equivalent, else `false`. |
| isEqualWith(value, other, customizer) X-Ref |
| This method is like `_.isEqual` except that it accepts `customizer` which is invoked to compare values. If `customizer` returns `undefined`, comparisons are handled by the method instead. The `customizer` is invoked with up to six arguments: (objValue, othValue [, index|key, object, other, stack]). param: {*} value The value to compare. param: {*} other The other value to compare. param: {Function} [customizer] The function to customize comparisons. returns: {boolean} Returns `true` if the values are equivalent, else `false`. |
| isError(value) X-Ref |
| Checks if `value` is an `Error`, `EvalError`, `RangeError`, `ReferenceError`, `SyntaxError`, `TypeError`, or `URIError` object. param: {*} value The value to check. returns: {boolean} Returns `true` if `value` is an error object, else `false`. |
| isFinite(value) X-Ref |
| Checks if `value` is a finite primitive number. **Note:** This method is based on [`Number.isFinite`](https://mdn.io/Number/isFinite). param: {*} value The value to check. returns: {boolean} Returns `true` if `value` is a finite number, else `false`. |
| isFunction(value) X-Ref |
| Checks if `value` is classified as a `Function` object. param: {*} value The value to check. returns: {boolean} Returns `true` if `value` is a function, else `false`. |
| isInteger(value) X-Ref |
| Checks if `value` is an integer. **Note:** This method is based on [`Number.isInteger`](https://mdn.io/Number/isInteger). param: {*} value The value to check. returns: {boolean} Returns `true` if `value` is an integer, else `false`. |
| isLength(value) X-Ref |
| Checks if `value` is a valid array-like length. **Note:** This method is loosely based on [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength). param: {*} value The value to check. returns: {boolean} Returns `true` if `value` is a valid length, else `false`. |
| isObject(value) X-Ref |
| Checks if `value` is the [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types) of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`) param: {*} value The value to check. returns: {boolean} Returns `true` if `value` is an object, else `false`. |
| isObjectLike(value) X-Ref |
| Checks if `value` is object-like. A value is object-like if it's not `null` and has a `typeof` result of "object". param: {*} value The value to check. returns: {boolean} Returns `true` if `value` is object-like, else `false`. |
| isMatch(object, source) X-Ref |
| Performs a partial deep comparison between `object` and `source` to determine if `object` contains equivalent property values. **Note:** This method is equivalent to `_.matches` when `source` is partially applied. Partial comparisons will match empty array and empty object `source` values against any array or object value, respectively. See `_.isEqual` for a list of supported value comparisons. param: {Object} object The object to inspect. param: {Object} source The object of property values to match. returns: {boolean} Returns `true` if `object` is a match, else `false`. |
| isMatchWith(object, source, customizer) X-Ref |
| This method is like `_.isMatch` except that it accepts `customizer` which is invoked to compare values. If `customizer` returns `undefined`, comparisons are handled by the method instead. The `customizer` is invoked with five arguments: (objValue, srcValue, index|key, object, source). param: {Object} object The object to inspect. param: {Object} source The object of property values to match. param: {Function} [customizer] The function to customize comparisons. returns: {boolean} Returns `true` if `object` is a match, else `false`. |
| isNaN(value) X-Ref |
| Checks if `value` is `NaN`. **Note:** This method is based on [`Number.isNaN`](https://mdn.io/Number/isNaN) and is not the same as global [`isNaN`](https://mdn.io/isNaN) which returns `true` for `undefined` and other non-number values. param: {*} value The value to check. returns: {boolean} Returns `true` if `value` is `NaN`, else `false`. |
| isNative(value) X-Ref |
| Checks if `value` is a pristine native function. **Note:** This method can't reliably detect native functions in the presence of the core-js package because core-js circumvents this kind of detection. Despite multiple requests, the core-js maintainer has made it clear: any attempt to fix the detection will be obstructed. As a result, we're left with little choice but to throw an error. Unfortunately, this also affects packages, like [babel-polyfill](https://www.npmjs.com/package/babel-polyfill), which rely on core-js. param: {*} value The value to check. returns: {boolean} Returns `true` if `value` is a native function, |
| isNull(value) X-Ref |
| Checks if `value` is `null`. param: {*} value The value to check. returns: {boolean} Returns `true` if `value` is `null`, else `false`. |
| isNil(value) X-Ref |
| Checks if `value` is `null` or `undefined`. param: {*} value The value to check. returns: {boolean} Returns `true` if `value` is nullish, else `false`. |
| isNumber(value) X-Ref |
| Checks if `value` is classified as a `Number` primitive or object. **Note:** To exclude `Infinity`, `-Infinity`, and `NaN`, which are classified as numbers, use the `_.isFinite` method. param: {*} value The value to check. returns: {boolean} Returns `true` if `value` is a number, else `false`. |
| isPlainObject(value) X-Ref |
| Checks if `value` is a plain object, that is, an object created by the `Object` constructor or one with a `[[Prototype]]` of `null`. param: {*} value The value to check. returns: {boolean} Returns `true` if `value` is a plain object, else `false`. |
| isSafeInteger(value) X-Ref |
| Checks if `value` is a safe integer. An integer is safe if it's an IEEE-754 double precision number which isn't the result of a rounded unsafe integer. **Note:** This method is based on [`Number.isSafeInteger`](https://mdn.io/Number/isSafeInteger). param: {*} value The value to check. returns: {boolean} Returns `true` if `value` is a safe integer, else `false`. |
| isString(value) X-Ref |
| Checks if `value` is classified as a `String` primitive or object. param: {*} value The value to check. returns: {boolean} Returns `true` if `value` is a string, else `false`. |
| isSymbol(value) X-Ref |
| Checks if `value` is classified as a `Symbol` primitive or object. param: {*} value The value to check. returns: {boolean} Returns `true` if `value` is a symbol, else `false`. |
| isUndefined(value) X-Ref |
| Checks if `value` is `undefined`. param: {*} value The value to check. returns: {boolean} Returns `true` if `value` is `undefined`, else `false`. |
| isWeakMap(value) X-Ref |
| Checks if `value` is classified as a `WeakMap` object. param: {*} value The value to check. returns: {boolean} Returns `true` if `value` is a weak map, else `false`. |
| isWeakSet(value) X-Ref |
| Checks if `value` is classified as a `WeakSet` object. param: {*} value The value to check. returns: {boolean} Returns `true` if `value` is a weak set, else `false`. |
| toArray(value) X-Ref |
| Converts `value` to an array. param: {*} value The value to convert. returns: {Array} Returns the converted array. |
| toFinite(value) X-Ref |
| Converts `value` to a finite number. param: {*} value The value to convert. returns: {number} Returns the converted number. |
| toInteger(value) X-Ref |
| Converts `value` to an integer. **Note:** This method is loosely based on [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger). param: {*} value The value to convert. returns: {number} Returns the converted integer. |
| toLength(value) X-Ref |
| Converts `value` to an integer suitable for use as the length of an array-like object. **Note:** This method is based on [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength). param: {*} value The value to convert. returns: {number} Returns the converted integer. |
| toNumber(value) X-Ref |
| Converts `value` to a number. param: {*} value The value to process. returns: {number} Returns the number. |
| toPlainObject(value) X-Ref |
| Converts `value` to a plain object flattening inherited enumerable string keyed properties of `value` to own properties of the plain object. param: {*} value The value to convert. returns: {Object} Returns the converted plain object. |
| toSafeInteger(value) X-Ref |
| Converts `value` to a safe integer. A safe integer can be compared and represented correctly. param: {*} value The value to convert. returns: {number} Returns the converted integer. |
| toString(value) X-Ref |
| Converts `value` to a string. An empty string is returned for `null` and `undefined` values. The sign of `-0` is preserved. param: {*} value The value to convert. returns: {string} Returns the converted string. |
| create(prototype, properties) X-Ref |
| Creates an object that inherits from the `prototype` object. If a `properties` object is given, its own enumerable string keyed properties are assigned to the created object. param: {Object} prototype The object to inherit from. param: {Object} [properties] The properties to assign to the object. returns: {Object} Returns the new object. |
| findKey(object, predicate) X-Ref |
| This method is like `_.find` except that it returns the key of the first element `predicate` returns truthy for instead of the element itself. param: {Object} object The object to inspect. param: {Function} [predicate=_.identity] The function invoked per iteration. returns: {string|undefined} Returns the key of the matched element, |
| findLastKey(object, predicate) X-Ref |
| This method is like `_.findKey` except that it iterates over elements of a collection in the opposite order. param: {Object} object The object to inspect. param: {Function} [predicate=_.identity] The function invoked per iteration. returns: {string|undefined} Returns the key of the matched element, |
| forIn(object, iteratee) X-Ref |
| Iterates over own and inherited enumerable string keyed properties of an object and invokes `iteratee` for each property. The iteratee is invoked with three arguments: (value, key, object). Iteratee functions may exit iteration early by explicitly returning `false`. param: {Object} object The object to iterate over. param: {Function} [iteratee=_.identity] The function invoked per iteration. returns: {Object} Returns `object`. |
| forInRight(object, iteratee) X-Ref |
| This method is like `_.forIn` except that it iterates over properties of `object` in the opposite order. param: {Object} object The object to iterate over. param: {Function} [iteratee=_.identity] The function invoked per iteration. returns: {Object} Returns `object`. |
| forOwn(object, iteratee) X-Ref |
| Iterates over own enumerable string keyed properties of an object and invokes `iteratee` for each property. The iteratee is invoked with three arguments: (value, key, object). Iteratee functions may exit iteration early by explicitly returning `false`. param: {Object} object The object to iterate over. param: {Function} [iteratee=_.identity] The function invoked per iteration. returns: {Object} Returns `object`. |
| forOwnRight(object, iteratee) X-Ref |
| This method is like `_.forOwn` except that it iterates over properties of `object` in the opposite order. param: {Object} object The object to iterate over. param: {Function} [iteratee=_.identity] The function invoked per iteration. returns: {Object} Returns `object`. |
| functions(object) X-Ref |
| Creates an array of function property names from own enumerable properties of `object`. param: {Object} object The object to inspect. returns: {Array} Returns the function names. |
| functionsIn(object) X-Ref |
| Creates an array of function property names from own and inherited enumerable properties of `object`. param: {Object} object The object to inspect. returns: {Array} Returns the function names. |
| get(object, path, defaultValue) X-Ref |
| Gets the value at `path` of `object`. If the resolved value is `undefined`, the `defaultValue` is returned in its place. param: {Object} object The object to query. param: {Array|string} path The path of the property to get. param: {*} [defaultValue] The value returned for `undefined` resolved values. returns: {*} Returns the resolved value. |
| has(object, path) X-Ref |
| Checks if `path` is a direct property of `object`. param: {Object} object The object to query. param: {Array|string} path The path to check. returns: {boolean} Returns `true` if `path` exists, else `false`. |
| hasIn(object, path) X-Ref |
| Checks if `path` is a direct or inherited property of `object`. param: {Object} object The object to query. param: {Array|string} path The path to check. returns: {boolean} Returns `true` if `path` exists, else `false`. |
| keys(object) X-Ref |
| Creates an array of the own enumerable property names of `object`. **Note:** Non-object values are coerced to objects. See the [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys) for more details. param: {Object} object The object to query. returns: {Array} Returns the array of property names. |
| keysIn(object) X-Ref |
| Creates an array of the own and inherited enumerable property names of `object`. **Note:** Non-object values are coerced to objects. param: {Object} object The object to query. returns: {Array} Returns the array of property names. |
| mapKeys(object, iteratee) X-Ref |
| The opposite of `_.mapValues`; this method creates an object with the same values as `object` and keys generated by running each own enumerable string keyed property of `object` thru `iteratee`. The iteratee is invoked with three arguments: (value, key, object). param: {Object} object The object to iterate over. param: {Function} [iteratee=_.identity] The function invoked per iteration. returns: {Object} Returns the new mapped object. |
| mapValues(object, iteratee) X-Ref |
| Creates an object with the same keys as `object` and values generated by running each own enumerable string keyed property of `object` thru `iteratee`. The iteratee is invoked with three arguments: (value, key, object). param: {Object} object The object to iterate over. param: {Function} [iteratee=_.identity] The function invoked per iteration. returns: {Object} Returns the new mapped object. |
| omitBy(object, predicate) X-Ref |
| The opposite of `_.pickBy`; this method creates an object composed of the own and inherited enumerable string keyed properties of `object` that `predicate` doesn't return truthy for. The predicate is invoked with two arguments: (value, key). param: {Object} object The source object. param: {Function} [predicate=_.identity] The function invoked per property. returns: {Object} Returns the new object. |
| pickBy(object, predicate) X-Ref |
| Creates an object composed of the `object` properties `predicate` returns truthy for. The predicate is invoked with two arguments: (value, key). param: {Object} object The source object. param: {Function} [predicate=_.identity] The function invoked per property. returns: {Object} Returns the new object. |
| result(object, path, defaultValue) X-Ref |
| 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. param: {Object} object The object to query. param: {Array|string} path The path of the property to resolve. param: {*} [defaultValue] The value returned for `undefined` resolved values. returns: {*} Returns the resolved value. |
| set(object, path, value) X-Ref |
| Sets the value at `path` of `object`. If a portion of `path` doesn't exist, it's created. Arrays are created for missing index properties while objects are created for all other missing properties. Use `_.setWith` to customize `path` creation. **Note:** This method mutates `object`. param: {Object} object The object to modify. param: {Array|string} path The path of the property to set. param: {*} value The value to set. returns: {Object} Returns `object`. |
| setWith(object, path, value, customizer) X-Ref |
| This method is like `_.set` except that it accepts `customizer` which is invoked to produce the objects of `path`. If `customizer` returns `undefined` path creation is handled by the method instead. The `customizer` is invoked with three arguments: (nsValue, key, nsObject). **Note:** This method mutates `object`. param: {Object} object The object to modify. param: {Array|string} path The path of the property to set. param: {*} value The value to set. param: {Function} [customizer] The function to customize assigned values. returns: {Object} Returns `object`. |
| transform(object, iteratee, accumulator) X-Ref |
| 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`, with each invocation potentially mutating the `accumulator` object. If `accumulator` is not provided, a new object with the same `[[Prototype]]` will be used. The iteratee is invoked with four arguments: (accumulator, value, key, object). Iteratee functions may exit iteration early by explicitly returning `false`. param: {Object} object The object to iterate over. param: {Function} [iteratee=_.identity] The function invoked per iteration. param: {*} [accumulator] The custom accumulator value. returns: {*} Returns the accumulated value. |
| unset(object, path) X-Ref |
| Removes the property at `path` of `object`. **Note:** This method mutates `object`. param: {Object} object The object to modify. param: {Array|string} path The path of the property to unset. returns: {boolean} Returns `true` if the property is deleted, else `false`. |
| update(object, path, updater) X-Ref |
| This method is like `_.set` except that accepts `updater` to produce the value to set. Use `_.updateWith` to customize `path` creation. The `updater` is invoked with one argument: (value). **Note:** This method mutates `object`. param: {Object} object The object to modify. param: {Array|string} path The path of the property to set. param: {Function} updater The function to produce the updated value. returns: {Object} Returns `object`. |
| updateWith(object, path, updater, customizer) X-Ref |
| This method is like `_.update` except that it accepts `customizer` which is invoked to produce the objects of `path`. If `customizer` returns `undefined` path creation is handled by the method instead. The `customizer` is invoked with three arguments: (nsValue, key, nsObject). **Note:** This method mutates `object`. param: {Object} object The object to modify. param: {Array|string} path The path of the property to set. param: {Function} updater The function to produce the updated value. param: {Function} [customizer] The function to customize assigned values. returns: {Object} Returns `object`. |
| values(object) X-Ref |
| Creates an array of the own enumerable string keyed property values of `object`. **Note:** Non-object values are coerced to objects. param: {Object} object The object to query. returns: {Array} Returns the array of property values. |
| valuesIn(object) X-Ref |
| Creates an array of the own and inherited enumerable string keyed property values of `object`. **Note:** Non-object values are coerced to objects. param: {Object} object The object to query. returns: {Array} Returns the array of property values. |
| clamp(number, lower, upper) X-Ref |
| Clamps `number` within the inclusive `lower` and `upper` bounds. param: {number} number The number to clamp. param: {number} [lower] The lower bound. param: {number} upper The upper bound. returns: {number} Returns the clamped number. |
| inRange(number, start, end) X-Ref |
| Checks if `n` is between `start` and up to, but not including, `end`. If `end` is not specified, it's set to `start` with `start` then set to `0`. If `start` is greater than `end` the params are swapped to support negative ranges. param: {number} number The number to check. param: {number} [start=0] The start of the range. param: {number} end The end of the range. returns: {boolean} Returns `true` if `number` is in the range, else `false`. |
| random(lower, upper, floating) X-Ref |
| 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. **Note:** JavaScript follows the IEEE-754 standard for resolving floating-point values which can produce unexpected results. param: {number} [lower=0] The lower bound. param: {number} [upper=1] The upper bound. param: {boolean} [floating] Specify returning a floating-point number. returns: {number} Returns the random number. |
| capitalize(string) X-Ref |
| Converts the first character of `string` to upper case and the remaining to lower case. param: {string} [string=''] The string to capitalize. returns: {string} Returns the capitalized string. |
| deburr(string) X-Ref |
| Deburrs `string` by converting [Latin-1 Supplement](https://en.wikipedia.org/wiki/Latin-1_Supplement_(Unicode_block)#Character_table) and [Latin Extended-A](https://en.wikipedia.org/wiki/Latin_Extended-A) letters to basic Latin letters and removing [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks). param: {string} [string=''] The string to deburr. returns: {string} Returns the deburred string. |
| endsWith(string, target, position) X-Ref |
| Checks if `string` ends with the given target string. param: {string} [string=''] The string to inspect. param: {string} [target] The string to search for. param: {number} [position=string.length] The position to search up to. returns: {boolean} Returns `true` if `string` ends with `target`, |
| escape(string) X-Ref |
| Converts the characters "&", "<", ">", '"', and "'" in `string` to their corresponding HTML entities. **Note:** No other characters are escaped. To escape additional characters use a third-party library like [_he_](https://mths.be/he). Though the ">" character is escaped for symmetry, characters like ">" and "/" don't need escaping in HTML and have no special meaning unless they're part of a tag or unquoted attribute value. See [Mathias Bynens's article](https://mathiasbynens.be/notes/ambiguous-ampersands) (under "semi-related fun fact") for more details. When working with HTML you should always [quote attribute values](http://wonko.com/post/html-escaping) to reduce XSS vectors. param: {string} [string=''] The string to escape. returns: {string} Returns the escaped string. |
| escapeRegExp(string) X-Ref |
| Escapes the `RegExp` special characters "^", "$", "\", ".", "*", "+", "?", "(", ")", "[", "]", "{", "}", and "|" in `string`. param: {string} [string=''] The string to escape. returns: {string} Returns the escaped string. |
| pad(string, length, chars) X-Ref |
| 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`. param: {string} [string=''] The string to pad. param: {number} [length=0] The padding length. param: {string} [chars=' '] The string used as padding. returns: {string} Returns the padded string. |
| padEnd(string, length, chars) X-Ref |
| Pads `string` on the right side if it's shorter than `length`. Padding characters are truncated if they exceed `length`. param: {string} [string=''] The string to pad. param: {number} [length=0] The padding length. param: {string} [chars=' '] The string used as padding. returns: {string} Returns the padded string. |
| padStart(string, length, chars) X-Ref |
| Pads `string` on the left side if it's shorter than `length`. Padding characters are truncated if they exceed `length`. param: {string} [string=''] The string to pad. param: {number} [length=0] The padding length. param: {string} [chars=' '] The string used as padding. returns: {string} Returns the padded string. |
| parseInt(string, radix, guard) X-Ref |
| Converts `string` to an integer of the specified radix. If `radix` is `undefined` or `0`, a `radix` of `10` is used unless `value` is a hexadecimal, in which case a `radix` of `16` is used. **Note:** This method aligns with the [ES5 implementation](https://es5.github.io/#x15.1.2.2) of `parseInt`. param: {string} string The string to convert. param: {number} [radix=10] The radix to interpret `value` by. param: - {Object} [guard] Enables use as an iteratee for methods like `_.map`. returns: {number} Returns the converted integer. |
| repeat(string, n, guard) X-Ref |
| Repeats the given string `n` times. param: {string} [string=''] The string to repeat. param: {number} [n=1] The number of times to repeat the string. param: - {Object} [guard] Enables use as an iteratee for methods like `_.map`. returns: {string} Returns the repeated string. |
| replace() X-Ref |
| Replaces matches for `pattern` in `string` with `replacement`. **Note:** This method is based on [`String#replace`](https://mdn.io/String/replace). param: {string} [string=''] The string to modify. param: {RegExp|string} pattern The pattern to replace. param: {Function|string} replacement The match replacement. returns: {string} Returns the modified string. |
| split(string, separator, limit) X-Ref |
| Splits `string` by `separator`. **Note:** This method is based on [`String#split`](https://mdn.io/String/split). param: {string} [string=''] The string to split. param: {RegExp|string} separator The separator pattern to split by. param: {number} [limit] The length to truncate results to. returns: {Array} Returns the string segments. |
| startsWith(string, target, position) X-Ref |
| Checks if `string` starts with the given target string. param: {string} [string=''] The string to inspect. param: {string} [target] The string to search for. param: {number} [position=0] The position to search from. returns: {boolean} Returns `true` if `string` starts with `target`, |
| template(string, options, guard) X-Ref |
| Creates a compiled template function that can interpolate data properties in "interpolate" delimiters, HTML-escape interpolated data properties in "escape" delimiters, and execute JavaScript in "evaluate" delimiters. Data properties may be accessed as free variables in the template. If a setting object is given, it takes precedence over `_.templateSettings` values. **Note:** In the development build `_.template` utilizes [sourceURLs](http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl) for easier debugging. For more information on precompiling templates see [lodash's custom builds documentation](https://lodash.com/custom-builds). For more information on Chrome extension sandboxes see [Chrome's extensions documentation](https://developer.chrome.com/extensions/sandboxingEval). param: {string} [string=''] The template string. param: {Object} [options={}] The options object. param: {RegExp} [options.escape=_.templateSettings.escape] param: {RegExp} [options.evaluate=_.templateSettings.evaluate] param: {Object} [options.imports=_.templateSettings.imports] param: {RegExp} [options.interpolate=_.templateSettings.interpolate] param: {string} [options.sourceURL='lodash.templateSources[n]'] param: {string} [options.variable='obj'] param: - {Object} [guard] Enables use as an iteratee for methods like `_.map`. returns: {Function} Returns the compiled template function. |
| toLower(value) X-Ref |
| Converts `string`, as a whole, to lower case just like [String#toLowerCase](https://mdn.io/toLowerCase). param: {string} [string=''] The string to convert. returns: {string} Returns the lower cased string. |
| toUpper(value) X-Ref |
| Converts `string`, as a whole, to upper case just like [String#toUpperCase](https://mdn.io/toUpperCase). param: {string} [string=''] The string to convert. returns: {string} Returns the upper cased string. |
| trim(string, chars, guard) X-Ref |
| Removes leading and trailing whitespace or specified characters from `string`. param: {string} [string=''] The string to trim. param: {string} [chars=whitespace] The characters to trim. param: - {Object} [guard] Enables use as an iteratee for methods like `_.map`. returns: {string} Returns the trimmed string. |
| trimEnd(string, chars, guard) X-Ref |
| Removes trailing whitespace or specified characters from `string`. param: {string} [string=''] The string to trim. param: {string} [chars=whitespace] The characters to trim. param: - {Object} [guard] Enables use as an iteratee for methods like `_.map`. returns: {string} Returns the trimmed string. |
| trimStart(string, chars, guard) X-Ref |
| Removes leading whitespace or specified characters from `string`. param: {string} [string=''] The string to trim. param: {string} [chars=whitespace] The characters to trim. param: - {Object} [guard] Enables use as an iteratee for methods like `_.map`. returns: {string} Returns the trimmed string. |
| truncate(string, options) X-Ref |
| 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 "...". param: {string} [string=''] The string to truncate. param: {Object} [options={}] The options object. param: {number} [options.length=30] The maximum string length. param: {string} [options.omission='...'] The string to indicate text is omitted. param: {RegExp|string} [options.separator] The separator pattern to truncate to. returns: {string} Returns the truncated string. |
| unescape(string) X-Ref |
| The inverse of `_.escape`; this method converts the HTML entities `&`, `<`, `>`, `"`, and `'` in `string` to their corresponding characters. **Note:** No other HTML entities are unescaped. To unescape additional HTML entities use a third-party library like [_he_](https://mths.be/he). param: {string} [string=''] The string to unescape. returns: {string} Returns the unescaped string. |
| words(string, pattern, guard) X-Ref |
| Splits `string` into an array of its words. param: {string} [string=''] The string to inspect. param: {RegExp|string} [pattern] The pattern to match words. param: - {Object} [guard] Enables use as an iteratee for methods like `_.map`. returns: {Array} Returns the words of `string`. |
| cond(pairs) X-Ref |
| Creates a function that iterates over `pairs` and invokes the corresponding function of the first predicate to return truthy. The predicate-function pairs are invoked with the `this` binding and arguments of the created function. param: {Array} pairs The predicate-function pairs. returns: {Function} Returns the new composite function. |
| conforms(source) X-Ref |
| Creates a function that invokes the predicate properties of `source` with the corresponding property values of a given object, returning `true` if all predicates return truthy, else `false`. **Note:** The created function is equivalent to `_.conformsTo` with `source` partially applied. param: {Object} source The object of property predicates to conform to. returns: {Function} Returns the new spec function. |
| constant(value) X-Ref |
| Creates a function that returns `value`. param: {*} value The value to return from the new function. returns: {Function} Returns the new constant function. |
| defaultTo(value, defaultValue) X-Ref |
| Checks `value` to determine whether a default value should be returned in its place. The `defaultValue` is returned if `value` is `NaN`, `null`, or `undefined`. param: {*} value The value to check. param: {*} defaultValue The default value. returns: {*} Returns the resolved value. |
| identity(value) X-Ref |
| This method returns the first argument it receives. param: {*} value Any value. returns: {*} Returns `value`. |
| iteratee(func) X-Ref |
| Creates a function that invokes `func` with the arguments of the created function. If `func` is a property name, the created function returns the property value for a given element. If `func` is an array or object, the created function returns `true` for elements that contain the equivalent source properties, otherwise it returns `false`. param: {*} [func=_.identity] The value to convert to a callback. returns: {Function} Returns the callback. |
| matches(source) X-Ref |
| Creates a function that performs a partial deep comparison between a given object and `source`, returning `true` if the given object has equivalent property values, else `false`. **Note:** The created function is equivalent to `_.isMatch` with `source` partially applied. Partial comparisons will match empty array and empty object `source` values against any array or object value, respectively. See `_.isEqual` for a list of supported value comparisons. **Note:** Multiple values can be checked by combining several matchers using `_.overSome` param: {Object} source The object of property values to match. returns: {Function} Returns the new spec function. |
| matchesProperty(path, srcValue) X-Ref |
| Creates a function that performs a partial deep comparison between the value at `path` of a given object to `srcValue`, returning `true` if the object value is equivalent, else `false`. **Note:** Partial comparisons will match empty array and empty object `srcValue` values against any array or object value, respectively. See `_.isEqual` for a list of supported value comparisons. **Note:** Multiple values can be checked by combining several matchers using `_.overSome` param: {Array|string} path The path of the property to get. param: {*} srcValue The value to match. returns: {Function} Returns the new spec function. |
| mixin(object, source, options) X-Ref |
| Adds all own enumerable string keyed function properties of a source object to the destination object. If `object` is a function, then methods are added to its prototype as well. **Note:** Use `_.runInContext` to create a pristine `lodash` function to avoid conflicts caused by modifying the original. param: {Function|Object} [object=lodash] The destination object. param: {Object} source The object of functions to add. param: {Object} [options={}] The options object. param: {boolean} [options.chain=true] Specify whether mixins are chainable. returns: {Function|Object} Returns `object`. |
| noConflict() X-Ref |
| Reverts the `_` variable to its previous value and returns a reference to the `lodash` function. returns: {Function} Returns the `lodash` function. |
| noop() X-Ref |
| This method returns `undefined`. |
| nthArg(n) X-Ref |
| Creates a function that gets the argument at index `n`. If `n` is negative, the nth argument from the end is returned. param: {number} [n=0] The index of the argument to return. returns: {Function} Returns the new pass-thru function. |
| property(path) X-Ref |
| Creates a function that returns the value at `path` of a given object. param: {Array|string} path The path of the property to get. returns: {Function} Returns the new accessor function. |
| propertyOf(object) X-Ref |
| The opposite of `_.property`; this method creates a function that returns the value at a given path of `object`. param: {Object} object The object to query. returns: {Function} Returns the new accessor function. |
| stubArray() X-Ref |
| This method returns a new empty array. returns: {Array} Returns the new empty array. |
| stubFalse() X-Ref |
| This method returns `false`. returns: {boolean} Returns `false`. |
| stubObject() X-Ref |
| This method returns a new empty object. returns: {Object} Returns the new empty object. |
| stubString() X-Ref |
| This method returns an empty string. returns: {string} Returns the empty string. |
| stubTrue() X-Ref |
| This method returns `true`. returns: {boolean} Returns `true`. |
| times(n, iteratee) X-Ref |
| Invokes the iteratee `n` times, returning an array of the results of each invocation. The iteratee is invoked with one argument; (index). param: {number} n The number of times to invoke `iteratee`. param: {Function} [iteratee=_.identity] The function invoked per iteration. returns: {Array} Returns the array of results. |
| toPath(value) X-Ref |
| Converts `value` to a property path array. param: {*} value The value to convert. returns: {Array} Returns the new property path array. |
| uniqueId(prefix) X-Ref |
| Generates a unique ID. If `prefix` is given, the ID is appended to it. param: {string} [prefix=''] The value to prefix the ID with. returns: {string} Returns the unique ID. |
| max(array) X-Ref |
| Computes the maximum value of `array`. If `array` is empty or falsey, `undefined` is returned. param: {Array} array The array to iterate over. returns: {*} Returns the maximum value. |
| maxBy(array, iteratee) X-Ref |
| 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. The iteratee is invoked with one argument: (value). param: {Array} array The array to iterate over. param: {Function} [iteratee=_.identity] The iteratee invoked per element. returns: {*} Returns the maximum value. |
| mean(array) X-Ref |
| Computes the mean of the values in `array`. param: {Array} array The array to iterate over. returns: {number} Returns the mean. |
| meanBy(array, iteratee) X-Ref |
| 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. The iteratee is invoked with one argument: (value). param: {Array} array The array to iterate over. param: {Function} [iteratee=_.identity] The iteratee invoked per element. returns: {number} Returns the mean. |
| min(array) X-Ref |
| Computes the minimum value of `array`. If `array` is empty or falsey, `undefined` is returned. param: {Array} array The array to iterate over. returns: {*} Returns the minimum value. |
| minBy(array, iteratee) X-Ref |
| 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. The iteratee is invoked with one argument: (value). param: {Array} array The array to iterate over. param: {Function} [iteratee=_.identity] The iteratee invoked per element. returns: {*} Returns the minimum value. |
| sum(array) X-Ref |
| Computes the sum of the values in `array`. param: {Array} array The array to iterate over. returns: {number} Returns the sum. |
| sumBy(array, iteratee) X-Ref |
| 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. The iteratee is invoked with one argument: (value). param: {Array} array The array to iterate over. param: {Function} [iteratee=_.identity] The iteratee invoked per element. returns: {number} Returns the sum. |
| Generated : Thu Nov 21 08:20:01 2024 | Cross-referenced by PHPXref |