| [ 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`. returns: {*} Returns the result of `func`. param: {Function} func The function to invoke. param: {*} thisArg The `this` binding of `func`. param: {Array} args The arguments to invoke `func` with. |
| arrayAggregator(array, setter, iteratee, accumulator) X-Ref |
| A specialized version of `baseAggregator` for arrays. returns: {Function} Returns `accumulator`. 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. |
| arrayEach(array, iteratee) X-Ref |
| A specialized version of `_.forEach` for arrays without support for iteratee shorthands. returns: {Array} Returns `array`. param: {Array} [array] The array to iterate over. param: {Function} iteratee The function invoked per iteration. |
| arrayEachRight(array, iteratee) X-Ref |
| A specialized version of `_.forEachRight` for arrays without support for iteratee shorthands. returns: {Array} Returns `array`. param: {Array} [array] The array to iterate over. param: {Function} iteratee The function invoked per iteration. |
| arrayEvery(array, predicate) X-Ref |
| A specialized version of `_.every` for arrays without support for iteratee shorthands. returns: {boolean} Returns `true` if all elements pass the predicate check, param: {Array} [array] The array to iterate over. param: {Function} predicate The function invoked per iteration. |
| arrayFilter(array, predicate) X-Ref |
| A specialized version of `_.filter` for arrays without support for iteratee shorthands. returns: {Array} Returns the new filtered array. param: {Array} [array] The array to iterate over. param: {Function} predicate The function invoked per iteration. |
| arrayIncludes(array, value) X-Ref |
| A specialized version of `_.includes` for arrays without support for specifying an index to search from. returns: {boolean} Returns `true` if `target` is found, else `false`. param: {Array} [array] The array to inspect. param: {*} target The value to search for. |
| arrayIncludesWith(array, value, comparator) X-Ref |
| This function is like `arrayIncludes` except that it accepts a comparator. returns: {boolean} Returns `true` if `target` is found, else `false`. param: {Array} [array] The array to inspect. param: {*} target The value to search for. param: {Function} comparator The comparator invoked per element. |
| arrayMap(array, iteratee) X-Ref |
| A specialized version of `_.map` for arrays without support for iteratee shorthands. returns: {Array} Returns the new mapped array. param: {Array} [array] The array to iterate over. param: {Function} iteratee The function invoked per iteration. |
| arrayPush(array, values) X-Ref |
| Appends the elements of `values` to `array`. returns: {Array} Returns `array`. param: {Array} array The array to modify. param: {Array} values The values to append. |
| arrayReduce(array, iteratee, accumulator, initAccum) X-Ref |
| A specialized version of `_.reduce` for arrays without support for iteratee shorthands. returns: {*} Returns the accumulated value. 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 |
| arrayReduceRight(array, iteratee, accumulator, initAccum) X-Ref |
| A specialized version of `_.reduceRight` for arrays without support for iteratee shorthands. returns: {*} Returns the accumulated value. 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 |
| arraySome(array, predicate) X-Ref |
| A specialized version of `_.some` for arrays without support for iteratee shorthands. returns: {boolean} Returns `true` if any element passes the predicate check, param: {Array} [array] The array to iterate over. param: {Function} predicate The function invoked per iteration. |
| asciiToArray(string) X-Ref |
| Converts an ASCII `string` to an array. returns: {Array} Returns the converted array. param: {string} string The string to convert. |
| asciiWords(string) X-Ref |
| Splits an ASCII `string` into an array of its words. returns: {Array} Returns the words of `string`. param: {string} The string to inspect. |
| 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`. returns: {*} Returns the found element or its key, else `undefined`. 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`. |
| baseFindIndex(array, predicate, fromIndex, fromRight) X-Ref |
| The base implementation of `_.findIndex` and `_.findLastIndex` without support for iteratee shorthands. returns: {number} Returns the index of the matched value, else `-1`. 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. |
| baseIndexOf(array, value, fromIndex) X-Ref |
| The base implementation of `_.indexOf` without `fromIndex` bounds checks. returns: {number} Returns the index of the matched value, else `-1`. param: {Array} array The array to inspect. param: {*} value The value to search for. param: {number} fromIndex The index to search from. |
| baseIndexOfWith(array, value, fromIndex, comparator) X-Ref |
| This function is like `baseIndexOf` except that it accepts a comparator. returns: {number} Returns the index of the matched value, else `-1`. 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. |
| baseIsNaN(value) X-Ref |
| The base implementation of `_.isNaN` without support for number objects. returns: {boolean} Returns `true` if `value` is `NaN`, else `false`. param: {*} value The value to check. |
| baseMean(array, iteratee) X-Ref |
| The base implementation of `_.mean` and `_.meanBy` without support for iteratee shorthands. returns: {number} Returns the mean. param: {Array} array The array to iterate over. param: {Function} iteratee The function invoked per iteration. |
| baseProperty(key) X-Ref |
| The base implementation of `_.property` without support for deep paths. returns: {Function} Returns the new accessor function. param: {string} key The key of the property to get. |
| basePropertyOf(object) X-Ref |
| The base implementation of `_.propertyOf` without support for deep paths. returns: {Function} Returns the new accessor function. param: {Object} object The object to query. |
| 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`. returns: {*} Returns the accumulated value. 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`. |
| 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. returns: {Array} Returns `array`. param: {Array} array The array to sort. param: {Function} comparer The function to define sort order. |
| baseSum(array, iteratee) X-Ref |
| The base implementation of `_.sum` and `_.sumBy` without support for iteratee shorthands. returns: {number} Returns the sum. param: {Array} array The array to iterate over. param: {Function} iteratee The function invoked per iteration. |
| baseTimes(n, iteratee) X-Ref |
| The base implementation of `_.times` without support for iteratee shorthands or max array length checks. returns: {Array} Returns the array of results. param: {number} n The number of times to invoke `iteratee`. param: {Function} iteratee The function invoked per iteration. |
| 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`. returns: {Object} Returns the key-value pairs. param: {Object} object The object to query. param: {Array} props The property names to get values for. |
| baseTrim(string) X-Ref |
| The base implementation of `_.trim`. returns: {string} Returns the trimmed string. param: {string} string The string to trim. |
| baseUnary(func) X-Ref |
| The base implementation of `_.unary` without support for storing metadata. returns: {Function} Returns the new capped function. param: {Function} func The function to cap arguments for. |
| 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`. returns: {Object} Returns the array of property values. param: {Object} object The object to query. param: {Array} props The property names to get values for. |
| cacheHas(cache, key) X-Ref |
| Checks if a `cache` value for `key` exists. returns: {boolean} Returns `true` if an entry for `key` exists, else `false`. param: {Object} cache The cache to query. param: {string} key The key of the entry to check. |
| 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. returns: {number} Returns the index of the first unmatched string symbol. param: {Array} strSymbols The string symbols to inspect. param: {Array} chrSymbols The character symbols to find. |
| 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. returns: {number} Returns the index of the last unmatched string symbol. param: {Array} strSymbols The string symbols to inspect. param: {Array} chrSymbols The character symbols to find. |
| countHolders(array, placeholder) X-Ref |
| Gets the number of `placeholder` occurrences in `array`. returns: {number} Returns the placeholder count. param: {Array} array The array to inspect. param: {*} placeholder The placeholder to search for. |
| escapeStringChar(chr) X-Ref |
| Used by `_.template` to escape characters for inclusion in compiled string literals. returns: {string} Returns the escaped character. param: {string} chr The matched character to escape. |
| getValue(object, key) X-Ref |
| Gets the value at `key` of `object`. returns: {*} Returns the property value. param: {Object} [object] The object to query. param: {string} key The key of the property to get. |
| hasUnicode(string) X-Ref |
| Checks if `string` contains Unicode symbols. returns: {boolean} Returns `true` if a symbol is found, else `false`. param: {string} string The string to inspect. |
| hasUnicodeWord(string) X-Ref |
| Checks if `string` contains a word composed of Unicode symbols. returns: {boolean} Returns `true` if a word is found, else `false`. param: {string} string The string to inspect. |
| iteratorToArray(iterator) X-Ref |
| Converts `iterator` to an array. returns: {Array} Returns the converted array. param: {Object} iterator The iterator to convert. |
| mapToArray(map) X-Ref |
| Converts `map` to its key-value pairs. returns: {Array} Returns the key-value pairs. param: {Object} map The map to convert. |
| overArg(func, transform) X-Ref |
| Creates a unary function that invokes `func` with its argument transformed. returns: {Function} Returns the new function. param: {Function} func The function to wrap. param: {Function} transform The argument transform. |
| replaceHolders(array, placeholder) X-Ref |
| Replaces all `placeholder` elements in `array` with an internal placeholder and returns an array of their indexes. returns: {Array} Returns the new array of placeholder indexes. param: {Array} array The array to modify. param: {*} placeholder The placeholder to replace. |
| setToArray(set) X-Ref |
| Converts `set` to an array of its values. returns: {Array} Returns the values. param: {Object} set The set to convert. |
| setToPairs(set) X-Ref |
| Converts `set` to its value-value pairs. returns: {Array} Returns the value-value pairs. param: {Object} set The set to convert. |
| strictIndexOf(array, value, fromIndex) X-Ref |
| A specialized version of `_.indexOf` which performs strict equality comparisons of values, i.e. `===`. returns: {number} Returns the index of the matched value, else `-1`. param: {Array} array The array to inspect. param: {*} value The value to search for. param: {number} fromIndex The index to search from. |
| strictLastIndexOf(array, value, fromIndex) X-Ref |
| A specialized version of `_.lastIndexOf` which performs strict equality comparisons of values, i.e. `===`. returns: {number} Returns the index of the matched value, else `-1`. param: {Array} array The array to inspect. param: {*} value The value to search for. param: {number} fromIndex The index to search from. |
| stringSize(string) X-Ref |
| Gets the number of symbols in `string`. returns: {number} Returns the string size. param: {string} string The string to inspect. |
| stringToArray(string) X-Ref |
| Converts `string` to an array. returns: {Array} Returns the converted array. param: {string} string The string to convert. |
| trimmedEndIndex(string) X-Ref |
| Used by `_.trim` and `_.trimEnd` to get the index of the last non-whitespace character of `string`. returns: {number} Returns the index of the last non-whitespace character. param: {string} string The string to inspect. |
| unicodeSize(string) X-Ref |
| Gets the size of a Unicode `string`. returns: {number} Returns the string size. param: {string} string The string inspect. |
| unicodeToArray(string) X-Ref |
| Converts a Unicode `string` to an array. returns: {Array} Returns the converted array. param: {string} string The string to convert. |
| unicodeWords(string) X-Ref |
| Splits a Unicode `string` into an array of its words. returns: {Array} Returns the words of `string`. param: {string} The string to inspect. |
| lodash(value) X-Ref |
| No description |
| object() X-Ref |
| The base implementation of `_.create` without support for assigning properties to the created object. returns: {Object} Returns the new object. param: {Object} proto The object to inherit from. |
| 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. returns: {boolean} Returns `true` if the entry was removed, else `false`. param: {Object} hash The hash to modify. param: {string} key The key of the value to remove. |
| hashGet(key) X-Ref |
| Gets the hash value for `key`. returns: {*} Returns the entry value. param: {string} key The key of the value to get. |
| hashHas(key) X-Ref |
| Checks if a hash value for `key` exists. returns: {boolean} Returns `true` if an entry for `key` exists, else `false`. param: {string} key The key of the entry to check. |
| hashSet(key, value) X-Ref |
| Sets the hash `key` to `value`. returns: {Object} Returns the hash instance. param: {string} key The key of the value to set. param: {*} value The value to set. |
| 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. returns: {boolean} Returns `true` if the entry was removed, else `false`. param: {string} key The key of the value to remove. |
| listCacheGet(key) X-Ref |
| Gets the list cache value for `key`. returns: {*} Returns the entry value. param: {string} key The key of the value to get. |
| listCacheHas(key) X-Ref |
| Checks if a list cache value for `key` exists. returns: {boolean} Returns `true` if an entry for `key` exists, else `false`. param: {string} key The key of the entry to check. |
| listCacheSet(key, value) X-Ref |
| Sets the list cache `key` to `value`. returns: {Object} Returns the list cache instance. param: {string} key The key of the value to set. param: {*} value The value to set. |
| 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. returns: {boolean} Returns `true` if the entry was removed, else `false`. param: {string} key The key of the value to remove. |
| mapCacheGet(key) X-Ref |
| Gets the map value for `key`. returns: {*} Returns the entry value. param: {string} key The key of the value to get. |
| mapCacheHas(key) X-Ref |
| Checks if a map value for `key` exists. returns: {boolean} Returns `true` if an entry for `key` exists, else `false`. param: {string} key The key of the entry to check. |
| mapCacheSet(key, value) X-Ref |
| Sets the map `key` to `value`. returns: {Object} Returns the map cache instance. param: {string} key The key of the value to set. param: {*} value The value to set. |
| 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. returns: {Object} Returns the cache instance. param: {*} value The value to cache. |
| setCacheHas(value) X-Ref |
| Checks if `value` is in the array cache. returns: {number} Returns `true` if `value` is found, else `false`. param: {*} value The value to search for. |
| 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. returns: {boolean} Returns `true` if the entry was removed, else `false`. param: {string} key The key of the value to remove. |
| stackGet(key) X-Ref |
| Gets the stack value for `key`. returns: {*} Returns the entry value. param: {string} key The key of the value to get. |
| stackHas(key) X-Ref |
| Checks if a stack value for `key` exists. returns: {boolean} Returns `true` if an entry for `key` exists, else `false`. param: {string} key The key of the entry to check. |
| stackSet(key, value) X-Ref |
| Sets the stack `key` to `value`. returns: {Object} Returns the stack cache instance. param: {string} key The key of the value to set. param: {*} value The value to set. |
| arrayLikeKeys(value, inherited) X-Ref |
| Creates an array of the enumerable property names of the array-like `value`. returns: {Array} Returns the array of property names. param: {*} value The value to query. param: {boolean} inherited Specify returning inherited property names. |
| arraySample(array) X-Ref |
| A specialized version of `_.sample` for arrays. returns: {*} Returns the random element. param: {Array} array The array to sample. |
| arraySampleSize(array, n) X-Ref |
| A specialized version of `_.sampleSize` for arrays. returns: {Array} Returns the random elements. param: {Array} array The array to sample. param: {number} n The number of elements to sample. |
| arrayShuffle(array) X-Ref |
| A specialized version of `_.shuffle` for arrays. returns: {Array} Returns the new shuffled array. param: {Array} array The array to shuffle. |
| 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. returns: {number} Returns the index of the matched value, else `-1`. param: {Array} array The array to inspect. param: {*} key The key to search for. |
| baseAggregator(collection, setter, iteratee, accumulator) X-Ref |
| Aggregates elements of `collection` on `accumulator` with keys transformed by `iteratee` and values set by `setter`. returns: {Function} Returns `accumulator`. 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. |
| baseAssign(object, source) X-Ref |
| The base implementation of `_.assign` without support for multiple sources or `customizer` functions. returns: {Object} Returns `object`. param: {Object} object The destination object. param: {Object} source The source object. |
| baseAssignIn(object, source) X-Ref |
| The base implementation of `_.assignIn` without support for multiple sources or `customizer` functions. returns: {Object} Returns `object`. param: {Object} object The destination object. param: {Object} source The source 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. returns: {Array} Returns the picked elements. param: {Object} object The object to iterate over. param: {string[]} paths The property paths to pick. |
| baseClamp(number, lower, upper) X-Ref |
| The base implementation of `_.clamp` which doesn't coerce arguments. returns: {number} Returns the clamped number. param: {number} number The number to clamp. param: {number} [lower] The lower bound. param: {number} upper The upper bound. |
| baseClone(value, bitmask, customizer, key, object, stack) X-Ref |
| The base implementation of `_.clone` and `_.cloneDeep` which tracks traversed objects. returns: {*} Returns the cloned value. 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. |
| baseConforms(source) X-Ref |
| The base implementation of `_.conforms` which doesn't clone `source`. returns: {Function} Returns the new spec function. param: {Object} source The object of property predicates to conform to. |
| baseConformsTo(object, source, props) X-Ref |
| The base implementation of `_.conformsTo` which accepts `props` to check. returns: {boolean} Returns `true` if `object` conforms, else `false`. param: {Object} object The object to inspect. param: {Object} source The object of property predicates to conform to. |
| baseDelay(func, wait, args) X-Ref |
| The base implementation of `_.delay` and `_.defer` which accepts `args` to provide to `func`. returns: {number|Object} Returns the timer id or timeout object. 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`. |
| baseDifference(array, values, iteratee, comparator) X-Ref |
| The base implementation of methods like `_.difference` without support for excluding multiple arrays or iteratee shorthands. returns: {Array} Returns the new array of filtered values. 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. |
| baseEvery(collection, predicate) X-Ref |
| The base implementation of `_.every` without support for iteratee shorthands. returns: {boolean} Returns `true` if all elements pass the predicate check, param: {Array|Object} collection The collection to iterate over. param: {Function} predicate The function invoked per iteration. |
| baseExtremum(array, iteratee, comparator) X-Ref |
| The base implementation of methods like `_.max` and `_.min` which accepts a `comparator` to determine the extremum value. returns: {*} Returns 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. |
| baseFill(array, value, start, end) X-Ref |
| The base implementation of `_.fill` without an iteratee call guard. returns: {Array} Returns `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. |
| baseFilter(collection, predicate) X-Ref |
| The base implementation of `_.filter` without support for iteratee shorthands. returns: {Array} Returns the new filtered array. param: {Array|Object} collection The collection to iterate over. param: {Function} predicate The function invoked per iteration. |
| baseFlatten(array, depth, predicate, isStrict, result) X-Ref |
| The base implementation of `_.flatten` with support for restricting flattening. returns: {Array} Returns the new flattened array. 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. |
| baseForOwn(object, iteratee) X-Ref |
| The base implementation of `_.forOwn` without support for iteratee shorthands. returns: {Object} Returns `object`. param: {Object} object The object to iterate over. param: {Function} iteratee The function invoked per iteration. |
| baseForOwnRight(object, iteratee) X-Ref |
| The base implementation of `_.forOwnRight` without support for iteratee shorthands. returns: {Object} Returns `object`. param: {Object} object The object to iterate over. param: {Function} iteratee The function invoked per iteration. |
| baseFunctions(object, props) X-Ref |
| The base implementation of `_.functions` which creates an array of `object` function property names filtered from `props`. returns: {Array} Returns the function names. param: {Object} object The object to inspect. param: {Array} props The property names to filter. |
| baseGet(object, path) X-Ref |
| The base implementation of `_.get` without support for default values. returns: {*} Returns the resolved value. param: {Object} object The object to query. param: {Array|string} path The path of the property to get. |
| 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`. returns: {Array} Returns the array of property names and symbols. 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`. |
| baseGetTag(value) X-Ref |
| The base implementation of `getTag` without fallbacks for buggy environments. returns: {string} Returns the `toStringTag`. param: {*} value The value to query. |
| baseGt(value, other) X-Ref |
| The base implementation of `_.gt` which doesn't coerce arguments. returns: {boolean} Returns `true` if `value` is greater than `other`, param: {*} value The value to compare. param: {*} other The other value to compare. |
| baseHas(object, key) X-Ref |
| The base implementation of `_.has` without support for deep paths. returns: {boolean} Returns `true` if `key` exists, else `false`. param: {Object} [object] The object to query. param: {Array|string} key The key to check. |
| baseHasIn(object, key) X-Ref |
| The base implementation of `_.hasIn` without support for deep paths. returns: {boolean} Returns `true` if `key` exists, else `false`. param: {Object} [object] The object to query. param: {Array|string} key The key to check. |
| baseInRange(number, start, end) X-Ref |
| The base implementation of `_.inRange` which doesn't coerce arguments. returns: {boolean} Returns `true` if `number` is in the range, else `false`. param: {number} number The number to check. param: {number} start The start of the range. param: {number} end The end of the range. |
| 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. returns: {Array} Returns the new array of shared values. param: {Array} arrays The arrays to inspect. param: {Function} [iteratee] The iteratee invoked per element. param: {Function} [comparator] The comparator invoked per element. |
| 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`. returns: {Function} Returns `accumulator`. 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. |
| baseInvoke(object, path, args) X-Ref |
| The base implementation of `_.invoke` without support for individual method arguments. returns: {*} Returns the result of the invoked method. 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. |
| baseIsArguments(value) X-Ref |
| The base implementation of `_.isArguments`. returns: {boolean} Returns `true` if `value` is an `arguments` object, param: {*} value The value to check. |
| baseIsArrayBuffer(value) X-Ref |
| The base implementation of `_.isArrayBuffer` without Node.js optimizations. returns: {boolean} Returns `true` if `value` is an array buffer, else `false`. param: {*} value The value to check. |
| baseIsDate(value) X-Ref |
| The base implementation of `_.isDate` without Node.js optimizations. returns: {boolean} Returns `true` if `value` is a date object, else `false`. param: {*} value The value to check. |
| baseIsEqual(value, other, bitmask, customizer, stack) X-Ref |
| The base implementation of `_.isEqual` which supports partial comparisons and tracks traversed objects. returns: {boolean} Returns `true` if the values are equivalent, else `false`. 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. |
| 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. returns: {boolean} Returns `true` if the objects are equivalent, else `false`. 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. |
| baseIsMap(value) X-Ref |
| The base implementation of `_.isMap` without Node.js optimizations. returns: {boolean} Returns `true` if `value` is a map, else `false`. param: {*} value The value to check. |
| baseIsMatch(object, source, matchData, customizer) X-Ref |
| The base implementation of `_.isMatch` without support for iteratee shorthands. returns: {boolean} Returns `true` if `object` is a match, else `false`. 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. |
| baseIsNative(value) X-Ref |
| The base implementation of `_.isNative` without bad shim checks. returns: {boolean} Returns `true` if `value` is a native function, param: {*} value The value to check. |
| baseIsRegExp(value) X-Ref |
| The base implementation of `_.isRegExp` without Node.js optimizations. returns: {boolean} Returns `true` if `value` is a regexp, else `false`. param: {*} value The value to check. |
| baseIsSet(value) X-Ref |
| The base implementation of `_.isSet` without Node.js optimizations. returns: {boolean} Returns `true` if `value` is a set, else `false`. param: {*} value The value to check. |
| baseIsTypedArray(value) X-Ref |
| The base implementation of `_.isTypedArray` without Node.js optimizations. returns: {boolean} Returns `true` if `value` is a typed array, else `false`. param: {*} value The value to check. |
| baseIteratee(value) X-Ref |
| The base implementation of `_.iteratee`. returns: {Function} Returns the iteratee. param: {*} [value=_.identity] The value to convert to an iteratee. |
| baseKeys(object) X-Ref |
| The base implementation of `_.keys` which doesn't treat sparse arrays as dense. returns: {Array} Returns the array of property names. param: {Object} object The object to query. |
| baseKeysIn(object) X-Ref |
| The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense. returns: {Array} Returns the array of property names. param: {Object} object The object to query. |
| baseLt(value, other) X-Ref |
| The base implementation of `_.lt` which doesn't coerce arguments. returns: {boolean} Returns `true` if `value` is less than `other`, param: {*} value The value to compare. param: {*} other The other value to compare. |
| baseMap(collection, iteratee) X-Ref |
| The base implementation of `_.map` without support for iteratee shorthands. returns: {Array} Returns the new mapped array. param: {Array|Object} collection The collection to iterate over. param: {Function} iteratee The function invoked per iteration. |
| baseMatches(source) X-Ref |
| The base implementation of `_.matches` which doesn't clone `source`. returns: {Function} Returns the new spec function. param: {Object} source The object of property values to match. |
| baseMatchesProperty(path, srcValue) X-Ref |
| The base implementation of `_.matchesProperty` which doesn't clone `srcValue`. returns: {Function} Returns the new spec function. param: {string} path The path of the property to get. param: {*} srcValue The value to match. |
| 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. returns: {*} Returns the nth element of `array`. param: {Array} array The array to query. param: {number} n The index of the element to return. |
| baseOrderBy(collection, iteratees, orders) X-Ref |
| The base implementation of `_.orderBy` without param guards. returns: {Array} Returns the new sorted array. 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`. |
| basePick(object, paths) X-Ref |
| The base implementation of `_.pick` without support for individual property identifiers. returns: {Object} Returns the new object. param: {Object} object The source object. param: {string[]} paths The property paths to pick. |
| basePickBy(object, paths, predicate) X-Ref |
| The base implementation of `_.pickBy` without support for iteratee shorthands. returns: {Object} Returns the new object. param: {Object} object The source object. param: {string[]} paths The property paths to pick. param: {Function} predicate The function invoked per property. |
| basePropertyDeep(path) X-Ref |
| A specialized version of `baseProperty` which supports deep paths. returns: {Function} Returns the new accessor function. param: {Array|string} path The path of the property to get. |
| basePullAll(array, values, iteratee, comparator) X-Ref |
| The base implementation of `_.pullAllBy` without support for iteratee shorthands. returns: {Array} Returns `array`. 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. |
| basePullAt(array, indexes) X-Ref |
| The base implementation of `_.pullAt` without support for individual indexes or capturing the removed elements. returns: {Array} Returns `array`. param: {Array} array The array to modify. param: {number[]} indexes The indexes of elements to remove. |
| baseRandom(lower, upper) X-Ref |
| The base implementation of `_.random` without support for returning floating-point numbers. returns: {number} Returns the random number. param: {number} lower The lower bound. param: {number} upper The upper bound. |
| baseRange(start, end, step, fromRight) X-Ref |
| The base implementation of `_.range` and `_.rangeRight` which doesn't coerce arguments. returns: {Array} Returns the range of numbers. 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. |
| baseRepeat(string, n) X-Ref |
| The base implementation of `_.repeat` which doesn't coerce arguments. returns: {string} Returns the repeated string. param: {string} string The string to repeat. param: {number} n The number of times to repeat the string. |
| baseRest(func, start) X-Ref |
| The base implementation of `_.rest` which doesn't validate or coerce arguments. returns: {Function} Returns the new function. param: {Function} func The function to apply a rest parameter to. param: {number} [start=func.length-1] The start position of the rest parameter. |
| baseSample(collection) X-Ref |
| The base implementation of `_.sample`. returns: {*} Returns the random element. param: {Array|Object} collection The collection to sample. |
| baseSampleSize(collection, n) X-Ref |
| The base implementation of `_.sampleSize` without param guards. returns: {Array} Returns the random elements. param: {Array|Object} collection The collection to sample. param: {number} n The number of elements to sample. |
| baseSet(object, path, value, customizer) X-Ref |
| The base implementation of `_.set`. returns: {Object} Returns `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 path creation. |
| baseShuffle(collection) X-Ref |
| The base implementation of `_.shuffle`. returns: {Array} Returns the new shuffled array. param: {Array|Object} collection The collection to shuffle. |
| baseSlice(array, start, end) X-Ref |
| The base implementation of `_.slice` without an iteratee call guard. returns: {Array} Returns the slice of `array`. param: {Array} array The array to slice. param: {number} [start=0] The start position. param: {number} [end=array.length] The end position. |
| baseSome(collection, predicate) X-Ref |
| The base implementation of `_.some` without support for iteratee shorthands. returns: {boolean} Returns `true` if any element passes the predicate check, param: {Array|Object} collection The collection to iterate over. param: {Function} predicate The function invoked per iteration. |
| 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. returns: {number} Returns the index at which `value` should be inserted param: {Array} array The sorted array to inspect. param: {*} value The value to evaluate. param: {boolean} [retHighest] Specify returning the highest qualified index. |
| 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). returns: {number} Returns the index at which `value` should be inserted 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. |
| baseSortedUniq(array, iteratee) X-Ref |
| The base implementation of `_.sortedUniq` and `_.sortedUniqBy` without support for iteratee shorthands. returns: {Array} Returns the new duplicate free array. param: {Array} array The array to inspect. param: {Function} [iteratee] The iteratee invoked per element. |
| baseToNumber(value) X-Ref |
| The base implementation of `_.toNumber` which doesn't ensure correct conversions of binary, hexadecimal, or octal string values. returns: {number} Returns the number. param: {*} value The value to process. |
| baseToString(value) X-Ref |
| The base implementation of `_.toString` which doesn't convert nullish values to empty strings. returns: {string} Returns the string. param: {*} value The value to process. |
| baseUniq(array, iteratee, comparator) X-Ref |
| The base implementation of `_.uniqBy` without support for iteratee shorthands. returns: {Array} Returns the new duplicate free array. param: {Array} array The array to inspect. param: {Function} [iteratee] The iteratee invoked per element. param: {Function} [comparator] The comparator invoked per element. |
| baseUnset(object, path) X-Ref |
| The base implementation of `_.unset`. returns: {boolean} Returns `true` if the property is deleted, else `false`. param: {Object} object The object to modify. param: {Array|string} path The property path to unset. |
| baseUpdate(object, path, updater, customizer) X-Ref |
| The base implementation of `_.update`. returns: {Object} Returns `object`. 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. |
| baseWhile(array, predicate, isDrop, fromRight) X-Ref |
| The base implementation of methods like `_.dropWhile` and `_.takeWhile` without support for iteratee shorthands. returns: {Array} Returns the slice of `array`. 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. |
| 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. returns: {*} Returns the resolved value. param: {*} value The unwrapped value. param: {Array} actions Actions to perform to resolve the unwrapped 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. returns: {Array} Returns the new array of values. param: {Array} arrays The arrays to inspect. param: {Function} [iteratee] The iteratee invoked per element. param: {Function} [comparator] The comparator invoked per element. |
| baseZipObject(props, values, assignFunc) X-Ref |
| This base implementation of `_.zipObject` which assigns values using `assignFunc`. returns: {Object} Returns the new object. param: {Array} props The property identifiers. param: {Array} values The property values. param: {Function} assignFunc The function to assign values. |
| castArrayLikeObject(value) X-Ref |
| Casts `value` to an empty array if it's not an array like object. returns: {Array|Object} Returns the cast array-like object. param: {*} value The value to inspect. |
| castFunction(value) X-Ref |
| Casts `value` to `identity` if it's not a function. returns: {Function} Returns cast function. param: {*} value The value to inspect. |
| castPath(value, object) X-Ref |
| Casts `value` to a path array if it's not one. returns: {Array} Returns the cast property path array. param: {*} value The value to inspect. param: {Object} [object] The object to query keys on. |
| castSlice(array, start, end) X-Ref |
| Casts `array` to a slice if it's needed. returns: {Array} Returns the cast slice. param: {Array} array The array to inspect. param: {number} start The start position. param: {number} [end=array.length] The end position. |
| cloneBuffer(buffer, isDeep) X-Ref |
| Creates a clone of `buffer`. returns: {Buffer} Returns the cloned buffer. param: {Buffer} buffer The buffer to clone. param: {boolean} [isDeep] Specify a deep clone. |
| cloneArrayBuffer(arrayBuffer) X-Ref |
| Creates a clone of `arrayBuffer`. returns: {ArrayBuffer} Returns the cloned array buffer. param: {ArrayBuffer} arrayBuffer The array buffer to clone. |
| cloneDataView(dataView, isDeep) X-Ref |
| Creates a clone of `dataView`. returns: {Object} Returns the cloned data view. param: {Object} dataView The data view to clone. param: {boolean} [isDeep] Specify a deep clone. |
| cloneRegExp(regexp) X-Ref |
| Creates a clone of `regexp`. returns: {Object} Returns the cloned regexp. param: {Object} regexp The regexp to clone. |
| cloneSymbol(symbol) X-Ref |
| Creates a clone of the `symbol` object. returns: {Object} Returns the cloned symbol object. param: {Object} symbol The symbol object to clone. |
| cloneTypedArray(typedArray, isDeep) X-Ref |
| Creates a clone of `typedArray`. returns: {Object} Returns the cloned typed array. param: {Object} typedArray The typed array to clone. param: {boolean} [isDeep] Specify a deep clone. |
| compareAscending(value, other) X-Ref |
| Compares values to sort them in ascending order. returns: {number} Returns the sort order indicator for `value`. param: {*} value The value to compare. param: {*} other The other value to compare. |
| 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. returns: {number} Returns the sort order indicator for `object`. 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. |
| 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. returns: {Array} Returns the new array of composed arguments. param: {Array} args The provided arguments. param: {Array} partials The arguments to prepend to those provided. param: {Array} holders The `partials` placeholder indexes. |
| composeArgsRight(args, partials, holders, isCurried) X-Ref |
| This function is like `composeArgs` except that the arguments composition is tailored for `_.partialRight`. returns: {Array} Returns the new array of composed arguments. param: {Array} args The provided arguments. param: {Array} partials The arguments to append to those provided. param: {Array} holders The `partials` placeholder indexes. |
| copyArray(source, array) X-Ref |
| Copies the values of `source` to `array`. returns: {Array} Returns `array`. param: {Array} source The array to copy values from. param: {Array} [array=[]] The array to copy values to. |
| copyObject(source, props, object, customizer) X-Ref |
| Copies properties of `source` to `object`. returns: {Object} Returns `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. |
| copySymbols(source, object) X-Ref |
| Copies own symbols of `source` to `object`. returns: {Object} Returns `object`. param: {Object} source The object to copy symbols from. param: {Object} [object={}] The object to copy symbols to. |
| copySymbolsIn(source, object) X-Ref |
| Copies own and inherited symbols of `source` to `object`. returns: {Object} Returns `object`. param: {Object} source The object to copy symbols from. param: {Object} [object={}] The object to copy symbols to. |
| createAggregator(setter, initializer) X-Ref |
| Creates a function like `_.groupBy`. returns: {Function} Returns the new aggregator function. param: {Function} setter The function to set accumulator values. param: {Function} [initializer] The accumulator object initializer. |
| createAssigner(assigner) X-Ref |
| Creates a function like `_.assign`. returns: {Function} Returns the new assigner function. param: {Function} assigner The function to assign values. |
| createBaseEach(eachFunc, fromRight) X-Ref |
| Creates a `baseEach` or `baseEachRight` function. returns: {Function} Returns the new base function. param: {Function} eachFunc The function to iterate over a collection. param: {boolean} [fromRight] Specify iterating from right to left. |
| createBaseFor(fromRight) X-Ref |
| Creates a base function for methods like `_.forIn` and `_.forOwn`. returns: {Function} Returns the new base function. param: {boolean} [fromRight] Specify iterating from right to left. |
| createBind(func, bitmask, thisArg) X-Ref |
| Creates a function that wraps `func` to invoke it with the optional `this` binding of `thisArg`. returns: {Function} Returns the new wrapped function. 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`. |
| wrapper() X-Ref |
| No description |
| createCaseFirst(methodName) X-Ref |
| Creates a function like `_.lowerFirst`. returns: {Function} Returns the new case function. param: {string} methodName The name of the `String` case method to use. |
| createCompounder(callback) X-Ref |
| Creates a function like `_.camelCase`. returns: {Function} Returns the new compounder function. param: {Function} callback The function to combine each word. |
| 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`. returns: {Function} Returns the new wrapped function. param: {Function} Ctor The constructor to wrap. |
| createCurry(func, bitmask, arity) X-Ref |
| Creates a function that wraps `func` to enable currying. returns: {Function} Returns the new wrapped function. 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`. |
| wrapper() X-Ref |
| No description |
| createFind(findIndexFunc) X-Ref |
| Creates a `_.find` or `_.findLast` function. returns: {Function} Returns the new find function. param: {Function} findIndexFunc The function to find the collection index. |
| createFlow(fromRight) X-Ref |
| Creates a `_.flow` or `_.flowRight` function. returns: {Function} Returns the new flow function. param: {boolean} [fromRight] Specify iterating from right to left. |
| 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. returns: {Function} Returns the new wrapped function. 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`. |
| wrapper() X-Ref |
| No description |
| createInverter(setter, toIteratee) X-Ref |
| Creates a function like `_.invertBy`. returns: {Function} Returns the new inverter function. param: {Function} setter The function to set accumulator values. param: {Function} toIteratee The function to resolve iteratees. |
| createMathOperation(operator, defaultValue) X-Ref |
| Creates a function that performs a mathematical operation on two values. returns: {Function} Returns the new mathematical operation function. param: {Function} operator The function to perform the operation. param: {number} [defaultValue] The value used for `undefined` arguments. |
| createOver(arrayFunc) X-Ref |
| Creates a function like `_.over`. returns: {Function} Returns the new over function. param: {Function} arrayFunc The function to iterate over iteratees. |
| 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`. returns: {string} Returns the padding for `string`. param: {number} length The padding length. param: {string} [chars=' '] The string used as padding. |
| 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. returns: {Function} Returns the new wrapped function. 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 |
| wrapper() X-Ref |
| No description |
| createRange(fromRight) X-Ref |
| Creates a `_.range` or `_.rangeRight` function. returns: {Function} Returns the new range function. param: {boolean} [fromRight] Specify iterating from right to left. |
| createRelationalOperation(operator) X-Ref |
| Creates a function that performs a relational operation on two values. returns: {Function} Returns the new relational operation function. param: {Function} operator The function to perform the operation. |
| createRecurry(func, bitmask, wrapFunc, placeholder, thisArg, partials, holders, argPos, ary, arity) X-Ref |
| Creates a function that wraps `func` to continue currying. returns: {Function} Returns the new wrapped function. 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`. |
| createRound(methodName) X-Ref |
| Creates a function like `_.round`. returns: {Function} Returns the new round function. param: {string} methodName The name of the `Math` method to use when rounding. |
| createToPairs(keysFunc) X-Ref |
| Creates a `_.toPairs` or `_.toPairsIn` function. returns: {Function} Returns the new pairs function. param: {Function} keysFunc The function to get the keys of a given object. |
| 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. returns: {Function} Returns the new wrapped function. 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`. |
| 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`. returns: {*} Returns the value to assign. 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`. |
| 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. returns: {*} Returns the value to assign. 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 |
| customOmitClone(value) X-Ref |
| Used by `_.omit` to customize its `_.cloneDeep` use to only clone plain objects. returns: {*} Returns the uncloned value or `undefined` to defer cloning to `_.cloneDeep`. param: {*} value The value to inspect. param: {string} key The key of the property to inspect. |
| equalArrays(array, other, bitmask, customizer, equalFunc, stack) X-Ref |
| A specialized version of `baseIsEqualDeep` for arrays with support for partial deep comparisons. returns: {boolean} Returns `true` if the arrays are equivalent, else `false`. 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. |
| 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`. returns: {boolean} Returns `true` if the objects are equivalent, else `false`. 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. |
| equalObjects(object, other, bitmask, customizer, equalFunc, stack) X-Ref |
| A specialized version of `baseIsEqualDeep` for objects with support for partial deep comparisons. returns: {boolean} Returns `true` if the objects are equivalent, else `false`. 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. |
| flatRest(func) X-Ref |
| A specialized version of `baseRest` which flattens the rest array. returns: {Function} Returns the new function. param: {Function} func The function to apply a rest parameter to. |
| getAllKeys(object) X-Ref |
| Creates an array of own enumerable property names and symbols of `object`. returns: {Array} Returns the array of property names and symbols. param: {Object} object The object to query. |
| getAllKeysIn(object) X-Ref |
| Creates an array of own and inherited enumerable property names and symbols of `object`. returns: {Array} Returns the array of property names and symbols. param: {Object} object The object to query. |
| getFuncName(func) X-Ref |
| Gets the name of `func`. returns: {string} Returns the function name. param: {Function} func The function to query. |
| getHolder(func) X-Ref |
| Gets the argument placeholder value for `func`. returns: {*} Returns the placeholder value. param: {Function} func The function to inspect. |
| 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. returns: {Function} Returns the chosen function or its result. param: {*} [value] The value to convert to an iteratee. param: {number} [arity] The arity of the created iteratee. |
| getMapData(map, key) X-Ref |
| Gets the data for `map`. returns: {*} Returns the map data. param: {Object} map The map to query. param: {string} key The reference key. |
| getMatchData(object) X-Ref |
| Gets the property names, values, and compare flags of `object`. returns: {Array} Returns the match data of `object`. param: {Object} object The object to query. |
| getNative(object, key) X-Ref |
| Gets the native function at `key` of `object`. returns: {*} Returns the function if it's native, else `undefined`. param: {Object} object The object to query. param: {string} key The key of the method to get. |
| getRawTag(value) X-Ref |
| A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values. returns: {string} Returns the raw `toStringTag`. param: {*} value The value to query. |
| getView(start, end, transforms) X-Ref |
| Gets the view, applying any `transforms` to the `start` and `end` positions. returns: {Object} Returns an object containing the `start` and `end` 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. |
| getWrapDetails(source) X-Ref |
| Extracts wrapper details from the `source` body comment. returns: {Array} Returns the wrapper details. param: {string} source The source to inspect. |
| hasPath(object, path, hasFunc) X-Ref |
| Checks if `path` exists on `object`. returns: {boolean} Returns `true` if `path` exists, else `false`. param: {Object} object The object to query. param: {Array|string} path The path to check. param: {Function} hasFunc The function to check properties. |
| initCloneArray(array) X-Ref |
| Initializes an array clone. returns: {Array} Returns the initialized clone. param: {Array} array The array to clone. |
| initCloneObject(object) X-Ref |
| Initializes an object clone. returns: {Object} Returns the initialized clone. param: {Object} object The object to 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`. returns: {Object} Returns the initialized clone. param: {Object} object The object to clone. param: {string} tag The `toStringTag` of the object to clone. param: {boolean} [isDeep] Specify a deep clone. |
| insertWrapDetails(source, details) X-Ref |
| Inserts wrapper `details` in a comment at the top of the `source` body. returns: {Array} details The details to insert. returns: {string} Returns the modified source. param: {string} source The source to modify. |
| isFlattenable(value) X-Ref |
| Checks if `value` is a flattenable `arguments` object or array. returns: {boolean} Returns `true` if `value` is flattenable, else `false`. param: {*} value The value to check. |
| isIndex(value, length) X-Ref |
| Checks if `value` is a valid array-like index. returns: {boolean} Returns `true` if `value` is a valid index, else `false`. param: {*} value The value to check. param: {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index. |
| isIterateeCall(value, index, object) X-Ref |
| Checks if the given arguments are from an iteratee call. returns: {boolean} Returns `true` if the 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. |
| isKey(value, object) X-Ref |
| Checks if `value` is a property name and not a property path. returns: {boolean} Returns `true` if `value` is a property name, else `false`. param: {*} value The value to check. param: {Object} [object] The object to query keys on. |
| isKeyable(value) X-Ref |
| Checks if `value` is suitable for use as unique object key. returns: {boolean} Returns `true` if `value` is suitable, else `false`. param: {*} value The value to check. |
| isLaziable(func) X-Ref |
| Checks if `func` has a lazy counterpart. returns: {boolean} Returns `true` if `func` has a lazy counterpart, param: {Function} func The function to check. |
| isMasked(func) X-Ref |
| Checks if `func` has its source masked. returns: {boolean} Returns `true` if `func` is masked, else `false`. param: {Function} func The function to check. |
| isPrototype(value) X-Ref |
| Checks if `value` is likely a prototype object. returns: {boolean} Returns `true` if `value` is a prototype, else `false`. param: {*} value The value to check. |
| isStrictComparable(value) X-Ref |
| Checks if `value` is suitable for strict equality comparisons, i.e. `===`. returns: {boolean} Returns `true` if `value` if suitable for strict param: {*} value The value to check. |
| matchesStrictComparable(key, srcValue) X-Ref |
| A specialized version of `matchesProperty` for source values suitable for strict equality comparisons, i.e. `===`. returns: {Function} Returns the new spec function. param: {string} key The key of the property to get. param: {*} srcValue The value to match. |
| memoizeCapped(func) X-Ref |
| A specialized version of `_.memoize` which clears the memoized function's cache when it exceeds `MAX_MEMOIZE_SIZE`. returns: {Function} Returns the new memoized function. param: {Function} func The function to have its output memoized. |
| 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. returns: {Array} Returns `data`. param: {Array} data The destination metadata. param: {Array} source The source metadata. |
| 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. returns: {Array} Returns the array of property names. param: {Object} object The object to query. |
| objectToString(value) X-Ref |
| Converts `value` to a string using `Object.prototype.toString`. returns: {string} Returns the converted string. param: {*} value The value to convert. |
| overRest(func, start, transform) X-Ref |
| A specialized version of `baseRest` which transforms the rest array. returns: {Function} Returns the new function. 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. |
| parent(object, path) X-Ref |
| Gets the parent value at `path` of `object`. returns: {*} Returns the parent value. param: {Object} object The object to query. param: {Array} path The path to get the parent value of. |
| 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. returns: {Array} Returns `array`. param: {Array} array The array to reorder. param: {Array} indexes The arranged array indexes. |
| safeGet(object, key) X-Ref |
| Gets the value at `key`, unless `key` is "__proto__" or "constructor". returns: {*} Returns the property value. param: {Object} object The object to query. param: {string} key The key of the property to get. |
| 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. returns: {Function} Returns `wrapper`. param: {Function} wrapper The function to modify. param: {Function} reference The reference function. param: {number} bitmask The bitmask flags. See `createWrap` for more details. |
| 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. returns: {Function} Returns the new shortable function. param: {Function} func The function to restrict. |
| shuffleSelf(array, size) X-Ref |
| A specialized version of `_.shuffle` which mutates and sets the size of `array`. returns: {Array} Returns `array`. param: {Array} array The array to shuffle. param: {number} [size=array.length] The size of `array`. |
| toKey(value) X-Ref |
| Converts `value` to a string key if it's not a string or symbol. returns: {string|symbol} Returns the key. param: {*} value The value to inspect. |
| toSource(func) X-Ref |
| Converts `func` to its source code. returns: {string} Returns the source code. param: {Function} func The function to convert. |
| updateWrapDetails(details, bitmask) X-Ref |
| Updates wrapper `details` based on `bitmask` flags. returns: {Array} details The details to modify. returns: {Array} Returns `details`. param: {number} bitmask The bitmask flags. See `createWrap` for more details. |
| wrapperClone(wrapper) X-Ref |
| Creates a clone of `wrapper`. returns: {Object} Returns the cloned wrapper. param: {Object} wrapper The wrapper to clone. |
| 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. returns: {Array} Returns the new array of chunks. 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`. |
| compact(array) X-Ref |
| Creates an array with all falsey values removed. The values `false`, `null`, `0`, `""`, `undefined`, and `NaN` are falsey. returns: {Array} Returns the new array of filtered values. param: {Array} array The array to compact. |
| concat() X-Ref |
| Creates a new array concatenating `array` with any additional arrays and/or values. returns: {Array} Returns the new concatenated array. param: {Array} array The array to concatenate. param: {...*} [values] The values to concatenate. |
| drop(array, n, guard) X-Ref |
| Creates a slice of `array` with `n` elements dropped from the beginning. returns: {Array} Returns the slice of `array`. 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`. |
| dropRight(array, n, guard) X-Ref |
| Creates a slice of `array` with `n` elements dropped from the end. returns: {Array} Returns the slice of `array`. 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`. |
| 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). returns: {Array} Returns the slice of `array`. param: {Array} array The array to query. param: {Function} [predicate=_.identity] The function invoked per iteration. |
| 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). returns: {Array} Returns the slice of `array`. param: {Array} array The array to query. param: {Function} [predicate=_.identity] The function invoked per iteration. |
| 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`. returns: {Array} Returns `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. |
| 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. returns: {number} Returns the index of the found element, else `-1`. 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. |
| findLastIndex(array, predicate, fromIndex) X-Ref |
| This method is like `_.findIndex` except that it iterates over elements of `collection` from right to left. returns: {number} Returns the index of the found element, else `-1`. 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. |
| flatten(array) X-Ref |
| Flattens `array` a single level deep. returns: {Array} Returns the new flattened array. param: {Array} array The array to flatten. |
| flattenDeep(array) X-Ref |
| Recursively flattens `array`. returns: {Array} Returns the new flattened array. param: {Array} array The array to flatten. |
| flattenDepth(array, depth) X-Ref |
| Recursively flatten `array` up to `depth` times. returns: {Array} Returns the new flattened array. param: {Array} array The array to flatten. param: {number} [depth=1] The maximum recursion depth. |
| fromPairs(pairs) X-Ref |
| The inverse of `_.toPairs`; this method returns an object composed from key-value `pairs`. returns: {Object} Returns the new object. param: {Array} pairs The key-value pairs. |
| head(array) X-Ref |
| Gets the first element of `array`. returns: {*} Returns the first element of `array`. param: {Array} array The array to query. |
| 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`. returns: {number} Returns the index of the matched value, else `-1`. param: {Array} array The array to inspect. param: {*} value The value to search for. param: {number} [fromIndex=0] The index to search from. |
| initial(array) X-Ref |
| Gets all but the last element of `array`. returns: {Array} Returns the slice of `array`. param: {Array} array The array to query. |
| join(array, separator) X-Ref |
| Converts all elements in `array` into a string separated by `separator`. returns: {string} Returns the joined string. param: {Array} array The array to convert. param: {string} [separator=','] The element separator. |
| last(array) X-Ref |
| Gets the last element of `array`. returns: {*} Returns the last element of `array`. param: {Array} array The array to query. |
| lastIndexOf(array, value, fromIndex) X-Ref |
| This method is like `_.indexOf` except that it iterates over elements of `array` from right to left. returns: {number} Returns the index of the matched value, else `-1`. 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. |
| 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. returns: {*} Returns the nth element of `array`. param: {Array} array The array to query. param: {number} [n=0] The index of the element to return. |
| 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`. returns: {Array} Returns `array`. param: {Array} array The array to modify. param: {Array} values The values to remove. |
| 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`. returns: {Array} Returns `array`. param: {Array} array The array to modify. param: {Array} values The values to remove. param: {Function} [iteratee=_.identity] The iteratee invoked per element. |
| 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`. returns: {Array} Returns `array`. param: {Array} array The array to modify. param: {Array} values The values to remove. param: {Function} [comparator] The comparator invoked per element. |
| 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. returns: {Array} Returns the new array of removed elements. param: {Array} array The array to modify. param: {Function} [predicate=_.identity] The function invoked per iteration. |
| 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). returns: {Array} Returns `array`. param: {Array} array The array to modify. |
| 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. returns: {Array} Returns the slice of `array`. param: {Array} array The array to slice. param: {number} [start=0] The start position. param: {number} [end=array.length] The end position. |
| 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. returns: {number} Returns the index at which `value` should be inserted param: {Array} array The sorted array to inspect. param: {*} value The value to evaluate. |
| 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). returns: {number} Returns the index at which `value` should be inserted param: {Array} array The sorted array to inspect. param: {*} value The value to evaluate. param: {Function} [iteratee=_.identity] The iteratee invoked per element. |
| sortedIndexOf(array, value) X-Ref |
| This method is like `_.indexOf` except that it performs a binary search on a sorted `array`. returns: {number} Returns the index of the matched value, else `-1`. param: {Array} array The array to inspect. param: {*} value The value to search for. |
| 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. returns: {number} Returns the index at which `value` should be inserted param: {Array} array The sorted array to inspect. param: {*} value The value to evaluate. |
| 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). returns: {number} Returns the index at which `value` should be inserted param: {Array} array The sorted array to inspect. param: {*} value The value to evaluate. param: {Function} [iteratee=_.identity] The iteratee invoked per element. |
| sortedLastIndexOf(array, value) X-Ref |
| This method is like `_.lastIndexOf` except that it performs a binary search on a sorted `array`. returns: {number} Returns the index of the matched value, else `-1`. param: {Array} array The array to inspect. param: {*} value The value to search for. |
| sortedUniq(array) X-Ref |
| This method is like `_.uniq` except that it's designed and optimized for sorted arrays. returns: {Array} Returns the new duplicate free array. param: {Array} array The array to inspect. |
| sortedUniqBy(array, iteratee) X-Ref |
| This method is like `_.uniqBy` except that it's designed and optimized for sorted arrays. returns: {Array} Returns the new duplicate free array. param: {Array} array The array to inspect. param: {Function} [iteratee] The iteratee invoked per element. |
| tail(array) X-Ref |
| Gets all but the first element of `array`. returns: {Array} Returns the slice of `array`. param: {Array} array The array to query. |
| take(array, n, guard) X-Ref |
| Creates a slice of `array` with `n` elements taken from the beginning. returns: {Array} Returns the slice of `array`. 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`. |
| takeRight(array, n, guard) X-Ref |
| Creates a slice of `array` with `n` elements taken from the end. returns: {Array} Returns the slice of `array`. 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`. |
| 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). returns: {Array} Returns the slice of `array`. param: {Array} array The array to query. param: {Function} [predicate=_.identity] The function invoked per iteration. |
| 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). returns: {Array} Returns the slice of `array`. param: {Array} array The array to query. param: {Function} [predicate=_.identity] The function invoked per iteration. |
| 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. returns: {Array} Returns the new duplicate free array. param: {Array} array The array to inspect. |
| 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). returns: {Array} Returns the new duplicate free array. param: {Array} array The array to inspect. param: {Function} [iteratee=_.identity] The iteratee invoked per element. |
| 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). returns: {Array} Returns the new duplicate free array. param: {Array} array The array to inspect. param: {Function} [comparator] The comparator invoked per element. |
| 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. returns: {Array} Returns the new array of regrouped elements. param: {Array} array The array of grouped elements to process. |
| 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). returns: {Array} Returns the new array of regrouped elements. param: {Array} array The array of grouped elements to process. param: {Function} [iteratee=_.identity] The function to combine |
| 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. returns: {Object} Returns the new object. param: {Array} [props=[]] The property identifiers. param: {Array} [values=[]] The property values. |
| zipObjectDeep(props, values) X-Ref |
| This method is like `_.zipObject` except that it supports property paths. returns: {Object} Returns the new object. param: {Array} [props=[]] The property identifiers. param: {Array} [values=[]] The property values. |
| 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`. returns: {Object} Returns the new `lodash` wrapper instance. param: {*} value The value to wrap. |
| 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. returns: {*} Returns `value`. param: {*} value The value to provide to `interceptor`. param: {Function} interceptor The function to invoke. |
| 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. returns: {*} Returns the result of `interceptor`. param: {*} value The value to provide to `interceptor`. param: {Function} interceptor The function to invoke. |
| 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. returns: {Object} Returns the new `lodash` wrapper instance. param: {*} value The value to plant. |
| 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. returns: {boolean} Returns `true` if all elements pass the predicate check, 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`. |
| 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. returns: {Array} Returns the new filtered array. param: {Array|Object} collection The collection to iterate over. param: {Function} [predicate=_.identity] The function invoked per iteration. |
| 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). returns: {Array} Returns the new flattened array. param: {Array|Object} collection The collection to iterate over. param: {Function} [iteratee=_.identity] The function invoked per iteration. |
| flatMapDeep(collection, iteratee) X-Ref |
| This method is like `_.flatMap` except that it recursively flattens the mapped results. returns: {Array} Returns the new flattened array. param: {Array|Object} collection The collection to iterate over. param: {Function} [iteratee=_.identity] The function invoked per iteration. |
| flatMapDepth(collection, iteratee, depth) X-Ref |
| This method is like `_.flatMap` except that it recursively flattens the mapped results up to `depth` times. returns: {Array} Returns the new flattened array. 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. |
| 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. returns: {Array|Object} Returns `collection`. param: {Array|Object} collection The collection to iterate over. param: {Function} [iteratee=_.identity] The function invoked per iteration. |
| forEachRight(collection, iteratee) X-Ref |
| This method is like `_.forEach` except that it iterates over elements of `collection` from right to left. returns: {Array|Object} Returns `collection`. param: {Array|Object} collection The collection to iterate over. param: {Function} [iteratee=_.identity] The function invoked per iteration. |
| 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`. returns: {boolean} Returns `true` if `value` is found, else `false`. 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`. |
| 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` returns: {Array} Returns the new mapped array. param: {Array|Object} collection The collection to iterate over. param: {Function} [iteratee=_.identity] The function invoked per iteration. |
| 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. returns: {Array} Returns the new sorted array. 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`. |
| 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` returns: {*} Returns the accumulated value. param: {Array|Object} collection The collection to iterate over. param: {Function} [iteratee=_.identity] The function invoked per iteration. param: {*} [accumulator] The initial value. |
| reduceRight(collection, iteratee, accumulator) X-Ref |
| This method is like `_.reduce` except that it iterates over elements of `collection` from right to left. returns: {*} Returns the accumulated value. param: {Array|Object} collection The collection to iterate over. param: {Function} [iteratee=_.identity] The function invoked per iteration. param: {*} [accumulator] The initial value. |
| reject(collection, predicate) X-Ref |
| The opposite of `_.filter`; this method returns the elements of `collection` that `predicate` does **not** return truthy for. returns: {Array} Returns the new filtered array. param: {Array|Object} collection The collection to iterate over. param: {Function} [predicate=_.identity] The function invoked per iteration. |
| sample(collection) X-Ref |
| Gets a random element from `collection`. returns: {*} Returns the random element. param: {Array|Object} collection The collection to sample. |
| sampleSize(collection, n, guard) X-Ref |
| Gets `n` random elements at unique keys from `collection` up to the size of `collection`. returns: {Array} Returns the random elements. 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`. |
| 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). returns: {Array} Returns the new shuffled array. param: {Array|Object} collection The collection to shuffle. |
| 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. returns: {number} Returns the collection size. param: {Array|Object|string} collection The collection to inspect. |
| 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). returns: {boolean} Returns `true` if any element passes the predicate check, 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`. |
| 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. returns: {Function} Returns the new restricted function. param: {number} n The number of calls before `func` is invoked. param: {Function} func The function to restrict. |
| ary(func, n, guard) X-Ref |
| Creates a function that invokes `func`, with up to `n` arguments, ignoring any additional arguments. returns: {Function} Returns the new capped function. 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`. |
| 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. returns: {Function} Returns the new restricted function. param: {number} n The number of calls at which `func` is no longer invoked. param: {Function} func The function to restrict. |
| 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. returns: {Function} Returns the new curried function. 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`. |
| 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. returns: {Function} Returns the new curried function. 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`. |
| 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`. returns: {Function} Returns the new debounced function. 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] |
| 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. returns: {Function} Returns the new flipped function. param: {Function} func The function to flip arguments for. |
| 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`. returns: {Function} Returns the new memoized function. param: {Function} func The function to have its output memoized. param: {Function} [resolver] The function to resolve the cache key. |
| 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. returns: {Function} Returns the new negated function. param: {Function} predicate The predicate to negate. |
| 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. returns: {Function} Returns the new restricted function. param: {Function} func The function to restrict. |
| 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). returns: {Function} Returns the new function. param: {Function} func The function to apply a rest parameter to. param: {number} [start=func.length-1] The start position of the rest parameter. |
| 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). returns: {Function} Returns the new function. param: {Function} func The function to spread arguments over. param: {number} [start=0] The start position of the spread. |
| 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`. returns: {Function} Returns the new throttled function. 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] |
| unary(func) X-Ref |
| Creates a function that accepts up to one argument, ignoring any additional arguments. returns: {Function} Returns the new capped function. param: {Function} func The function to cap arguments for. |
| 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. returns: {Function} Returns the new function. param: {*} value The value to wrap. param: {Function} [wrapper=identity] The wrapper function. |
| castArray() X-Ref |
| Casts `value` as an array if it's not one. returns: {Array} Returns the cast array. param: {*} value The value to inspect. |
| 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. returns: {*} Returns the cloned value. param: {*} value The value to clone. |
| 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]). returns: {*} Returns the cloned value. param: {*} value The value to clone. param: {Function} [customizer] The function to customize cloning. |
| cloneDeep(value) X-Ref |
| This method is like `_.clone` except that it recursively clones `value`. returns: {*} Returns the deep cloned value. param: {*} value The value to recursively clone. |
| cloneDeepWith(value, customizer) X-Ref |
| This method is like `_.cloneWith` except that it recursively clones `value`. returns: {*} Returns the deep cloned value. param: {*} value The value to recursively clone. param: {Function} [customizer] The function to customize cloning. |
| 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. returns: {boolean} Returns `true` if `object` conforms, else `false`. param: {Object} object The object to inspect. param: {Object} source The object of property predicates to conform to. |
| 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. returns: {boolean} Returns `true` if the values are equivalent, else `false`. param: {*} value The value to compare. param: {*} other The other value to compare. |
| 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`. returns: {boolean} Returns `true` if `value` is array-like, else `false`. param: {*} value The value to check. |
| isArrayLikeObject(value) X-Ref |
| This method is like `_.isArrayLike` except that it also checks if `value` is an object. returns: {boolean} Returns `true` if `value` is an array-like object, param: {*} value The value to check. |
| isBoolean(value) X-Ref |
| Checks if `value` is classified as a boolean primitive or object. returns: {boolean} Returns `true` if `value` is a boolean, else `false`. param: {*} value The value to check. |
| isElement(value) X-Ref |
| Checks if `value` is likely a DOM element. returns: {boolean} Returns `true` if `value` is a DOM element, else `false`. param: {*} value The value to check. |
| 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`. returns: {boolean} Returns `true` if `value` is empty, else `false`. param: {*} value The value to check. |
| 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. `===`. returns: {boolean} Returns `true` if the values are equivalent, else `false`. param: {*} value The value to compare. param: {*} other The other value to compare. |
| 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]). returns: {boolean} Returns `true` if the values are equivalent, else `false`. param: {*} value The value to compare. param: {*} other The other value to compare. param: {Function} [customizer] The function to customize comparisons. |
| isError(value) X-Ref |
| Checks if `value` is an `Error`, `EvalError`, `RangeError`, `ReferenceError`, `SyntaxError`, `TypeError`, or `URIError` object. returns: {boolean} Returns `true` if `value` is an error object, else `false`. param: {*} value The value to check. |
| 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). returns: {boolean} Returns `true` if `value` is a finite number, else `false`. param: {*} value The value to check. |
| isFunction(value) X-Ref |
| Checks if `value` is classified as a `Function` object. returns: {boolean} Returns `true` if `value` is a function, else `false`. param: {*} value The value to check. |
| isInteger(value) X-Ref |
| Checks if `value` is an integer. **Note:** This method is based on [`Number.isInteger`](https://mdn.io/Number/isInteger). returns: {boolean} Returns `true` if `value` is an integer, else `false`. param: {*} value The value to check. |
| 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). returns: {boolean} Returns `true` if `value` is a valid length, else `false`. param: {*} value The value to check. |
| 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('')`) returns: {boolean} Returns `true` if `value` is an object, else `false`. param: {*} value The value to check. |
| 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". returns: {boolean} Returns `true` if `value` is object-like, else `false`. param: {*} value The value to check. |
| 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. returns: {boolean} Returns `true` if `object` is a match, else `false`. param: {Object} object The object to inspect. param: {Object} source The object of property values to match. |
| 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). returns: {boolean} Returns `true` if `object` is a match, else `false`. 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. |
| 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. returns: {boolean} Returns `true` if `value` is `NaN`, else `false`. param: {*} value The value to check. |
| 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. returns: {boolean} Returns `true` if `value` is a native function, param: {*} value The value to check. |
| isNull(value) X-Ref |
| Checks if `value` is `null`. returns: {boolean} Returns `true` if `value` is `null`, else `false`. param: {*} value The value to check. |
| isNil(value) X-Ref |
| Checks if `value` is `null` or `undefined`. returns: {boolean} Returns `true` if `value` is nullish, else `false`. param: {*} value The value to check. |
| 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. returns: {boolean} Returns `true` if `value` is a number, else `false`. param: {*} value The value to check. |
| 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`. returns: {boolean} Returns `true` if `value` is a plain object, else `false`. param: {*} value The value to check. |
| 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). returns: {boolean} Returns `true` if `value` is a safe integer, else `false`. param: {*} value The value to check. |
| isString(value) X-Ref |
| Checks if `value` is classified as a `String` primitive or object. returns: {boolean} Returns `true` if `value` is a string, else `false`. param: {*} value The value to check. |
| isSymbol(value) X-Ref |
| Checks if `value` is classified as a `Symbol` primitive or object. returns: {boolean} Returns `true` if `value` is a symbol, else `false`. param: {*} value The value to check. |
| isUndefined(value) X-Ref |
| Checks if `value` is `undefined`. returns: {boolean} Returns `true` if `value` is `undefined`, else `false`. param: {*} value The value to check. |
| isWeakMap(value) X-Ref |
| Checks if `value` is classified as a `WeakMap` object. returns: {boolean} Returns `true` if `value` is a weak map, else `false`. param: {*} value The value to check. |
| isWeakSet(value) X-Ref |
| Checks if `value` is classified as a `WeakSet` object. returns: {boolean} Returns `true` if `value` is a weak set, else `false`. param: {*} value The value to check. |
| toArray(value) X-Ref |
| Converts `value` to an array. returns: {Array} Returns the converted array. param: {*} value The value to convert. |
| toFinite(value) X-Ref |
| Converts `value` to a finite number. returns: {number} Returns the converted number. param: {*} value The value to convert. |
| 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). returns: {number} Returns the converted integer. param: {*} value The value to convert. |
| 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). returns: {number} Returns the converted integer. param: {*} value The value to convert. |
| toNumber(value) X-Ref |
| Converts `value` to a number. returns: {number} Returns the number. param: {*} value The value to process. |
| 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. returns: {Object} Returns the converted plain object. param: {*} value The value to convert. |
| toSafeInteger(value) X-Ref |
| Converts `value` to a safe integer. A safe integer can be compared and represented correctly. returns: {number} Returns the converted integer. param: {*} value The value to convert. |
| 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. returns: {string} Returns the converted string. param: {*} value The value to convert. |
| 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. returns: {Object} Returns the new object. param: {Object} prototype The object to inherit from. param: {Object} [properties] The properties to assign to the 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. returns: {string|undefined} Returns the key of the matched element, param: {Object} object The object to inspect. param: {Function} [predicate=_.identity] The function invoked per iteration. |
| findLastKey(object, predicate) X-Ref |
| This method is like `_.findKey` except that it iterates over elements of a collection in the opposite order. returns: {string|undefined} Returns the key of the matched element, param: {Object} object The object to inspect. param: {Function} [predicate=_.identity] The function invoked per iteration. |
| 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`. returns: {Object} Returns `object`. param: {Object} object The object to iterate over. param: {Function} [iteratee=_.identity] The function invoked per iteration. |
| forInRight(object, iteratee) X-Ref |
| This method is like `_.forIn` except that it iterates over properties of `object` in the opposite order. returns: {Object} Returns `object`. param: {Object} object The object to iterate over. param: {Function} [iteratee=_.identity] The function invoked per iteration. |
| 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`. returns: {Object} Returns `object`. param: {Object} object The object to iterate over. param: {Function} [iteratee=_.identity] The function invoked per iteration. |
| forOwnRight(object, iteratee) X-Ref |
| This method is like `_.forOwn` except that it iterates over properties of `object` in the opposite order. returns: {Object} Returns `object`. param: {Object} object The object to iterate over. param: {Function} [iteratee=_.identity] The function invoked per iteration. |
| functions(object) X-Ref |
| Creates an array of function property names from own enumerable properties of `object`. returns: {Array} Returns the function names. param: {Object} object The object to inspect. |
| functionsIn(object) X-Ref |
| Creates an array of function property names from own and inherited enumerable properties of `object`. returns: {Array} Returns the function names. param: {Object} object The object to inspect. |
| 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. returns: {*} Returns the resolved value. 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. |
| has(object, path) X-Ref |
| Checks if `path` is a direct property of `object`. returns: {boolean} Returns `true` if `path` exists, else `false`. param: {Object} object The object to query. param: {Array|string} path The path to check. |
| hasIn(object, path) X-Ref |
| Checks if `path` is a direct or inherited property of `object`. returns: {boolean} Returns `true` if `path` exists, else `false`. param: {Object} object The object to query. param: {Array|string} path The path to check. |
| 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. returns: {Array} Returns the array of property names. param: {Object} object The object to query. |
| 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. returns: {Array} Returns the array of property names. param: {Object} object The object to query. |
| 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). returns: {Object} Returns the new mapped object. param: {Object} object The object to iterate over. param: {Function} [iteratee=_.identity] The function invoked per iteration. |
| 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). returns: {Object} Returns the new mapped object. param: {Object} object The object to iterate over. param: {Function} [iteratee=_.identity] The function invoked per iteration. |
| 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). returns: {Object} Returns the new object. param: {Object} object The source object. param: {Function} [predicate=_.identity] The function invoked per property. |
| 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). returns: {Object} Returns the new object. param: {Object} object The source object. param: {Function} [predicate=_.identity] The function invoked per property. |
| 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. returns: {*} Returns the resolved value. 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. |
| 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`. returns: {Object} Returns `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. |
| 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`. returns: {Object} Returns `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. |
| 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`. returns: {*} Returns the accumulated value. param: {Object} object The object to iterate over. param: {Function} [iteratee=_.identity] The function invoked per iteration. param: {*} [accumulator] The custom accumulator value. |
| unset(object, path) X-Ref |
| Removes the property at `path` of `object`. **Note:** This method mutates `object`. returns: {boolean} Returns `true` if the property is deleted, else `false`. param: {Object} object The object to modify. param: {Array|string} path The path of the property to unset. |
| 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`. returns: {Object} Returns `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. |
| 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`. returns: {Object} Returns `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. |
| 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. returns: {Array} Returns the array of property values. param: {Object} object The object to query. |
| 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. returns: {Array} Returns the array of property values. param: {Object} object The object to query. |
| clamp(number, lower, upper) X-Ref |
| Clamps `number` within the inclusive `lower` and `upper` bounds. returns: {number} Returns the clamped number. param: {number} number The number to clamp. param: {number} [lower] The lower bound. param: {number} upper The upper bound. |
| 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. returns: {boolean} Returns `true` if `number` is in the range, else `false`. param: {number} number The number to check. param: {number} [start=0] The start of the range. param: {number} end The end of the range. |
| 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. returns: {number} Returns the random number. param: {number} [lower=0] The lower bound. param: {number} [upper=1] The upper bound. param: {boolean} [floating] Specify returning a floating-point number. |
| capitalize(string) X-Ref |
| Converts the first character of `string` to upper case and the remaining to lower case. returns: {string} Returns the capitalized string. param: {string} [string=''] The string to capitalize. |
| 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). returns: {string} Returns the deburred string. param: {string} [string=''] The string to deburr. |
| endsWith(string, target, position) X-Ref |
| Checks if `string` ends with the given target string. returns: {boolean} Returns `true` if `string` ends with `target`, 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. |
| 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. returns: {string} Returns the escaped string. param: {string} [string=''] The string to escape. |
| escapeRegExp(string) X-Ref |
| Escapes the `RegExp` special characters "^", "$", "\", ".", "*", "+", "?", "(", ")", "[", "]", "{", "}", and "|" in `string`. returns: {string} Returns the escaped string. param: {string} [string=''] The string to escape. |
| 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`. returns: {string} Returns the padded string. param: {string} [string=''] The string to pad. param: {number} [length=0] The padding length. param: {string} [chars=' '] The string used as padding. |
| 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`. returns: {string} Returns the padded string. param: {string} [string=''] The string to pad. param: {number} [length=0] The padding length. param: {string} [chars=' '] The string used as padding. |
| 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`. returns: {string} Returns the padded string. param: {string} [string=''] The string to pad. param: {number} [length=0] The padding length. param: {string} [chars=' '] The string used as padding. |
| 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`. returns: {number} Returns the converted integer. 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`. |
| repeat(string, n, guard) X-Ref |
| Repeats the given string `n` times. returns: {string} Returns the repeated string. 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`. |
| replace() X-Ref |
| Replaces matches for `pattern` in `string` with `replacement`. **Note:** This method is based on [`String#replace`](https://mdn.io/String/replace). returns: {string} Returns the modified string. param: {string} [string=''] The string to modify. param: {RegExp|string} pattern The pattern to replace. param: {Function|string} replacement The match replacement. |
| split(string, separator, limit) X-Ref |
| Splits `string` by `separator`. **Note:** This method is based on [`String#split`](https://mdn.io/String/split). returns: {Array} Returns the string segments. 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. |
| startsWith(string, target, position) X-Ref |
| Checks if `string` starts with the given target string. returns: {boolean} Returns `true` if `string` starts with `target`, param: {string} [string=''] The string to inspect. param: {string} [target] The string to search for. param: {number} [position=0] The position to search from. |
| 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). returns: {Function} Returns the compiled template function. 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`. |
| toLower(value) X-Ref |
| Converts `string`, as a whole, to lower case just like [String#toLowerCase](https://mdn.io/toLowerCase). returns: {string} Returns the lower cased string. param: {string} [string=''] The string to convert. |
| toUpper(value) X-Ref |
| Converts `string`, as a whole, to upper case just like [String#toUpperCase](https://mdn.io/toUpperCase). returns: {string} Returns the upper cased string. param: {string} [string=''] The string to convert. |
| trim(string, chars, guard) X-Ref |
| Removes leading and trailing whitespace or specified characters from `string`. returns: {string} Returns the trimmed 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`. |
| trimEnd(string, chars, guard) X-Ref |
| Removes trailing whitespace or specified characters from `string`. returns: {string} Returns the trimmed 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`. |
| trimStart(string, chars, guard) X-Ref |
| Removes leading whitespace or specified characters from `string`. returns: {string} Returns the trimmed 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`. |
| 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 "...". returns: {string} Returns the truncated string. 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. |
| 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). returns: {string} Returns the unescaped string. param: {string} [string=''] The string to unescape. |
| words(string, pattern, guard) X-Ref |
| Splits `string` into an array of its words. returns: {Array} Returns the words of `string`. 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`. |
| 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. returns: {Function} Returns the new composite function. param: {Array} pairs The predicate-function pairs. |
| 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. returns: {Function} Returns the new spec function. param: {Object} source The object of property predicates to conform to. |
| constant(value) X-Ref |
| Creates a function that returns `value`. returns: {Function} Returns the new constant function. param: {*} value The value to return from the new 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`. returns: {*} Returns the resolved value. param: {*} value The value to check. param: {*} defaultValue The default value. |
| identity(value) X-Ref |
| This method returns the first argument it receives. returns: {*} Returns `value`. param: {*} value Any 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`. returns: {Function} Returns the callback. param: {*} [func=_.identity] The value to convert to a 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` returns: {Function} Returns the new spec function. param: {Object} source The object of property values to match. |
| 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` returns: {Function} Returns the new spec function. param: {Array|string} path The path of the property to get. param: {*} srcValue The value to match. |
| 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. returns: {Function|Object} Returns `object`. 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. |
| 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. returns: {Function} Returns the new pass-thru function. param: {number} [n=0] The index of the argument to return. |
| property(path) X-Ref |
| Creates a function that returns the value at `path` of a given object. returns: {Function} Returns the new accessor function. param: {Array|string} path The path of the property to get. |
| propertyOf(object) X-Ref |
| The opposite of `_.property`; this method creates a function that returns the value at a given path of `object`. returns: {Function} Returns the new accessor function. param: {Object} object The object to query. |
| 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). returns: {Array} Returns the array of results. param: {number} n The number of times to invoke `iteratee`. param: {Function} [iteratee=_.identity] The function invoked per iteration. |
| toPath(value) X-Ref |
| Converts `value` to a property path array. returns: {Array} Returns the new property path array. param: {*} value The value to convert. |
| uniqueId(prefix) X-Ref |
| Generates a unique ID. If `prefix` is given, the ID is appended to it. returns: {string} Returns the unique ID. param: {string} [prefix=''] The value to prefix the ID with. |
| max(array) X-Ref |
| Computes the maximum value of `array`. If `array` is empty or falsey, `undefined` is returned. returns: {*} Returns the maximum value. param: {Array} array The array to iterate over. |
| 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). returns: {*} Returns the maximum value. param: {Array} array The array to iterate over. param: {Function} [iteratee=_.identity] The iteratee invoked per element. |
| mean(array) X-Ref |
| Computes the mean of the values in `array`. returns: {number} Returns the mean. param: {Array} array The array to iterate over. |
| 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). returns: {number} Returns the mean. param: {Array} array The array to iterate over. param: {Function} [iteratee=_.identity] The iteratee invoked per element. |
| min(array) X-Ref |
| Computes the minimum value of `array`. If `array` is empty or falsey, `undefined` is returned. returns: {*} Returns the minimum value. param: {Array} array The array to iterate over. |
| 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). returns: {*} Returns the minimum value. param: {Array} array The array to iterate over. param: {Function} [iteratee=_.identity] The iteratee invoked per element. |
| sum(array) X-Ref |
| Computes the sum of the values in `array`. returns: {number} Returns the sum. param: {Array} array The array to iterate over. |
| 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). returns: {number} Returns the sum. param: {Array} array The array to iterate over. param: {Function} [iteratee=_.identity] The iteratee invoked per element. |
| Generated : Fri Apr 26 08:20:02 2024 | Cross-referenced by PHPXref |