2016-03-11 00:48:53 +00:00
<!DOCTYPE html>
< html >
< head >
< title > underscore.js< / title >
< meta http-equiv = "content-type" content = "text/html; charset=UTF-8" >
< meta name = "viewport" content = "width=device-width, target-densitydpi=160dpi, initial-scale=1.0; maximum-scale=1.0; user-scalable=0;" >
< link rel = "stylesheet" media = "all" href = "docco.css" / >
< / head >
< body >
< div id = "container" >
< div id = "background" > < / div >
< ul class = "sections" >
< li id = "title" >
< div class = "annotation" >
< h1 > underscore.js< / h1 >
< / div >
< / li >
< li id = "section-1" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-1" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< pre > < code > Underscore.js < span class = "hljs-number" > 1.8< / span > < span class = "hljs-number" > .3< / span >
http:< span class = "hljs-comment" > //underscorejs.org< / span >
(c) < span class = "hljs-number" > 2009< / span > -< span class = "hljs-number" > 2017< / span > Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
Underscore may be freely distributed under the MIT license.
< / code > < / pre >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre >
(< span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > ()< / span > < / span > {< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-2" >
< div class = "annotation" >
2017-04-21 08:10:07 +00:00
< div class = "pilwrap " >
2016-03-11 00:48:53 +00:00
< a class = "pilcrow" href = "#section-2" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< h2 id = "baseline-setup" > Baseline setup< / h2 >
2016-03-11 00:48:53 +00:00
< / div >
< / li >
< li id = "section-3" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-3" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
2016-03-11 00:48:53 +00:00
< / div >
< / li >
< li id = "section-4" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-4" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Establish the root object, < code > window< / code > in the browser, or < code > exports< / code > on the server.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > < span class = "hljs-keyword" > var< / span > root = < span class = "hljs-keyword" > this< / span > ;< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-5" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-5" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Save the previous value of the < code > _< / code > variable.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > < span class = "hljs-keyword" > var< / span > previousUnderscore = root._;< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-6" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-6" > ¶ < / a >
< / div >
< p > Save bytes in the minified (but not gzipped) version:< / p >
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > < span class = "hljs-keyword" > var< / span > ArrayProto = < span class = "hljs-built_in" > Array< / span > .prototype, ObjProto = < span class = "hljs-built_in" > Object< / span > .prototype, FuncProto = < span class = "hljs-built_in" > Function< / span > .prototype;< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-7" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-7" > ¶ < / a >
< / div >
< p > Create quick reference variables for speed access to core prototypes.< / p >
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > < span class = "hljs-keyword" > var< / span >
2016-03-11 00:48:53 +00:00
push = ArrayProto.push,
slice = ArrayProto.slice,
toString = ObjProto.toString,
hasOwnProperty = ObjProto.hasOwnProperty;< / pre > < / div > < / div >
< / li >
< li id = "section-8" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-8" > ¶ < / a >
< / div >
< p > All < strong > ECMAScript 5< / strong > native function implementations that we hope to use
are declared here.< / p >
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > < span class = "hljs-keyword" > var< / span >
nativeIsArray = < span class = "hljs-built_in" > Array< / span > .isArray,
nativeKeys = < span class = "hljs-built_in" > Object< / span > .keys,
nativeBind = FuncProto.bind,
nativeCreate = < span class = "hljs-built_in" > Object< / span > .create;< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-9" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-9" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Naked function reference for surrogate-prototype-swapping.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > < span class = "hljs-keyword" > var< / span > Ctor = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > ()< / span > < / span > {};< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-10" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-10" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Create a safe reference to the Underscore object for use below.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > < span class = "hljs-keyword" > var< / span > _ = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (obj)< / span > < / span > {
< span class = "hljs-keyword" > if< / span > (obj < span class = "hljs-keyword" > instanceof< / span > _) < span class = "hljs-keyword" > return< / span > obj;
< span class = "hljs-keyword" > if< / span > (!(< span class = "hljs-keyword" > this< / span > < span class = "hljs-keyword" > instanceof< / span > _)) < span class = "hljs-keyword" > return< / span > < span class = "hljs-keyword" > new< / span > _(obj);
< span class = "hljs-keyword" > this< / span > ._wrapped = obj;
};< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-11" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-11" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Export the Underscore object for < strong > Node.js< / strong > , with
backwards-compatibility for the old < code > require()< / code > API. If we’
the browser, add < code > _< / code > as a global object.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > < span class = "hljs-keyword" > if< / span > (< span class = "hljs-keyword" > typeof< / span > exports !== < span class = "hljs-string" > 'undefined'< / span > ) {
< span class = "hljs-keyword" > if< / span > (< span class = "hljs-keyword" > typeof< / span > < span class = "hljs-built_in" > module< / span > !== < span class = "hljs-string" > 'undefined'< / span > & & < span class = "hljs-built_in" > module< / span > .exports) {
exports = < span class = "hljs-built_in" > module< / span > .exports = _;
}
exports._ = _;
} < span class = "hljs-keyword" > else< / span > {
root._ = _;
}< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-12" >
< div class = "annotation" >
2017-04-21 08:10:07 +00:00
< div class = "pilwrap " >
2016-03-11 00:48:53 +00:00
< a class = "pilcrow" href = "#section-12" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Current version.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.VERSION = < span class = "hljs-string" > '1.8.3'< / span > ;< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-13" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-13" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Internal function that returns an efficient (for current engines) version
of the passed-in callback, to be repeatedly applied in other Underscore
functions.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > < span class = "hljs-keyword" > var< / span > optimizeCb = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (func, context, argCount)< / span > < / span > {
< span class = "hljs-keyword" > if< / span > (context === < span class = "hljs-keyword" > void< / span > < span class = "hljs-number" > 0< / span > ) < span class = "hljs-keyword" > return< / span > func;
< span class = "hljs-keyword" > switch< / span > (argCount == < span class = "hljs-literal" > null< / span > ? < span class = "hljs-number" > 3< / span > : argCount) {
< span class = "hljs-keyword" > case< / span > < span class = "hljs-number" > 1< / span > : < span class = "hljs-keyword" > return< / span > < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (value)< / span > < / span > {
< span class = "hljs-keyword" > return< / span > func.call(context, value);
};
< span class = "hljs-keyword" > case< / span > < span class = "hljs-number" > 2< / span > : < span class = "hljs-keyword" > return< / span > < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (value, other)< / span > < / span > {
< span class = "hljs-keyword" > return< / span > func.call(context, value, other);
};
< span class = "hljs-keyword" > case< / span > < span class = "hljs-number" > 3< / span > : < span class = "hljs-keyword" > return< / span > < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (value, index, collection)< / span > < / span > {
< span class = "hljs-keyword" > return< / span > func.call(context, value, index, collection);
};
< span class = "hljs-keyword" > case< / span > < span class = "hljs-number" > 4< / span > : < span class = "hljs-keyword" > return< / span > < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (accumulator, value, index, collection)< / span > < / span > {
< span class = "hljs-keyword" > return< / span > func.call(context, accumulator, value, index, collection);
};
2016-03-11 00:48:53 +00:00
}
2017-04-21 08:10:07 +00:00
< span class = "hljs-keyword" > return< / span > < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > ()< / span > < / span > {
< span class = "hljs-keyword" > return< / span > func.apply(context, < span class = "hljs-built_in" > arguments< / span > );
};
2016-03-11 00:48:53 +00:00
};< / pre > < / div > < / div >
< / li >
< li id = "section-14" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-14" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > A mostly-internal function to generate callbacks that can be applied
to each element in a collection, returning the desired result — either
identity, an arbitrary callback, a property matcher, or a property accessor.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > < span class = "hljs-keyword" > var< / span > cb = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (value, context, argCount)< / span > < / span > {
< span class = "hljs-keyword" > if< / span > (value == < span class = "hljs-literal" > null< / span > ) < span class = "hljs-keyword" > return< / span > _.identity;
< span class = "hljs-keyword" > if< / span > (_.isFunction(value)) < span class = "hljs-keyword" > return< / span > optimizeCb(value, context, argCount);
< span class = "hljs-keyword" > if< / span > (_.isObject(value)) < span class = "hljs-keyword" > return< / span > _.matcher(value);
< span class = "hljs-keyword" > return< / span > _.property(value);
2016-03-11 00:48:53 +00:00
};
2017-04-21 08:10:07 +00:00
_.iteratee = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (value, context)< / span > < / span > {
< span class = "hljs-keyword" > return< / span > cb(value, context, < span class = "hljs-literal" > Infinity< / span > );
};< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-15" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-15" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > An internal function for creating assigner functions.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > < span class = "hljs-keyword" > var< / span > createAssigner = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (keysFunc, undefinedOnly)< / span > < / span > {
< span class = "hljs-keyword" > return< / span > < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (obj)< / span > < / span > {
< span class = "hljs-keyword" > var< / span > length = < span class = "hljs-built_in" > arguments< / span > .length;
< span class = "hljs-keyword" > if< / span > (length < < span class = "hljs-number" > 2< / span > || obj == < span class = "hljs-literal" > null< / span > ) < span class = "hljs-keyword" > return< / span > obj;
< span class = "hljs-keyword" > for< / span > (< span class = "hljs-keyword" > var< / span > index = < span class = "hljs-number" > 1< / span > ; index < length; index++) {
< span class = "hljs-keyword" > var< / span > source = < span class = "hljs-built_in" > arguments< / span > [index],
keys = keysFunc(source),
l = keys.length;
< span class = "hljs-keyword" > for< / span > (< span class = "hljs-keyword" > var< / span > i = < span class = "hljs-number" > 0< / span > ; i < l; i++) {
< span class = "hljs-keyword" > var< / span > key = keys[i];
< span class = "hljs-keyword" > if< / span > (!undefinedOnly || obj[key] === < span class = "hljs-keyword" > void< / span > < span class = "hljs-number" > 0< / span > ) obj[key] = source[key];
}
2016-03-11 00:48:53 +00:00
}
2017-04-21 08:10:07 +00:00
< span class = "hljs-keyword" > return< / span > obj;
};
2016-03-11 00:48:53 +00:00
};< / pre > < / div > < / div >
< / li >
< li id = "section-16" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-16" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > An internal function for creating a new object that inherits from another.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > < span class = "hljs-keyword" > var< / span > baseCreate = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (prototype)< / span > < / span > {
< span class = "hljs-keyword" > if< / span > (!_.isObject(prototype)) < span class = "hljs-keyword" > return< / span > {};
< span class = "hljs-keyword" > if< / span > (nativeCreate) < span class = "hljs-keyword" > return< / span > nativeCreate(prototype);
Ctor.prototype = prototype;
< span class = "hljs-keyword" > var< / span > result = < span class = "hljs-keyword" > new< / span > Ctor;
Ctor.prototype = < span class = "hljs-literal" > null< / span > ;
< span class = "hljs-keyword" > return< / span > result;
};
< span class = "hljs-keyword" > var< / span > property = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (key)< / span > < / span > {
< span class = "hljs-keyword" > return< / span > < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (obj)< / span > < / span > {
< span class = "hljs-keyword" > return< / span > obj == < span class = "hljs-literal" > null< / span > ? < span class = "hljs-keyword" > void< / span > < span class = "hljs-number" > 0< / span > : obj[key];
};
2016-03-11 00:48:53 +00:00
};< / pre > < / div > < / div >
< / li >
< li id = "section-17" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-17" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Helper for collection methods to determine whether a collection
should be iterated as an array or as an object
Related: < a href = "http://people.mozilla.org/~jorendorff/es6-draft.html#sec-tolength" > http://people.mozilla.org/~jorendorff/es6-draft.html#sec-tolength< / a >
Avoids a very nasty iOS 8 JIT bug on ARM-64. #2094< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > < span class = "hljs-keyword" > var< / span > MAX_ARRAY_INDEX = < span class = "hljs-built_in" > Math< / span > .pow(< span class = "hljs-number" > 2< / span > , < span class = "hljs-number" > 53< / span > ) - < span class = "hljs-number" > 1< / span > ;
< span class = "hljs-keyword" > var< / span > getLength = property(< span class = "hljs-string" > 'length'< / span > );
< span class = "hljs-keyword" > var< / span > isArrayLike = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (collection)< / span > < / span > {
< span class = "hljs-keyword" > var< / span > length = getLength(collection);
< span class = "hljs-keyword" > return< / span > < span class = "hljs-keyword" > typeof< / span > length == < span class = "hljs-string" > 'number'< / span > & & length > = < span class = "hljs-number" > 0< / span > & & length < = MAX_ARRAY_INDEX;
2016-03-11 00:48:53 +00:00
};< / pre > < / div > < / div >
< / li >
< li id = "section-18" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-18" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< h2 id = "collection-functions" > Collection Functions< / h2 >
2016-03-11 00:48:53 +00:00
< / div >
< / li >
< li id = "section-19" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-19" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
2016-03-11 00:48:53 +00:00
< / div >
< / li >
< li id = "section-20" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-20" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > The cornerstone, an < code > each< / code > implementation, aka < code > forEach< / code > .
Handles raw objects in addition to array-likes. Treats all
sparse array-likes as if they were dense.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.each = _.forEach = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (obj, iteratee, context)< / span > < / span > {
iteratee = optimizeCb(iteratee, context);
< span class = "hljs-keyword" > var< / span > i, length;
< span class = "hljs-keyword" > if< / span > (isArrayLike(obj)) {
< span class = "hljs-keyword" > for< / span > (i = < span class = "hljs-number" > 0< / span > , length = obj.length; i < length; i++) {
iteratee(obj[i], i, obj);
}
} < span class = "hljs-keyword" > else< / span > {
< span class = "hljs-keyword" > var< / span > keys = _.keys(obj);
< span class = "hljs-keyword" > for< / span > (i = < span class = "hljs-number" > 0< / span > , length = keys.length; i < length; i++) {
iteratee(obj[keys[i]], keys[i], obj);
}
}
< span class = "hljs-keyword" > return< / span > obj;
2016-03-11 00:48:53 +00:00
};< / pre > < / div > < / div >
< / li >
< li id = "section-21" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-21" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Return the results of applying the iteratee to each element.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.map = _.collect = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (obj, iteratee, context)< / span > < / span > {
iteratee = cb(iteratee, context);
< span class = "hljs-keyword" > var< / span > keys = !isArrayLike(obj) & & _.keys(obj),
length = (keys || obj).length,
results = < span class = "hljs-built_in" > Array< / span > (length);
< span class = "hljs-keyword" > for< / span > (< span class = "hljs-keyword" > var< / span > index = < span class = "hljs-number" > 0< / span > ; index < length; index++) {
< span class = "hljs-keyword" > var< / span > currentKey = keys ? keys[index] : index;
results[index] = iteratee(obj[currentKey], currentKey, obj);
}
< span class = "hljs-keyword" > return< / span > results;
2016-03-11 00:48:53 +00:00
};< / pre > < / div > < / div >
< / li >
< li id = "section-22" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-22" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Create a reducing function iterating left or right.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-title" > createReduce< / span > < span class = "hljs-params" > (dir)< / span > < / span > {< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-23" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-23" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Optimized iterator function as using arguments.length
in the main function will deoptimize the, see #1991.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-title" > iterator< / span > < span class = "hljs-params" > (obj, iteratee, memo, keys, index, length)< / span > < / span > {
< span class = "hljs-keyword" > for< / span > (; index > = < span class = "hljs-number" > 0< / span > & & index < length; index += dir) {
< span class = "hljs-keyword" > var< / span > currentKey = keys ? keys[index] : index;
memo = iteratee(memo, obj[currentKey], currentKey, obj);
}
< span class = "hljs-keyword" > return< / span > memo;
}
< span class = "hljs-keyword" > return< / span > < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (obj, iteratee, memo, context)< / span > < / span > {
iteratee = optimizeCb(iteratee, context, < span class = "hljs-number" > 4< / span > );
< span class = "hljs-keyword" > var< / span > keys = !isArrayLike(obj) & & _.keys(obj),
length = (keys || obj).length,
index = dir > < span class = "hljs-number" > 0< / span > ? < span class = "hljs-number" > 0< / span > : length - < span class = "hljs-number" > 1< / span > ;< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-24" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-24" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Determine the initial value if none is provided.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > < span class = "hljs-keyword" > if< / span > (< span class = "hljs-built_in" > arguments< / span > .length < < span class = "hljs-number" > 3< / span > ) {
memo = obj[keys ? keys[index] : index];
index += dir;
}
< span class = "hljs-keyword" > return< / span > iterator(obj, iteratee, memo, keys, index, length);
};
}< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-25" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-25" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > < strong > Reduce< / strong > builds up a single result from a list of values, aka < code > inject< / code > ,
or < code > foldl< / code > .< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.reduce = _.foldl = _.inject = createReduce(< span class = "hljs-number" > 1< / span > );< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-26" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-26" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > The right-associative version of reduce, also known as < code > foldr< / code > .< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.reduceRight = _.foldr = createReduce(-< span class = "hljs-number" > 1< / span > );< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-27" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-27" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Return the first value which passes a truth test. Aliased as < code > detect< / code > .< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.find = _.detect = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (obj, predicate, context)< / span > < / span > {
< span class = "hljs-keyword" > var< / span > key;
< span class = "hljs-keyword" > if< / span > (isArrayLike(obj)) {
key = _.findIndex(obj, predicate, context);
} < span class = "hljs-keyword" > else< / span > {
key = _.findKey(obj, predicate, context);
2016-03-11 00:48:53 +00:00
}
2017-04-21 08:10:07 +00:00
< span class = "hljs-keyword" > if< / span > (key !== < span class = "hljs-keyword" > void< / span > < span class = "hljs-number" > 0< / span > & & key !== -< span class = "hljs-number" > 1< / span > ) < span class = "hljs-keyword" > return< / span > obj[key];
2016-03-11 00:48:53 +00:00
};< / pre > < / div > < / div >
< / li >
< li id = "section-28" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-28" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Return all the elements that pass a truth test.
Aliased as < code > select< / code > .< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.filter = _.select = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (obj, predicate, context)< / span > < / span > {
< span class = "hljs-keyword" > var< / span > results = [];
predicate = cb(predicate, context);
_.each(obj, < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (value, index, list)< / span > < / span > {
< span class = "hljs-keyword" > if< / span > (predicate(value, index, list)) results.push(value);
2016-03-11 00:48:53 +00:00
});
2017-04-21 08:10:07 +00:00
< span class = "hljs-keyword" > return< / span > results;
2016-03-11 00:48:53 +00:00
};< / pre > < / div > < / div >
< / li >
< li id = "section-29" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-29" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Return all the elements for which a truth test fails.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.reject = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (obj, predicate, context)< / span > < / span > {
< span class = "hljs-keyword" > return< / span > _.filter(obj, _.negate(cb(predicate)), context);
2016-03-11 00:48:53 +00:00
};< / pre > < / div > < / div >
< / li >
< li id = "section-30" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-30" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Determine whether all of the elements match a truth test.
Aliased as < code > all< / code > .< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.every = _.all = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (obj, predicate, context)< / span > < / span > {
predicate = cb(predicate, context);
< span class = "hljs-keyword" > var< / span > keys = !isArrayLike(obj) & & _.keys(obj),
length = (keys || obj).length;
< span class = "hljs-keyword" > for< / span > (< span class = "hljs-keyword" > var< / span > index = < span class = "hljs-number" > 0< / span > ; index < length; index++) {
< span class = "hljs-keyword" > var< / span > currentKey = keys ? keys[index] : index;
< span class = "hljs-keyword" > if< / span > (!predicate(obj[currentKey], currentKey, obj)) < span class = "hljs-keyword" > return< / span > < span class = "hljs-literal" > false< / span > ;
2016-03-11 00:48:53 +00:00
}
2017-04-21 08:10:07 +00:00
< span class = "hljs-keyword" > return< / span > < span class = "hljs-literal" > true< / span > ;
2016-03-11 00:48:53 +00:00
};< / pre > < / div > < / div >
< / li >
< li id = "section-31" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-31" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Determine if at least one element in the object matches a truth test.
Aliased as < code > any< / code > .< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.some = _.any = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (obj, predicate, context)< / span > < / span > {
predicate = cb(predicate, context);
< span class = "hljs-keyword" > var< / span > keys = !isArrayLike(obj) & & _.keys(obj),
length = (keys || obj).length;
< span class = "hljs-keyword" > for< / span > (< span class = "hljs-keyword" > var< / span > index = < span class = "hljs-number" > 0< / span > ; index < length; index++) {
< span class = "hljs-keyword" > var< / span > currentKey = keys ? keys[index] : index;
< span class = "hljs-keyword" > if< / span > (predicate(obj[currentKey], currentKey, obj)) < span class = "hljs-keyword" > return< / span > < span class = "hljs-literal" > true< / span > ;
}
< span class = "hljs-keyword" > return< / span > < span class = "hljs-literal" > false< / span > ;
2016-03-11 00:48:53 +00:00
};< / pre > < / div > < / div >
< / li >
< li id = "section-32" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-32" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Determine if the array or object contains a given item (using < code > ===< / code > ).
Aliased as < code > includes< / code > and < code > include< / code > .< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.contains = _.includes = _.include = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (obj, item, fromIndex, guard)< / span > < / span > {
< span class = "hljs-keyword" > if< / span > (!isArrayLike(obj)) obj = _.values(obj);
< span class = "hljs-keyword" > if< / span > (< span class = "hljs-keyword" > typeof< / span > fromIndex != < span class = "hljs-string" > 'number'< / span > || guard) fromIndex = < span class = "hljs-number" > 0< / span > ;
< span class = "hljs-keyword" > return< / span > _.indexOf(obj, item, fromIndex) > = < span class = "hljs-number" > 0< / span > ;
2016-03-11 00:48:53 +00:00
};< / pre > < / div > < / div >
< / li >
< li id = "section-33" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-33" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Invoke a method (with arguments) on every item in a collection.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.invoke = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (obj, method)< / span > < / span > {
< span class = "hljs-keyword" > var< / span > args = slice.call(< span class = "hljs-built_in" > arguments< / span > , < span class = "hljs-number" > 2< / span > );
< span class = "hljs-keyword" > var< / span > isFunc = _.isFunction(method);
< span class = "hljs-keyword" > return< / span > _.map(obj, < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (value)< / span > < / span > {
< span class = "hljs-keyword" > var< / span > func = isFunc ? method : value[method];
< span class = "hljs-keyword" > return< / span > func == < span class = "hljs-literal" > null< / span > ? func : func.apply(value, args);
});
2016-03-11 00:48:53 +00:00
};< / pre > < / div > < / div >
< / li >
< li id = "section-34" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-34" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Convenience version of a common use case of < code > map< / code > : fetching a property.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.pluck = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (obj, key)< / span > < / span > {
< span class = "hljs-keyword" > return< / span > _.map(obj, _.property(key));
};< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-35" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-35" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Convenience version of a common use case of < code > filter< / code > : selecting only objects
containing specific < code > key:value< / code > pairs.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.where = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (obj, attrs)< / span > < / span > {
< span class = "hljs-keyword" > return< / span > _.filter(obj, _.matcher(attrs));
};< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-36" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-36" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Convenience version of a common use case of < code > find< / code > : getting the first object
containing specific < code > key:value< / code > pairs.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.findWhere = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (obj, attrs)< / span > < / span > {
< span class = "hljs-keyword" > return< / span > _.find(obj, _.matcher(attrs));
};< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-37" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-37" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Return the maximum element (or element-based computation).< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.max = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (obj, iteratee, context)< / span > < / span > {
< span class = "hljs-keyword" > var< / span > result = -< span class = "hljs-literal" > Infinity< / span > , lastComputed = -< span class = "hljs-literal" > Infinity< / span > ,
value, computed;
< span class = "hljs-keyword" > if< / span > (iteratee == < span class = "hljs-literal" > null< / span > & & obj != < span class = "hljs-literal" > null< / span > ) {
obj = isArrayLike(obj) ? obj : _.values(obj);
< span class = "hljs-keyword" > for< / span > (< span class = "hljs-keyword" > var< / span > i = < span class = "hljs-number" > 0< / span > , length = obj.length; i < length; i++) {
value = obj[i];
< span class = "hljs-keyword" > if< / span > (value > result) {
result = value;
}
}
} < span class = "hljs-keyword" > else< / span > {
iteratee = cb(iteratee, context);
_.each(obj, < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (value, index, list)< / span > < / span > {
computed = iteratee(value, index, list);
< span class = "hljs-keyword" > if< / span > (computed > lastComputed || computed === -< span class = "hljs-literal" > Infinity< / span > & & result === -< span class = "hljs-literal" > Infinity< / span > ) {
result = value;
lastComputed = computed;
}
});
2016-03-11 00:48:53 +00:00
}
2017-04-21 08:10:07 +00:00
< span class = "hljs-keyword" > return< / span > result;
2016-03-11 00:48:53 +00:00
};< / pre > < / div > < / div >
< / li >
< li id = "section-38" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-38" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Return the minimum element (or element-based computation).< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.min = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (obj, iteratee, context)< / span > < / span > {
< span class = "hljs-keyword" > var< / span > result = < span class = "hljs-literal" > Infinity< / span > , lastComputed = < span class = "hljs-literal" > Infinity< / span > ,
value, computed;
< span class = "hljs-keyword" > if< / span > (iteratee == < span class = "hljs-literal" > null< / span > & & obj != < span class = "hljs-literal" > null< / span > ) {
obj = isArrayLike(obj) ? obj : _.values(obj);
< span class = "hljs-keyword" > for< / span > (< span class = "hljs-keyword" > var< / span > i = < span class = "hljs-number" > 0< / span > , length = obj.length; i < length; i++) {
value = obj[i];
< span class = "hljs-keyword" > if< / span > (value < result) {
result = value;
}
}
} < span class = "hljs-keyword" > else< / span > {
iteratee = cb(iteratee, context);
_.each(obj, < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (value, index, list)< / span > < / span > {
computed = iteratee(value, index, list);
< span class = "hljs-keyword" > if< / span > (computed < lastComputed || computed === < span class = "hljs-literal" > Infinity< / span > & & result === < span class = "hljs-literal" > Infinity< / span > ) {
result = value;
lastComputed = computed;
}
});
}
< span class = "hljs-keyword" > return< / span > result;
2016-03-11 00:48:53 +00:00
};< / pre > < / div > < / div >
< / li >
< li id = "section-39" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-39" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Shuffle a collection, using the modern version of the
< a href = "http://en.wikipedia.org/wiki/Fisher– > Fisher-Yates shuffle< / a > .< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.shuffle = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (obj)< / span > < / span > {
< span class = "hljs-keyword" > var< / span > set = isArrayLike(obj) ? obj : _.values(obj);
< span class = "hljs-keyword" > var< / span > length = set.length;
< span class = "hljs-keyword" > var< / span > shuffled = < span class = "hljs-built_in" > Array< / span > (length);
< span class = "hljs-keyword" > for< / span > (< span class = "hljs-keyword" > var< / span > index = < span class = "hljs-number" > 0< / span > , rand; index < length; index++) {
rand = _.random(< span class = "hljs-number" > 0< / span > , index);
< span class = "hljs-keyword" > if< / span > (rand !== index) shuffled[index] = shuffled[rand];
shuffled[rand] = set[index];
}
< span class = "hljs-keyword" > return< / span > shuffled;
2016-03-11 00:48:53 +00:00
};< / pre > < / div > < / div >
< / li >
< li id = "section-40" >
< div class = "annotation" >
2017-04-21 08:10:07 +00:00
< div class = "pilwrap " >
2016-03-11 00:48:53 +00:00
< a class = "pilcrow" href = "#section-40" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Sample < strong > n< / strong > random values from a collection.
If < strong > n< / strong > is not specified, returns a single random element.
The internal < code > guard< / code > argument allows it to work with < code > map< / code > .< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.sample = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (obj, n, guard)< / span > < / span > {
< span class = "hljs-keyword" > if< / span > (n == < span class = "hljs-literal" > null< / span > || guard) {
< span class = "hljs-keyword" > if< / span > (!isArrayLike(obj)) obj = _.values(obj);
< span class = "hljs-keyword" > return< / span > obj[_.random(obj.length - < span class = "hljs-number" > 1< / span > )];
}
< span class = "hljs-keyword" > return< / span > _.shuffle(obj).slice(< span class = "hljs-number" > 0< / span > , < span class = "hljs-built_in" > Math< / span > .max(< span class = "hljs-number" > 0< / span > , n));
};< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-41" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-41" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Sort the object’ < / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.sortBy = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (obj, iteratee, context)< / span > < / span > {
iteratee = cb(iteratee, context);
< span class = "hljs-keyword" > return< / span > _.pluck(_.map(obj, < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (value, index, list)< / span > < / span > {
< span class = "hljs-keyword" > return< / span > {
value: value,
index: index,
criteria: iteratee(value, index, list)
};
}).sort(< span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (left, right)< / span > < / span > {
< span class = "hljs-keyword" > var< / span > a = left.criteria;
< span class = "hljs-keyword" > var< / span > b = right.criteria;
< span class = "hljs-keyword" > if< / span > (a !== b) {
< span class = "hljs-keyword" > if< / span > (a > b || a === < span class = "hljs-keyword" > void< / span > < span class = "hljs-number" > 0< / span > ) < span class = "hljs-keyword" > return< / span > < span class = "hljs-number" > 1< / span > ;
< span class = "hljs-keyword" > if< / span > (a < b || b === < span class = "hljs-keyword" > void< / span > < span class = "hljs-number" > 0< / span > ) < span class = "hljs-keyword" > return< / span > -< span class = "hljs-number" > 1< / span > ;
}
< span class = "hljs-keyword" > return< / span > left.index - right.index;
}), < span class = "hljs-string" > 'value'< / span > );
2016-03-11 00:48:53 +00:00
};< / pre > < / div > < / div >
< / li >
< li id = "section-42" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-42" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > An internal function used for aggregate “group by” operations.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > < span class = "hljs-keyword" > var< / span > group = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (behavior)< / span > < / span > {
< span class = "hljs-keyword" > return< / span > < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (obj, iteratee, context)< / span > < / span > {
< span class = "hljs-keyword" > var< / span > result = {};
iteratee = cb(iteratee, context);
_.each(obj, < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (value, index)< / span > < / span > {
< span class = "hljs-keyword" > var< / span > key = iteratee(value, index, obj);
behavior(result, value, key);
});
< span class = "hljs-keyword" > return< / span > result;
};
2016-03-11 00:48:53 +00:00
};< / pre > < / div > < / div >
< / li >
< li id = "section-43" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-43" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Groups the object’
to group by, or a function that returns the criterion.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.groupBy = group(< span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (result, value, key)< / span > < / span > {
< span class = "hljs-keyword" > if< / span > (_.has(result, key)) result[key].push(value); < span class = "hljs-keyword" > else< / span > result[key] = [value];
});< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-44" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-44" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Indexes the object’ < code > groupBy< / code > , but for
when you know that your index values will be unique.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.indexBy = group(< span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (result, value, key)< / span > < / span > {
result[key] = value;
});< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-45" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-45" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Counts instances of an object that group by a certain criterion. Pass
either a string attribute to count by, or a function that returns the
criterion.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.countBy = group(< span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (result, value, key)< / span > < / span > {
< span class = "hljs-keyword" > if< / span > (_.has(result, key)) result[key]++; < span class = "hljs-keyword" > else< / span > result[key] = < span class = "hljs-number" > 1< / span > ;
});< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-46" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-46" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Safely create a real, live array from anything iterable.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.toArray = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (obj)< / span > < / span > {
< span class = "hljs-keyword" > if< / span > (!obj) < span class = "hljs-keyword" > return< / span > [];
< span class = "hljs-keyword" > if< / span > (_.isArray(obj)) < span class = "hljs-keyword" > return< / span > slice.call(obj);
< span class = "hljs-keyword" > if< / span > (isArrayLike(obj)) < span class = "hljs-keyword" > return< / span > _.map(obj, _.identity);
< span class = "hljs-keyword" > return< / span > _.values(obj);
2016-03-11 00:48:53 +00:00
};< / pre > < / div > < / div >
< / li >
< li id = "section-47" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-47" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Return the number of elements in an object.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.size = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (obj)< / span > < / span > {
< span class = "hljs-keyword" > if< / span > (obj == < span class = "hljs-literal" > null< / span > ) < span class = "hljs-keyword" > return< / span > < span class = "hljs-number" > 0< / span > ;
< span class = "hljs-keyword" > return< / span > isArrayLike(obj) ? obj.length : _.keys(obj).length;
2016-03-11 00:48:53 +00:00
};< / pre > < / div > < / div >
< / li >
< li id = "section-48" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-48" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Split a collection into two arrays: one whose elements all satisfy the given
predicate, and one whose elements all do not satisfy the predicate.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.partition = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (obj, predicate, context)< / span > < / span > {
predicate = cb(predicate, context);
< span class = "hljs-keyword" > var< / span > pass = [], fail = [];
_.each(obj, < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (value, key, obj)< / span > < / span > {
(predicate(value, key, obj) ? pass : fail).push(value);
});
< span class = "hljs-keyword" > return< / span > [pass, fail];
2016-03-11 00:48:53 +00:00
};< / pre > < / div > < / div >
< / li >
2017-04-21 08:10:07 +00:00
2016-03-11 00:48:53 +00:00
< li id = "section-49" >
< div class = "annotation" >
< div class = "pilwrap " >
2017-04-21 08:10:07 +00:00
< a class = "pilcrow" href = "#section-55" > ¶ < / a >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< p > Trim out all falsy values from an object.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.compact = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (obj)< / span > < / span > {
< span class = "hljs-keyword" > return< / span > _.filter(obj, _.identity);
2016-03-11 00:48:53 +00:00
};< / pre > < / div > < / div >
< / li >
2017-04-21 08:10:07 +00:00
2016-03-11 00:48:53 +00:00
< li id = "section-50" >
< div class = "annotation" >
< div class = "pilwrap " >
2017-04-21 08:10:07 +00:00
< a class = "pilcrow" href = "#section-49" > ¶ < / a >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< h2 id = "array-functions" > Array Functions< / h2 >
2016-03-11 00:48:53 +00:00
< / div >
< / li >
< li id = "section-51" >
< div class = "annotation" >
< div class = "pilwrap " >
2017-04-21 08:10:07 +00:00
< a class = "pilcrow" href = "#section-50" > ¶ < / a >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
2016-03-11 00:48:53 +00:00
< / div >
< / li >
< li id = "section-52" >
< div class = "annotation" >
< div class = "pilwrap " >
2017-04-21 08:10:07 +00:00
< a class = "pilcrow" href = "#section-51" > ¶ < / a >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< p > Get the first element of an array. Passing < strong > n< / strong > will return the first N
values in the array. Aliased as < code > head< / code > and < code > take< / code > . The < strong > guard< / strong > check
allows it to work with < code > _.map< / code > .< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.first = _.head = _.take = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (array, n, guard)< / span > < / span > {
< span class = "hljs-keyword" > if< / span > (array == < span class = "hljs-literal" > null< / span > ) < span class = "hljs-keyword" > return< / span > < span class = "hljs-keyword" > void< / span > < span class = "hljs-number" > 0< / span > ;
< span class = "hljs-keyword" > if< / span > (n == < span class = "hljs-literal" > null< / span > || guard) < span class = "hljs-keyword" > return< / span > array[< span class = "hljs-number" > 0< / span > ];
< span class = "hljs-keyword" > return< / span > _.initial(array, array.length - n);
2016-03-11 00:48:53 +00:00
};< / pre > < / div > < / div >
< / li >
< li id = "section-53" >
< div class = "annotation" >
< div class = "pilwrap " >
2017-04-21 08:10:07 +00:00
< a class = "pilcrow" href = "#section-52" > ¶ < / a >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< p > Returns everything but the last entry of the array. Especially useful on
the arguments object. Passing < strong > n< / strong > will return all the values in
the array, excluding the last N.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.initial = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (array, n, guard)< / span > < / span > {
< span class = "hljs-keyword" > return< / span > slice.call(array, < span class = "hljs-number" > 0< / span > , < span class = "hljs-built_in" > Math< / span > .max(< span class = "hljs-number" > 0< / span > , array.length - (n == < span class = "hljs-literal" > null< / span > || guard ? < span class = "hljs-number" > 1< / span > : n)));
2016-03-11 00:48:53 +00:00
};< / pre > < / div > < / div >
< / li >
< li id = "section-54" >
< div class = "annotation" >
< div class = "pilwrap " >
2017-04-21 08:10:07 +00:00
< a class = "pilcrow" href = "#section-53" > ¶ < / a >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< p > Get the last element of an array. Passing < strong > n< / strong > will return the last N
values in the array.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.last = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (array, n, guard)< / span > < / span > {
< span class = "hljs-keyword" > if< / span > (array == < span class = "hljs-literal" > null< / span > ) < span class = "hljs-keyword" > return< / span > < span class = "hljs-keyword" > void< / span > < span class = "hljs-number" > 0< / span > ;
< span class = "hljs-keyword" > if< / span > (n == < span class = "hljs-literal" > null< / span > || guard) < span class = "hljs-keyword" > return< / span > array[array.length - < span class = "hljs-number" > 1< / span > ];
< span class = "hljs-keyword" > return< / span > _.rest(array, < span class = "hljs-built_in" > Math< / span > .max(< span class = "hljs-number" > 0< / span > , array.length - n));
2016-03-11 00:48:53 +00:00
};< / pre > < / div > < / div >
< / li >
< li id = "section-55" >
< div class = "annotation" >
< div class = "pilwrap " >
2017-04-21 08:10:07 +00:00
< a class = "pilcrow" href = "#section-54" > ¶ < / a >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< p > Returns everything but the first entry of the array. Aliased as < code > tail< / code > and < code > drop< / code > .
Especially useful on the arguments object. Passing an < strong > n< / strong > will return
the rest N values in the array.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.rest = _.tail = _.drop = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (array, n, guard)< / span > < / span > {
< span class = "hljs-keyword" > return< / span > slice.call(array, n == < span class = "hljs-literal" > null< / span > || guard ? < span class = "hljs-number" > 1< / span > : n);
2016-03-11 00:48:53 +00:00
};< / pre > < / div > < / div >
2017-04-21 08:10:07 +00:00
< / li >
2016-03-11 00:48:53 +00:00
< li id = "section-56" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-56" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Internal implementation of a recursive < code > flatten< / code > function.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > < span class = "hljs-keyword" > var< / span > flatten = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (input, shallow, strict, startIndex)< / span > < / span > {
< span class = "hljs-keyword" > var< / span > output = [], idx = < span class = "hljs-number" > 0< / span > ;
< span class = "hljs-keyword" > for< / span > (< span class = "hljs-keyword" > var< / span > i = startIndex || < span class = "hljs-number" > 0< / span > , length = getLength(input); i < length; i++) {
< span class = "hljs-keyword" > var< / span > value = input[i];
< span class = "hljs-keyword" > if< / span > (isArrayLike(value) & & (_.isArray(value) || _.isArguments(value))) {< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-57" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-57" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > flatten current level of array or arguments object< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > < span class = "hljs-keyword" > if< / span > (!shallow) value = flatten(value, shallow, strict);
< span class = "hljs-keyword" > var< / span > j = < span class = "hljs-number" > 0< / span > , len = value.length;
output.length += len;
< span class = "hljs-keyword" > while< / span > (j < len) {
output[idx++] = value[j++];
}
} < span class = "hljs-keyword" > else< / span > < span class = "hljs-keyword" > if< / span > (!strict) {
output[idx++] = value;
}
2016-03-11 00:48:53 +00:00
}
2017-04-21 08:10:07 +00:00
< span class = "hljs-keyword" > return< / span > output;
2016-03-11 00:48:53 +00:00
};< / pre > < / div > < / div >
< / li >
< li id = "section-58" >
< div class = "annotation" >
2017-04-21 08:10:07 +00:00
< div class = "pilwrap " >
2016-03-11 00:48:53 +00:00
< a class = "pilcrow" href = "#section-58" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Flatten out an array, either recursively (by default), or just one level.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.flatten = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (array, shallow)< / span > < / span > {
< span class = "hljs-keyword" > return< / span > flatten(array, shallow, < span class = "hljs-literal" > false< / span > );
};< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-59" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-59" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Return a version of the array that does not contain the specified value(s).< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.without = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (array)< / span > < / span > {
< span class = "hljs-keyword" > return< / span > _.difference(array, slice.call(< span class = "hljs-built_in" > arguments< / span > , < span class = "hljs-number" > 1< / span > ));
};< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-60" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-60" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Produce a duplicate-free version of the array. If the array has already
been sorted, you have the option of using a faster algorithm.
Aliased as < code > unique< / code > .< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.uniq = _.unique = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (array, isSorted, iteratee, context)< / span > < / span > {
< span class = "hljs-keyword" > if< / span > (!_.isBoolean(isSorted)) {
context = iteratee;
iteratee = isSorted;
isSorted = < span class = "hljs-literal" > false< / span > ;
}
< span class = "hljs-keyword" > if< / span > (iteratee != < span class = "hljs-literal" > null< / span > ) iteratee = cb(iteratee, context);
< span class = "hljs-keyword" > var< / span > result = [];
< span class = "hljs-keyword" > var< / span > seen = [];
< span class = "hljs-keyword" > for< / span > (< span class = "hljs-keyword" > var< / span > i = < span class = "hljs-number" > 0< / span > , length = getLength(array); i < length; i++) {
< span class = "hljs-keyword" > var< / span > value = array[i],
computed = iteratee ? iteratee(value, i, array) : value;
< span class = "hljs-keyword" > if< / span > (isSorted) {
< span class = "hljs-keyword" > if< / span > (!i || seen !== computed) result.push(value);
seen = computed;
} < span class = "hljs-keyword" > else< / span > < span class = "hljs-keyword" > if< / span > (iteratee) {
< span class = "hljs-keyword" > if< / span > (!_.contains(seen, computed)) {
seen.push(computed);
result.push(value);
}
} < span class = "hljs-keyword" > else< / span > < span class = "hljs-keyword" > if< / span > (!_.contains(result, value)) {
result.push(value);
}
}
< span class = "hljs-keyword" > return< / span > result;
2016-03-11 00:48:53 +00:00
};< / pre > < / div > < / div >
< / li >
< li id = "section-61" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-61" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Produce an array that contains the union: each distinct element from all of
the passed-in arrays.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.union = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > ()< / span > < / span > {
< span class = "hljs-keyword" > return< / span > _.uniq(flatten(< span class = "hljs-built_in" > arguments< / span > , < span class = "hljs-literal" > true< / span > , < span class = "hljs-literal" > true< / span > ));
2016-03-11 00:48:53 +00:00
};< / pre > < / div > < / div >
< / li >
< li id = "section-62" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-62" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Produce an array that contains every item shared between all the
passed-in arrays.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.intersection = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (array)< / span > < / span > {
< span class = "hljs-keyword" > var< / span > result = [];
< span class = "hljs-keyword" > var< / span > argsLength = < span class = "hljs-built_in" > arguments< / span > .length;
< span class = "hljs-keyword" > for< / span > (< span class = "hljs-keyword" > var< / span > i = < span class = "hljs-number" > 0< / span > , length = getLength(array); i < length; i++) {
< span class = "hljs-keyword" > var< / span > item = array[i];
< span class = "hljs-keyword" > if< / span > (_.contains(result, item)) < span class = "hljs-keyword" > continue< / span > ;
< span class = "hljs-keyword" > for< / span > (< span class = "hljs-keyword" > var< / span > j = < span class = "hljs-number" > 1< / span > ; j < argsLength; j++) {
< span class = "hljs-keyword" > if< / span > (!_.contains(< span class = "hljs-built_in" > arguments< / span > [j], item)) < span class = "hljs-keyword" > break< / span > ;
}
< span class = "hljs-keyword" > if< / span > (j === argsLength) result.push(item);
}
< span class = "hljs-keyword" > return< / span > result;
2016-03-11 00:48:53 +00:00
};< / pre > < / div > < / div >
< / li >
< li id = "section-63" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-63" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Take the difference between one array and a number of other arrays.
Only the elements present in just the first array will remain.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.difference = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (array)< / span > < / span > {
< span class = "hljs-keyword" > var< / span > rest = flatten(< span class = "hljs-built_in" > arguments< / span > , < span class = "hljs-literal" > true< / span > , < span class = "hljs-literal" > true< / span > , < span class = "hljs-number" > 1< / span > );
< span class = "hljs-keyword" > return< / span > _.filter(array, < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (value)< / span > < / span > {
< span class = "hljs-keyword" > return< / span > !_.contains(rest, value);
});
2016-03-11 00:48:53 +00:00
};< / pre > < / div > < / div >
< / li >
< li id = "section-64" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-64" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Zip together multiple lists into a single array — elements that share
an index go together.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.zip = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > ()< / span > < / span > {
< span class = "hljs-keyword" > return< / span > _.unzip(< span class = "hljs-built_in" > arguments< / span > );
2016-03-11 00:48:53 +00:00
};< / pre > < / div > < / div >
< / li >
< li id = "section-65" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-65" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Complement of _.zip. Unzip accepts an array of arrays and groups
each array’ < / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.unzip = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (array)< / span > < / span > {
< span class = "hljs-keyword" > var< / span > length = array & & _.max(array, getLength).length || < span class = "hljs-number" > 0< / span > ;
< span class = "hljs-keyword" > var< / span > result = < span class = "hljs-built_in" > Array< / span > (length);
< span class = "hljs-keyword" > for< / span > (< span class = "hljs-keyword" > var< / span > index = < span class = "hljs-number" > 0< / span > ; index < length; index++) {
result[index] = _.pluck(array, index);
}
< span class = "hljs-keyword" > return< / span > result;
2016-03-11 00:48:53 +00:00
};< / pre > < / div > < / div >
< / li >
< li id = "section-66" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-66" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Converts lists into objects. Pass either a single array of < code > [key, value]< / code >
pairs, or two parallel arrays of the same length — one of keys, and one of
the corresponding values.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.object = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (list, values)< / span > < / span > {
< span class = "hljs-keyword" > var< / span > result = {};
< span class = "hljs-keyword" > for< / span > (< span class = "hljs-keyword" > var< / span > i = < span class = "hljs-number" > 0< / span > , length = getLength(list); i < length; i++) {
< span class = "hljs-keyword" > if< / span > (values) {
result[list[i]] = values[i];
} < span class = "hljs-keyword" > else< / span > {
result[list[i][< span class = "hljs-number" > 0< / span > ]] = list[i][< span class = "hljs-number" > 1< / span > ];
2016-03-11 00:48:53 +00:00
}
2017-04-21 08:10:07 +00:00
}
< span class = "hljs-keyword" > return< / span > result;
2016-03-11 00:48:53 +00:00
};< / pre > < / div > < / div >
< / li >
< li id = "section-67" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-67" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Generator function to create the findIndex and findLastIndex functions< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-title" > createPredicateIndexFinder< / span > < span class = "hljs-params" > (dir)< / span > < / span > {
< span class = "hljs-keyword" > return< / span > < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (array, predicate, context)< / span > < / span > {
predicate = cb(predicate, context);
< span class = "hljs-keyword" > var< / span > length = getLength(array);
< span class = "hljs-keyword" > var< / span > index = dir > < span class = "hljs-number" > 0< / span > ? < span class = "hljs-number" > 0< / span > : length - < span class = "hljs-number" > 1< / span > ;
< span class = "hljs-keyword" > for< / span > (; index > = < span class = "hljs-number" > 0< / span > & & index < length; index += dir) {
< span class = "hljs-keyword" > if< / span > (predicate(array[index], index, array)) < span class = "hljs-keyword" > return< / span > index;
2016-03-11 00:48:53 +00:00
}
2017-04-21 08:10:07 +00:00
< span class = "hljs-keyword" > return< / span > -< span class = "hljs-number" > 1< / span > ;
2016-03-11 00:48:53 +00:00
};
2017-04-21 08:10:07 +00:00
}< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-68" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-68" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Returns the first index on an array-like that passes a predicate test< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.findIndex = createPredicateIndexFinder(< span class = "hljs-number" > 1< / span > );
_.findLastIndex = createPredicateIndexFinder(-< span class = "hljs-number" > 1< / span > );< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-69" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-69" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Use a comparator function to figure out the smallest index at which
an object should be inserted so as to maintain order. Uses binary search.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.sortedIndex = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (array, obj, iteratee, context)< / span > < / span > {
iteratee = cb(iteratee, context, < span class = "hljs-number" > 1< / span > );
< span class = "hljs-keyword" > var< / span > value = iteratee(obj);
< span class = "hljs-keyword" > var< / span > low = < span class = "hljs-number" > 0< / span > , high = getLength(array);
< span class = "hljs-keyword" > while< / span > (low < high) {
< span class = "hljs-keyword" > var< / span > mid = < span class = "hljs-built_in" > Math< / span > .floor((low + high) / < span class = "hljs-number" > 2< / span > );
< span class = "hljs-keyword" > if< / span > (iteratee(array[mid]) < value) low = mid + < span class = "hljs-number" > 1< / span > ; < span class = "hljs-keyword" > else< / span > high = mid;
}
< span class = "hljs-keyword" > return< / span > low;
2016-03-11 00:48:53 +00:00
};< / pre > < / div > < / div >
< / li >
< li id = "section-70" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-70" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Generator function to create the indexOf and lastIndexOf functions< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-title" > createIndexFinder< / span > < span class = "hljs-params" > (dir, predicateFind, sortedIndex)< / span > < / span > {
< span class = "hljs-keyword" > return< / span > < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (array, item, idx)< / span > < / span > {
< span class = "hljs-keyword" > var< / span > i = < span class = "hljs-number" > 0< / span > , length = getLength(array);
< span class = "hljs-keyword" > if< / span > (< span class = "hljs-keyword" > typeof< / span > idx == < span class = "hljs-string" > 'number'< / span > ) {
< span class = "hljs-keyword" > if< / span > (dir > < span class = "hljs-number" > 0< / span > ) {
i = idx > = < span class = "hljs-number" > 0< / span > ? idx : < span class = "hljs-built_in" > Math< / span > .max(idx + length, i);
} < span class = "hljs-keyword" > else< / span > {
length = idx > = < span class = "hljs-number" > 0< / span > ? < span class = "hljs-built_in" > Math< / span > .min(idx + < span class = "hljs-number" > 1< / span > , length) : idx + length + < span class = "hljs-number" > 1< / span > ;
}
} < span class = "hljs-keyword" > else< / span > < span class = "hljs-keyword" > if< / span > (sortedIndex & & idx & & length) {
idx = sortedIndex(array, item);
< span class = "hljs-keyword" > return< / span > array[idx] === item ? idx : -< span class = "hljs-number" > 1< / span > ;
2016-03-11 00:48:53 +00:00
}
2017-04-21 08:10:07 +00:00
< span class = "hljs-keyword" > if< / span > (item !== item) {
idx = predicateFind(slice.call(array, i, length), _.isNaN);
< span class = "hljs-keyword" > return< / span > idx > = < span class = "hljs-number" > 0< / span > ? idx + i : -< span class = "hljs-number" > 1< / span > ;
}
< span class = "hljs-keyword" > for< / span > (idx = dir > < span class = "hljs-number" > 0< / span > ? i : length - < span class = "hljs-number" > 1< / span > ; idx > = < span class = "hljs-number" > 0< / span > & & idx < length; idx += dir) {
< span class = "hljs-keyword" > if< / span > (array[idx] === item) < span class = "hljs-keyword" > return< / span > idx;
}
< span class = "hljs-keyword" > return< / span > -< span class = "hljs-number" > 1< / span > ;
2016-03-11 00:48:53 +00:00
};
2017-04-21 08:10:07 +00:00
}< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-71" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-71" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Return the position of the first occurrence of an item in an array,
or -1 if the item is not included in the array.
If the array is large and already in sort order, pass < code > true< / code >
for < strong > isSorted< / strong > to use binary search.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.indexOf = createIndexFinder(< span class = "hljs-number" > 1< / span > , _.findIndex, _.sortedIndex);
_.lastIndexOf = createIndexFinder(-< span class = "hljs-number" > 1< / span > , _.findLastIndex);< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-72" >
< div class = "annotation" >
2017-04-21 08:10:07 +00:00
< div class = "pilwrap " >
2016-03-11 00:48:53 +00:00
< a class = "pilcrow" href = "#section-72" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Generate an integer Array containing an arithmetic progression. A port of
the native Python < code > range()< / code > function. See
< a href = "http://docs.python.org/library/functions.html#range" > the Python documentation< / a > .< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.range = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (start, stop, step)< / span > < / span > {
< span class = "hljs-keyword" > if< / span > (stop == < span class = "hljs-literal" > null< / span > ) {
stop = start || < span class = "hljs-number" > 0< / span > ;
start = < span class = "hljs-number" > 0< / span > ;
}
step = step || < span class = "hljs-number" > 1< / span > ;
< span class = "hljs-keyword" > var< / span > length = < span class = "hljs-built_in" > Math< / span > .max(< span class = "hljs-built_in" > Math< / span > .ceil((stop - start) / step), < span class = "hljs-number" > 0< / span > );
< span class = "hljs-keyword" > var< / span > range = < span class = "hljs-built_in" > Array< / span > (length);
< span class = "hljs-keyword" > for< / span > (< span class = "hljs-keyword" > var< / span > idx = < span class = "hljs-number" > 0< / span > ; idx < length; idx++, start += step) {
range[idx] = start;
}
< span class = "hljs-keyword" > return< / span > range;
};< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-73" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-73" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< h2 id = "function-ahem-functions" > Function (ahem) Functions< / h2 >
2016-03-11 00:48:53 +00:00
< / div >
< / li >
< li id = "section-74" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-74" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
2016-03-11 00:48:53 +00:00
< / div >
< / li >
< li id = "section-75" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-75" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Determines whether to execute a function as a constructor
or a normal function with the provided arguments< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > < span class = "hljs-keyword" > var< / span > executeBound = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (sourceFunc, boundFunc, context, callingContext, args)< / span > < / span > {
< span class = "hljs-keyword" > if< / span > (!(callingContext < span class = "hljs-keyword" > instanceof< / span > boundFunc)) < span class = "hljs-keyword" > return< / span > sourceFunc.apply(context, args);
< span class = "hljs-keyword" > var< / span > self = baseCreate(sourceFunc.prototype);
< span class = "hljs-keyword" > var< / span > result = sourceFunc.apply(self, args);
< span class = "hljs-keyword" > if< / span > (_.isObject(result)) < span class = "hljs-keyword" > return< / span > result;
< span class = "hljs-keyword" > return< / span > self;
2016-03-11 00:48:53 +00:00
};< / pre > < / div > < / div >
< / li >
< li id = "section-76" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-76" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Create a function bound to a given object (assigning < code > this< / code > , and arguments,
optionally). Delegates to < strong > ECMAScript 5< / strong > ‘ < code > Function.bind< / code > if
available.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.bind = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (func, context)< / span > < / span > {
< span class = "hljs-keyword" > if< / span > (nativeBind & & func.bind === nativeBind) < span class = "hljs-keyword" > return< / span > nativeBind.apply(func, slice.call(< span class = "hljs-built_in" > arguments< / span > , < span class = "hljs-number" > 1< / span > ));
< span class = "hljs-keyword" > if< / span > (!_.isFunction(func)) < span class = "hljs-keyword" > throw< / span > < span class = "hljs-keyword" > new< / span > < span class = "hljs-built_in" > TypeError< / span > (< span class = "hljs-string" > 'Bind must be called on a function'< / span > );
< span class = "hljs-keyword" > var< / span > args = slice.call(< span class = "hljs-built_in" > arguments< / span > , < span class = "hljs-number" > 2< / span > );
< span class = "hljs-keyword" > var< / span > bound = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > ()< / span > < / span > {
< span class = "hljs-keyword" > return< / span > executeBound(func, bound, context, < span class = "hljs-keyword" > this< / span > , args.concat(slice.call(< span class = "hljs-built_in" > arguments< / span > )));
};
< span class = "hljs-keyword" > return< / span > bound;
2016-03-11 00:48:53 +00:00
};< / pre > < / div > < / div >
< / li >
< li id = "section-77" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-77" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Partially apply a function by creating a version that has had some of its
arguments pre-filled, without changing its dynamic < code > this< / code > context. _ acts
as a placeholder, allowing any combination of arguments to be pre-filled.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.partial = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (func)< / span > < / span > {
< span class = "hljs-keyword" > var< / span > boundArgs = slice.call(< span class = "hljs-built_in" > arguments< / span > , < span class = "hljs-number" > 1< / span > );
< span class = "hljs-keyword" > var< / span > bound = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > ()< / span > < / span > {
< span class = "hljs-keyword" > var< / span > position = < span class = "hljs-number" > 0< / span > , length = boundArgs.length;
< span class = "hljs-keyword" > var< / span > args = < span class = "hljs-built_in" > Array< / span > (length);
< span class = "hljs-keyword" > for< / span > (< span class = "hljs-keyword" > var< / span > i = < span class = "hljs-number" > 0< / span > ; i < length; i++) {
args[i] = boundArgs[i] === _ ? < span class = "hljs-built_in" > arguments< / span > [position++] : boundArgs[i];
}
< span class = "hljs-keyword" > while< / span > (position < < span class = "hljs-built_in" > arguments< / span > .length) args.push(< span class = "hljs-built_in" > arguments< / span > [position++]);
< span class = "hljs-keyword" > return< / span > executeBound(func, bound, < span class = "hljs-keyword" > this< / span > , < span class = "hljs-keyword" > this< / span > , args);
};
< span class = "hljs-keyword" > return< / span > bound;
2016-03-11 00:48:53 +00:00
};< / pre > < / div > < / div >
< / li >
< li id = "section-78" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-78" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Bind a number of an object’
are the method names to be bound. Useful for ensuring that all callbacks
defined on an object belong to it.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.bindAll = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (obj)< / span > < / span > {
< span class = "hljs-keyword" > var< / span > i, length = < span class = "hljs-built_in" > arguments< / span > .length, key;
< span class = "hljs-keyword" > if< / span > (length < = < span class = "hljs-number" > 1< / span > ) < span class = "hljs-keyword" > throw< / span > < span class = "hljs-keyword" > new< / span > < span class = "hljs-built_in" > Error< / span > (< span class = "hljs-string" > 'bindAll must be passed function names'< / span > );
< span class = "hljs-keyword" > for< / span > (i = < span class = "hljs-number" > 1< / span > ; i < length; i++) {
key = < span class = "hljs-built_in" > arguments< / span > [i];
obj[key] = _.bind(obj[key], obj);
}
< span class = "hljs-keyword" > return< / span > obj;
2016-03-11 00:48:53 +00:00
};< / pre > < / div > < / div >
< / li >
< li id = "section-79" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-79" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Memoize an expensive function by storing its results.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.memoize = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (func, hasher)< / span > < / span > {
< span class = "hljs-keyword" > var< / span > memoize = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (key)< / span > < / span > {
< span class = "hljs-keyword" > var< / span > cache = memoize.cache;
< span class = "hljs-keyword" > var< / span > address = < span class = "hljs-string" > ''< / span > + (hasher ? hasher.apply(< span class = "hljs-keyword" > this< / span > , < span class = "hljs-built_in" > arguments< / span > ) : key);
< span class = "hljs-keyword" > if< / span > (!_.has(cache, address)) cache[address] = func.apply(< span class = "hljs-keyword" > this< / span > , < span class = "hljs-built_in" > arguments< / span > );
< span class = "hljs-keyword" > return< / span > cache[address];
};
memoize.cache = {};
< span class = "hljs-keyword" > return< / span > memoize;
2016-03-11 00:48:53 +00:00
};< / pre > < / div > < / div >
< / li >
< li id = "section-80" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-80" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Delays a function for the given number of milliseconds, and then calls
it with the arguments supplied.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.delay = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (func, wait)< / span > < / span > {
< span class = "hljs-keyword" > var< / span > args = slice.call(< span class = "hljs-built_in" > arguments< / span > , < span class = "hljs-number" > 2< / span > );
< span class = "hljs-keyword" > return< / span > setTimeout(< span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > ()< / span > < / span > {
< span class = "hljs-keyword" > return< / span > func.apply(< span class = "hljs-literal" > null< / span > , args);
}, wait);
2016-03-11 00:48:53 +00:00
};< / pre > < / div > < / div >
< / li >
< li id = "section-81" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-81" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Defers a function, scheduling it to run after the current call stack has
cleared.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.defer = _.partial(_.delay, _, < span class = "hljs-number" > 1< / span > );< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-82" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-82" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Returns a function, that, when invoked, will only be triggered at most once
during a given window of time. Normally, the throttled function will run
as much as it can, without ever going more than once per < code > wait< / code > duration;
but if you’
< code > {leading: false}< / code > . To disable execution on the trailing edge, ditto.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.throttle = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (func, wait, options)< / span > < / span > {
< span class = "hljs-keyword" > var< / span > context, args, result;
< span class = "hljs-keyword" > var< / span > timeout = < span class = "hljs-literal" > null< / span > ;
< span class = "hljs-keyword" > var< / span > previous = < span class = "hljs-number" > 0< / span > ;
< span class = "hljs-keyword" > if< / span > (!options) options = {};
< span class = "hljs-keyword" > var< / span > later = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > ()< / span > < / span > {
previous = options.leading === < span class = "hljs-literal" > false< / span > ? < span class = "hljs-number" > 0< / span > : _.now();
timeout = < span class = "hljs-literal" > null< / span > ;
result = func.apply(context, args);
< span class = "hljs-keyword" > if< / span > (!timeout) context = args = < span class = "hljs-literal" > null< / span > ;
};
< span class = "hljs-keyword" > return< / span > < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > ()< / span > < / span > {
< span class = "hljs-keyword" > var< / span > now = _.now();
< span class = "hljs-keyword" > if< / span > (!previous & & options.leading === < span class = "hljs-literal" > false< / span > ) previous = now;
< span class = "hljs-keyword" > var< / span > remaining = wait - (now - previous);
context = < span class = "hljs-keyword" > this< / span > ;
args = < span class = "hljs-built_in" > arguments< / span > ;
< span class = "hljs-keyword" > if< / span > (remaining < = < span class = "hljs-number" > 0< / span > || remaining > wait) {
< span class = "hljs-keyword" > if< / span > (timeout) {
clearTimeout(timeout);
timeout = < span class = "hljs-literal" > null< / span > ;
}
previous = now;
result = func.apply(context, args);
< span class = "hljs-keyword" > if< / span > (!timeout) context = args = < span class = "hljs-literal" > null< / span > ;
} < span class = "hljs-keyword" > else< / span > < span class = "hljs-keyword" > if< / span > (!timeout & & options.trailing !== < span class = "hljs-literal" > false< / span > ) {
timeout = setTimeout(later, remaining);
}
< span class = "hljs-keyword" > return< / span > result;
};
2016-03-11 00:48:53 +00:00
};< / pre > < / div > < / div >
< / li >
< li id = "section-83" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-83" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Returns a function, that, as long as it continues to be invoked, will not
be triggered. The function will be called after it stops being called for
N milliseconds. If < code > immediate< / code > is passed, trigger the function on the
leading edge, instead of the trailing.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.debounce = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (func, wait, immediate)< / span > < / span > {
< span class = "hljs-keyword" > var< / span > timeout, args, context, timestamp, result;
< span class = "hljs-keyword" > var< / span > later = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > ()< / span > < / span > {
< span class = "hljs-keyword" > var< / span > last = _.now() - timestamp;
< span class = "hljs-keyword" > if< / span > (last < wait & & last > = < span class = "hljs-number" > 0< / span > ) {
timeout = setTimeout(later, wait - last);
} < span class = "hljs-keyword" > else< / span > {
timeout = < span class = "hljs-literal" > null< / span > ;
< span class = "hljs-keyword" > if< / span > (!immediate) {
result = func.apply(context, args);
< span class = "hljs-keyword" > if< / span > (!timeout) context = args = < span class = "hljs-literal" > null< / span > ;
}
}
};
< span class = "hljs-keyword" > return< / span > < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > ()< / span > < / span > {
context = < span class = "hljs-keyword" > this< / span > ;
args = < span class = "hljs-built_in" > arguments< / span > ;
timestamp = _.now();
< span class = "hljs-keyword" > var< / span > callNow = immediate & & !timeout;
< span class = "hljs-keyword" > if< / span > (!timeout) timeout = setTimeout(later, wait);
< span class = "hljs-keyword" > if< / span > (callNow) {
result = func.apply(context, args);
context = args = < span class = "hljs-literal" > null< / span > ;
}
< span class = "hljs-keyword" > return< / span > result;
};
2016-03-11 00:48:53 +00:00
};< / pre > < / div > < / div >
< / li >
< li id = "section-84" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-84" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Returns the first function passed as an argument to the second,
allowing you to adjust arguments, run code before and after, and
conditionally execute the original function.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.wrap = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (func, wrapper)< / span > < / span > {
< span class = "hljs-keyword" > return< / span > _.partial(wrapper, func);
};< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-85" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-85" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Returns a negated version of the passed-in predicate.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.negate = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (predicate)< / span > < / span > {
< span class = "hljs-keyword" > return< / span > < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > ()< / span > < / span > {
< span class = "hljs-keyword" > return< / span > !predicate.apply(< span class = "hljs-keyword" > this< / span > , < span class = "hljs-built_in" > arguments< / span > );
};
};< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-86" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-86" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Returns a function that is the composition of a list of functions, each
consuming the return value of the function that follows.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.compose = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > ()< / span > < / span > {
< span class = "hljs-keyword" > var< / span > args = < span class = "hljs-built_in" > arguments< / span > ;
< span class = "hljs-keyword" > var< / span > start = args.length - < span class = "hljs-number" > 1< / span > ;
< span class = "hljs-keyword" > return< / span > < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > ()< / span > < / span > {
< span class = "hljs-keyword" > var< / span > i = start;
< span class = "hljs-keyword" > var< / span > result = args[start].apply(< span class = "hljs-keyword" > this< / span > , < span class = "hljs-built_in" > arguments< / span > );
< span class = "hljs-keyword" > while< / span > (i--) result = args[i].call(< span class = "hljs-keyword" > this< / span > , result);
< span class = "hljs-keyword" > return< / span > result;
};
};< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-87" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-87" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Returns a function that will only be executed on and after the Nth call.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.after = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (times, func)< / span > < / span > {
< span class = "hljs-keyword" > return< / span > < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > ()< / span > < / span > {
< span class = "hljs-keyword" > if< / span > (--times < < span class = "hljs-number" > 1< / span > ) {
< span class = "hljs-keyword" > return< / span > func.apply(< span class = "hljs-keyword" > this< / span > , < span class = "hljs-built_in" > arguments< / span > );
}
};
};< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-88" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-88" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Returns a function that will only be executed up to (but not including) the Nth call.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.before = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (times, func)< / span > < / span > {
< span class = "hljs-keyword" > var< / span > memo;
< span class = "hljs-keyword" > return< / span > < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > ()< / span > < / span > {
< span class = "hljs-keyword" > if< / span > (--times > < span class = "hljs-number" > 0< / span > ) {
memo = func.apply(< span class = "hljs-keyword" > this< / span > , < span class = "hljs-built_in" > arguments< / span > );
}
< span class = "hljs-keyword" > if< / span > (times < = < span class = "hljs-number" > 1< / span > ) func = < span class = "hljs-literal" > null< / span > ;
< span class = "hljs-keyword" > return< / span > memo;
};
};< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-89" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-89" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Returns a function that will be executed at most one time, no matter how
often you call it. Useful for lazy initialization.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.once = _.partial(_.before, < span class = "hljs-number" > 2< / span > );< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-90" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-90" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< h2 id = "object-functions" > Object Functions< / h2 >
2016-03-11 00:48:53 +00:00
< / div >
< / li >
< li id = "section-91" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-91" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
2016-03-11 00:48:53 +00:00
< / div >
< / li >
< li id = "section-92" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-92" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Keys in IE < 9 that won’ < code > for key in ...< / code > and thus missed.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > < span class = "hljs-keyword" > var< / span > hasEnumBug = !{toString: < span class = "hljs-literal" > null< / span > }.propertyIsEnumerable(< span class = "hljs-string" > 'toString'< / span > );
< span class = "hljs-keyword" > var< / span > nonEnumerableProps = [< span class = "hljs-string" > 'valueOf'< / span > , < span class = "hljs-string" > 'isPrototypeOf'< / span > , < span class = "hljs-string" > 'toString'< / span > ,
< span class = "hljs-string" > 'propertyIsEnumerable'< / span > , < span class = "hljs-string" > 'hasOwnProperty'< / span > , < span class = "hljs-string" > 'toLocaleString'< / span > ];
< span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-title" > collectNonEnumProps< / span > < span class = "hljs-params" > (obj, keys)< / span > < / span > {
< span class = "hljs-keyword" > var< / span > nonEnumIdx = nonEnumerableProps.length;
< span class = "hljs-keyword" > var< / span > constructor = obj.constructor;
< span class = "hljs-keyword" > var< / span > proto = (_.isFunction(constructor) & & constructor.prototype) || ObjProto;< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-93" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-93" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Constructor is a special case.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > < span class = "hljs-keyword" > var< / span > prop = < span class = "hljs-string" > 'constructor'< / span > ;
< span class = "hljs-keyword" > if< / span > (_.has(obj, prop) & & !_.contains(keys, prop)) keys.push(prop);
< span class = "hljs-keyword" > while< / span > (nonEnumIdx--) {
prop = nonEnumerableProps[nonEnumIdx];
< span class = "hljs-keyword" > if< / span > (prop < span class = "hljs-keyword" > in< / span > obj & & obj[prop] !== proto[prop] & & !_.contains(keys, prop)) {
keys.push(prop);
}
2016-03-11 00:48:53 +00:00
}
2017-04-21 08:10:07 +00:00
}< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-94" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-94" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Retrieve the names of an object’
Delegates to < strong > ECMAScript 5< / strong > ‘ < code > Object.keys< / code > < / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.keys = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (obj)< / span > < / span > {
< span class = "hljs-keyword" > if< / span > (!_.isObject(obj)) < span class = "hljs-keyword" > return< / span > [];
< span class = "hljs-keyword" > if< / span > (nativeKeys) < span class = "hljs-keyword" > return< / span > nativeKeys(obj);
< span class = "hljs-keyword" > var< / span > keys = [];
< span class = "hljs-keyword" > for< / span > (< span class = "hljs-keyword" > var< / span > key < span class = "hljs-keyword" > in< / span > obj) < span class = "hljs-keyword" > if< / span > (_.has(obj, key)) keys.push(key);< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-95" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-95" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Ahem, IE < 9.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > < span class = "hljs-keyword" > if< / span > (hasEnumBug) collectNonEnumProps(obj, keys);
< span class = "hljs-keyword" > return< / span > keys;
};< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-96" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-96" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Retrieve all the property names of an object.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.allKeys = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (obj)< / span > < / span > {
< span class = "hljs-keyword" > if< / span > (!_.isObject(obj)) < span class = "hljs-keyword" > return< / span > [];
< span class = "hljs-keyword" > var< / span > keys = [];
< span class = "hljs-keyword" > for< / span > (< span class = "hljs-keyword" > var< / span > key < span class = "hljs-keyword" > in< / span > obj) keys.push(key);< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-97" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-97" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Ahem, IE < 9.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > < span class = "hljs-keyword" > if< / span > (hasEnumBug) collectNonEnumProps(obj, keys);
< span class = "hljs-keyword" > return< / span > keys;
};< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-98" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-98" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Retrieve the values of an object’ < / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.values = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (obj)< / span > < / span > {
< span class = "hljs-keyword" > var< / span > keys = _.keys(obj);
< span class = "hljs-keyword" > var< / span > length = keys.length;
< span class = "hljs-keyword" > var< / span > values = < span class = "hljs-built_in" > Array< / span > (length);
< span class = "hljs-keyword" > for< / span > (< span class = "hljs-keyword" > var< / span > i = < span class = "hljs-number" > 0< / span > ; i < length; i++) {
values[i] = obj[keys[i]];
}
< span class = "hljs-keyword" > return< / span > values;
};< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-99" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-99" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Returns the results of applying the iteratee to each element of the object
In contrast to _.map it returns an object< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.mapObject = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (obj, iteratee, context)< / span > < / span > {
iteratee = cb(iteratee, context);
< span class = "hljs-keyword" > var< / span > keys = _.keys(obj),
length = keys.length,
results = {},
currentKey;
< span class = "hljs-keyword" > for< / span > (< span class = "hljs-keyword" > var< / span > index = < span class = "hljs-number" > 0< / span > ; index < length; index++) {
currentKey = keys[index];
results[currentKey] = iteratee(obj[currentKey], currentKey, obj);
}
< span class = "hljs-keyword" > return< / span > results;
};< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-100" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-100" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Convert an object into a list of < code > [key, value]< / code > pairs.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.pairs = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (obj)< / span > < / span > {
< span class = "hljs-keyword" > var< / span > keys = _.keys(obj);
< span class = "hljs-keyword" > var< / span > length = keys.length;
< span class = "hljs-keyword" > var< / span > pairs = < span class = "hljs-built_in" > Array< / span > (length);
< span class = "hljs-keyword" > for< / span > (< span class = "hljs-keyword" > var< / span > i = < span class = "hljs-number" > 0< / span > ; i < length; i++) {
pairs[i] = [keys[i], obj[keys[i]]];
}
< span class = "hljs-keyword" > return< / span > pairs;
};< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-101" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-101" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Invert the keys and values of an object. The values must be serializable.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.invert = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (obj)< / span > < / span > {
< span class = "hljs-keyword" > var< / span > result = {};
< span class = "hljs-keyword" > var< / span > keys = _.keys(obj);
< span class = "hljs-keyword" > for< / span > (< span class = "hljs-keyword" > var< / span > i = < span class = "hljs-number" > 0< / span > , length = keys.length; i < length; i++) {
result[obj[keys[i]]] = keys[i];
}
< span class = "hljs-keyword" > return< / span > result;
};< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-102" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-102" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Return a sorted list of the function names available on the object.
Aliased as < code > methods< / code > < / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.functions = _.methods = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (obj)< / span > < / span > {
< span class = "hljs-keyword" > var< / span > names = [];
< span class = "hljs-keyword" > for< / span > (< span class = "hljs-keyword" > var< / span > key < span class = "hljs-keyword" > in< / span > obj) {
< span class = "hljs-keyword" > if< / span > (_.isFunction(obj[key])) names.push(key);
}
< span class = "hljs-keyword" > return< / span > names.sort();
};< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-103" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-103" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Extend a given object with all the properties in passed-in object(s).< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.extend = createAssigner(_.allKeys);< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-104" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-104" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Assigns a given object with all the own properties in the passed-in object(s)
(< a href = "https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object/assign" > https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object/assign< / a > )< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.extendOwn = _.assign = createAssigner(_.keys);< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-105" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-105" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Returns the first key on an object that passes a predicate test< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.findKey = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (obj, predicate, context)< / span > < / span > {
predicate = cb(predicate, context);
< span class = "hljs-keyword" > var< / span > keys = _.keys(obj), key;
< span class = "hljs-keyword" > for< / span > (< span class = "hljs-keyword" > var< / span > i = < span class = "hljs-number" > 0< / span > , length = keys.length; i < length; i++) {
key = keys[i];
< span class = "hljs-keyword" > if< / span > (predicate(obj[key], key, obj)) < span class = "hljs-keyword" > return< / span > key;
}
2016-03-11 00:48:53 +00:00
};< / pre > < / div > < / div >
< / li >
< li id = "section-106" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-106" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Return a copy of the object only containing the whitelisted properties.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.pick = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (object, oiteratee, context)< / span > < / span > {
< span class = "hljs-keyword" > var< / span > result = {}, obj = object, iteratee, keys;
< span class = "hljs-keyword" > if< / span > (obj == < span class = "hljs-literal" > null< / span > ) < span class = "hljs-keyword" > return< / span > result;
< span class = "hljs-keyword" > if< / span > (_.isFunction(oiteratee)) {
keys = _.allKeys(obj);
iteratee = optimizeCb(oiteratee, context);
} < span class = "hljs-keyword" > else< / span > {
keys = flatten(< span class = "hljs-built_in" > arguments< / span > , < span class = "hljs-literal" > false< / span > , < span class = "hljs-literal" > false< / span > , < span class = "hljs-number" > 1< / span > );
iteratee = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (value, key, obj)< / span > < / span > { < span class = "hljs-keyword" > return< / span > key < span class = "hljs-keyword" > in< / span > obj; };
obj = < span class = "hljs-built_in" > Object< / span > (obj);
}
< span class = "hljs-keyword" > for< / span > (< span class = "hljs-keyword" > var< / span > i = < span class = "hljs-number" > 0< / span > , length = keys.length; i < length; i++) {
< span class = "hljs-keyword" > var< / span > key = keys[i];
< span class = "hljs-keyword" > var< / span > value = obj[key];
< span class = "hljs-keyword" > if< / span > (iteratee(value, key, obj)) result[key] = value;
}
< span class = "hljs-keyword" > return< / span > result;
};< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-107" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-107" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Return a copy of the object without the blacklisted properties.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.omit = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (obj, iteratee, context)< / span > < / span > {
< span class = "hljs-keyword" > if< / span > (_.isFunction(iteratee)) {
iteratee = _.negate(iteratee);
} < span class = "hljs-keyword" > else< / span > {
< span class = "hljs-keyword" > var< / span > keys = _.map(flatten(< span class = "hljs-built_in" > arguments< / span > , < span class = "hljs-literal" > false< / span > , < span class = "hljs-literal" > false< / span > , < span class = "hljs-number" > 1< / span > ), < span class = "hljs-built_in" > String< / span > );
iteratee = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (value, key)< / span > < / span > {
< span class = "hljs-keyword" > return< / span > !_.contains(keys, key);
};
}
< span class = "hljs-keyword" > return< / span > _.pick(obj, iteratee, context);
2016-03-11 00:48:53 +00:00
};< / pre > < / div > < / div >
< / li >
< li id = "section-108" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-108" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Fill in a given object with default properties.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.defaults = createAssigner(_.allKeys, < span class = "hljs-literal" > true< / span > );< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-109" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-109" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Creates an object that inherits from the given prototype object.
If additional properties are provided then they will be added to the
created object.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.create = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (prototype, props)< / span > < / span > {
< span class = "hljs-keyword" > var< / span > result = baseCreate(prototype);
< span class = "hljs-keyword" > if< / span > (props) _.extendOwn(result, props);
< span class = "hljs-keyword" > return< / span > result;
2016-03-11 00:48:53 +00:00
};< / pre > < / div > < / div >
< / li >
< li id = "section-110" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-110" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Create a (shallow-cloned) duplicate of an object.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.clone = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (obj)< / span > < / span > {
< span class = "hljs-keyword" > if< / span > (!_.isObject(obj)) < span class = "hljs-keyword" > return< / span > obj;
< span class = "hljs-keyword" > return< / span > _.isArray(obj) ? obj.slice() : _.extend({}, obj);
2016-03-11 00:48:53 +00:00
};< / pre > < / div > < / div >
< / li >
< li id = "section-111" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-111" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Invokes interceptor with the obj, and then returns obj.
The primary purpose of this method is to “tap into” a method chain, in
order to perform operations on intermediate results within the chain.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.tap = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (obj, interceptor)< / span > < / span > {
interceptor(obj);
< span class = "hljs-keyword" > return< / span > obj;
};< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-112" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-112" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Returns whether an object has a given set of < code > key:value< / code > pairs.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.isMatch = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (object, attrs)< / span > < / span > {
< span class = "hljs-keyword" > var< / span > keys = _.keys(attrs), length = keys.length;
< span class = "hljs-keyword" > if< / span > (object == < span class = "hljs-literal" > null< / span > ) < span class = "hljs-keyword" > return< / span > !length;
< span class = "hljs-keyword" > var< / span > obj = < span class = "hljs-built_in" > Object< / span > (object);
< span class = "hljs-keyword" > for< / span > (< span class = "hljs-keyword" > var< / span > i = < span class = "hljs-number" > 0< / span > ; i < length; i++) {
< span class = "hljs-keyword" > var< / span > key = keys[i];
< span class = "hljs-keyword" > if< / span > (attrs[key] !== obj[key] || !(key < span class = "hljs-keyword" > in< / span > obj)) < span class = "hljs-keyword" > return< / span > < span class = "hljs-literal" > false< / span > ;
}
< span class = "hljs-keyword" > return< / span > < span class = "hljs-literal" > true< / span > ;
};< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-113" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-113" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Internal recursive comparison function for < code > isEqual< / code > .< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > < span class = "hljs-keyword" > var< / span > eq = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (a, b, aStack, bStack)< / span > < / span > {< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-114" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-114" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Identical objects are equal. < code > 0 === -0< / code > , but they aren’
See the < a href = "http://wiki.ecmascript.org/doku.php?id=harmony:egal" > Harmony < code > egal< / code > proposal< / a > .< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > < span class = "hljs-keyword" > if< / span > (a === b) < span class = "hljs-keyword" > return< / span > a !== < span class = "hljs-number" > 0< / span > || < span class = "hljs-number" > 1< / span > / a === < span class = "hljs-number" > 1< / span > / b;< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-115" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-115" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > A strict comparison is necessary because < code > null == undefined< / code > .< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > < span class = "hljs-keyword" > if< / span > (a == < span class = "hljs-literal" > null< / span > || b == < span class = "hljs-literal" > null< / span > ) < span class = "hljs-keyword" > return< / span > a === b;< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-116" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-116" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Unwrap any wrapped objects.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > < span class = "hljs-keyword" > if< / span > (a < span class = "hljs-keyword" > instanceof< / span > _) a = a._wrapped;
< span class = "hljs-keyword" > if< / span > (b < span class = "hljs-keyword" > instanceof< / span > _) b = b._wrapped;< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-117" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-117" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Compare < code > [[Class]]< / code > names.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > < span class = "hljs-keyword" > var< / span > className = toString.call(a);
< span class = "hljs-keyword" > if< / span > (className !== toString.call(b)) < span class = "hljs-keyword" > return< / span > < span class = "hljs-literal" > false< / span > ;
< span class = "hljs-keyword" > switch< / span > (className) {< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-118" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-118" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Strings, numbers, regular expressions, dates, and booleans are compared by value.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > < span class = "hljs-keyword" > case< / span > < span class = "hljs-string" > '[object RegExp]'< / span > :< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-119" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-119" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > RegExps are coerced to strings for comparison (Note: ‘ ’ ‘ ’ < / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > < span class = "hljs-keyword" > case< / span > < span class = "hljs-string" > '[object String]'< / span > :< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-120" >
< div class = "annotation" >
2017-04-21 08:10:07 +00:00
< div class = "pilwrap " >
2016-03-11 00:48:53 +00:00
< a class = "pilcrow" href = "#section-120" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Primitives and their corresponding object wrappers are equivalent; thus, < code > " 5" < / code > is
equivalent to < code > new String(" 5" )< / code > .< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > < span class = "hljs-keyword" > return< / span > < span class = "hljs-string" > ''< / span > + a === < span class = "hljs-string" > ''< / span > + b;
< span class = "hljs-keyword" > case< / span > < span class = "hljs-string" > '[object Number]'< / span > :< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-121" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-121" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > < code > NaN< / code > s are equivalent, but non-reflexive.
Object(NaN) is equivalent to NaN< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > < span class = "hljs-keyword" > if< / span > (+a !== +a) < span class = "hljs-keyword" > return< / span > +b !== +b;< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-122" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-122" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > An < code > egal< / code > comparison is performed for other numeric values.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > < span class = "hljs-keyword" > return< / span > +a === < span class = "hljs-number" > 0< / span > ? < span class = "hljs-number" > 1< / span > / +a === < span class = "hljs-number" > 1< / span > / b : +a === +b;
< span class = "hljs-keyword" > case< / span > < span class = "hljs-string" > '[object Date]'< / span > :
< span class = "hljs-keyword" > case< / span > < span class = "hljs-string" > '[object Boolean]'< / span > :< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-123" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-123" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Coerce dates and booleans to numeric primitive values. Dates are compared by their
millisecond representations. Note that invalid dates with millisecond representations
of < code > NaN< / code > are not equivalent.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > < span class = "hljs-keyword" > return< / span > +a === +b;
}
< span class = "hljs-keyword" > var< / span > areArrays = className === < span class = "hljs-string" > '[object Array]'< / span > ;
< span class = "hljs-keyword" > if< / span > (!areArrays) {
< span class = "hljs-keyword" > if< / span > (< span class = "hljs-keyword" > typeof< / span > a != < span class = "hljs-string" > 'object'< / span > || < span class = "hljs-keyword" > typeof< / span > b != < span class = "hljs-string" > 'object'< / span > ) < span class = "hljs-keyword" > return< / span > < span class = "hljs-literal" > false< / span > ;< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-124" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-124" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Objects with different constructors are not equivalent, but < code > Object< / code > s or < code > Array< / code > s
from different frames are.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > < span class = "hljs-keyword" > var< / span > aCtor = a.constructor, bCtor = b.constructor;
< span class = "hljs-keyword" > if< / span > (aCtor !== bCtor & & !(_.isFunction(aCtor) & & aCtor < span class = "hljs-keyword" > instanceof< / span > aCtor & &
_.isFunction(bCtor) & & bCtor < span class = "hljs-keyword" > instanceof< / span > bCtor)
& & (< span class = "hljs-string" > 'constructor'< / span > < span class = "hljs-keyword" > in< / span > a & & < span class = "hljs-string" > 'constructor'< / span > < span class = "hljs-keyword" > in< / span > b)) {
< span class = "hljs-keyword" > return< / span > < span class = "hljs-literal" > false< / span > ;
}
}< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-125" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-125" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Assume equality for cyclic structures. The algorithm for detecting cyclic
structures is adapted from ES 5.1 section 15.12.3, abstract operation < code > JO< / code > .< / p >
2016-03-11 00:48:53 +00:00
< / div >
< / li >
< li id = "section-126" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-126" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Initializing stack of traversed objects.
It’ < / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > aStack = aStack || [];
bStack = bStack || [];
< span class = "hljs-keyword" > var< / span > length = aStack.length;
< span class = "hljs-keyword" > while< / span > (length--) {< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-127" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-127" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Linear search. Performance is inversely proportional to the number of
unique nested structures.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > < span class = "hljs-keyword" > if< / span > (aStack[length] === a) < span class = "hljs-keyword" > return< / span > bStack[length] === b;
}< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-128" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-128" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Add the first object to the stack of traversed objects.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > aStack.push(a);
bStack.push(b);< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-129" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-129" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Recursively compare objects and arrays.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > < span class = "hljs-keyword" > if< / span > (areArrays) {< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-130" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-130" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Compare array lengths to determine if a deep comparison is necessary.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > length = a.length;
< span class = "hljs-keyword" > if< / span > (length !== b.length) < span class = "hljs-keyword" > return< / span > < span class = "hljs-literal" > false< / span > ;< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-131" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-131" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Deep compare the contents, ignoring non-numeric properties.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > < span class = "hljs-keyword" > while< / span > (length--) {
< span class = "hljs-keyword" > if< / span > (!eq(a[length], b[length], aStack, bStack)) < span class = "hljs-keyword" > return< / span > < span class = "hljs-literal" > false< / span > ;
}
} < span class = "hljs-keyword" > else< / span > {< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-132" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-132" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Deep compare objects.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > < span class = "hljs-keyword" > var< / span > keys = _.keys(a), key;
length = keys.length;< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-133" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-133" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Ensure that both objects contain the same number of properties before comparing deep equality.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > < span class = "hljs-keyword" > if< / span > (_.keys(b).length !== length) < span class = "hljs-keyword" > return< / span > < span class = "hljs-literal" > false< / span > ;
< span class = "hljs-keyword" > while< / span > (length--) {< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-134" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-134" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Deep compare each member< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > key = keys[length];
< span class = "hljs-keyword" > if< / span > (!(_.has(b, key) & & eq(a[key], b[key], aStack, bStack))) < span class = "hljs-keyword" > return< / span > < span class = "hljs-literal" > false< / span > ;
}
}< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-135" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-135" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Remove the first object from the stack of traversed objects.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > aStack.pop();
bStack.pop();
< span class = "hljs-keyword" > return< / span > < span class = "hljs-literal" > true< / span > ;
};< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-136" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-136" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Perform a deep comparison to check if two objects are equal.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.isEqual = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (a, b)< / span > < / span > {
< span class = "hljs-keyword" > return< / span > eq(a, b);
};< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-137" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-137" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Is a given array, string, or object empty?
An “empty” object has no enumerable own-properties.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.isEmpty = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (obj)< / span > < / span > {
< span class = "hljs-keyword" > if< / span > (obj == < span class = "hljs-literal" > null< / span > ) < span class = "hljs-keyword" > return< / span > < span class = "hljs-literal" > true< / span > ;
< span class = "hljs-keyword" > if< / span > (isArrayLike(obj) & & (_.isArray(obj) || _.isString(obj) || _.isArguments(obj))) < span class = "hljs-keyword" > return< / span > obj.length === < span class = "hljs-number" > 0< / span > ;
< span class = "hljs-keyword" > return< / span > _.keys(obj).length === < span class = "hljs-number" > 0< / span > ;
};< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-138" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-138" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Is a given value a DOM element?< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.isElement = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (obj)< / span > < / span > {
< span class = "hljs-keyword" > return< / span > !!(obj & & obj.nodeType === < span class = "hljs-number" > 1< / span > );
2016-03-11 00:48:53 +00:00
};< / pre > < / div > < / div >
< / li >
< li id = "section-139" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-139" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Is a given value an array?
Delegates to ECMA5’ < / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.isArray = nativeIsArray || < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (obj)< / span > < / span > {
< span class = "hljs-keyword" > return< / span > toString.call(obj) === < span class = "hljs-string" > '[object Array]'< / span > ;
2016-03-11 00:48:53 +00:00
};< / pre > < / div > < / div >
< / li >
< li id = "section-140" >
< div class = "annotation" >
2017-04-21 08:10:07 +00:00
< div class = "pilwrap " >
2016-03-11 00:48:53 +00:00
< a class = "pilcrow" href = "#section-140" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Is a given variable an object?< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.isObject = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (obj)< / span > < / span > {
< span class = "hljs-keyword" > var< / span > type = < span class = "hljs-keyword" > typeof< / span > obj;
< span class = "hljs-keyword" > return< / span > type === < span class = "hljs-string" > 'function'< / span > || type === < span class = "hljs-string" > 'object'< / span > & & !!obj;
};< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-141" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-141" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Add some isType methods: isArguments, isFunction, isString, isNumber, isDate, isRegExp, isError.< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.each([< span class = "hljs-string" > 'Arguments'< / span > , < span class = "hljs-string" > 'Function'< / span > , < span class = "hljs-string" > 'String'< / span > , < span class = "hljs-string" > 'Number'< / span > , < span class = "hljs-string" > 'Date'< / span > , < span class = "hljs-string" > 'RegExp'< / span > , < span class = "hljs-string" > 'Error'< / span > ], < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (name)< / span > < / span > {
_[< span class = "hljs-string" > 'is'< / span > + name] = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (obj)< / span > < / span > {
< span class = "hljs-keyword" > return< / span > toString.call(obj) === < span class = "hljs-string" > '[object '< / span > + name + < span class = "hljs-string" > ']'< / span > ;
};
});< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-142" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-142" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Define a fallback version of the method in browsers (ahem, IE < 9), where
there isn’ < / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > < span class = "hljs-keyword" > if< / span > (!_.isArguments(< span class = "hljs-built_in" > arguments< / span > )) {
_.isArguments = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (obj)< / span > < / span > {
< span class = "hljs-keyword" > return< / span > _.has(obj, < span class = "hljs-string" > 'callee'< / span > );
};
}< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-143" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-143" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Optimize < code > isFunction< / code > if appropriate. Work around some typeof bugs in old v8,
IE 11 (#1621), and in Safari 8 (#1929).< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > < span class = "hljs-keyword" > if< / span > (< span class = "hljs-keyword" > typeof< / span > /./ != < span class = "hljs-string" > 'function'< / span > & & < span class = "hljs-keyword" > typeof< / span > < span class = "hljs-built_in" > Int8Array< / span > != < span class = "hljs-string" > 'object'< / span > ) {
_.isFunction = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (obj)< / span > < / span > {
< span class = "hljs-keyword" > return< / span > < span class = "hljs-keyword" > typeof< / span > obj == < span class = "hljs-string" > 'function'< / span > || < span class = "hljs-literal" > false< / span > ;
2016-03-11 00:48:53 +00:00
};
2017-04-21 08:10:07 +00:00
}< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-144" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-144" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Is a given object a finite number?< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.isFinite = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (obj)< / span > < / span > {
< span class = "hljs-keyword" > return< / span > < span class = "hljs-built_in" > isFinite< / span > (obj) & & !< span class = "hljs-built_in" > isNaN< / span > (< span class = "hljs-built_in" > parseFloat< / span > (obj));
};< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-145" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-145" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Is the given value < code > NaN< / code > ? (NaN is the only number which does not equal itself).< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.isNaN = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (obj)< / span > < / span > {
< span class = "hljs-keyword" > return< / span > _.isNumber(obj) & & obj !== +obj;
};< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< li id = "section-146" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-146" > ¶ < / a >
< / div >
2017-04-21 08:10:07 +00:00
< p > Is a given value a boolean?< / p >
2016-03-11 00:48:53 +00:00
< / div >
2017-04-21 08:10:07 +00:00
< div class = "content" > < div class = 'highlight' > < pre > _.isBoolean = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (obj)< / span > < / span > {
< span class = "hljs-keyword" > return< / span > obj === < span class = "hljs-literal" > true< / span > || obj === < span class = "hljs-literal" > false< / span > || toString.call(obj) === < span class = "hljs-string" > '[object Boolean]'< / span > ;
};< / pre > < / div > < / div >
< / li >
< li id = "section-147" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-147" > ¶ < / a >
< / div >
< p > Is a given value equal to null?< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > _.isNull = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (obj)< / span > < / span > {
< span class = "hljs-keyword" > return< / span > obj === < span class = "hljs-literal" > null< / span > ;
};< / pre > < / div > < / div >
< / li >
< li id = "section-148" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-148" > ¶ < / a >
< / div >
< p > Is a given variable undefined?< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > _.isUndefined = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (obj)< / span > < / span > {
< span class = "hljs-keyword" > return< / span > obj === < span class = "hljs-keyword" > void< / span > < span class = "hljs-number" > 0< / span > ;
};< / pre > < / div > < / div >
< / li >
< li id = "section-149" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-149" > ¶ < / a >
< / div >
< p > Shortcut function for checking if an object has a given property directly
on itself (in other words, not on a prototype).< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > _.has = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (obj, key)< / span > < / span > {
< span class = "hljs-keyword" > return< / span > obj != < span class = "hljs-literal" > null< / span > & & hasOwnProperty.call(obj, key);
};< / pre > < / div > < / div >
< / li >
< li id = "section-150" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-150" > ¶ < / a >
< / div >
< h2 id = "utility-functions" > Utility Functions< / h2 >
< / div >
< / li >
< li id = "section-151" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-151" > ¶ < / a >
< / div >
< / div >
< / li >
< li id = "section-152" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-152" > ¶ < / a >
< / div >
< p > Run Underscore.js in < em > noConflict< / em > mode, returning the < code > _< / code > variable to its
previous owner. Returns a reference to the Underscore object.< / p >
2016-03-11 00:48:53 +00:00
2017-04-21 08:10:07 +00:00
< / div >
< div class = "content" > < div class = 'highlight' > < pre > _.noConflict = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > ()< / span > < / span > {
root._ = previousUnderscore;
< span class = "hljs-keyword" > return< / span > < span class = "hljs-keyword" > this< / span > ;
};< / pre > < / div > < / div >
< / li >
< li id = "section-153" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-153" > ¶ < / a >
< / div >
< p > Keep the identity function around for default iteratees.< / p >
2016-03-11 00:48:53 +00:00
2017-04-21 08:10:07 +00:00
< / div >
< div class = "content" > < div class = 'highlight' > < pre > _.identity = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (value)< / span > < / span > {
< span class = "hljs-keyword" > return< / span > value;
};< / pre > < / div > < / div >
< / li >
< li id = "section-154" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-154" > ¶ < / a >
< / div >
< p > Predicate-generating functions. Often useful outside of Underscore.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > _.constant = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (value)< / span > < / span > {
< span class = "hljs-keyword" > return< / span > < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > ()< / span > < / span > {
< span class = "hljs-keyword" > return< / span > value;
};
};
_.noop = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > ()< / span > < / span > {};
_.property = property;< / pre > < / div > < / div >
< / li >
< li id = "section-155" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-155" > ¶ < / a >
< / div >
< p > Generates a function for a given object that returns a given property.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > _.propertyOf = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (obj)< / span > < / span > {
< span class = "hljs-keyword" > return< / span > obj == < span class = "hljs-literal" > null< / span > ? < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > ()< / span > < / span > {} : < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (key)< / span > < / span > {
< span class = "hljs-keyword" > return< / span > obj[key];
};
};< / pre > < / div > < / div >
< / li >
< li id = "section-156" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-156" > ¶ < / a >
< / div >
< p > Returns a predicate for checking whether an object has a given set of
< code > key:value< / code > pairs.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > _.matcher = _.matches = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (attrs)< / span > < / span > {
attrs = _.extendOwn({}, attrs);
< span class = "hljs-keyword" > return< / span > < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (obj)< / span > < / span > {
< span class = "hljs-keyword" > return< / span > _.isMatch(obj, attrs);
};
};< / pre > < / div > < / div >
< / li >
< li id = "section-157" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-157" > ¶ < / a >
< / div >
< p > Run a function < strong > n< / strong > times.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > _.times = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (n, iteratee, context)< / span > < / span > {
< span class = "hljs-keyword" > var< / span > accum = < span class = "hljs-built_in" > Array< / span > (< span class = "hljs-built_in" > Math< / span > .max(< span class = "hljs-number" > 0< / span > , n));
iteratee = optimizeCb(iteratee, context, < span class = "hljs-number" > 1< / span > );
< span class = "hljs-keyword" > for< / span > (< span class = "hljs-keyword" > var< / span > i = < span class = "hljs-number" > 0< / span > ; i < n; i++) accum[i] = iteratee(i);
< span class = "hljs-keyword" > return< / span > accum;
};< / pre > < / div > < / div >
< / li >
< li id = "section-158" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-158" > ¶ < / a >
< / div >
< p > Return a random integer between min and max (inclusive).< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > _.random = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (min, max)< / span > < / span > {
< span class = "hljs-keyword" > if< / span > (max == < span class = "hljs-literal" > null< / span > ) {
max = min;
min = < span class = "hljs-number" > 0< / span > ;
}
< span class = "hljs-keyword" > return< / span > min + < span class = "hljs-built_in" > Math< / span > .floor(< span class = "hljs-built_in" > Math< / span > .random() * (max - min + < span class = "hljs-number" > 1< / span > ));
};< / pre > < / div > < / div >
< / li >
< li id = "section-159" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-159" > ¶ < / a >
< / div >
< p > A (possibly faster) way to get the current timestamp as an integer.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > _.now = < span class = "hljs-built_in" > Date< / span > .now || < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > ()< / span > < / span > {
< span class = "hljs-keyword" > return< / span > < span class = "hljs-keyword" > new< / span > < span class = "hljs-built_in" > Date< / span > ().getTime();
};< / pre > < / div > < / div >
< / li >
< li id = "section-160" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-160" > ¶ < / a >
< / div >
< p > List of HTML entities for escaping.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > < span class = "hljs-keyword" > var< / span > escapeMap = {
< span class = "hljs-string" > '& '< / span > : < span class = "hljs-string" > '& amp;'< / span > ,
< span class = "hljs-string" > '< '< / span > : < span class = "hljs-string" > '& lt;'< / span > ,
< span class = "hljs-string" > '> '< / span > : < span class = "hljs-string" > '& gt;'< / span > ,
< span class = "hljs-string" > '"'< / span > : < span class = "hljs-string" > '& quot;'< / span > ,
< span class = "hljs-string" > "'"< / span > : < span class = "hljs-string" > '& #x27;'< / span > ,
< span class = "hljs-string" > '`'< / span > : < span class = "hljs-string" > '& #x60;'< / span >
};
< span class = "hljs-keyword" > var< / span > unescapeMap = _.invert(escapeMap);< / pre > < / div > < / div >
< / li >
< li id = "section-161" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-161" > ¶ < / a >
< / div >
< p > Functions for escaping and unescaping strings to/from HTML interpolation.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > < span class = "hljs-keyword" > var< / span > createEscaper = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (map)< / span > < / span > {
< span class = "hljs-keyword" > var< / span > escaper = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (match)< / span > < / span > {
< span class = "hljs-keyword" > return< / span > map[match];
};< / pre > < / div > < / div >
< / li >
< li id = "section-162" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-162" > ¶ < / a >
< / div >
< p > Regexes for identifying a key that needs to be escaped< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > < span class = "hljs-keyword" > var< / span > source = < span class = "hljs-string" > '(?:'< / span > + _.keys(map).join(< span class = "hljs-string" > '|'< / span > ) + < span class = "hljs-string" > ')'< / span > ;
< span class = "hljs-keyword" > var< / span > testRegexp = < span class = "hljs-built_in" > RegExp< / span > (source);
< span class = "hljs-keyword" > var< / span > replaceRegexp = < span class = "hljs-built_in" > RegExp< / span > (source, < span class = "hljs-string" > 'g'< / span > );
< span class = "hljs-keyword" > return< / span > < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (string)< / span > < / span > {
string = string == < span class = "hljs-literal" > null< / span > ? < span class = "hljs-string" > ''< / span > : < span class = "hljs-string" > ''< / span > + string;
< span class = "hljs-keyword" > return< / span > testRegexp.test(string) ? string.replace(replaceRegexp, escaper) : string;
};
};
_.escape = createEscaper(escapeMap);
_.unescape = createEscaper(unescapeMap);< / pre > < / div > < / div >
< / li >
< li id = "section-163" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-163" > ¶ < / a >
< / div >
< p > If the value of the named < code > property< / code > is a function then invoke it with the
< code > object< / code > as context; otherwise, return it.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > _.result = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (object, property, fallback)< / span > < / span > {
< span class = "hljs-keyword" > var< / span > value = object == < span class = "hljs-literal" > null< / span > ? < span class = "hljs-keyword" > void< / span > < span class = "hljs-number" > 0< / span > : object[property];
< span class = "hljs-keyword" > if< / span > (value === < span class = "hljs-keyword" > void< / span > < span class = "hljs-number" > 0< / span > ) {
value = fallback;
}
< span class = "hljs-keyword" > return< / span > _.isFunction(value) ? value.call(object) : value;
};< / pre > < / div > < / div >
< / li >
< li id = "section-164" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-164" > ¶ < / a >
< / div >
< p > Generate a unique integer id (unique within the entire client session).
Useful for temporary DOM ids.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > < span class = "hljs-keyword" > var< / span > idCounter = < span class = "hljs-number" > 0< / span > ;
_.uniqueId = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (prefix)< / span > < / span > {
< span class = "hljs-keyword" > var< / span > id = ++idCounter + < span class = "hljs-string" > ''< / span > ;
< span class = "hljs-keyword" > return< / span > prefix ? prefix + id : id;
};< / pre > < / div > < / div >
< / li >
< li id = "section-165" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-165" > ¶ < / a >
< / div >
< p > By default, Underscore uses ERB-style template delimiters, change the
following template settings to use alternative delimiters.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > _.templateSettings = {
evaluate : < span class = "hljs-regexp" > /< %([\s\S]+?)%> /g< / span > ,
interpolate : < span class = "hljs-regexp" > /< %=([\s\S]+?)%> /g< / span > ,
< span class = "hljs-built_in" > escape< / span > : < span class = "hljs-regexp" > /< %-([\s\S]+?)%> /g< / span >
};< / pre > < / div > < / div >
< / li >
< li id = "section-166" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-166" > ¶ < / a >
< / div >
< p > When customizing < code > templateSettings< / code > , if you don’
interpolation, evaluation or escaping regex, we need one that is
guaranteed not to match.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > < span class = "hljs-keyword" > var< / span > noMatch = < span class = "hljs-regexp" > /(.)^/< / span > ;< / pre > < / div > < / div >
< / li >
< li id = "section-167" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-167" > ¶ < / a >
< / div >
< p > Certain characters need to be escaped so that they can be put into a
string literal.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > < span class = "hljs-keyword" > var< / span > escapes = {
< span class = "hljs-string" > "'"< / span > : < span class = "hljs-string" > "'"< / span > ,
< span class = "hljs-string" > '\\'< / span > : < span class = "hljs-string" > '\\'< / span > ,
< span class = "hljs-string" > '\r'< / span > : < span class = "hljs-string" > 'r'< / span > ,
< span class = "hljs-string" > '\n'< / span > : < span class = "hljs-string" > 'n'< / span > ,
< span class = "hljs-string" > '\u2028'< / span > : < span class = "hljs-string" > 'u2028'< / span > ,
< span class = "hljs-string" > '\u2029'< / span > : < span class = "hljs-string" > 'u2029'< / span >
};
< span class = "hljs-keyword" > var< / span > escaper = < span class = "hljs-regexp" > /\\|'|\r|\n|\u2028|\u2029/g< / span > ;
< span class = "hljs-keyword" > var< / span > escapeChar = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (match)< / span > < / span > {
< span class = "hljs-keyword" > return< / span > < span class = "hljs-string" > '\\'< / span > + escapes[match];
};< / pre > < / div > < / div >
< / li >
< li id = "section-168" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-168" > ¶ < / a >
< / div >
< p > JavaScript micro-templating, similar to John Resig’
Underscore templating handles arbitrary delimiters, preserves whitespace,
and correctly escapes quotes within interpolated code.
NB: < code > oldSettings< / code > only exists for backwards compatibility.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > _.template = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (text, settings, oldSettings)< / span > < / span > {
< span class = "hljs-keyword" > if< / span > (!settings & & oldSettings) settings = oldSettings;
settings = _.defaults({}, settings, _.templateSettings);< / pre > < / div > < / div >
< / li >
< li id = "section-169" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-169" > ¶ < / a >
< / div >
< p > Combine delimiters into one regular expression via alternation.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > < span class = "hljs-keyword" > var< / span > matcher = < span class = "hljs-built_in" > RegExp< / span > ([
(settings.escape || noMatch).source,
(settings.interpolate || noMatch).source,
(settings.evaluate || noMatch).source
].join(< span class = "hljs-string" > '|'< / span > ) + < span class = "hljs-string" > '|$'< / span > , < span class = "hljs-string" > 'g'< / span > );< / pre > < / div > < / div >
< / li >
< li id = "section-170" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-170" > ¶ < / a >
< / div >
< p > Compile the template source, escaping string literals appropriately.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > < span class = "hljs-keyword" > var< / span > index = < span class = "hljs-number" > 0< / span > ;
< span class = "hljs-keyword" > var< / span > source = < span class = "hljs-string" > "__p+='"< / span > ;
text.replace(matcher, < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (match, escape, interpolate, evaluate, offset)< / span > < / span > {
source += text.slice(index, offset).replace(escaper, escapeChar);
index = offset + match.length;
< span class = "hljs-keyword" > if< / span > (< span class = "hljs-built_in" > escape< / span > ) {
source += < span class = "hljs-string" > "'+\n((__t=("< / span > + < span class = "hljs-built_in" > escape< / span > + < span class = "hljs-string" > "))==null?'':_.escape(__t))+\n'"< / span > ;
} < span class = "hljs-keyword" > else< / span > < span class = "hljs-keyword" > if< / span > (interpolate) {
source += < span class = "hljs-string" > "'+\n((__t=("< / span > + interpolate + < span class = "hljs-string" > "))==null?'':__t)+\n'"< / span > ;
} < span class = "hljs-keyword" > else< / span > < span class = "hljs-keyword" > if< / span > (evaluate) {
source += < span class = "hljs-string" > "';\n"< / span > + evaluate + < span class = "hljs-string" > "\n__p+='"< / span > ;
}< / pre > < / div > < / div >
< / li >
< li id = "section-171" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-171" > ¶ < / a >
< / div >
< p > Adobe VMs need the match returned to produce the correct offset.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > < span class = "hljs-keyword" > return< / span > match;
});
source += < span class = "hljs-string" > "';\n"< / span > ;< / pre > < / div > < / div >
< / li >
< li id = "section-172" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-172" > ¶ < / a >
< / div >
< p > If a variable is not specified, place data values in local scope.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > < span class = "hljs-keyword" > if< / span > (!settings.variable) source = < span class = "hljs-string" > 'with(obj||{}){\n'< / span > + source + < span class = "hljs-string" > '}\n'< / span > ;
source = < span class = "hljs-string" > "var __t,__p='',__j=Array.prototype.join,"< / span > +
< span class = "hljs-string" > "print=function(){__p+=__j.call(arguments,'');};\n"< / span > +
source + < span class = "hljs-string" > 'return __p;\n'< / span > ;
< span class = "hljs-keyword" > try< / span > {
< span class = "hljs-keyword" > var< / span > render = < span class = "hljs-keyword" > new< / span > < span class = "hljs-built_in" > Function< / span > (settings.variable || < span class = "hljs-string" > 'obj'< / span > , < span class = "hljs-string" > '_'< / span > , source);
} < span class = "hljs-keyword" > catch< / span > (e) {
e.source = source;
< span class = "hljs-keyword" > throw< / span > e;
}
< span class = "hljs-keyword" > var< / span > template = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (data)< / span > < / span > {
< span class = "hljs-keyword" > return< / span > render.call(< span class = "hljs-keyword" > this< / span > , data, _);
};< / pre > < / div > < / div >
< / li >
< li id = "section-173" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-173" > ¶ < / a >
< / div >
< p > Provide the compiled source as a convenience for precompilation.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > < span class = "hljs-keyword" > var< / span > argument = settings.variable || < span class = "hljs-string" > 'obj'< / span > ;
template.source = < span class = "hljs-string" > 'function('< / span > + argument + < span class = "hljs-string" > '){\n'< / span > + source + < span class = "hljs-string" > '}'< / span > ;
< span class = "hljs-keyword" > return< / span > template;
};< / pre > < / div > < / div >
< / li >
< li id = "section-174" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-174" > ¶ < / a >
< / div >
< p > Add a “chain” function. Start chaining a wrapped Underscore object.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > _.chain = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (obj)< / span > < / span > {
< span class = "hljs-keyword" > var< / span > instance = _(obj);
instance._chain = < span class = "hljs-literal" > true< / span > ;
< span class = "hljs-keyword" > return< / span > instance;
};< / pre > < / div > < / div >
< / li >
< li id = "section-175" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-175" > ¶ < / a >
< / div >
< h2 id = "oop" > OOP< / h2 >
< / div >
< / li >
< li id = "section-176" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-176" > ¶ < / a >
< / div >
< p > If Underscore is called as a function, it returns a wrapped object that
can be used OO-style. This wrapper holds altered versions of all the
underscore functions. Wrapped objects may be chained.< / p >
< / div >
< / li >
< li id = "section-177" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-177" > ¶ < / a >
< / div >
< p > Helper function to continue chaining intermediate results.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > < span class = "hljs-keyword" > var< / span > result = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (instance, obj)< / span > < / span > {
< span class = "hljs-keyword" > return< / span > instance._chain ? _(obj).chain() : obj;
};< / pre > < / div > < / div >
< / li >
< li id = "section-178" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-178" > ¶ < / a >
< / div >
< p > Add your own custom functions to the Underscore object.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > _.mixin = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (obj)< / span > < / span > {
_.each(_.functions(obj), < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (name)< / span > < / span > {
< span class = "hljs-keyword" > var< / span > func = _[name] = obj[name];
_.prototype[name] = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > ()< / span > < / span > {
< span class = "hljs-keyword" > var< / span > args = [< span class = "hljs-keyword" > this< / span > ._wrapped];
push.apply(args, < span class = "hljs-built_in" > arguments< / span > );
< span class = "hljs-keyword" > return< / span > result(< span class = "hljs-keyword" > this< / span > , func.apply(_, args));
};
});
};< / pre > < / div > < / div >
< / li >
< li id = "section-179" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-179" > ¶ < / a >
< / div >
< p > Add all of the Underscore functions to the wrapper object.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > _.mixin(_);< / pre > < / div > < / div >
< / li >
< li id = "section-180" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-180" > ¶ < / a >
< / div >
< p > Add all mutator Array functions to the wrapper.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > _.each([< span class = "hljs-string" > 'pop'< / span > , < span class = "hljs-string" > 'push'< / span > , < span class = "hljs-string" > 'reverse'< / span > , < span class = "hljs-string" > 'shift'< / span > , < span class = "hljs-string" > 'sort'< / span > , < span class = "hljs-string" > 'splice'< / span > , < span class = "hljs-string" > 'unshift'< / span > ], < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (name)< / span > < / span > {
< span class = "hljs-keyword" > var< / span > method = ArrayProto[name];
_.prototype[name] = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > ()< / span > < / span > {
< span class = "hljs-keyword" > var< / span > obj = < span class = "hljs-keyword" > this< / span > ._wrapped;
method.apply(obj, < span class = "hljs-built_in" > arguments< / span > );
< span class = "hljs-keyword" > if< / span > ((name === < span class = "hljs-string" > 'shift'< / span > || name === < span class = "hljs-string" > 'splice'< / span > ) & & obj.length === < span class = "hljs-number" > 0< / span > ) < span class = "hljs-keyword" > delete< / span > obj[< span class = "hljs-number" > 0< / span > ];
< span class = "hljs-keyword" > return< / span > result(< span class = "hljs-keyword" > this< / span > , obj);
};
});< / pre > < / div > < / div >
< / li >
< li id = "section-181" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-181" > ¶ < / a >
< / div >
< p > Add all accessor Array functions to the wrapper.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > _.each([< span class = "hljs-string" > 'concat'< / span > , < span class = "hljs-string" > 'join'< / span > , < span class = "hljs-string" > 'slice'< / span > ], < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > (name)< / span > < / span > {
< span class = "hljs-keyword" > var< / span > method = ArrayProto[name];
_.prototype[name] = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > ()< / span > < / span > {
< span class = "hljs-keyword" > return< / span > result(< span class = "hljs-keyword" > this< / span > , method.apply(< span class = "hljs-keyword" > this< / span > ._wrapped, < span class = "hljs-built_in" > arguments< / span > ));
};
});< / pre > < / div > < / div >
< / li >
< li id = "section-182" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-182" > ¶ < / a >
< / div >
< p > Extracts the result from a wrapped and chained object.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > _.prototype.value = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > ()< / span > < / span > {
< span class = "hljs-keyword" > return< / span > < span class = "hljs-keyword" > this< / span > ._wrapped;
};< / pre > < / div > < / div >
< / li >
< li id = "section-183" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-183" > ¶ < / a >
< / div >
< p > Provide unwrapping proxy for some methods used in engine operations
such as arithmetic and JSON stringification.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > _.prototype.valueOf = _.prototype.toJSON = _.prototype.value;
_.prototype.toString = < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > ()< / span > < / span > {
< span class = "hljs-keyword" > return< / span > < span class = "hljs-string" > ''< / span > + < span class = "hljs-keyword" > this< / span > ._wrapped;
};< / pre > < / div > < / div >
< / li >
< li id = "section-184" >
< div class = "annotation" >
< div class = "pilwrap " >
< a class = "pilcrow" href = "#section-184" > ¶ < / a >
< / div >
< p > AMD registration happens at the end for compatibility with AMD loaders
that may not enforce next-turn semantics on modules. Even though general
practice for AMD registration is to be anonymous, underscore registers
as a named module because, like jQuery, it is a base library that is
popular enough to be bundled in a third party lib, but not be part of
an AMD load request. Those cases could generate an error when an
anonymous define() is called outside of a loader request.< / p >
< / div >
< div class = "content" > < div class = 'highlight' > < pre > < span class = "hljs-keyword" > if< / span > (< span class = "hljs-keyword" > typeof< / span > define === < span class = "hljs-string" > 'function'< / span > & & define.amd) {
define(< span class = "hljs-string" > 'underscore'< / span > , [], < span class = "hljs-function" > < span class = "hljs-keyword" > function< / span > < span class = "hljs-params" > ()< / span > < / span > {
< span class = "hljs-keyword" > return< / span > _;
});
}
}.call(< span class = "hljs-keyword" > this< / span > ));< / pre > < / div > < / div >
2016-03-11 00:48:53 +00:00
< / li >
< / ul >
< / div >
< / body >
< / html >
