Lines Matching refs:_
8 * <a href="#_chunkarray-size1">`_.chunk`</a>
9 * <a href="#_compactarray">`_.compact`</a>
10 * <a href="#_concatarray-values">`_.concat`</a>
11 * <a href="#_differencearray-values">`_.difference`</a>
12 * <a href="#_differencebyarray-values-iteratee_identity">`_.differenceBy`</a>
13 * <a href="#_differencewitharray-values-comparator">`_.differenceWith`</a>
14 * <a href="#_droparray-n1">`_.drop`</a>
15 * <a href="#_droprightarray-n1">`_.dropRight`</a>
16 * <a href="#_droprightwhilearray-predicate_identity">`_.dropRightWhile`</a>
17 * <a href="#_dropwhilearray-predicate_identity">`_.dropWhile`</a>
18 * <a href="#_fillarray-value-start0-endarraylength">`_.fill`</a>
19 * <a href="#_findindexarray-predicate_identity-fromindex0">`_.findIndex`</a>
20 * <a href="#_findlastindexarray-predicate_identity-fromindexarraylength-1">`_.findLastIndex`</a>
21 * <a href="#_headarray" class="alias">`_.first` -> `head`</a>
22 * <a href="#_flattenarray">`_.flatten`</a>
23 * <a href="#_flattendeeparray">`_.flattenDeep`</a>
24 * <a href="#_flattendeptharray-depth1">`_.flattenDepth`</a>
25 * <a href="#_frompairspairs">`_.fromPairs`</a>
26 * <a href="#_headarray">`_.head`</a>
27 * <a href="#_indexofarray-value-fromindex0">`_.indexOf`</a>
28 * <a href="#_initialarray">`_.initial`</a>
29 * <a href="#_intersectionarrays">`_.intersection`</a>
30 * <a href="#_intersectionbyarrays-iteratee_identity">`_.intersectionBy`</a>
31 * <a href="#_intersectionwitharrays-comparator">`_.intersectionWith`</a>
32 * <a href="#_joinarray-separator-">`_.join`</a>
33 * <a href="#_lastarray">`_.last`</a>
34 * <a href="#_lastindexofarray-value-fromindexarraylength-1">`_.lastIndexOf`</a>
35 * <a href="#_ntharray-n0">`_.nth`</a>
36 * <a href="#_pullarray-values">`_.pull`</a>
37 * <a href="#_pullallarray-values">`_.pullAll`</a>
38 * <a href="#_pullallbyarray-values-iteratee_identity">`_.pullAllBy`</a>
39 * <a href="#_pullallwitharray-values-comparator">`_.pullAllWith`</a>
40 * <a href="#_pullatarray-indexes">`_.pullAt`</a>
41 * <a href="#_removearray-predicate_identity">`_.remove`</a>
42 * <a href="#_reversearray">`_.reverse`</a>
43 * <a href="#_slicearray-start0-endarraylength">`_.slice`</a>
44 * <a href="#_sortedindexarray-value">`_.sortedIndex`</a>
45 * <a href="#_sortedindexbyarray-value-iteratee_identity">`_.sortedIndexBy`</a>
46 * <a href="#_sortedindexofarray-value">`_.sortedIndexOf`</a>
47 * <a href="#_sortedlastindexarray-value">`_.sortedLastIndex`</a>
48 * <a href="#_sortedlastindexbyarray-value-iteratee_identity">`_.sortedLastIndexBy`</a>
49 * <a href="#_sortedlastindexofarray-value">`_.sortedLastIndexOf`</a>
50 * <a href="#_sorteduniqarray">`_.sortedUniq`</a>
51 * <a href="#_sorteduniqbyarray-iteratee">`_.sortedUniqBy`</a>
52 * <a href="#_tailarray">`_.tail`</a>
53 * <a href="#_takearray-n1">`_.take`</a>
54 * <a href="#_takerightarray-n1">`_.takeRight`</a>
55 * <a href="#_takerightwhilearray-predicate_identity">`_.takeRightWhile`</a>
56 * <a href="#_takewhilearray-predicate_identity">`_.takeWhile`</a>
57 * <a href="#_unionarrays">`_.union`</a>
58 * <a href="#_unionbyarrays-iteratee_identity">`_.unionBy`</a>
59 * <a href="#_unionwitharrays-comparator">`_.unionWith`</a>
60 * <a href="#_uniqarray">`_.uniq`</a>
61 * <a href="#_uniqbyarray-iteratee_identity">`_.uniqBy`</a>
62 * <a href="#_uniqwitharray-comparator">`_.uniqWith`</a>
63 * <a href="#_unziparray">`_.unzip`</a>
64 * <a href="#_unzipwitharray-iteratee_identity">`_.unzipWith`</a>
65 * <a href="#_withoutarray-values">`_.without`</a>
66 * <a href="#_xorarrays">`_.xor`</a>
67 * <a href="#_xorbyarrays-iteratee_identity">`_.xorBy`</a>
68 * <a href="#_xorwitharrays-comparator">`_.xorWith`</a>
69 * <a href="#_ziparrays">`_.zip`</a>
70 * <a href="#_zipobjectprops-values">`_.zipObject`</a>
71 * <a href="#_zipobjectdeepprops-values">`_.zipObjectDeep`</a>
72 * <a href="#_zipwitharrays-iteratee_identity">`_.zipWith`</a>
79 * <a href="#_countbycollection-iteratee_identity">`_.countBy`</a>
80 * <a href="#_foreachcollection-iteratee_identity" class="alias">`_.each` -> `forEach`</a>
81 * <a href="#_foreachrightcollection-iteratee_identity" class="alias">`_.eachRight` -> `forEachRight…
82 * <a href="#_everycollection-predicate_identity">`_.every`</a>
83 * <a href="#_filtercollection-predicate_identity">`_.filter`</a>
84 * <a href="#_findcollection-predicate_identity-fromindex0">`_.find`</a>
85 * <a href="#_findlastcollection-predicate_identity-fromindexcollectionlength-1">`_.findLast`</a>
86 * <a href="#_flatmapcollection-iteratee_identity">`_.flatMap`</a>
87 * <a href="#_flatmapdeepcollection-iteratee_identity">`_.flatMapDeep`</a>
88 * <a href="#_flatmapdepthcollection-iteratee_identity-depth1">`_.flatMapDepth`</a>
89 * <a href="#_foreachcollection-iteratee_identity">`_.forEach`</a>
90 * <a href="#_foreachrightcollection-iteratee_identity">`_.forEachRight`</a>
91 * <a href="#_groupbycollection-iteratee_identity">`_.groupBy`</a>
92 * <a href="#_includescollection-value-fromindex0">`_.includes`</a>
93 * <a href="#_invokemapcollection-path-args">`_.invokeMap`</a>
94 * <a href="#_keybycollection-iteratee_identity">`_.keyBy`</a>
95 * <a href="#_mapcollection-iteratee_identity">`_.map`</a>
96 * <a href="#_orderbycollection-iteratees_identity-orders">`_.orderBy`</a>
97 * <a href="#_partitioncollection-predicate_identity">`_.partition`</a>
98 * <a href="#_reducecollection-iteratee_identity-accumulator">`_.reduce`</a>
99 * <a href="#_reducerightcollection-iteratee_identity-accumulator">`_.reduceRight`</a>
100 * <a href="#_rejectcollection-predicate_identity">`_.reject`</a>
101 * <a href="#_samplecollection">`_.sample`</a>
102 * <a href="#_samplesizecollection-n1">`_.sampleSize`</a>
103 * <a href="#_shufflecollection">`_.shuffle`</a>
104 * <a href="#_sizecollection">`_.size`</a>
105 * <a href="#_somecollection-predicate_identity">`_.some`</a>
106 * <a href="#_sortbycollection-iteratees_identity">`_.sortBy`</a>
113 * <a href="#_now">`_.now`</a>
120 * <a href="#_aftern-func">`_.after`</a>
121 * <a href="#_aryfunc-nfunclength">`_.ary`</a>
122 * <a href="#_beforen-func">`_.before`</a>
123 * <a href="#_bindfunc-thisarg-partials">`_.bind`</a>
124 * <a href="#_bindkeyobject-key-partials">`_.bindKey`</a>
125 * <a href="#_curryfunc-arityfunclength">`_.curry`</a>
126 * <a href="#_curryrightfunc-arityfunclength">`_.curryRight`</a>
127 * <a href="#_debouncefunc-wait0-options">`_.debounce`</a>
128 * <a href="#_deferfunc-args">`_.defer`</a>
129 * <a href="#_delayfunc-wait-args">`_.delay`</a>
130 * <a href="#_flipfunc">`_.flip`</a>
131 * <a href="#_memoizefunc-resolver">`_.memoize`</a>
132 * <a href="#_negatepredicate">`_.negate`</a>
133 * <a href="#_oncefunc">`_.once`</a>
134 * <a href="#_overargsfunc-transforms_identity">`_.overArgs`</a>
135 * <a href="#_partialfunc-partials">`_.partial`</a>
136 * <a href="#_partialrightfunc-partials">`_.partialRight`</a>
137 * <a href="#_reargfunc-indexes">`_.rearg`</a>
138 * <a href="#_restfunc-startfunclength-1">`_.rest`</a>
139 * <a href="#_spreadfunc-start0">`_.spread`</a>
140 * <a href="#_throttlefunc-wait0-options">`_.throttle`</a>
141 * <a href="#_unaryfunc">`_.unary`</a>
142 * <a href="#_wrapvalue-wrapperidentity">`_.wrap`</a>
149 * <a href="#_castarrayvalue">`_.castArray`</a>
150 * <a href="#_clonevalue">`_.clone`</a>
151 * <a href="#_clonedeepvalue">`_.cloneDeep`</a>
152 * <a href="#_clonedeepwithvalue-customizer">`_.cloneDeepWith`</a>
153 * <a href="#_clonewithvalue-customizer">`_.cloneWith`</a>
154 * <a href="#_conformstoobject-source">`_.conformsTo`</a>
155 * <a href="#_eqvalue-other">`_.eq`</a>
156 * <a href="#_gtvalue-other">`_.gt`</a>
157 * <a href="#_gtevalue-other">`_.gte`</a>
158 * <a href="#_isargumentsvalue">`_.isArguments`</a>
159 * <a href="#_isarrayvalue">`_.isArray`</a>
160 * <a href="#_isarraybuffervalue">`_.isArrayBuffer`</a>
161 * <a href="#_isarraylikevalue">`_.isArrayLike`</a>
162 * <a href="#_isarraylikeobjectvalue">`_.isArrayLikeObject`</a>
163 * <a href="#_isbooleanvalue">`_.isBoolean`</a>
164 * <a href="#_isbuffervalue">`_.isBuffer`</a>
165 * <a href="#_isdatevalue">`_.isDate`</a>
166 * <a href="#_iselementvalue">`_.isElement`</a>
167 * <a href="#_isemptyvalue">`_.isEmpty`</a>
168 * <a href="#_isequalvalue-other">`_.isEqual`</a>
169 * <a href="#_isequalwithvalue-other-customizer">`_.isEqualWith`</a>
170 * <a href="#_iserrorvalue">`_.isError`</a>
171 * <a href="#_isfinitevalue">`_.isFinite`</a>
172 * <a href="#_isfunctionvalue">`_.isFunction`</a>
173 * <a href="#_isintegervalue">`_.isInteger`</a>
174 * <a href="#_islengthvalue">`_.isLength`</a>
175 * <a href="#_ismapvalue">`_.isMap`</a>
176 * <a href="#_ismatchobject-source">`_.isMatch`</a>
177 * <a href="#_ismatchwithobject-source-customizer">`_.isMatchWith`</a>
178 * <a href="#_isnanvalue">`_.isNaN`</a>
179 * <a href="#_isnativevalue">`_.isNative`</a>
180 * <a href="#_isnilvalue">`_.isNil`</a>
181 * <a href="#_isnullvalue">`_.isNull`</a>
182 * <a href="#_isnumbervalue">`_.isNumber`</a>
183 * <a href="#_isobjectvalue">`_.isObject`</a>
184 * <a href="#_isobjectlikevalue">`_.isObjectLike`</a>
185 * <a href="#_isplainobjectvalue">`_.isPlainObject`</a>
186 * <a href="#_isregexpvalue">`_.isRegExp`</a>
187 * <a href="#_issafeintegervalue">`_.isSafeInteger`</a>
188 * <a href="#_issetvalue">`_.isSet`</a>
189 * <a href="#_isstringvalue">`_.isString`</a>
190 * <a href="#_issymbolvalue">`_.isSymbol`</a>
191 * <a href="#_istypedarrayvalue">`_.isTypedArray`</a>
192 * <a href="#_isundefinedvalue">`_.isUndefined`</a>
193 * <a href="#_isweakmapvalue">`_.isWeakMap`</a>
194 * <a href="#_isweaksetvalue">`_.isWeakSet`</a>
195 * <a href="#_ltvalue-other">`_.lt`</a>
196 * <a href="#_ltevalue-other">`_.lte`</a>
197 * <a href="#_toarrayvalue">`_.toArray`</a>
198 * <a href="#_tofinitevalue">`_.toFinite`</a>
199 * <a href="#_tointegervalue">`_.toInteger`</a>
200 * <a href="#_tolengthvalue">`_.toLength`</a>
201 * <a href="#_tonumbervalue">`_.toNumber`</a>
202 * <a href="#_toplainobjectvalue">`_.toPlainObject`</a>
203 * <a href="#_tosafeintegervalue">`_.toSafeInteger`</a>
204 * <a href="#_tostringvalue">`_.toString`</a>
211 * <a href="#_addaugend-addend">`_.add`</a>
212 * <a href="#_ceilnumber-precision0">`_.ceil`</a>
213 * <a href="#_dividedividend-divisor">`_.divide`</a>
214 * <a href="#_floornumber-precision0">`_.floor`</a>
215 * <a href="#_maxarray">`_.max`</a>
216 * <a href="#_maxbyarray-iteratee_identity">`_.maxBy`</a>
217 * <a href="#_meanarray">`_.mean`</a>
218 * <a href="#_meanbyarray-iteratee_identity">`_.meanBy`</a>
219 * <a href="#_minarray">`_.min`</a>
220 * <a href="#_minbyarray-iteratee_identity">`_.minBy`</a>
221 * <a href="#_multiplymultiplier-multiplicand">`_.multiply`</a>
222 * <a href="#_roundnumber-precision0">`_.round`</a>
223 * <a href="#_subtractminuend-subtrahend">`_.subtract`</a>
224 * <a href="#_sumarray">`_.sum`</a>
225 * <a href="#_sumbyarray-iteratee_identity">`_.sumBy`</a>
232 * <a href="#_clampnumber-lower-upper">`_.clamp`</a>
233 * <a href="#_inrangenumber-start0-end">`_.inRange`</a>
234 * <a href="#_randomlower0-upper1-floating">`_.random`</a>
241 * <a href="#_assignobject-sources">`_.assign`</a>
242 * <a href="#_assigninobject-sources">`_.assignIn`</a>
243 * <a href="#_assigninwithobject-sources-customizer">`_.assignInWith`</a>
244 * <a href="#_assignwithobject-sources-customizer">`_.assignWith`</a>
245 * <a href="#_atobject-paths">`_.at`</a>
246 * <a href="#_createprototype-properties">`_.create`</a>
247 * <a href="#_defaultsobject-sources">`_.defaults`</a>
248 * <a href="#_defaultsdeepobject-sources">`_.defaultsDeep`</a>
249 * <a href="#_topairsobject" class="alias">`_.entries` -> `toPairs`</a>
250 * <a href="#_topairsinobject" class="alias">`_.entriesIn` -> `toPairsIn`</a>
251 * <a href="#_assigninobject-sources" class="alias">`_.extend` -> `assignIn`</a>
252 * <a href="#_assigninwithobject-sources-customizer" class="alias">`_.extendWith` -> `assignInWith`<…
253 * <a href="#_findkeyobject-predicate_identity">`_.findKey`</a>
254 * <a href="#_findlastkeyobject-predicate_identity">`_.findLastKey`</a>
255 * <a href="#_forinobject-iteratee_identity">`_.forIn`</a>
256 * <a href="#_forinrightobject-iteratee_identity">`_.forInRight`</a>
257 * <a href="#_forownobject-iteratee_identity">`_.forOwn`</a>
258 * <a href="#_forownrightobject-iteratee_identity">`_.forOwnRight`</a>
259 * <a href="#_functionsobject">`_.functions`</a>
260 * <a href="#_functionsinobject">`_.functionsIn`</a>
261 * <a href="#_getobject-path-defaultvalue">`_.get`</a>
262 * <a href="#_hasobject-path">`_.has`</a>
263 * <a href="#_hasinobject-path">`_.hasIn`</a>
264 * <a href="#_invertobject">`_.invert`</a>
265 * <a href="#_invertbyobject-iteratee_identity">`_.invertBy`</a>
266 * <a href="#_invokeobject-path-args">`_.invoke`</a>
267 * <a href="#_keysobject">`_.keys`</a>
268 * <a href="#_keysinobject">`_.keysIn`</a>
269 * <a href="#_mapkeysobject-iteratee_identity">`_.mapKeys`</a>
270 * <a href="#_mapvaluesobject-iteratee_identity">`_.mapValues`</a>
271 * <a href="#_mergeobject-sources">`_.merge`</a>
272 * <a href="#_mergewithobject-sources-customizer">`_.mergeWith`</a>
273 * <a href="#_omitobject-paths">`_.omit`</a>
274 * <a href="#_omitbyobject-predicate_identity">`_.omitBy`</a>
275 * <a href="#_pickobject-paths">`_.pick`</a>
276 * <a href="#_pickbyobject-predicate_identity">`_.pickBy`</a>
277 * <a href="#_resultobject-path-defaultvalue">`_.result`</a>
278 * <a href="#_setobject-path-value">`_.set`</a>
279 * <a href="#_setwithobject-path-value-customizer">`_.setWith`</a>
280 * <a href="#_topairsobject">`_.toPairs`</a>
281 * <a href="#_topairsinobject">`_.toPairsIn`</a>
282 * <a href="#_transformobject-iteratee_identity-accumulator">`_.transform`</a>
283 * <a href="#_unsetobject-path">`_.unset`</a>
284 * <a href="#_updateobject-path-updater">`_.update`</a>
285 * <a href="#_updatewithobject-path-updater-customizer">`_.updateWith`</a>
286 * <a href="#_valuesobject">`_.values`</a>
287 * <a href="#_valuesinobject">`_.valuesIn`</a>
294 * <a href="#_value">`_`</a>
295 * <a href="#_chainvalue">`_.chain`</a>
296 * <a href="#_tapvalue-interceptor">`_.tap`</a>
297 * <a href="#_thruvalue-interceptor">`_.thru`</a>
298 * <a href="#_prototypesymboliterator">`_.prototype[Symbol.iterator]`</a>
299 * <a href="#_prototypeatpaths">`_.prototype.at`</a>
300 * <a href="#_prototypechain">`_.prototype.chain`</a>
301 * <a href="#_prototypecommit">`_.prototype.commit`</a>
302 * <a href="#_prototypenext">`_.prototype.next`</a>
303 * <a href="#_prototypeplantvalue">`_.prototype.plant`</a>
304 * <a href="#_prototypereverse">`_.prototype.reverse`</a>
305 * <a href="#_prototypevalue" class="alias">`_.prototype.toJSON` -> `value`</a>
306 * <a href="#_prototypevalue">`_.prototype.value`</a>
307 * <a href="#_prototypevalue" class="alias">`_.prototype.valueOf` -> `value`</a>
314 * <a href="#_camelcasestring">`_.camelCase`</a>
315 * <a href="#_capitalizestring">`_.capitalize`</a>
316 * <a href="#_deburrstring">`_.deburr`</a>
317 * <a href="#_endswithstring-target-positionstringlength">`_.endsWith`</a>
318 * <a href="#_escapestring">`_.escape`</a>
319 * <a href="#_escaperegexpstring">`_.escapeRegExp`</a>
320 * <a href="#_kebabcasestring">`_.kebabCase`</a>
321 * <a href="#_lowercasestring">`_.lowerCase`</a>
322 * <a href="#_lowerfirststring">`_.lowerFirst`</a>
323 * <a href="#_padstring-length0-chars">`_.pad`</a>
324 * <a href="#_padendstring-length0-chars">`_.padEnd`</a>
325 * <a href="#_padstartstring-length0-chars">`_.padStart`</a>
326 * <a href="#_parseintstring-radix10">`_.parseInt`</a>
327 * <a href="#_repeatstring-n1">`_.repeat`</a>
328 * <a href="#_replacestring-pattern-replacement">`_.replace`</a>
329 * <a href="#_snakecasestring">`_.snakeCase`</a>
330 * <a href="#_splitstring-separator-limit">`_.split`</a>
331 * <a href="#_startcasestring">`_.startCase`</a>
332 * <a href="#_startswithstring-target-position0">`_.startsWith`</a>
333 * <a href="#_templatestring-options">`_.template`</a>
334 * <a href="#_tolowerstring">`_.toLower`</a>
335 * <a href="#_toupperstring">`_.toUpper`</a>
336 * <a href="#_trimstring-charswhitespace">`_.trim`</a>
337 * <a href="#_trimendstring-charswhitespace">`_.trimEnd`</a>
338 * <a href="#_trimstartstring-charswhitespace">`_.trimStart`</a>
339 * <a href="#_truncatestring-options">`_.truncate`</a>
340 * <a href="#_unescapestring">`_.unescape`</a>
341 * <a href="#_uppercasestring">`_.upperCase`</a>
342 * <a href="#_upperfirststring">`_.upperFirst`</a>
343 * <a href="#_wordsstring-pattern">`_.words`</a>
350 * <a href="#_attemptfunc-args">`_.attempt`</a>
351 * <a href="#_bindallobject-methodnames">`_.bindAll`</a>
352 * <a href="#_condpairs">`_.cond`</a>
353 * <a href="#_conformssource">`_.conforms`</a>
354 * <a href="#_constantvalue">`_.constant`</a>
355 * <a href="#_defaulttovalue-defaultvalue">`_.defaultTo`</a>
356 * <a href="#_flowfuncs">`_.flow`</a>
357 * <a href="#_flowrightfuncs">`_.flowRight`</a>
358 * <a href="#_identityvalue">`_.identity`</a>
359 * <a href="#_iterateefunc_identity">`_.iteratee`</a>
360 * <a href="#_matchessource">`_.matches`</a>
361 * <a href="#_matchespropertypath-srcvalue">`_.matchesProperty`</a>
362 * <a href="#_methodpath-args">`_.method`</a>
363 * <a href="#_methodofobject-args">`_.methodOf`</a>
364 * <a href="#_mixinobjectlodash-source-options">`_.mixin`</a>
365 * <a href="#_noconflict">`_.noConflict`</a>
366 * <a href="#_noop">`_.noop`</a>
367 * <a href="#_nthargn0">`_.nthArg`</a>
368 * <a href="#_overiteratees_identity">`_.over`</a>
369 * <a href="#_overeverypredicates_identity">`_.overEvery`</a>
370 * <a href="#_oversomepredicates_identity">`_.overSome`</a>
371 * <a href="#_propertypath">`_.property`</a>
372 * <a href="#_propertyofobject">`_.propertyOf`</a>
373 * <a href="#_rangestart0-end-step1">`_.range`</a>
374 * <a href="#_rangerightstart0-end-step1">`_.rangeRight`</a>
375 * <a href="#_runincontextcontextroot">`_.runInContext`</a>
376 * <a href="#_stubarray">`_.stubArray`</a>
377 * <a href="#_stubfalse">`_.stubFalse`</a>
378 * <a href="#_stubobject">`_.stubObject`</a>
379 * <a href="#_stubstring">`_.stubString`</a>
380 * <a href="#_stubtrue">`_.stubTrue`</a>
381 * <a href="#_timesn-iteratee_identity">`_.times`</a>
382 * <a href="#_topathvalue">`_.toPath`</a>
383 * <a href="#_uniqueidprefix">`_.uniqueId`</a>
390 * <a href="#_version">`_.VERSION`</a>
391 * <a href="#_templatesettings">`_.templateSettings`</a>
392 * <a href="#_templatesettingsescape">`_.templateSettings.escape`</a>
393 * <a href="#_templatesettingsevaluate">`_.templateSettings.evaluate`</a>
394 * <a href="#_templatesettingsimports">`_.templateSettings.imports`</a>
395 * <a href="#_templatesettingsinterpolate">`_.templateSettings.interpolate`</a>
396 * <a href="#_templatesettingsvariable">`_.templateSettings.variable`</a>
403 * <a href="#_templatesettingsimports_">`_.templateSettings.imports._`</a>
417 <h3 id="_chunkarray-size1"><code>_.chunk(array, [size=1])</code></h3>
436 _.chunk(['a', 'b', 'c', 'd'], 2);
439 _.chunk(['a', 'b', 'c', 'd'], 3);
448 <h3 id="_compactarray"><code>_.compact(array)</code></h3>
465 _.compact([0, 1, false, 2, '', 3]);
474 <h3 id="_concatarray-values"><code>_.concat(array, [values])</code></h3>
493 var other = _.concat(array, 2, [3], [[4]]);
507 <h3 id="_differencearray-values"><code>_.difference(array, [values])</code></h3>
516 **Note:** Unlike `_.pullAll`, this method returns a new array.
530 _.difference([2, 1], [2, 3]);
539 …id="_differencebyarray-values-iteratee_identity"><code>_.differenceBy(array, [values], [iteratee=_…
542 This method is like `_.difference` except that it accepts `iteratee` which
549 **Note:** Unlike `_.pullAllBy`, this method returns a new array.
557 3. `[iteratee=_.identity]` *(Function)*: The iteratee invoked per element.
564 _.differenceBy([2.1, 1.2], [2.3, 3.4], Math.floor);
567 // The `_.property` iteratee shorthand.
568 _.differenceBy([{ 'x': 2 }, { 'x': 1 }], [{ 'x': 1 }], 'x');
577 <h3 id="_differencewitharray-values-comparator"><code>_.differenceWith(array, [values], [comparator…
580 This method is like `_.difference` except that it accepts `comparator`
586 **Note:** Unlike `_.pullAllWith`, this method returns a new array.
603 _.differenceWith(objects, [{ 'x': 1, 'y': 2 }], _.isEqual);
612 <h3 id="_droparray-n1"><code>_.drop(array, [n=1])</code></h3>
629 _.drop([1, 2, 3]);
632 _.drop([1, 2, 3], 2);
635 _.drop([1, 2, 3], 5);
638 _.drop([1, 2, 3], 0);
647 <h3 id="_droprightarray-n1"><code>_.dropRight(array, [n=1])</code></h3>
664 _.dropRight([1, 2, 3]);
667 _.dropRight([1, 2, 3], 2);
670 _.dropRight([1, 2, 3], 5);
673 _.dropRight([1, 2, 3], 0);
682 <h3 id="_droprightwhilearray-predicate_identity"><code>_.dropRightWhile(array, [predicate=_.identit…
694 2. `[predicate=_.identity]` *(Function)*: The function invoked per iteration.
707 _.dropRightWhile(users, function(o) { return !o.active; });
710 // The `_.matches` iteratee shorthand.
711 _.dropRightWhile(users, { 'user': 'pebbles', 'active': false });
714 // The `_.matchesProperty` iteratee shorthand.
715 _.dropRightWhile(users, ['active', false]);
718 // The `_.property` iteratee shorthand.
719 _.dropRightWhile(users, 'active');
728 <h3 id="_dropwhilearray-predicate_identity"><code>_.dropWhile(array, [predicate=_.identity])</code>…
740 2. `[predicate=_.identity]` *(Function)*: The function invoked per iteration.
753 _.dropWhile(users, function(o) { return !o.active; });
756 // The `_.matches` iteratee shorthand.
757 _.dropWhile(users, { 'user': 'barney', 'active': false });
760 // The `_.matchesProperty` iteratee shorthand.
761 _.dropWhile(users, ['active', false]);
764 // The `_.property` iteratee shorthand.
765 _.dropWhile(users, 'active');
774 <h3 id="_fillarray-value-start0-endarraylength"><code>_.fill(array, value, [start=0], [end=array.le…
799 _.fill(array, 'a');
803 _.fill(Array(3), 2);
806 _.fill([4, 6, 8, 10], '*', 1, 3);
815 <h3 id="_findindexarray-predicate_identity-fromindex0"><code>_.findIndex(array, [predicate=_.identi…
818 This method is like `_.find` except that it returns the index of the first
826 2. `[predicate=_.identity]` *(Function)*: The function invoked per iteration.
840 _.findIndex(users, function(o) { return o.user == 'barney'; });
843 // The `_.matches` iteratee shorthand.
844 _.findIndex(users, { 'user': 'fred', 'active': false });
847 // The `_.matchesProperty` iteratee shorthand.
848 _.findIndex(users, ['active', false]);
851 // The `_.property` iteratee shorthand.
852 _.findIndex(users, 'active');
861 …ndexarray-predicate_identity-fromindexarraylength-1"><code>_.findLastIndex(array, [predicate=_.ide…
864 This method is like `_.findIndex` except that it iterates over elements
872 2. `[predicate=_.identity]` *(Function)*: The function invoked per iteration.
886 _.findLastIndex(users, function(o) { return o.user == 'pebbles'; });
889 // The `_.matches` iteratee shorthand.
890 _.findLastIndex(users, { 'user': 'barney', 'active': true });
893 // The `_.matchesProperty` iteratee shorthand.
894 _.findLastIndex(users, ['active', false]);
897 // The `_.property` iteratee shorthand.
898 _.findLastIndex(users, 'active');
907 <h3 id="_flattenarray"><code>_.flatten(array)</code></h3>
923 _.flatten([1, [2, [3, [4]], 5]]);
932 <h3 id="_flattendeeparray"><code>_.flattenDeep(array)</code></h3>
948 _.flattenDeep([1, [2, [3, [4]], 5]]);
957 <h3 id="_flattendeptharray-depth1"><code>_.flattenDepth(array, [depth=1])</code></h3>
976 _.flattenDepth(array, 1);
979 _.flattenDepth(array, 2);
988 <h3 id="_frompairspairs"><code>_.fromPairs(pairs)</code></h3>
991 The inverse of `_.toPairs`; this method returns an object composed
1005 _.fromPairs([['a', 1], ['b', 2]]);
1014 <h3 id="_headarray"><code>_.head(array)</code></h3>
1023 *_.first*
1033 _.head([1, 2, 3]);
1036 _.head([]);
1045 <h3 id="_indexofarray-value-fromindex0"><code>_.indexOf(array, value, [fromIndex=0])</code></h3>
1066 _.indexOf([1, 2, 1, 2], 2);
1070 _.indexOf([1, 2, 1, 2], 2, 2);
1079 <h3 id="_initialarray"><code>_.initial(array)</code></h3>
1095 _.initial([1, 2, 3]);
1104 <h3 id="_intersectionarrays"><code>_.intersection([arrays])</code></h3>
1123 _.intersection([2, 1], [2, 3]);
1132 <h3 id="_intersectionbyarrays-iteratee_identity"><code>_.intersectionBy([arrays], [iteratee=_.ident…
1135 This method is like `_.intersection` except that it accepts `iteratee`
1146 2. `[iteratee=_.identity]` *(Function)*: The iteratee invoked per element.
1153 _.intersectionBy([2.1, 1.2], [2.3, 3.4], Math.floor);
1156 // The `_.property` iteratee shorthand.
1157 _.intersectionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
1166 <h3 id="_intersectionwitharrays-comparator"><code>_.intersectionWith([arrays], [comparator])</code>…
1169 This method is like `_.intersection` except that it accepts `comparator`
1189 _.intersectionWith(objects, others, _.isEqual);
1198 <h3 id="_joinarray-separator-"><code>_.join(array, [separator=','])</code></h3>
1215 _.join(['a', 'b', 'c'], '~');
1224 <h3 id="_lastarray"><code>_.last(array)</code></h3>
1240 _.last([1, 2, 3]);
1249 <h3 id="_lastindexofarray-value-fromindexarraylength-1"><code>_.lastIndexOf(array, value, [fromInde…
1252 This method is like `_.indexOf` except that it iterates over elements of
1268 _.lastIndexOf([1, 2, 1, 2], 2);
1272 _.lastIndexOf([1, 2, 1, 2], 2, 2);
1281 <h3 id="_ntharray-n0"><code>_.nth(array, [n=0])</code></h3>
1301 _.nth(array, 1);
1304 _.nth(array, -2);
1313 <h3 id="_pullarray-values"><code>_.pull(array, [values])</code></h3>
1321 **Note:** Unlike `_.without`, this method mutates `array`. Use `_.remove`
1338 _.pull(array, 'a', 'c');
1348 <h3 id="_pullallarray-values"><code>_.pullAll(array, values)</code></h3>
1351 This method is like `_.pull` except that it accepts an array of values to remove.
1354 **Note:** Unlike `_.difference`, this method mutates `array`.
1370 _.pullAll(array, ['a', 'c']);
1380 <h3 id="_pullallbyarray-values-iteratee_identity"><code>_.pullAllBy(array, values, [iteratee=_.iden…
1383 This method is like `_.pullAll` except that it accepts `iteratee` which is
1388 **Note:** Unlike `_.differenceBy`, this method mutates `array`.
1396 3. `[iteratee=_.identity]` *(Function)*: The iteratee invoked per element.
1405 _.pullAllBy(array, [{ 'x': 1 }, { 'x': 3 }], 'x');
1415 <h3 id="_pullallwitharray-values-comparator"><code>_.pullAllWith(array, values, [comparator])</code…
1418 This method is like `_.pullAll` except that it accepts `comparator` which
1423 **Note:** Unlike `_.differenceWith`, this method mutates `array`.
1440 _.pullAllWith(array, [{ 'x': 3, 'y': 4 }], _.isEqual);
1450 <h3 id="_pullatarray-indexes"><code>_.pullAt(array, [indexes])</code></h3>
1457 **Note:** Unlike `_.at`, this method mutates `array`.
1472 var pulled = _.pullAt(array, [1, 3]);
1486 <h3 id="_removearray-predicate_identity"><code>_.remove(array, [predicate=_.identity])</code></h3>
1494 **Note:** Unlike `_.filter`, this method mutates `array`. Use `_.pull`
1502 2. `[predicate=_.identity]` *(Function)*: The function invoked per iteration.
1510 var evens = _.remove(array, function(n) {
1526 <h3 id="_reversearray"><code>_.reverse(array)</code></h3>
1549 _.reverse(array);
1561 <h3 id="_slicearray-start0-endarraylength"><code>_.slice(array, [start=0], [end=array.length])</cod…
1588 <h3 id="_sortedindexarray-value"><code>_.sortedIndex(array, value)</code></h3>
1606 _.sortedIndex([30, 50], 40);
1615 … id="_sortedindexbyarray-value-iteratee_identity"><code>_.sortedIndexBy(array, value, [iteratee=_.…
1618 This method is like `_.sortedIndex` except that it accepts `iteratee`
1628 3. `[iteratee=_.identity]` *(Function)*: The iteratee invoked per element.
1637 _.sortedIndexBy(objects, { 'x': 4 }, function(o) { return o.x; });
1640 // The `_.property` iteratee shorthand.
1641 _.sortedIndexBy(objects, { 'x': 4 }, 'x');
1650 <h3 id="_sortedindexofarray-value"><code>_.sortedIndexOf(array, value)</code></h3>
1653 This method is like `_.indexOf` except that it performs a binary
1668 _.sortedIndexOf([4, 5, 5, 5, 6], 5);
1677 <h3 id="_sortedlastindexarray-value"><code>_.sortedLastIndex(array, value)</code></h3>
1680 This method is like `_.sortedIndex` except that it returns the highest
1696 _.sortedLastIndex([4, 5, 5, 5, 6], 5);
1705 …sortedlastindexbyarray-value-iteratee_identity"><code>_.sortedLastIndexBy(array, value, [iteratee=…
1708 This method is like `_.sortedLastIndex` except that it accepts `iteratee`
1718 3. `[iteratee=_.identity]` *(Function)*: The iteratee invoked per element.
1727 _.sortedLastIndexBy(objects, { 'x': 4 }, function(o) { return o.x; });
1730 // The `_.property` iteratee shorthand.
1731 _.sortedLastIndexBy(objects, { 'x': 4 }, 'x');
1740 <h3 id="_sortedlastindexofarray-value"><code>_.sortedLastIndexOf(array, value)</code></h3>
1743 This method is like `_.lastIndexOf` except that it performs a binary
1758 _.sortedLastIndexOf([4, 5, 5, 5, 6], 5);
1767 <h3 id="_sorteduniqarray"><code>_.sortedUniq(array)</code></h3>
1770 This method is like `_.uniq` except that it's designed and optimized
1784 _.sortedUniq([1, 1, 2]);
1793 <h3 id="_sorteduniqbyarray-iteratee"><code>_.sortedUniqBy(array, [iteratee])</code></h3>
1796 This method is like `_.uniqBy` except that it's designed and optimized
1811 _.sortedUniqBy([1.1, 1.2, 2.3, 2.4], Math.floor);
1820 <h3 id="_tailarray"><code>_.tail(array)</code></h3>
1836 _.tail([1, 2, 3]);
1845 <h3 id="_takearray-n1"><code>_.take(array, [n=1])</code></h3>
1862 _.take([1, 2, 3]);
1865 _.take([1, 2, 3], 2);
1868 _.take([1, 2, 3], 5);
1871 _.take([1, 2, 3], 0);
1880 <h3 id="_takerightarray-n1"><code>_.takeRight(array, [n=1])</code></h3>
1897 _.takeRight([1, 2, 3]);
1900 _.takeRight([1, 2, 3], 2);
1903 _.takeRight([1, 2, 3], 5);
1906 _.takeRight([1, 2, 3], 0);
1915 <h3 id="_takerightwhilearray-predicate_identity"><code>_.takeRightWhile(array, [predicate=_.identit…
1927 2. `[predicate=_.identity]` *(Function)*: The function invoked per iteration.
1940 _.takeRightWhile(users, function(o) { return !o.active; });
1943 // The `_.matches` iteratee shorthand.
1944 _.takeRightWhile(users, { 'user': 'pebbles', 'active': false });
1947 // The `_.matchesProperty` iteratee shorthand.
1948 _.takeRightWhile(users, ['active', false]);
1951 // The `_.property` iteratee shorthand.
1952 _.takeRightWhile(users, 'active');
1961 <h3 id="_takewhilearray-predicate_identity"><code>_.takeWhile(array, [predicate=_.identity])</code>…
1973 2. `[predicate=_.identity]` *(Function)*: The function invoked per iteration.
1986 _.takeWhile(users, function(o) { return !o.active; });
1989 // The `_.matches` iteratee shorthand.
1990 _.takeWhile(users, { 'user': 'barney', 'active': false });
1993 // The `_.matchesProperty` iteratee shorthand.
1994 _.takeWhile(users, ['active', false]);
1997 // The `_.property` iteratee shorthand.
1998 _.takeWhile(users, 'active');
2007 <h3 id="_unionarrays"><code>_.union([arrays])</code></h3>
2025 _.union([2], [1, 2]);
2034 <h3 id="_unionbyarrays-iteratee_identity"><code>_.unionBy([arrays], [iteratee=_.identity])</code></…
2037 This method is like `_.union` except that it accepts `iteratee` which is
2048 2. `[iteratee=_.identity]` *(Function)*: The iteratee invoked per element.
2055 _.unionBy([2.1], [1.2, 2.3], Math.floor);
2058 // The `_.property` iteratee shorthand.
2059 _.unionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
2068 <h3 id="_unionwitharrays-comparator"><code>_.unionWith([arrays], [comparator])</code></h3>
2071 This method is like `_.union` except that it accepts `comparator` which
2091 _.unionWith(objects, others, _.isEqual);
2100 <h3 id="_uniqarray"><code>_.uniq(array)</code></h3>
2120 _.uniq([2, 1, 2]);
2129 <h3 id="_uniqbyarray-iteratee_identity"><code>_.uniqBy(array, [iteratee=_.identity])</code></h3>
2132 This method is like `_.uniq` except that it accepts `iteratee` which is
2143 2. `[iteratee=_.identity]` *(Function)*: The iteratee invoked per element.
2150 _.uniqBy([2.1, 1.2, 2.3], Math.floor);
2153 // The `_.property` iteratee shorthand.
2154 _.uniqBy([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x');
2163 <h3 id="_uniqwitharray-comparator"><code>_.uniqWith(array, [comparator])</code></h3>
2166 This method is like `_.uniq` except that it accepts `comparator` which
2185 _.uniqWith(objects, _.isEqual);
2194 <h3 id="_unziparray"><code>_.unzip(array)</code></h3>
2197 This method is like `_.zip` except that it accepts an array of grouped
2212 var zipped = _.zip(['a', 'b'], [1, 2], [true, false]);
2215 _.unzip(zipped);
2224 <h3 id="_unzipwitharray-iteratee_identity"><code>_.unzipWith(array, [iteratee=_.identity])</code></…
2227 This method is like `_.unzip` except that it accepts `iteratee` to specify
2236 2. `[iteratee=_.identity]` *(Function)*: The function to combine regrouped values.
2243 var zipped = _.zip([1, 2], [10, 20], [100, 200]);
2246 _.unzipWith(zipped, _.add);
2255 <h3 id="_withoutarray-values"><code>_.without(array, [values])</code></h3>
2263 **Note:** Unlike `_.pull`, this method returns a new array.
2277 _.without([2, 1, 2, 3], 1, 2);
2286 <h3 id="_xorarrays"><code>_.xor([arrays])</code></h3>
2305 _.xor([2, 1], [2, 3]);
2314 <h3 id="_xorbyarrays-iteratee_identity"><code>_.xorBy([arrays], [iteratee=_.identity])</code></h3>
2317 This method is like `_.xor` except that it accepts `iteratee` which is
2328 2. `[iteratee=_.identity]` *(Function)*: The iteratee invoked per element.
2335 _.xorBy([2.1, 1.2], [2.3, 3.4], Math.floor);
2338 // The `_.property` iteratee shorthand.
2339 _.xorBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');
2348 <h3 id="_xorwitharrays-comparator"><code>_.xorWith([arrays], [comparator])</code></h3>
2351 This method is like `_.xor` except that it accepts `comparator` which is
2371 _.xorWith(objects, others, _.isEqual);
2380 <h3 id="_ziparrays"><code>_.zip([arrays])</code></h3>
2398 _.zip(['a', 'b'], [1, 2], [true, false]);
2407 <h3 id="_zipobjectprops-values"><code>_.zipObject([props=[]], [values=[]])</code></h3>
2410 This method is like `_.fromPairs` except that it accepts two arrays,
2425 _.zipObject(['a', 'b'], [1, 2]);
2434 <h3 id="_zipobjectdeepprops-values"><code>_.zipObjectDeep([props=[]], [values=[]])</code></h3>
2437 This method is like `_.zipObject` except that it supports property paths.
2451 _.zipObjectDeep(['a.b[0].c', 'a.b[1].d'], [1, 2]);
2460 <h3 id="_zipwitharrays-iteratee_identity"><code>_.zipWith([arrays], [iteratee=_.identity])</code></…
2463 This method is like `_.zip` except that it accepts `iteratee` to specify
2472 2. `[iteratee=_.identity]` *(Function)*: The function to combine grouped values.
2479 _.zipWith([1, 2], [10, 20], [100, 200], function(a, b, c) {
2496 <h3 id="_countbycollection-iteratee_identity"><code>_.countBy(collection, [iteratee=_.identity])</c…
2509 2. `[iteratee=_.identity]` *(Function)*: The iteratee to transform keys.
2516 _.countBy([6.1, 4.2, 6.3], Math.floor);
2519 // The `_.property` iteratee shorthand.
2520 _.countBy(['one', 'two', 'three'], 'length');
2529 <h3 id="_everycollection-predicate_identity"><code>_.every(collection, [predicate=_.identity])</cod…
2547 2. `[predicate=_.identity]` *(Function)*: The function invoked per iteration.
2554 _.every([true, 1, null, 'yes'], Boolean);
2562 // The `_.matches` iteratee shorthand.
2563 _.every(users, { 'user': 'barney', 'active': false });
2566 // The `_.matchesProperty` iteratee shorthand.
2567 _.every(users, ['active', false]);
2570 // The `_.property` iteratee shorthand.
2571 _.every(users, 'active');
2580 <h3 id="_filtercollection-predicate_identity"><code>_.filter(collection, [predicate=_.identity])</c…
2588 **Note:** Unlike `_.remove`, this method returns a new array.
2595 2. `[predicate=_.identity]` *(Function)*: The function invoked per iteration.
2607 _.filter(users, function(o) { return !o.active; });
2610 // The `_.matches` iteratee shorthand.
2611 _.filter(users, { 'age': 36, 'active': true });
2614 // The `_.matchesProperty` iteratee shorthand.
2615 _.filter(users, ['active', false]);
2618 // The `_.property` iteratee shorthand.
2619 _.filter(users, 'active');
2628 <h3 id="_findcollection-predicate_identity-fromindex0"><code>_.find(collection, [predicate=_.identi…
2640 2. `[predicate=_.identity]` *(Function)*: The function invoked per iteration.
2654 _.find(users, function(o) { return o.age < 40; });
2657 // The `_.matches` iteratee shorthand.
2658 _.find(users, { 'age': 1, 'active': true });
2661 // The `_.matchesProperty` iteratee shorthand.
2662 _.find(users, ['active', false]);
2665 // The `_.property` iteratee shorthand.
2666 _.find(users, 'active');
2675 …tion-predicate_identity-fromindexcollectionlength-1"><code>_.findLast(collection, [predicate=_.ide…
2678 This method is like `_.find` except that it iterates over elements of
2686 2. `[predicate=_.identity]` *(Function)*: The function invoked per iteration.
2694 _.findLast([1, 2, 3, 4], function(n) {
2705 <h3 id="_flatmapcollection-iteratee_identity"><code>_.flatMap(collection, [iteratee=_.identity])</c…
2717 2. `[iteratee=_.identity]` *(Function)*: The function invoked per iteration.
2728 _.flatMap([1, 2], duplicate);
2737 <h3 id="_flatmapdeepcollection-iteratee_identity"><code>_.flatMapDeep(collection, [iteratee=_.ident…
2740 This method is like `_.flatMap` except that it recursively flattens the
2748 2. `[iteratee=_.identity]` *(Function)*: The function invoked per iteration.
2759 _.flatMapDeep([1, 2], duplicate);
2768 …"_flatmapdepthcollection-iteratee_identity-depth1"><code>_.flatMapDepth(collection, [iteratee=_.id…
2771 This method is like `_.flatMap` except that it recursively flattens the
2779 2. `[iteratee=_.identity]` *(Function)*: The function invoked per iteration.
2791 _.flatMapDepth([1, 2], duplicate, 2);
2800 <h3 id="_foreachcollection-iteratee_identity"><code>_.forEach(collection, [iteratee=_.identity])</c…
2809 property are iterated like arrays. To avoid this behavior use `_.forIn`
2810 or `_.forOwn` for object iteration.
2816 *_.each*
2820 2. `[iteratee=_.identity]` *(Function)*: The function invoked per iteration.
2827 _.forEach([1, 2], function(value) {
2832 _.forEach({ 'a': 1, 'b': 2 }, function(value, key) {
2843 <h3 id="_foreachrightcollection-iteratee_identity"><code>_.forEachRight(collection, [iteratee=_.ide…
2846 This method is like `_.forEach` except that it iterates over elements of
2853 *_.eachRight*
2857 2. `[iteratee=_.identity]` *(Function)*: The function invoked per iteration.
2864 _.forEachRight([1, 2], function(value) {
2875 <h3 id="_groupbycollection-iteratee_identity"><code>_.groupBy(collection, [iteratee=_.identity])</c…
2889 2. `[iteratee=_.identity]` *(Function)*: The iteratee to transform keys.
2896 _.groupBy([6.1, 4.2, 6.3], Math.floor);
2899 // The `_.property` iteratee shorthand.
2900 _.groupBy(['one', 'two', 'three'], 'length');
2909 <h3 id="_includescollection-value-fromindex0"><code>_.includes(collection, value, [fromIndex=0])</c…
2931 _.includes([1, 2, 3], 1);
2934 _.includes([1, 2, 3], 1, 2);
2937 _.includes({ 'a': 1, 'b': 2 }, 1);
2940 _.includes('abcd', 'bc');
2949 <h3 id="_invokemapcollection-path-args"><code>_.invokeMap(collection, path, [args])</code></h3>
2970 _.invokeMap([[5, 1, 7], [3, 2, 1]], 'sort');
2973 _.invokeMap([123, 456], String.prototype.split, '');
2982 <h3 id="_keybycollection-iteratee_identity"><code>_.keyBy(collection, [iteratee=_.identity])</code>…
2995 2. `[iteratee=_.identity]` *(Function)*: The iteratee to transform keys.
3007 _.keyBy(array, function(o) {
3012 _.keyBy(array, 'dir');
3021 <h3 id="_mapcollection-iteratee_identity"><code>_.map(collection, [iteratee=_.identity])</code></h3>
3030 `_.every`, `_.filter`, `_.map`, `_.mapValues`, `_.reject`, and `_.some`.
3044 2. `[iteratee=_.identity]` *(Function)*: The function invoked per iteration.
3055 _.map([4, 8], square);
3058 _.map({ 'a': 4, 'b': 8 }, square);
3066 // The `_.property` iteratee shorthand.
3067 _.map(users, 'user');
3076 <h3 id="_orderbycollection-iteratees_identity-orders"><code>_.orderBy(collection, [iteratees=[_.ide…
3079 This method is like `_.sortBy` except that it allows specifying the sort
3089 2. `[iteratees=[_.identity]]` *(Array[]|Function[]|Object[]|string[]…
3105 _.orderBy(users, ['user', 'age'], ['asc', 'desc']);
3114 <h3 id="_partitioncollection-predicate_identity"><code>_.partition(collection, [predicate=_.identit…
3127 2. `[predicate=_.identity]` *(Function)*: The function invoked per iteration.
3140 _.partition(users, function(o) { return o.active; });
3143 // The `_.matches` iteratee shorthand.
3144 _.partition(users, { 'age': 1, 'active': false });
3147 // The `_.matchesProperty` iteratee shorthand.
3148 _.partition(users, ['active', false]);
3151 // The `_.property` iteratee shorthand.
3152 _.partition(users, 'active');
3161 <h3 id="_reducecollection-iteratee_identity-accumulator"><code>_.reduce(collection, [iteratee=_.ide…
3173 `_.reduce`, `_.reduceRight`, and `_.transform`.
3185 2. `[iteratee=_.identity]` *(Function)*: The function invoked per iteration.
3193 _.reduce([1, 2], function(sum, n) {
3198 _.reduce({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) {
3210 …educerightcollection-iteratee_identity-accumulator"><code>_.reduceRight(collection, [iteratee=_.id…
3213 This method is like `_.reduce` except that it iterates over elements of
3221 2. `[iteratee=_.identity]` *(Function)*: The function invoked per iteration.
3231 _.reduceRight(array, function(flattened, other) {
3242 <h3 id="_rejectcollection-predicate_identity"><code>_.reject(collection, [predicate=_.identity])</c…
3245 The opposite of `_.filter`; this method returns the elements of `collection`
3253 2. `[predicate=_.identity]` *(Function)*: The function invoked per iteration.
3265 _.reject(users, function(o) { return !o.active; });
3268 // The `_.matches` iteratee shorthand.
3269 _.reject(users, { 'age': 40, 'active': true });
3272 // The `_.matchesProperty` iteratee shorthand.
3273 _.reject(users, ['active', false]);
3276 // The `_.property` iteratee shorthand.
3277 _.reject(users, 'active');
3286 <h3 id="_samplecollection"><code>_.sample(collection)</code></h3>
3302 _.sample([1, 2, 3, 4]);
3311 <h3 id="_samplesizecollection-n1"><code>_.sampleSize(collection, [n=1])</code></h3>
3329 _.sampleSize([1, 2, 3], 2);
3332 _.sampleSize([1, 2, 3], 4);
3341 <h3 id="_shufflecollection"><code>_.shuffle(collection)</code></h3>
3358 _.shuffle([1, 2, 3, 4]);
3367 <h3 id="_sizecollection"><code>_.size(collection)</code></h3>
3384 _.size([1, 2, 3]);
3387 _.size({ 'a': 1, 'b': 2 });
3390 _.size('pebbles');
3399 <h3 id="_somecollection-predicate_identity"><code>_.some(collection, [predicate=_.identity])</code>…
3411 2. `[predicate=_.identity]` *(Function)*: The function invoked per iteration.
3418 _.some([null, 0, 'yes', false], Boolean);
3426 // The `_.matches` iteratee shorthand.
3427 _.some(users, { 'user': 'barney', 'active': false });
3430 // The `_.matchesProperty` iteratee shorthand.
3431 _.some(users, ['active', false]);
3434 // The `_.property` iteratee shorthand.
3435 _.some(users, 'active');
3444 <h3 id="_sortbycollection-iteratees_identity"><code>_.sortBy(collection, [iteratees=[_.identity]])<…
3457 2. `[iteratees=[_.identity]]` *(...(Function|Function[]))*: The iteratees to sort by.
3471 _.sortBy(users, [function(o) { return o.user; }]);
3474 _.sortBy(users, ['user', 'age']);
3489 <h3 id="_now"><code>_.now()</code></h3>
3503 _.defer(function(stamp) {
3504 console.log(_.now() - stamp);
3505 }, _.now());
3520 <h3 id="_aftern-func"><code>_.after(n, func)</code></h3>
3523 The opposite of `_.before`; this method creates a function that invokes
3540 var done = _.after(saves.length, function() {
3544 _.forEach(saves, function(type) {
3555 <h3 id="_aryfunc-nfunclength"><code>_.ary(func, [n=func.length])</code></h3>
3573 _.map(['6', '8', '10'], _.ary(parseInt, 1));
3582 <h3 id="_beforen-func"><code>_.before(n, func)</code></h3>
3601 jQuery(element).on('click', _.before(5, addContactToList));
3610 <h3 id="_bindfunc-thisarg-partials"><code>_.bind(func, thisArg, [partials])</code></h3>
3617 The `_.bind.placeholder` value, which defaults to `_` in monolithic builds,
3643 var bound = _.bind(greet, object, 'hi');
3648 var bound = _.bind(greet, object, _, '!');
3658 <h3 id="_bindkeyobject-key-partials"><code>_.bindKey(object, key, [partials])</code></h3>
3665 This method differs from `_.bind` by allowing bound functions to reference
3671 The `_.bindKey.placeholder` value, which defaults to `_` in monolithic
3694 var bound = _.bindKey(object, 'greet', 'hi');
3706 var bound = _.bindKey(object, 'greet', _, '!');
3716 <h3 id="_curryfunc-arityfunclength"><code>_.curry(func, [arity=func.length])</code></h3>
3726 The `_.curry.placeholder` value, which defaults to `_` in monolithic builds,
3748 var curried = _.curry(abc);
3760 curried(1)(_, 3)(2);
3769 <h3 id="_curryrightfunc-arityfunclength"><code>_.curryRight(func, [arity=func.length])</code></h3>
3772 This method is like `_.curry` except that arguments are applied to `func`
3773 in the manner of `_.partialRight` instead of `_.partial`.
3776 The `_.curryRight.placeholder` value, which defaults to `_` in monolithic
3798 var curried = _.curryRight(abc);
3810 curried(3)(1, _)(2);
3819 <h3 id="_debouncefunc-wait0-options"><code>_.debounce(func, [wait=0], [options={}])</code></h3>
3843 for details over the differences between `_.debounce` and `_.throttle`.
3862 jQuery(window).on('resize', _.debounce(calculateLayout, 150));
3865 jQuery(element).on('click', _.debounce(sendMail, 300, {
3871 var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });
3884 <h3 id="_deferfunc-args"><code>_.defer(func, [args])</code></h3>
3902 _.defer(function(text) {
3913 <h3 id="_delayfunc-wait-args"><code>_.delay(func, wait, [args])</code></h3>
3932 _.delay(function(text) {
3943 <h3 id="_flipfunc"><code>_.flip(func)</code></h3>
3959 var flipped = _.flip(function() {
3960 return _.toArray(arguments);
3972 <h3 id="_memoizefunc-resolver"><code>_.memoize(func, [resolver])</code></h3>
3983 function. Its creation may be customized by replacing the `_.memoize.Cache`
4003 var values = _.memoize(_.values);
4019 // Replace `_.memoize.Cache`.
4020 _.memoize.Cache = WeakMap;
4028 <h3 id="_negatepredicate"><code>_.negate(predicate)</code></h3>
4050 _.filter([1, 2, 3, 4, 5, 6], _.negate(isEven));
4059 <h3 id="_oncefunc"><code>_.once(func)</code></h3>
4077 var initialize = _.once(createApplication);
4088 <h3 id="_overargsfunc-transforms_identity"><code>_.overArgs(func, [transforms=[_.identity]])</code>…
4098 2. `[transforms=[_.identity]]` *(...(Function|Function[]))*: The argument transforms.
4113 var func = _.overArgs(function(x, y) {
4129 <h3 id="_partialfunc-partials"><code>_.partial(func, [partials])</code></h3>
4133 arguments it receives. This method is like `_.bind` except it does **not**
4137 The `_.partial.placeholder` value, which defaults to `_` in monolithic
4160 var sayHelloTo = _.partial(greet, 'hello');
4165 var greetFred = _.partial(greet, _, 'fred');
4175 <h3 id="_partialrightfunc-partials"><code>_.partialRight(func, [partials])</code></h3>
4178 This method is like `_.partial` except that partially applied arguments
4182 The `_.partialRight.placeholder` value, which defaults to `_` in monolithic
4205 var greetFred = _.partialRight(greet, 'fred');
4210 var sayHelloTo = _.partialRight(greet, 'hello', _);
4220 <h3 id="_reargfunc-indexes"><code>_.rearg(func, indexes)</code></h3>
4240 var rearged = _.rearg(function(a, b, c) {
4253 <h3 id="_restfunc-startfunclength-1"><code>_.rest(func, [start=func.length-1])</code></h3>
4276 var say = _.rest(function(what, names) {
4277 return what + ' ' + _.initial(names).join(', ') +
4278 (_.size(names) > 1 ? ', & ' : '') + _.last(names);
4290 <h3 id="_spreadfunc-start0"><code>_.spread(func, [start=0])</code></h3>
4313 var say = _.spread(function(who, what) {
4325 numbers.then(_.spread(function(x, y) {
4336 <h3 id="_throttlefunc-wait0-options"><code>_.throttle(func, [wait=0], [options={}])</code></h3>
4359 for details over the differences between `_.throttle` and `_.debounce`.
4377 jQuery(window).on('scroll', _.throttle(updatePosition, 100));
4380 var throttled = _.throttle(renewToken, 300000, { 'trailing': false });
4392 <h3 id="_unaryfunc"><code>_.unary(func)</code></h3>
4409 _.map(['6', '8', '10'], _.unary(parseInt));
4418 <h3 id="_wrapvalue-wrapperidentity"><code>_.wrap(value, [wrapper=identity])</code></h3>
4438 var p = _.wrap(_.escape, function(func, text) {
4457 <h3 id="_castarrayvalue"><code>_.castArray(value)</code></h3>
4473 _.castArray(1);
4476 _.castArray({ 'a': 1 });
4479 _.castArray('abc');
4482 _.castArray(null);
4485 _.castArray(undefined);
4488 _.castArray();
4492 console.log(_.castArray(array) === array);
4501 <h3 id="_clonevalue"><code>_.clone(value)</code></h3>
4528 var shallow = _.clone(objects);
4538 <h3 id="_clonedeepvalue"><code>_.cloneDeep(value)</code></h3>
4541 This method is like `_.clone` except that it recursively clones `value`.
4556 var deep = _.cloneDeep(objects);
4566 <h3 id="_clonedeepwithvalue-customizer"><code>_.cloneDeepWith(value, [customizer])</code></h3>
4569 This method is like `_.cloneWith` except that it recursively clones `value`.
4584 if (_.isElement(value)) {
4589 var el = _.cloneDeepWith(document.body, customizer);
4604 <h3 id="_clonewithvalue-customizer"><code>_.cloneWith(value, [customizer])</code></h3>
4607 This method is like `_.clone` except that it accepts `customizer` which
4625 if (_.isElement(value)) {
4630 var el = _.cloneWith(document.body, customizer);
4645 <h3 id="_conformstoobject-source"><code>_.conformsTo(object, source)</code></h3>
4652 **Note:** This method is equivalent to `_.conforms` when `source` is
4669 _.conformsTo(object, { 'b': function(n) { return n > 1; } });
4672 _.conformsTo(object, { 'b': function(n) { return n > 2; } });
4681 <h3 id="_eqvalue-other"><code>_.eq(value, other)</code></h3>
4703 _.eq(object, object);
4706 _.eq(object, other);
4709 _.eq('a', 'a');
4712 _.eq('a', Object('a'));
4715 _.eq(NaN, NaN);
4724 <h3 id="_gtvalue-other"><code>_.gt(value, other)</code></h3>
4741 _.gt(3, 1);
4744 _.gt(3, 3);
4747 _.gt(1, 3);
4756 <h3 id="_gtevalue-other"><code>_.gte(value, other)</code></h3>
4773 _.gte(3, 1);
4776 _.gte(3, 3);
4779 _.gte(1, 3);
4788 <h3 id="_isargumentsvalue"><code>_.isArguments(value)</code></h3>
4804 _.isArguments(function() { return arguments; }());
4807 _.isArguments([1, 2, 3]);
4816 <h3 id="_isarrayvalue"><code>_.isArray(value)</code></h3>
4832 _.isArray([1, 2, 3]);
4835 _.isArray(document.body.children);
4838 _.isArray('abc');
4841 _.isArray(_.noop);
4850 <h3 id="_isarraybuffervalue"><code>_.isArrayBuffer(value)</code></h3>
4866 _.isArrayBuffer(new ArrayBuffer(2));
4869 _.isArrayBuffer(new Array(2));
4878 <h3 id="_isarraylikevalue"><code>_.isArrayLike(value)</code></h3>
4896 _.isArrayLike([1, 2, 3]);
4899 _.isArrayLike(document.body.children);
4902 _.isArrayLike('abc');
4905 _.isArrayLike(_.noop);
4914 <h3 id="_isarraylikeobjectvalue"><code>_.isArrayLikeObject(value)</code></h3>
4917 This method is like `_.isArrayLike` except that it also checks if `value`
4931 _.isArrayLikeObject([1, 2, 3]);
4934 _.isArrayLikeObject(document.body.children);
4937 _.isArrayLikeObject('abc');
4940 _.isArrayLikeObject(_.noop);
4949 <h3 id="_isbooleanvalue"><code>_.isBoolean(value)</code></h3>
4965 _.isBoolean(false);
4968 _.isBoolean(null);
4977 <h3 id="_isbuffervalue"><code>_.isBuffer(value)</code></h3>
4993 _.isBuffer(new Buffer(2));
4996 _.isBuffer(new Uint8Array(2));
5005 <h3 id="_isdatevalue"><code>_.isDate(value)</code></h3>
5021 _.isDate(new Date);
5024 _.isDate('Mon April 23 2012');
5033 <h3 id="_iselementvalue"><code>_.isElement(value)</code></h3>
5049 _.isElement(document.body);
5052 _.isElement('<body>');
5061 <h3 id="_isemptyvalue"><code>_.isEmpty(value)</code></h3>
5086 _.isEmpty(null);
5089 _.isEmpty(true);
5092 _.isEmpty(1);
5095 _.isEmpty([1, 2, 3]);
5098 _.isEmpty({ 'a': 1 });
5107 <h3 id="_isequalvalue-other"><code>_.isEqual(value, other)</code></h3>
5135 _.isEqual(object, other);
5147 <h3 id="_isequalwithvalue-other-customizer"><code>_.isEqualWith(value, other, [customizer])</code><…
5150 This method is like `_.isEqual` except that it accepts `customizer` which
5181 _.isEqualWith(array, other, customizer);
5190 <h3 id="_iserrorvalue"><code>_.isError(value)</code></h3>
5207 _.isError(new Error);
5210 _.isError(Error);
5219 <h3 id="_isfinitevalue"><code>_.isFinite(value)</code></h3>
5239 _.isFinite(3);
5242 _.isFinite(Number.MIN_VALUE);
5245 _.isFinite(Infinity);
5248 _.isFinite('3');
5257 <h3 id="_isfunctionvalue"><code>_.isFunction(value)</code></h3>
5273 _.isFunction(_);
5276 _.isFunction(/abc/);
5285 <h3 id="_isintegervalue"><code>_.isInteger(value)</code></h3>
5305 _.isInteger(3);
5308 _.isInteger(Number.MIN_VALUE);
5311 _.isInteger(Infinity);
5314 _.isInteger('3');
5323 <h3 id="_islengthvalue"><code>_.isLength(value)</code></h3>
5343 _.isLength(3);
5346 _.isLength(Number.MIN_VALUE);
5349 _.isLength(Infinity);
5352 _.isLength('3');
5361 <h3 id="_ismapvalue"><code>_.isMap(value)</code></h3>
5377 _.isMap(new Map);
5380 _.isMap(new WeakMap);
5389 <h3 id="_ismatchobject-source"><code>_.isMatch(object, source)</code></h3>
5396 **Note:** This method is equivalent to `_.matches` when `source` is
5401 values against any array or object value, respectively. See `_.isEqual`
5418 _.isMatch(object, { 'b': 2 });
5421 _.isMatch(object, { 'b': 1 });
5430 <h3 id="_ismatchwithobject-source-customizer"><code>_.isMatchWith(object, source, [customizer])</co…
5433 This method is like `_.isMatch` except that it accepts `customizer` which
5464 _.isMatchWith(object, source, customizer);
5473 <h3 id="_isnanvalue"><code>_.isNaN(value)</code></h3>
5495 _.isNaN(NaN);
5498 _.isNaN(new Number(NaN));
5504 _.isNaN(undefined);
5513 <h3 id="_isnativevalue"><code>_.isNative(value)</code></h3>
5538 _.isNative(Array.prototype.push);
5541 _.isNative(_);
5550 <h3 id="_isnilvalue"><code>_.isNil(value)</code></h3>
5566 _.isNil(null);
5569 _.isNil(void 0);
5572 _.isNil(NaN);
5581 <h3 id="_isnullvalue"><code>_.isNull(value)</code></h3>
5597 _.isNull(null);
5600 _.isNull(void 0);
5609 <h3 id="_isnumbervalue"><code>_.isNumber(value)</code></h3>
5616 classified as numbers, use the `_.isFinite` method.
5629 _.isNumber(3);
5632 _.isNumber(Number.MIN_VALUE);
5635 _.isNumber(Infinity);
5638 _.isNumber('3');
5647 <h3 id="_isobjectvalue"><code>_.isObject(value)</code></h3>
5665 _.isObject({});
5668 _.isObject([1, 2, 3]);
5671 _.isObject(_.noop);
5674 _.isObject(null);
5683 <h3 id="_isobjectlikevalue"><code>_.isObjectLike(value)</code></h3>
5700 _.isObjectLike({});
5703 _.isObjectLike([1, 2, 3]);
5706 _.isObjectLike(_.noop);
5709 _.isObjectLike(null);
5718 <h3 id="_isplainobjectvalue"><code>_.isPlainObject(value)</code></h3>
5739 _.isPlainObject(new Foo);
5742 _.isPlainObject([1, 2, 3]);
5745 _.isPlainObject({ 'x': 0, 'y': 0 });
5748 _.isPlainObject(Object.create(null));
5757 <h3 id="_isregexpvalue"><code>_.isRegExp(value)</code></h3>
5773 _.isRegExp(/abc/);
5776 _.isRegExp('/abc/');
5785 <h3 id="_issafeintegervalue"><code>_.isSafeInteger(value)</code></h3>
5806 _.isSafeInteger(3);
5809 _.isSafeInteger(Number.MIN_VALUE);
5812 _.isSafeInteger(Infinity);
5815 _.isSafeInteger('3');
5824 <h3 id="_issetvalue"><code>_.isSet(value)</code></h3>
5840 _.isSet(new Set);
5843 _.isSet(new WeakSet);
5852 <h3 id="_isstringvalue"><code>_.isString(value)</code></h3>
5868 _.isString('abc');
5871 _.isString(1);
5880 <h3 id="_issymbolvalue"><code>_.isSymbol(value)</code></h3>
5896 _.isSymbol(Symbol.iterator);
5899 _.isSymbol('abc');
5908 <h3 id="_istypedarrayvalue"><code>_.isTypedArray(value)</code></h3>
5924 _.isTypedArray(new Uint8Array);
5927 _.isTypedArray([]);
5936 <h3 id="_isundefinedvalue"><code>_.isUndefined(value)</code></h3>
5952 _.isUndefined(void 0);
5955 _.isUndefined(null);
5964 <h3 id="_isweakmapvalue"><code>_.isWeakMap(value)</code></h3>
5980 _.isWeakMap(new WeakMap);
5983 _.isWeakMap(new Map);
5992 <h3 id="_isweaksetvalue"><code>_.isWeakSet(value)</code></h3>
6008 _.isWeakSet(new WeakSet);
6011 _.isWeakSet(new Set);
6020 <h3 id="_ltvalue-other"><code>_.lt(value, other)</code></h3>
6037 _.lt(1, 3);
6040 _.lt(3, 3);
6043 _.lt(3, 1);
6052 <h3 id="_ltevalue-other"><code>_.lte(value, other)</code></h3>
6069 _.lte(1, 3);
6072 _.lte(3, 3);
6075 _.lte(3, 1);
6084 <h3 id="_toarrayvalue"><code>_.toArray(value)</code></h3>
6100 _.toArray({ 'a': 1, 'b': 2 });
6103 _.toArray('abc');
6106 _.toArray(1);
6109 _.toArray(null);
6118 <h3 id="_tofinitevalue"><code>_.toFinite(value)</code></h3>
6134 _.toFinite(3.2);
6137 _.toFinite(Number.MIN_VALUE);
6140 _.toFinite(Infinity);
6143 _.toFinite('3.2');
6152 <h3 id="_tointegervalue"><code>_.toInteger(value)</code></h3>
6172 _.toInteger(3.2);
6175 _.toInteger(Number.MIN_VALUE);
6178 _.toInteger(Infinity);
6181 _.toInteger('3.2');
6190 <h3 id="_tolengthvalue"><code>_.toLength(value)</code></h3>
6211 _.toLength(3.2);
6214 _.toLength(Number.MIN_VALUE);
6217 _.toLength(Infinity);
6220 _.toLength('3.2');
6229 <h3 id="_tonumbervalue"><code>_.toNumber(value)</code></h3>
6245 _.toNumber(3.2);
6248 _.toNumber(Number.MIN_VALUE);
6251 _.toNumber(Infinity);
6254 _.toNumber('3.2');
6263 <h3 id="_toplainobjectvalue"><code>_.toPlainObject(value)</code></h3>
6286 _.assign({ 'a': 1 }, new Foo);
6289 _.assign({ 'a': 1 }, _.toPlainObject(new Foo));
6298 <h3 id="_tosafeintegervalue"><code>_.toSafeInteger(value)</code></h3>
6315 _.toSafeInteger(3.2);
6318 _.toSafeInteger(Number.MIN_VALUE);
6321 _.toSafeInteger(Infinity);
6324 _.toSafeInteger('3.2');
6333 <h3 id="_tostringvalue"><code>_.toString(value)</code></h3>
6350 _.toString(null);
6353 _.toString(-0);
6356 _.toString([1, 2, 3]);
6371 <h3 id="_addaugend-addend"><code>_.add(augend, addend)</code></h3>
6388 _.add(6, 4);
6397 <h3 id="_ceilnumber-precision0"><code>_.ceil(number, [precision=0])</code></h3>
6414 _.ceil(4.006);
6417 _.ceil(6.004, 2);
6420 _.ceil(6040, -2);
6429 <h3 id="_dividedividend-divisor"><code>_.divide(dividend, divisor)</code></h3>
6446 _.divide(6, 4);
6455 <h3 id="_floornumber-precision0"><code>_.floor(number, [precision=0])</code></h3>
6472 _.floor(4.006);
6475 _.floor(0.046, 2);
6478 _.floor(4060, -2);
6487 <h3 id="_maxarray"><code>_.max(array)</code></h3>
6504 _.max([4, 2, 8, 6]);
6507 _.max([]);
6516 <h3 id="_maxbyarray-iteratee_identity"><code>_.maxBy(array, [iteratee=_.identity])</code></h3>
6519 This method is like `_.max` except that it accepts `iteratee` which is
6528 2. `[iteratee=_.identity]` *(Function)*: The iteratee invoked per element.
6537 _.maxBy(objects, function(o) { return o.n; });
6540 // The `_.property` iteratee shorthand.
6541 _.maxBy(objects, 'n');
6550 <h3 id="_meanarray"><code>_.mean(array)</code></h3>
6566 _.mean([4, 2, 8, 6]);
6575 <h3 id="_meanbyarray-iteratee_identity"><code>_.meanBy(array, [iteratee=_.identity])</code></h3>
6578 This method is like `_.mean` except that it accepts `iteratee` which is
6587 2. `[iteratee=_.identity]` *(Function)*: The iteratee invoked per element.
6596 _.meanBy(objects, function(o) { return o.n; });
6599 // The `_.property` iteratee shorthand.
6600 _.meanBy(objects, 'n');
6609 <h3 id="_minarray"><code>_.min(array)</code></h3>
6626 _.min([4, 2, 8, 6]);
6629 _.min([]);
6638 <h3 id="_minbyarray-iteratee_identity"><code>_.minBy(array, [iteratee=_.identity])</code></h3>
6641 This method is like `_.min` except that it accepts `iteratee` which is
6650 2. `[iteratee=_.identity]` *(Function)*: The iteratee invoked per element.
6659 _.minBy(objects, function(o) { return o.n; });
6662 // The `_.property` iteratee shorthand.
6663 _.minBy(objects, 'n');
6672 <h3 id="_multiplymultiplier-multiplicand"><code>_.multiply(multiplier, multiplicand)</code></h3>
6689 _.multiply(6, 4);
6698 <h3 id="_roundnumber-precision0"><code>_.round(number, [precision=0])</code></h3>
6715 _.round(4.006);
6718 _.round(4.006, 2);
6721 _.round(4060, -2);
6730 <h3 id="_subtractminuend-subtrahend"><code>_.subtract(minuend, subtrahend)</code></h3>
6747 _.subtract(6, 4);
6756 <h3 id="_sumarray"><code>_.sum(array)</code></h3>
6772 _.sum([4, 2, 8, 6]);
6781 <h3 id="_sumbyarray-iteratee_identity"><code>_.sumBy(array, [iteratee=_.identity])</code></h3>
6784 This method is like `_.sum` except that it accepts `iteratee` which is
6793 2. `[iteratee=_.identity]` *(Function)*: The iteratee invoked per element.
6802 _.sumBy(objects, function(o) { return o.n; });
6805 // The `_.property` iteratee shorthand.
6806 _.sumBy(objects, 'n');
6821 <h3 id="_clampnumber-lower-upper"><code>_.clamp(number, [lower], upper)</code></h3>
6839 _.clamp(-10, -5, 5);
6842 _.clamp(10, -5, 5);
6851 <h3 id="_inrangenumber-start0-end"><code>_.inRange(number, [start=0], end)</code></h3>
6872 _.inRange(3, 2, 4);
6875 _.inRange(4, 8);
6878 _.inRange(4, 2);
6881 _.inRange(2, 2);
6884 _.inRange(1.2, 2);
6887 _.inRange(5.2, 4);
6890 _.inRange(-3, -2, -6);
6899 <h3 id="_randomlower0-upper1-floating"><code>_.random([lower=0], [upper=1], [floating])</code></h3>
6924 _.random(0, 5);
6927 _.random(5);
6930 _.random(5, true);
6933 _.random(1.2, 5.2);
6948 <h3 id="_assignobject-sources"><code>_.assign(object, [sources])</code></h3>
6982 _.assign({ 'a': 0 }, new Foo, new Bar);
6991 <h3 id="_assigninobject-sources"><code>_.assignIn(object, [sources])</code></h3>
6994 This method is like `_.assign` except that it iterates over own and
7004 *_.extend*
7026 _.assignIn({ 'a': 0 }, new Foo, new Bar);
7035 <h3 id="_assigninwithobject-sources-customizer"><code>_.assignInWith(object, sources, [customizer])…
7038 This method is like `_.assignIn` except that it accepts `customizer`
7050 *_.extendWith*
7063 return _.isUndefined(objValue) ? srcValue : objValue;
7066 var defaults = _.partialRight(_.assignInWith, customizer);
7077 <h3 id="_assignwithobject-sources-customizer"><code>_.assignWith(object, sources, [customizer])</co…
7080 This method is like `_.assign` except that it accepts `customizer`
7102 return _.isUndefined(objValue) ? srcValue : objValue;
7105 var defaults = _.partialRight(_.assignWith, customizer);
7116 <h3 id="_atobject-paths"><code>_.at(object, [paths])</code></h3>
7135 _.at(object, ['a[0].b.c', 'a[1]']);
7144 <h3 id="_createprototype-properties"><code>_.create(prototype, [properties])</code></h3>
7172 Circle.prototype = _.create(Shape.prototype, {
7189 <h3 id="_defaultsobject-sources"><code>_.defaults(object, [sources])</code></h3>
7212 _.defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });
7221 <h3 id="_defaultsdeepobject-sources"><code>_.defaultsDeep(object, [sources])</code></h3>
7224 This method is like `_.defaults` except that it recursively assigns
7242 _.defaultsDeep({ 'a': { 'b': 2 } }, { 'a': { 'b': 1, 'c': 3 } });
7251 <h3 id="_findkeyobject-predicate_identity"><code>_.findKey(object, [predicate=_.identity])</code></…
7254 This method is like `_.find` except that it returns the key of the first
7262 2. `[predicate=_.identity]` *(Function)*: The function invoked per iteration.
7275 _.findKey(users, function(o) { return o.age < 40; });
7278 // The `_.matches` iteratee shorthand.
7279 _.findKey(users, { 'age': 1, 'active': true });
7282 // The `_.matchesProperty` iteratee shorthand.
7283 _.findKey(users, ['active', false]);
7286 // The `_.property` iteratee shorthand.
7287 _.findKey(users, 'active');
7296 <h3 id="_findlastkeyobject-predicate_identity"><code>_.findLastKey(object, [predicate=_.identity])<…
7299 This method is like `_.findKey` except that it iterates over elements of
7307 2. `[predicate=_.identity]` *(Function)*: The function invoked per iteration.
7320 _.findLastKey(users, function(o) { return o.age < 40; });
7321 // => returns 'pebbles' assuming `_.findKey` returns 'barney'
7323 // The `_.matches` iteratee shorthand.
7324 _.findLastKey(users, { 'age': 36, 'active': true });
7327 // The `_.matchesProperty` iteratee shorthand.
7328 _.findLastKey(users, ['active', false]);
7331 // The `_.property` iteratee shorthand.
7332 _.findLastKey(users, 'active');
7341 <h3 id="_forinobject-iteratee_identity"><code>_.forIn(object, [iteratee=_.identity])</code></h3>
7354 2. `[iteratee=_.identity]` *(Function)*: The function invoked per iteration.
7368 _.forIn(new Foo, function(value, key) {
7379 <h3 id="_forinrightobject-iteratee_identity"><code>_.forInRight(object, [iteratee=_.identity])</cod…
7382 This method is like `_.forIn` except that it iterates over properties of
7390 2. `[iteratee=_.identity]` *(Function)*: The function invoked per iteration.
7404 _.forInRight(new Foo, function(value, key) {
7407 // => Logs 'c', 'b', then 'a' assuming `_.forIn` logs 'a', 'b', then 'c'.
7415 <h3 id="_forownobject-iteratee_identity"><code>_.forOwn(object, [iteratee=_.identity])</code></h3>
7428 2. `[iteratee=_.identity]` *(Function)*: The function invoked per iteration.
7442 _.forOwn(new Foo, function(value, key) {
7453 <h3 id="_forownrightobject-iteratee_identity"><code>_.forOwnRight(object, [iteratee=_.identity])</c…
7456 This method is like `_.forOwn` except that it iterates over properties of
7464 2. `[iteratee=_.identity]` *(Function)*: The function invoked per iteration.
7478 _.forOwnRight(new Foo, function(value, key) {
7481 // => Logs 'b' then 'a' assuming `_.forOwn` logs 'a' then 'b'.
7489 <h3 id="_functionsobject"><code>_.functions(object)</code></h3>
7507 this.a = _.constant('a');
7508 this.b = _.constant('b');
7511 Foo.prototype.c = _.constant('c');
7513 _.functions(new Foo);
7522 <h3 id="_functionsinobject"><code>_.functionsIn(object)</code></h3>
7540 this.a = _.constant('a');
7541 this.b = _.constant('b');
7544 Foo.prototype.c = _.constant('c');
7546 _.functionsIn(new Foo);
7555 <h3 id="_getobject-path-defaultvalue"><code>_.get(object, path, [defaultValue])</code></h3>
7576 _.get(object, 'a[0].b.c');
7579 _.get(object, ['a', '0', 'b', 'c']);
7582 _.get(object, 'a.b.c', 'default');
7591 <h3 id="_hasobject-path"><code>_.has(object, path)</code></h3>
7609 var other = _.create({ 'a': _.create({ 'b': 2 }) });
7611 _.has(object, 'a');
7614 _.has(object, 'a.b');
7617 _.has(object, ['a', 'b']);
7620 _.has(other, 'a');
7629 <h3 id="_hasinobject-path"><code>_.hasIn(object, path)</code></h3>
7646 var object = _.create({ 'a': _.create({ 'b': 2 }) });
7648 _.hasIn(object, 'a');
7651 _.hasIn(object, 'a.b');
7654 _.hasIn(object, ['a', 'b']);
7657 _.hasIn(object, 'b');
7666 <h3 id="_invertobject"><code>_.invert(object)</code></h3>
7686 _.invert(object);
7695 <h3 id="_invertbyobject-iteratee_identity"><code>_.invertBy(object, [iteratee=_.identity])</code></…
7698 This method is like `_.invert` except that the inverted object is generated
7709 2. `[iteratee=_.identity]` *(Function)*: The iteratee invoked per element.
7718 _.invertBy(object);
7721 _.invertBy(object, function(value) {
7732 <h3 id="_invokeobject-path-args"><code>_.invoke(object, path, [args])</code></h3>
7752 _.invoke(object, 'a[0].b.c.slice', 1, 3);
7761 <h3 id="_keysobject"><code>_.keys(object)</code></h3>
7789 _.keys(new Foo);
7792 _.keys('hi');
7801 <h3 id="_keysinobject"><code>_.keysIn(object)</code></h3>
7827 _.keysIn(new Foo);
7836 <h3 id="_mapkeysobject-iteratee_identity"><code>_.mapKeys(object, [iteratee=_.identity])</code></h3>
7839 The opposite of `_.mapValues`; this method creates an object with the
7849 2. `[iteratee=_.identity]` *(Function)*: The function invoked per iteration.
7856 _.mapKeys({ 'a': 1, 'b': 2 }, function(value, key) {
7867 <h3 id="_mapvaluesobject-iteratee_identity"><code>_.mapValues(object, [iteratee=_.identity])</code>…
7880 2. `[iteratee=_.identity]` *(Function)*: The function invoked per iteration.
7892 _.mapValues(users, function(o) { return o.age; });
7895 // The `_.property` iteratee shorthand.
7896 _.mapValues(users, 'age');
7905 <h3 id="_mergeobject-sources"><code>_.merge(object, [sources])</code></h3>
7908 This method is like `_.assign` except that it recursively merges own and
7939 _.merge(object, other);
7948 <h3 id="_mergewithobject-sources-customizer"><code>_.mergeWith(object, sources, customizer)</code><…
7951 This method is like `_.merge` except that it accepts `customizer` which
7974 if (_.isArray(objValue)) {
7982 _.mergeWith(object, other, customizer);
7991 <h3 id="_omitobject-paths"><code>_.omit(object, [paths])</code></h3>
7994 The opposite of `_.pick`; this method creates an object composed of the
7998 **Note:** This method is considerably slower than `_.pick`.
8014 _.omit(object, ['a', 'c']);
8023 <h3 id="_omitbyobject-predicate_identity"><code>_.omitBy(object, [predicate=_.identity])</code></h3>
8026 The opposite of `_.pickBy`; this method creates an object composed of
8036 2. `[predicate=_.identity]` *(Function)*: The function invoked per property.
8045 _.omitBy(object, _.isNumber);
8054 <h3 id="_pickobject-paths"><code>_.pick(object, [paths])</code></h3>
8073 _.pick(object, ['a', 'c']);
8082 <h3 id="_pickbyobject-predicate_identity"><code>_.pickBy(object, [predicate=_.identity])</code></h3>
8093 2. `[predicate=_.identity]` *(Function)*: The function invoked per property.
8102 _.pickBy(object, _.isNumber);
8111 <h3 id="_resultobject-path-defaultvalue"><code>_.result(object, path, [defaultValue])</code></h3>
8114 This method is like `_.get` except that if the resolved value is a
8131 var object = { 'a': [{ 'b': { 'c1': 3, 'c2': _.constant(4) } }] };
8133 _.result(object, 'a[0].b.c1');
8136 _.result(object, 'a[0].b.c2');
8139 _.result(object, 'a[0].b.c3', 'default');
8142 _.result(object, 'a[0].b.c3', _.constant('default'));
8151 <h3 id="_setobject-path-value"><code>_.set(object, path, value)</code></h3>
8156 are created for all other missing properties. Use `_.setWith` to customize
8177 _.set(object, 'a[0].b.c', 4);
8181 _.set(object, ['x', '0', 'y', 'z'], 5);
8191 <h3 id="_setwithobject-path-value-customizer"><code>_.setWith(object, path, value, [customizer])</c…
8194 This method is like `_.set` except that it accepts `customizer` which is
8218 _.setWith(object, '[0][1]', 'a', Object);
8227 <h3 id="_topairsobject"><code>_.toPairs(object)</code></h3>
8231 which can be consumed by `_.fromPairs`. If `object` is a map or set, its
8238 *_.entries*
8255 _.toPairs(new Foo);
8264 <h3 id="_topairsinobject"><code>_.toPairsIn(object)</code></h3>
8268 for `object` which can be consumed by `_.fromPairs`. If `object` is a map
8275 *_.entriesIn*
8292 _.toPairsIn(new Foo);
8301 <h3 id="_transformobject-iteratee_identity-accumulator"><code>_.transform(object, [iteratee=_.ident…
8304 An alternative to `_.reduce`; this method transforms `object` to a new
8317 2. `[iteratee=_.identity]` *(Function)*: The function invoked per iteration.
8325 _.transform([2, 3, 4], function(result, n) {
8331 _.transform({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) {
8342 <h3 id="_unsetobject-path"><code>_.unset(object, path)</code></h3>
8363 _.unset(object, 'a[0].b.c');
8369 _.unset(object, ['a', '0', 'b', 'c']);
8381 <h3 id="_updateobject-path-updater"><code>_.update(object, path, updater)</code></h3>
8384 This method is like `_.set` except that accepts `updater` to produce the
8385 value to set. Use `_.updateWith` to customize `path` creation. The `updater`
8406 _.update(object, 'a[0].b.c', function(n) { return n * n; });
8410 _.update(object, 'x[0].y.z', function(n) { return n ? n + 1 : 0; });
8420 <h3 id="_updatewithobject-path-updater-customizer"><code>_.updateWith(object, path, updater, [custo…
8423 This method is like `_.update` except that it accepts `customizer` which is
8447 _.updateWith(object, '[0][1]', _.constant('a'), Object);
8456 <h3 id="_valuesobject"><code>_.values(object)</code></h3>
8482 _.values(new Foo);
8485 _.values('hi');
8494 <h3 id="_valuesinobject"><code>_.valuesIn(object)</code></h3>
8521 _.valuesIn(new Foo);
8536 <h3 id="_value"><code>_(value)</code></h3>
8544 with `_#value`.
8547 Explicit chain sequences, which must be unwrapped with `_#value`, may be
8548 enabled using `_.chain`.
8552 `_#value` is implicitly or explicitly called.
8564 Chaining is supported in custom builds as long as the `_#value` method is
8651 var wrapped = _([1, 2, 3]);
8654 wrapped.reduce(_.add);
8660 _.isArray(squares);
8663 _.isArray(squares.value());
8672 <h3 id="_chainvalue"><code>_.chain(value)</code></h3>
8677 with `_#value`.
8696 var youngest = _
8712 <h3 id="_tapvalue-interceptor"><code>_.tap(value, interceptor)</code></h3>
8731 _([1, 2, 3])
8746 <h3 id="_thruvalue-interceptor"><code>_.thru(value, interceptor)</code></h3>
8749 This method is like `_.tap` except that it returns the result of `interceptor`.
8765 _(' abc ')
8780 <h3 id="_prototypesymboliterator"><code>_.prototype[Symbol.iterator]()</code></h3>
8793 var wrapped = _([1, 2]);
8807 <h3 id="_prototypeatpaths"><code>_.prototype.at([paths])</code></h3>
8810 This method is the wrapper version of `_.at`.
8825 _(object).at(['a[0].b.c', 'a[1]']).value();
8834 <h3 id="_prototypechain"><code>_.prototype.chain()</code></h3>
8853 _(users).head();
8857 _(users)
8870 <h3 id="_prototypecommit"><code>_.prototype.commit()</code></h3>
8884 var wrapped = _(array).push(3);
8905 <h3 id="_prototypenext"><code>_.prototype.next()</code></h3>
8919 var wrapped = _([1, 2]);
8936 <h3 id="_prototypeplantvalue"><code>_.prototype.plant(value)</code></h3>
8956 var wrapped = _([1, 2]).map(square);
8971 <h3 id="_prototypereverse"><code>_.prototype.reverse()</code></h3>
8974 This method is the wrapper version of `_.reverse`.
8989 _(array).reverse().value()
9001 <h3 id="_prototypevalue"><code>_.prototype.value()</code></h3>
9010 *_.prototype.toJSON, _.prototype.valueOf*
9017 _([1, 2, 3]).value();
9032 <h3 id="_camelcasestring"><code>_.camelCase([string=''])</code></h3>
9048 _.camelCase('Foo Bar');
9051 _.camelCase('--foo-bar--');
9054 _.camelCase('__FOO_BAR__');
9063 <h3 id="_capitalizestring"><code>_.capitalize([string=''])</code></h3>
9080 _.capitalize('FRED');
9089 <h3 id="_deburrstring"><code>_.deburr([string=''])</code></h3>
9109 _.deburr('déjà vu');
9118 <h3 id="_endswithstring-target-positionstringlength"><code>_.endsWith([string=''], [target], [posit…
9136 _.endsWith('abc', 'c');
9139 _.endsWith('abc', 'b');
9142 _.endsWith('abc', 'b', 2);
9151 <h3 id="_escapestring"><code>_.escape([string=''])</code></h3>
9184 _.escape('fred, barney, & pebbles');
9193 <h3 id="_escaperegexpstring"><code>_.escapeRegExp([string=''])</code></h3>
9210 _.escapeRegExp('[lodash](https://lodash.com/)');
9219 <h3 id="_kebabcasestring"><code>_.kebabCase([string=''])</code></h3>
9236 _.kebabCase('Foo Bar');
9239 _.kebabCase('fooBar');
9242 _.kebabCase('__FOO_BAR__');
9251 <h3 id="_lowercasestring"><code>_.lowerCase([string=''])</code></h3>
9267 _.lowerCase('--Foo-Bar--');
9270 _.lowerCase('fooBar');
9273 _.lowerCase('__FOO_BAR__');
9282 <h3 id="_lowerfirststring"><code>_.lowerFirst([string=''])</code></h3>
9298 _.lowerFirst('Fred');
9301 _.lowerFirst('FRED');
9310 <h3 id="_padstring-length0-chars"><code>_.pad([string=''], [length=0], [chars=' '])</code></h3>
9329 _.pad('abc', 8);
9332 _.pad('abc', 8, '_-');
9333 // => '_-abc_-_'
9335 _.pad('abc', 3);
9344 <h3 id="_padendstring-length0-chars"><code>_.padEnd([string=''], [length=0], [chars=' '])</code></h…
9363 _.padEnd('abc', 6);
9366 _.padEnd('abc', 6, '_-');
9367 // => 'abc_-_'
9369 _.padEnd('abc', 3);
9378 <h3 id="_padstartstring-length0-chars"><code>_.padStart([string=''], [length=0], [chars=' '])</code…
9397 _.padStart('abc', 6);
9400 _.padStart('abc', 6, '_-');
9401 // => '_-_abc'
9403 _.padStart('abc', 3);
9412 <h3 id="_parseintstring-radix10"><code>_.parseInt(string, [radix=10])</code></h3>
9435 _.parseInt('08');
9438 _.map(['6', '08', '10'], _.parseInt);
9447 <h3 id="_repeatstring-n1"><code>_.repeat([string=''], [n=1])</code></h3>
9464 _.repeat('*', 3);
9467 _.repeat('abc', 2);
9470 _.repeat('abc', 0);
9479 <h3 id="_replacestring-pattern-replacement"><code>_.replace([string=''], pattern, replacement)</cod…
9501 _.replace('Hi Fred', 'Fred', 'Barney');
9510 <h3 id="_snakecasestring"><code>_.snakeCase([string=''])</code></h3>
9527 _.snakeCase('Foo Bar');
9530 _.snakeCase('fooBar');
9533 _.snakeCase('--FOO-BAR--');
9542 <h3 id="_splitstring-separator-limit"><code>_.split([string=''], separator, [limit])</code></h3>
9564 _.split('a-b-c', '-', 2);
9573 <h3 id="_startcasestring"><code>_.startCase([string=''])</code></h3>
9590 _.startCase('--foo-bar--');
9593 _.startCase('fooBar');
9596 _.startCase('__FOO_BAR__');
9605 <h3 id="_startswithstring-target-position0"><code>_.startsWith([string=''], [target], [position=0])…
9623 _.startsWith('abc', 'a');
9626 _.startsWith('abc', 'b');
9629 _.startsWith('abc', 'b', 1);
9638 <h3 id="_templatestring-options"><code>_.template([string=''], [options={}])</code></h3>
9645 object is given, it takes precedence over `_.templateSettings` values.
9648 **Note:** In the development build `_.template` utilizes
9666 3. `[options.escape=_.templateSettings.escape]` *(RegExp)*: The HTML "escape" delimiter.
9667 4. `[options.evaluate=_.templateSettings.evaluate]` *(RegExp)*: The "evaluate" delimiter.
9668 5. `[options.imports=_.templateSettings.imports]` *(Object)*: An object to import into the template…
9669 6. `[options.interpolate=_.templateSettings.interpolate]` *(RegExp)*: The "interpolate" delimiter.
9679 var compiled = _.template('hello <%= user %>!');
9684 var compiled = _.template('<b><%- value %></b>');
9689 var compiled = _.template('<% _.forEach(users, function(user) { %><li><%- user %></li><% }); %>');
9694 var compiled = _.template('<% print("hello " + user); %>!');
9700 var compiled = _.template('hello ${ user }!');
9705 var compiled = _.template('<%= "\\<%- value %\\>" %>');
9711 var compiled = _.template(text, { 'imports': { 'jq': jQuery } });
9716 var compiled = _.template('hello <%= user %>!', { 'sourceURL': '/basic/greeting.jst' });
9721 var compiled = _.template('hi <%= data.user %>!', { 'variable': 'data' });
9730 _.templateSettings.interpolate = /{{([\s\S]+?)}}/g;
9731 var compiled = _.template('hello {{ user }}!');
9739 "main": ' + _.template(mainText).source + '\
9749 <h3 id="_tolowerstring"><code>_.toLower([string=''])</code></h3>
9766 _.toLower('--Foo-Bar--');
9769 _.toLower('fooBar');
9772 _.toLower('__FOO_BAR__');
9781 <h3 id="_toupperstring"><code>_.toUpper([string=''])</code></h3>
9798 _.toUpper('--foo-bar--');
9801 _.toUpper('fooBar');
9804 _.toUpper('__foo_bar__');
9813 <h3 id="_trimstring-charswhitespace"><code>_.trim([string=''], [chars=whitespace])</code></h3>
9830 _.trim(' abc ');
9833 _.trim('-_-abc-_-', '_-');
9836 _.map([' foo ', ' bar '], _.trim);
9845 <h3 id="_trimendstring-charswhitespace"><code>_.trimEnd([string=''], [chars=whitespace])</code></h3>
9862 _.trimEnd(' abc ');
9865 _.trimEnd('-_-abc-_-', '_-');
9866 // => '-_-abc'
9874 <h3 id="_trimstartstring-charswhitespace"><code>_.trimStart([string=''], [chars=whitespace])</code>…
9891 _.trimStart(' abc ');
9894 _.trimStart('-_-abc-_-', '_-');
9895 // => 'abc-_-'
9903 <h3 id="_truncatestring-options"><code>_.truncate([string=''], [options={}])</code></h3>
9925 _.truncate('hi-diddly-ho there, neighborino');
9928 _.truncate('hi-diddly-ho there, neighborino', {
9934 _.truncate('hi-diddly-ho there, neighborino', {
9940 _.truncate('hi-diddly-ho there, neighborino', {
9951 <h3 id="_unescapestring"><code>_.unescape([string=''])</code></h3>
9954 The inverse of `_.escape`; this method converts the HTML entities
9973 _.unescape('fred, barney, & pebbles');
9982 <h3 id="_uppercasestring"><code>_.upperCase([string=''])</code></h3>
9998 _.upperCase('--foo-bar');
10001 _.upperCase('fooBar');
10004 _.upperCase('__foo_bar__');
10013 <h3 id="_upperfirststring"><code>_.upperFirst([string=''])</code></h3>
10029 _.upperFirst('fred');
10032 _.upperFirst('FRED');
10041 <h3 id="_wordsstring-pattern"><code>_.words([string=''], [pattern])</code></h3>
10058 _.words('fred, barney, & pebbles');
10061 _.words('fred, barney, & pebbles', /[^, ]+/g);
10076 <h3 id="_attemptfunc-args"><code>_.attempt(func, [args])</code></h3>
10095 var elements = _.attempt(function(selector) {
10097 }, '>_>');
10099 if (_.isError(elements)) {
10109 <h3 id="_bindallobject-methodnames"><code>_.bindAll(object, methodNames)</code></h3>
10137 _.bindAll(view, ['click']);
10147 <h3 id="_condpairs"><code>_.cond(pairs)</code></h3>
10166 var func = _.cond([
10167 [_.matches({ 'a': 1 }), _.constant('matches A')],
10168 [_.conforms({ 'b': _.isNumber }), _.constant('matches B')],
10169 [_.stubTrue, _.constant('no match')]
10187 <h3 id="_conformssource"><code>_.conforms(source)</code></h3>
10195 **Note:** The created function is equivalent to `_.conformsTo` with
10214 _.filter(objects, _.conforms({ 'b': function(n) { return n > 1; } }));
10223 <h3 id="_constantvalue"><code>_.constant(value)</code></h3>
10239 var objects = _.times(2, _.constant({ 'a': 1 }));
10253 <h3 id="_defaulttovalue-defaultvalue"><code>_.defaultTo(value, defaultValue)</code></h3>
10272 _.defaultTo(1, 10);
10275 _.defaultTo(undefined, 10);
10284 <h3 id="_flowfuncs"><code>_.flow([funcs])</code></h3>
10306 var addSquare = _.flow([_.add, square]);
10316 <h3 id="_flowrightfuncs"><code>_.flowRight([funcs])</code></h3>
10319 This method is like `_.flow` except that it creates a function that
10337 var addSquare = _.flowRight([square, _.add]);
10347 <h3 id="_identityvalue"><code>_.identity(value)</code></h3>
10365 console.log(_.identity(object) === object);
10374 <h3 id="_iterateefunc_identity"><code>_.iteratee([func=_.identity])</code></h3>
10387 1. `[func=_.identity]` *(*)*: The value to convert to a callback.
10399 // The `_.matches` iteratee shorthand.
10400 _.filter(users, _.iteratee({ 'user': 'barney', 'active': true }));
10403 // The `_.matchesProperty` iteratee shorthand.
10404 _.filter(users, _.iteratee(['user', 'fred']));
10407 // The `_.property` iteratee shorthand.
10408 _.map(users, _.iteratee('user'));
10412 _.iteratee = _.wrap(_.iteratee, function(iteratee, func) {
10413 return !_.isRegExp(func) ? iteratee(func) : function(string) {
10418 _.filter(['abc', 'def'], /ef/);
10427 <h3 id="_matchessource"><code>_.matches(source)</code></h3>
10435 **Note:** The created function is equivalent to `_.isMatch` with `source`
10440 values against any array or object value, respectively. See `_.isEqual`
10459 _.filter(objects, _.matches({ 'a': 4, 'c': 6 }));
10468 <h3 id="_matchespropertypath-srcvalue"><code>_.matchesProperty(path, srcValue)</code></h3>
10478 `_.isEqual` for a list of supported value comparisons.
10497 _.find(objects, _.matchesProperty('a', 4));
10506 <h3 id="_methodpath-args"><code>_.method(path, [args])</code></h3>
10525 { 'a': { 'b': _.constant(2) } },
10526 { 'a': { 'b': _.constant(1) } }
10529 _.map(objects, _.method('a.b'));
10532 _.map(objects, _.method(['a', 'b']));
10541 <h3 id="_methodofobject-args"><code>_.methodOf(object, [args])</code></h3>
10544 The opposite of `_.method`; this method creates a function that invokes
10560 var array = _.times(3, _.constant),
10563 _.map(['a[2]', 'c[0]'], _.methodOf(object));
10566 _.map([['a', '2'], ['c', '0']], _.methodOf(object));
10575 <h3 id="_mixinobjectlodash-source-options"><code>_.mixin([object=lodash], source, [options={}])</co…
10583 **Note:** Use `_.runInContext` to create a pristine `lodash` function to
10601 return _.filter(string, function(v) {
10606 _.mixin({ 'vowels': vowels });
10607 _.vowels('fred');
10610 _('fred').vowels().value();
10613 _.mixin({ 'vowels': vowels }, { 'chain': false });
10614 _('fred').vowels();
10623 <h3 id="_noconflict"><code>_.noConflict()</code></h3>
10626 Reverts the `_` variable to its previous value and returns a reference to
10637 var lodash = _.noConflict();
10645 <h3 id="_noop"><code>_.noop()</code></h3>
10655 _.times(2, _.noop);
10664 <h3 id="_nthargn0"><code>_.nthArg([n=0])</code></h3>
10681 var func = _.nthArg(1);
10685 var func = _.nthArg(-2);
10695 <h3 id="_overiteratees_identity"><code>_.over([iteratees=[_.identity]])</code></h3>
10705 1. `[iteratees=[_.identity]]` *(...(Function|Function[]))*: The iteratees to invoke.
10712 var func = _.over([Math.max, Math.min]);
10723 <h3 id="_overeverypredicates_identity"><code>_.overEvery([predicates=[_.identity]])</code></h3>
10733 1. `[predicates=[_.identity]]` *(...(Function|Function[]))*: The predicates to check.
10740 var func = _.overEvery([Boolean, isFinite]);
10757 <h3 id="_oversomepredicates_identity"><code>_.overSome([predicates=[_.identity]])</code></h3>
10767 1. `[predicates=[_.identity]]` *(...(Function|Function[]))*: The predicates to check.
10774 var func = _.overSome([Boolean, isFinite]);
10791 <h3 id="_propertypath"><code>_.property(path)</code></h3>
10812 _.map(objects, _.property('a.b'));
10815 _.map(_.sortBy(objects, _.property(['a', 'b'])), 'a.b');
10824 <h3 id="_propertyofobject"><code>_.propertyOf(object)</code></h3>
10827 The opposite of `_.property`; this method creates a function that returns
10844 _.map(['a[2]', 'c[0]'], _.propertyOf(object));
10847 _.map([['a', '2'], ['c', '0']], _.propertyOf(object));
10856 <h3 id="_rangestart0-end-step1"><code>_.range([start=0], end, [step=1])</code></h3>
10881 _.range(4);
10884 _.range(-4);
10887 _.range(1, 5);
10890 _.range(0, 20, 5);
10893 _.range(0, -4, -1);
10896 _.range(1, 4, 0);
10899 _.range(0);
10908 <h3 id="_rangerightstart0-end-step1"><code>_.rangeRight([start=0], end, [step=1])</code></h3>
10911 This method is like `_.range` except that it populates values in
10927 _.rangeRight(4);
10930 _.rangeRight(-4);
10933 _.rangeRight(1, 5);
10936 _.rangeRight(0, 20, 5);
10939 _.rangeRight(0, -4, -1);
10942 _.rangeRight(1, 4, 0);
10945 _.rangeRight(0);
10954 <h3 id="_runincontextcontextroot"><code>_.runInContext([context=root])</code></h3>
10970 _.mixin({ 'foo': _.constant('foo') });
10972 var lodash = _.runInContext();
10975 _.isFunction(_.foo);
10977 _.isFunction(_.bar);
10986 var defer = _.runInContext({ 'setTimeout': setImmediate }).defer;
10994 <h3 id="_stubarray"><code>_.stubArray()</code></h3>
11007 var arrays = _.times(2, _.stubArray);
11021 <h3 id="_stubfalse"><code>_.stubFalse()</code></h3>
11034 _.times(2, _.stubFalse);
11043 <h3 id="_stubobject"><code>_.stubObject()</code></h3>
11056 var objects = _.times(2, _.stubObject);
11070 <h3 id="_stubstring"><code>_.stubString()</code></h3>
11083 _.times(2, _.stubString);
11092 <h3 id="_stubtrue"><code>_.stubTrue()</code></h3>
11105 _.times(2, _.stubTrue);
11114 <h3 id="_timesn-iteratee_identity"><code>_.times(n, [iteratee=_.identity])</code></h3>
11125 2. `[iteratee=_.identity]` *(Function)*: The function invoked per iteration.
11132 _.times(3, String);
11135 _.times(4, _.constant(0));
11144 <h3 id="_topathvalue"><code>_.toPath(value)</code></h3>
11160 _.toPath('a.b.c');
11163 _.toPath('a[0].b.c');
11172 <h3 id="_uniqueidprefix"><code>_.uniqueId([prefix=''])</code></h3>
11188 _.uniqueId('contact_');
11191 _.uniqueId();
11206 <h3 id="_version"><code>_.VERSION</code></h3>
11217 <h3 id="_templatesettings"><code>_.templateSettings</code></h3>
11230 <h3 id="_templatesettingsescape"><code>_.templateSettings.escape</code></h3>
11241 <h3 id="_templatesettingsevaluate"><code>_.templateSettings.evaluate</code></h3>
11252 <h3 id="_templatesettingsimports"><code>_.templateSettings.imports</code></h3>
11263 <h3 id="_templatesettingsinterpolate"><code>_.templateSettings.interpolate</code></h3>
11274 <h3 id="_templatesettingsvariable"><code>_.templateSettings.variable</code></h3>
11291 <h3 id="_templatesettingsimports_"><code>_.templateSettings.imports._</code></h3>