Lea/web-apps
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity
web-apps/vendor/underscore/docs/underscore.html
Julia Radzhabova 96712db8cb Update for underscore 1.8.3.
2017-04-21 11:10:07 +03:00

3793 lines
173 KiB
HTML
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

<!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">&#182;</a>
</div>
<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 &amp; Editors
Underscore may be freely distributed under the MIT license.
</code></pre>
</div>
<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>
</li>
<li id="section-2">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-2">&#182;</a>
</div>
<h2 id="baseline-setup">Baseline setup</h2>
</div>
</li>
<li id="section-3">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-3">&#182;</a>
</div>
</div>
</li>
<li id="section-4">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-4">&#182;</a>
</div>
<p>Establish the root object, <code>window</code> in the browser, or <code>exports</code> on the server.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> root = <span class="hljs-keyword">this</span>;</pre></div></div>
</li>
<li id="section-5">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-5">&#182;</a>
</div>
<p>Save the previous value of the <code>_</code> variable.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> previousUnderscore = root._;</pre></div></div>
</li>
<li id="section-6">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-6">&#182;</a>
</div>
<p>Save bytes in the minified (but not gzipped) version:</p>
</div>
<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>
</li>
<li id="section-7">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-7">&#182;</a>
</div>
<p>Create quick reference variables for speed access to core prototypes.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span>
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">&#182;</a>
</div>
<p>All <strong>ECMAScript 5</strong> native function implementations that we hope to use
are declared here.</p>
</div>
<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>
</li>
<li id="section-9">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-9">&#182;</a>
</div>
<p>Naked function reference for surrogate-prototype-swapping.</p>
</div>
<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>
</li>
<li id="section-10">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-10">&#182;</a>
</div>
<p>Create a safe reference to the Underscore object for use below.</p>
</div>
<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>
</li>
<li id="section-11">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-11">&#182;</a>
</div>
<p>Export the Underscore object for <strong>Node.js</strong>, with
backwards-compatibility for the old <code>require()</code> API. If we’re in
the browser, add <code>_</code> as a global object.</p>
</div>
<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> &amp;&amp; <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>
</li>
<li id="section-12">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-12">&#182;</a>
</div>
<p>Current version.</p>
</div>
<div class="content"><div class='highlight'><pre> _.VERSION = <span class="hljs-string">'1.8.3'</span>;</pre></div></div>
</li>
<li id="section-13">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-13">&#182;</a>
</div>
<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>
</div>
<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);
};
}
<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>);
};
};</pre></div></div>
</li>
<li id="section-14">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-14">&#182;</a>
</div>
<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>
</div>
<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);
};
_.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>
</li>
<li id="section-15">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-15">&#182;</a>
</div>
<p>An internal function for creating assigner functions.</p>
</div>
<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 &lt; <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 &lt; 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 &lt; 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];
}
}
<span class="hljs-keyword">return</span> obj;
};
};</pre></div></div>
</li>
<li id="section-16">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-16">&#182;</a>
</div>
<p>An internal function for creating a new object that inherits from another.</p>
</div>
<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];
};
};</pre></div></div>
</li>
<li id="section-17">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-17">&#182;</a>
</div>
<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>
</div>
<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> &amp;&amp; length &gt;= <span class="hljs-number">0</span> &amp;&amp; length &lt;= MAX_ARRAY_INDEX;
};</pre></div></div>
</li>
<li id="section-18">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-18">&#182;</a>
</div>
<h2 id="collection-functions">Collection Functions</h2>
</div>
</li>
<li id="section-19">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-19">&#182;</a>
</div>
</div>
</li>
<li id="section-20">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-20">&#182;</a>
</div>
<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>
</div>
<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 &lt; 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 &lt; length; i++) {
iteratee(obj[keys[i]], keys[i], obj);
}
}
<span class="hljs-keyword">return</span> obj;
};</pre></div></div>
</li>
<li id="section-21">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-21">&#182;</a>
</div>
<p>Return the results of applying the iteratee to each element.</p>
</div>
<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) &amp;&amp; _.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 &lt; 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;
};</pre></div></div>
</li>
<li id="section-22">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-22">&#182;</a>
</div>
<p>Create a reducing function iterating left or right.</p>
</div>
<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>
</li>
<li id="section-23">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-23">&#182;</a>
</div>
<p>Optimized iterator function as using arguments.length
in the main function will deoptimize the, see #1991.</p>
</div>
<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 &gt;= <span class="hljs-number">0</span> &amp;&amp; index &lt; 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) &amp;&amp; _.keys(obj),
length = (keys || obj).length,
index = dir &gt; <span class="hljs-number">0</span> ? <span class="hljs-number">0</span> : length - <span class="hljs-number">1</span>;</pre></div></div>
</li>
<li id="section-24">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-24">&#182;</a>
</div>
<p>Determine the initial value if none is provided.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (<span class="hljs-built_in">arguments</span>.length &lt; <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>
</li>
<li id="section-25">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-25">&#182;</a>
</div>
<p><strong>Reduce</strong> builds up a single result from a list of values, aka <code>inject</code>,
or <code>foldl</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> _.reduce = _.foldl = _.inject = createReduce(<span class="hljs-number">1</span>);</pre></div></div>
</li>
<li id="section-26">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-26">&#182;</a>
</div>
<p>The right-associative version of reduce, also known as <code>foldr</code>.</p>
</div>
<div class="content"><div class='highlight'><pre> _.reduceRight = _.foldr = createReduce(-<span class="hljs-number">1</span>);</pre></div></div>
</li>
<li id="section-27">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-27">&#182;</a>
</div>
<p>Return the first value which passes a truth test. Aliased as <code>detect</code>.</p>
</div>
<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);
}
<span class="hljs-keyword">if</span> (key !== <span class="hljs-keyword">void</span> <span class="hljs-number">0</span> &amp;&amp; key !== -<span class="hljs-number">1</span>) <span class="hljs-keyword">return</span> obj[key];
};</pre></div></div>
</li>
<li id="section-28">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-28">&#182;</a>
</div>
<p>Return all the elements that pass a truth test.
Aliased as <code>select</code>.</p>
</div>
<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);
});
<span class="hljs-keyword">return</span> results;
};</pre></div></div>
</li>
<li id="section-29">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-29">&#182;</a>
</div>
<p>Return all the elements for which a truth test fails.</p>
</div>
<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);
};</pre></div></div>
</li>
<li id="section-30">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-30">&#182;</a>
</div>
<p>Determine whether all of the elements match a truth test.
Aliased as <code>all</code>.</p>
</div>
<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) &amp;&amp; _.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 &lt; 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>;
}
<span class="hljs-keyword">return</span> <span class="hljs-literal">true</span>;
};</pre></div></div>
</li>
<li id="section-31">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-31">&#182;</a>
</div>
<p>Determine if at least one element in the object matches a truth test.
Aliased as <code>any</code>.</p>
</div>
<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) &amp;&amp; _.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 &lt; 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>;
};</pre></div></div>
</li>
<li id="section-32">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-32">&#182;</a>
</div>
<p>Determine if the array or object contains a given item (using <code>===</code>).
Aliased as <code>includes</code> and <code>include</code>.</p>
</div>
<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) &gt;= <span class="hljs-number">0</span>;
};</pre></div></div>
</li>
<li id="section-33">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-33">&#182;</a>
</div>
<p>Invoke a method (with arguments) on every item in a collection.</p>
</div>
<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);
});
};</pre></div></div>
</li>
<li id="section-34">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-34">&#182;</a>
</div>
<p>Convenience version of a common use case of <code>map</code>: fetching a property.</p>
</div>
<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>
</li>
<li id="section-35">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-35">&#182;</a>
</div>
<p>Convenience version of a common use case of <code>filter</code>: selecting only objects
containing specific <code>key:value</code> pairs.</p>
</div>
<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>
</li>
<li id="section-36">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-36">&#182;</a>
</div>
<p>Convenience version of a common use case of <code>find</code>: getting the first object
containing specific <code>key:value</code> pairs.</p>
</div>
<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>
</li>
<li id="section-37">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-37">&#182;</a>
</div>
<p>Return the maximum element (or element-based computation).</p>
</div>
<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> &amp;&amp; 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 &lt; length; i++) {
value = obj[i];
<span class="hljs-keyword">if</span> (value &gt; 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 &gt; lastComputed || computed === -<span class="hljs-literal">Infinity</span> &amp;&amp; result === -<span class="hljs-literal">Infinity</span>) {
result = value;
lastComputed = computed;
}
});
}
<span class="hljs-keyword">return</span> result;
};</pre></div></div>
</li>
<li id="section-38">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-38">&#182;</a>
</div>
<p>Return the minimum element (or element-based computation).</p>
</div>
<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> &amp;&amp; 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 &lt; length; i++) {
value = obj[i];
<span class="hljs-keyword">if</span> (value &lt; 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 &lt; lastComputed || computed === <span class="hljs-literal">Infinity</span> &amp;&amp; result === <span class="hljs-literal">Infinity</span>) {
result = value;
lastComputed = computed;
}
});
}
<span class="hljs-keyword">return</span> result;
};</pre></div></div>
</li>
<li id="section-39">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-39">&#182;</a>
</div>
<p>Shuffle a collection, using the modern version of the
<a href="http://en.wikipedia.org/wiki/Fisher–Yates_shuffle">Fisher-Yates shuffle</a>.</p>
</div>
<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 &lt; 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;
};</pre></div></div>
</li>
<li id="section-40">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-40">&#182;</a>
</div>
<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>
</div>
<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>
</li>
<li id="section-41">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-41">&#182;</a>
</div>
<p>Sort the object’s values by a criterion produced by an iteratee.</p>
</div>
<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 &gt; 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 &lt; 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>);
};</pre></div></div>
</li>
<li id="section-42">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-42">&#182;</a>
</div>
<p>An internal function used for aggregate “group by” operations.</p>
</div>
<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;
};
};</pre></div></div>
</li>
<li id="section-43">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-43">&#182;</a>
</div>
<p>Groups the object’s values by a criterion. Pass either a string attribute
to group by, or a function that returns the criterion.</p>
</div>
<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>
</li>
<li id="section-44">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-44">&#182;</a>
</div>
<p>Indexes the object’s values by a criterion, similar to <code>groupBy</code>, but for
when you know that your index values will be unique.</p>
</div>
<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>
</li>
<li id="section-45">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-45">&#182;</a>
</div>
<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>
</div>
<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>
</li>
<li id="section-46">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-46">&#182;</a>
</div>
<p>Safely create a real, live array from anything iterable.</p>
</div>
<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);
};</pre></div></div>
</li>
<li id="section-47">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-47">&#182;</a>
</div>
<p>Return the number of elements in an object.</p>
</div>
<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;
};</pre></div></div>
</li>
<li id="section-48">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-48">&#182;</a>
</div>
<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>
</div>
<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];
};</pre></div></div>
</li>
<li id="section-49">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-55">&#182;</a>
</div>
<p>Trim out all falsy values from an object.</p>
</div>
<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);
};</pre></div></div>
</li>
<li id="section-50">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-49">&#182;</a>
</div>
<h2 id="array-functions">Array Functions</h2>
</div>
</li>
<li id="section-51">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-50">&#182;</a>
</div>
</div>
</li>
<li id="section-52">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-51">&#182;</a>
</div>
<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>
</div>
<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);
};</pre></div></div>
</li>
<li id="section-53">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-52">&#182;</a>
</div>
<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>
</div>
<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)));
};</pre></div></div>
</li>
<li id="section-54">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-53">&#182;</a>
</div>
<p>Get the last element of an array. Passing <strong>n</strong> will return the last N
values in the array.</p>
</div>
<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));
};</pre></div></div>
</li>
<li id="section-55">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-54">&#182;</a>
</div>
<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>
</div>
<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);
};</pre></div></div>
</li>
<li id="section-56">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-56">&#182;</a>
</div>
<p>Internal implementation of a recursive <code>flatten</code> function.</p>
</div>
<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 &lt; length; i++) {
<span class="hljs-keyword">var</span> value = input[i];
<span class="hljs-keyword">if</span> (isArrayLike(value) &amp;&amp; (_.isArray(value) || _.isArguments(value))) {</pre></div></div>
</li>
<li id="section-57">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-57">&#182;</a>
</div>
<p>flatten current level of array or arguments object</p>
</div>
<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 &lt; len) {
output[idx++] = value[j++];
}
} <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (!strict) {
output[idx++] = value;
}
}
<span class="hljs-keyword">return</span> output;
};</pre></div></div>
</li>
<li id="section-58">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-58">&#182;</a>
</div>
<p>Flatten out an array, either recursively (by default), or just one level.</p>
</div>
<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>
</li>
<li id="section-59">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-59">&#182;</a>
</div>
<p>Return a version of the array that does not contain the specified value(s).</p>
</div>
<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>
</li>
<li id="section-60">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-60">&#182;</a>
</div>
<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>
</div>
<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 &lt; 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;
};</pre></div></div>
</li>
<li id="section-61">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-61">&#182;</a>
</div>
<p>Produce an array that contains the union: each distinct element from all of
the passed-in arrays.</p>
</div>
<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>));
};</pre></div></div>
</li>
<li id="section-62">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-62">&#182;</a>
</div>
<p>Produce an array that contains every item shared between all the
passed-in arrays.</p>
</div>
<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 &lt; 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 &lt; 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;
};</pre></div></div>
</li>
<li id="section-63">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-63">&#182;</a>
</div>
<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>
</div>
<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);
});
};</pre></div></div>
</li>
<li id="section-64">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-64">&#182;</a>
</div>
<p>Zip together multiple lists into a single array — elements that share
an index go together.</p>
</div>
<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>);
};</pre></div></div>
</li>
<li id="section-65">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-65">&#182;</a>
</div>
<p>Complement of _.zip. Unzip accepts an array of arrays and groups
each array’s elements on shared indices</p>
</div>
<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 &amp;&amp; _.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 &lt; length; index++) {
result[index] = _.pluck(array, index);
}
<span class="hljs-keyword">return</span> result;
};</pre></div></div>
</li>
<li id="section-66">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-66">&#182;</a>
</div>
<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>
</div>
<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 &lt; 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>];
}
}
<span class="hljs-keyword">return</span> result;
};</pre></div></div>
</li>
<li id="section-67">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-67">&#182;</a>
</div>
<p>Generator function to create the findIndex and findLastIndex functions</p>
</div>
<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 &gt; <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 &gt;= <span class="hljs-number">0</span> &amp;&amp; index &lt; length; index += dir) {
<span class="hljs-keyword">if</span> (predicate(array[index], index, array)) <span class="hljs-keyword">return</span> index;
}
<span class="hljs-keyword">return</span> -<span class="hljs-number">1</span>;
};
}</pre></div></div>
</li>
<li id="section-68">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-68">&#182;</a>
</div>
<p>Returns the first index on an array-like that passes a predicate test</p>
</div>
<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>
</li>
<li id="section-69">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-69">&#182;</a>
</div>
<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>
</div>
<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 &lt; 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]) &lt; value) low = mid + <span class="hljs-number">1</span>; <span class="hljs-keyword">else</span> high = mid;
}
<span class="hljs-keyword">return</span> low;
};</pre></div></div>
</li>
<li id="section-70">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-70">&#182;</a>
</div>
<p>Generator function to create the indexOf and lastIndexOf functions</p>
</div>
<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 &gt; <span class="hljs-number">0</span>) {
i = idx &gt;= <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 &gt;= <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 &amp;&amp; idx &amp;&amp; length) {
idx = sortedIndex(array, item);
<span class="hljs-keyword">return</span> array[idx] === item ? idx : -<span class="hljs-number">1</span>;
}
<span class="hljs-keyword">if</span> (item !== item) {
idx = predicateFind(slice.call(array, i, length), _.isNaN);
<span class="hljs-keyword">return</span> idx &gt;= <span class="hljs-number">0</span> ? idx + i : -<span class="hljs-number">1</span>;
}
<span class="hljs-keyword">for</span> (idx = dir &gt; <span class="hljs-number">0</span> ? i : length - <span class="hljs-number">1</span>; idx &gt;= <span class="hljs-number">0</span> &amp;&amp; idx &lt; 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>;
};
}</pre></div></div>
</li>
<li id="section-71">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-71">&#182;</a>
</div>
<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>
</div>
<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>
</li>
<li id="section-72">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-72">&#182;</a>
</div>
<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>
</div>
<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 &lt; length; idx++, start += step) {
range[idx] = start;
}
<span class="hljs-keyword">return</span> range;
};</pre></div></div>
</li>
<li id="section-73">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-73">&#182;</a>
</div>
<h2 id="function-ahem-functions">Function (ahem) Functions</h2>
</div>
</li>
<li id="section-74">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-74">&#182;</a>
</div>
</div>
</li>
<li id="section-75">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-75">&#182;</a>
</div>
<p>Determines whether to execute a function as a constructor
or a normal function with the provided arguments</p>
</div>
<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;
};</pre></div></div>
</li>
<li id="section-76">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-76">&#182;</a>
</div>
<p>Create a function bound to a given object (assigning <code>this</code>, and arguments,
optionally). Delegates to <strong>ECMAScript 5</strong>‘s native <code>Function.bind</code> if
available.</p>
</div>
<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 &amp;&amp; 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;
};</pre></div></div>
</li>
<li id="section-77">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-77">&#182;</a>
</div>
<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>
</div>
<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 &lt; length; i++) {
args[i] = boundArgs[i] === _ ? <span class="hljs-built_in">arguments</span>[position++] : boundArgs[i];
}
<span class="hljs-keyword">while</span> (position &lt; <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;
};</pre></div></div>
</li>
<li id="section-78">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-78">&#182;</a>
</div>
<p>Bind a number of an object’s methods to that object. Remaining arguments
are the method names to be bound. Useful for ensuring that all callbacks
defined on an object belong to it.</p>
</div>
<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 &lt;= <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 &lt; length; i++) {
key = <span class="hljs-built_in">arguments</span>[i];
obj[key] = _.bind(obj[key], obj);
}
<span class="hljs-keyword">return</span> obj;
};</pre></div></div>
</li>
<li id="section-79">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-79">&#182;</a>
</div>
<p>Memoize an expensive function by storing its results.</p>
</div>
<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;
};</pre></div></div>
</li>
<li id="section-80">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-80">&#182;</a>
</div>
<p>Delays a function for the given number of milliseconds, and then calls
it with the arguments supplied.</p>
</div>
<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);
};</pre></div></div>
</li>
<li id="section-81">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-81">&#182;</a>
</div>
<p>Defers a function, scheduling it to run after the current call stack has
cleared.</p>
</div>
<div class="content"><div class='highlight'><pre> _.defer = _.partial(_.delay, _, <span class="hljs-number">1</span>);</pre></div></div>
</li>
<li id="section-82">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-82">&#182;</a>
</div>
<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’d like to disable the execution on the leading edge, pass
<code>{leading: false}</code>. To disable execution on the trailing edge, ditto.</p>
</div>
<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 &amp;&amp; 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 &lt;= <span class="hljs-number">0</span> || remaining &gt; 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 &amp;&amp; options.trailing !== <span class="hljs-literal">false</span>) {
timeout = setTimeout(later, remaining);
}
<span class="hljs-keyword">return</span> result;
};
};</pre></div></div>
</li>
<li id="section-83">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-83">&#182;</a>
</div>
<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>
</div>
<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 &lt; wait &amp;&amp; last &gt;= <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 &amp;&amp; !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;
};
};</pre></div></div>
</li>
<li id="section-84">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-84">&#182;</a>
</div>
<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>
</div>
<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>
</li>
<li id="section-85">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-85">&#182;</a>
</div>
<p>Returns a negated version of the passed-in predicate.</p>
</div>
<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>
</li>
<li id="section-86">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-86">&#182;</a>
</div>
<p>Returns a function that is the composition of a list of functions, each
consuming the return value of the function that follows.</p>
</div>
<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>
</li>
<li id="section-87">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-87">&#182;</a>
</div>
<p>Returns a function that will only be executed on and after the Nth call.</p>
</div>
<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 &lt; <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>
</li>
<li id="section-88">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-88">&#182;</a>
</div>
<p>Returns a function that will only be executed up to (but not including) the Nth call.</p>
</div>
<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 &gt; <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 &lt;= <span class="hljs-number">1</span>) func = <span class="hljs-literal">null</span>;
<span class="hljs-keyword">return</span> memo;
};
};</pre></div></div>
</li>
<li id="section-89">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-89">&#182;</a>
</div>
<p>Returns a function that will be executed at most one time, no matter how
often you call it. Useful for lazy initialization.</p>
</div>
<div class="content"><div class='highlight'><pre> _.once = _.partial(_.before, <span class="hljs-number">2</span>);</pre></div></div>
</li>
<li id="section-90">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-90">&#182;</a>
</div>
<h2 id="object-functions">Object Functions</h2>
</div>
</li>
<li id="section-91">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-91">&#182;</a>
</div>
</div>
</li>
<li id="section-92">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-92">&#182;</a>
</div>
<p>Keys in IE &lt; 9 that won’t be iterated by <code>for key in ...</code> and thus missed.</p>
</div>
<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) &amp;&amp; constructor.prototype) || ObjProto;</pre></div></div>
</li>
<li id="section-93">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-93">&#182;</a>
</div>
<p>Constructor is a special case.</p>
</div>
<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) &amp;&amp; !_.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 &amp;&amp; obj[prop] !== proto[prop] &amp;&amp; !_.contains(keys, prop)) {
keys.push(prop);
}
}
}</pre></div></div>
</li>
<li id="section-94">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-94">&#182;</a>
</div>
<p>Retrieve the names of an object’s own properties.
Delegates to <strong>ECMAScript 5</strong>‘s native <code>Object.keys</code></p>
</div>
<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>
</li>
<li id="section-95">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-95">&#182;</a>
</div>
<p>Ahem, IE &lt; 9.</p>
</div>
<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>
</li>
<li id="section-96">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-96">&#182;</a>
</div>
<p>Retrieve all the property names of an object.</p>
</div>
<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>
</li>
<li id="section-97">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-97">&#182;</a>
</div>
<p>Ahem, IE &lt; 9.</p>
</div>
<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>
</li>
<li id="section-98">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-98">&#182;</a>
</div>
<p>Retrieve the values of an object’s properties.</p>
</div>
<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 &lt; length; i++) {
values[i] = obj[keys[i]];
}
<span class="hljs-keyword">return</span> values;
};</pre></div></div>
</li>
<li id="section-99">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-99">&#182;</a>
</div>
<p>Returns the results of applying the iteratee to each element of the object
In contrast to _.map it returns an object</p>
</div>
<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 &lt; length; index++) {
currentKey = keys[index];
results[currentKey] = iteratee(obj[currentKey], currentKey, obj);
}
<span class="hljs-keyword">return</span> results;
};</pre></div></div>
</li>
<li id="section-100">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-100">&#182;</a>
</div>
<p>Convert an object into a list of <code>[key, value]</code> pairs.</p>
</div>
<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 &lt; length; i++) {
pairs[i] = [keys[i], obj[keys[i]]];
}
<span class="hljs-keyword">return</span> pairs;
};</pre></div></div>
</li>
<li id="section-101">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-101">&#182;</a>
</div>
<p>Invert the keys and values of an object. The values must be serializable.</p>
</div>
<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 &lt; length; i++) {
result[obj[keys[i]]] = keys[i];
}
<span class="hljs-keyword">return</span> result;
};</pre></div></div>
</li>
<li id="section-102">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-102">&#182;</a>
</div>
<p>Return a sorted list of the function names available on the object.
Aliased as <code>methods</code></p>
</div>
<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>
</li>
<li id="section-103">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-103">&#182;</a>
</div>
<p>Extend a given object with all the properties in passed-in object(s).</p>
</div>
<div class="content"><div class='highlight'><pre> _.extend = createAssigner(_.allKeys);</pre></div></div>
</li>
<li id="section-104">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-104">&#182;</a>
</div>
<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>
</div>
<div class="content"><div class='highlight'><pre> _.extendOwn = _.assign = createAssigner(_.keys);</pre></div></div>
</li>
<li id="section-105">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-105">&#182;</a>
</div>
<p>Returns the first key on an object that passes a predicate test</p>
</div>
<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 &lt; length; i++) {
key = keys[i];
<span class="hljs-keyword">if</span> (predicate(obj[key], key, obj)) <span class="hljs-keyword">return</span> key;
}
};</pre></div></div>
</li>
<li id="section-106">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-106">&#182;</a>
</div>
<p>Return a copy of the object only containing the whitelisted properties.</p>
</div>
<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 &lt; 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>
</li>
<li id="section-107">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-107">&#182;</a>
</div>
<p>Return a copy of the object without the blacklisted properties.</p>
</div>
<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);
};</pre></div></div>
</li>
<li id="section-108">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-108">&#182;</a>
</div>
<p>Fill in a given object with default properties.</p>
</div>
<div class="content"><div class='highlight'><pre> _.defaults = createAssigner(_.allKeys, <span class="hljs-literal">true</span>);</pre></div></div>
</li>
<li id="section-109">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-109">&#182;</a>
</div>
<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>
</div>
<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;
};</pre></div></div>
</li>
<li id="section-110">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-110">&#182;</a>
</div>
<p>Create a (shallow-cloned) duplicate of an object.</p>
</div>
<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);
};</pre></div></div>
</li>
<li id="section-111">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-111">&#182;</a>
</div>
<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>
</div>
<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>
</li>
<li id="section-112">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-112">&#182;</a>
</div>
<p>Returns whether an object has a given set of <code>key:value</code> pairs.</p>
</div>
<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 &lt; 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>
</li>
<li id="section-113">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-113">&#182;</a>
</div>
<p>Internal recursive comparison function for <code>isEqual</code>.</p>
</div>
<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>
</li>
<li id="section-114">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-114">&#182;</a>
</div>
<p>Identical objects are equal. <code>0 === -0</code>, but they aren’t identical.
See the <a href="http://wiki.ecmascript.org/doku.php?id=harmony:egal">Harmony <code>egal</code> proposal</a>.</p>
</div>
<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>
</li>
<li id="section-115">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-115">&#182;</a>
</div>
<p>A strict comparison is necessary because <code>null == undefined</code>.</p>
</div>
<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>
</li>
<li id="section-116">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-116">&#182;</a>
</div>
<p>Unwrap any wrapped objects.</p>
</div>
<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>
</li>
<li id="section-117">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-117">&#182;</a>
</div>
<p>Compare <code>[[Class]]</code> names.</p>
</div>
<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>
</li>
<li id="section-118">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-118">&#182;</a>
</div>
<p>Strings, numbers, regular expressions, dates, and booleans are compared by value.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">case</span> <span class="hljs-string">'[object RegExp]'</span>:</pre></div></div>
</li>
<li id="section-119">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-119">&#182;</a>
</div>
<p>RegExps are coerced to strings for comparison (Note: ‘’ + /a/i === ‘/a/i’)</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">case</span> <span class="hljs-string">'[object String]'</span>:</pre></div></div>
</li>
<li id="section-120">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-120">&#182;</a>
</div>
<p>Primitives and their corresponding object wrappers are equivalent; thus, <code>&quot;5&quot;</code> is
equivalent to <code>new String(&quot;5&quot;)</code>.</p>
</div>
<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>
</li>
<li id="section-121">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-121">&#182;</a>
</div>
<p><code>NaN</code>s are equivalent, but non-reflexive.
Object(NaN) is equivalent to NaN</p>
</div>
<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>
</li>
<li id="section-122">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-122">&#182;</a>
</div>
<p>An <code>egal</code> comparison is performed for other numeric values.</p>
</div>
<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>
</li>
<li id="section-123">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-123">&#182;</a>
</div>
<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>
</div>
<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>
</li>
<li id="section-124">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-124">&#182;</a>
</div>
<p>Objects with different constructors are not equivalent, but <code>Object</code>s or <code>Array</code>s
from different frames are.</p>
</div>
<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 &amp;&amp; !(_.isFunction(aCtor) &amp;&amp; aCtor <span class="hljs-keyword">instanceof</span> aCtor &amp;&amp;
_.isFunction(bCtor) &amp;&amp; bCtor <span class="hljs-keyword">instanceof</span> bCtor)
&amp;&amp; (<span class="hljs-string">'constructor'</span> <span class="hljs-keyword">in</span> a &amp;&amp; <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>
</li>
<li id="section-125">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-125">&#182;</a>
</div>
<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>
</div>
</li>
<li id="section-126">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-126">&#182;</a>
</div>
<p>Initializing stack of traversed objects.
It’s done here since we only need them for objects and arrays comparison.</p>
</div>
<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>
</li>
<li id="section-127">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-127">&#182;</a>
</div>
<p>Linear search. Performance is inversely proportional to the number of
unique nested structures.</p>
</div>
<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>
</li>
<li id="section-128">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-128">&#182;</a>
</div>
<p>Add the first object to the stack of traversed objects.</p>
</div>
<div class="content"><div class='highlight'><pre> aStack.push(a);
bStack.push(b);</pre></div></div>
</li>
<li id="section-129">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-129">&#182;</a>
</div>
<p>Recursively compare objects and arrays.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">if</span> (areArrays) {</pre></div></div>
</li>
<li id="section-130">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-130">&#182;</a>
</div>
<p>Compare array lengths to determine if a deep comparison is necessary.</p>
</div>
<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>
</li>
<li id="section-131">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-131">&#182;</a>
</div>
<p>Deep compare the contents, ignoring non-numeric properties.</p>
</div>
<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>
</li>
<li id="section-132">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-132">&#182;</a>
</div>
<p>Deep compare objects.</p>
</div>
<div class="content"><div class='highlight'><pre> <span class="hljs-keyword">var</span> keys = _.keys(a), key;
length = keys.length;</pre></div></div>
</li>
<li id="section-133">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-133">&#182;</a>
</div>
<p>Ensure that both objects contain the same number of properties before comparing deep equality.</p>
</div>
<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>
</li>
<li id="section-134">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-134">&#182;</a>
</div>
<p>Deep compare each member</p>
</div>
<div class="content"><div class='highlight'><pre> key = keys[length];
<span class="hljs-keyword">if</span> (!(_.has(b, key) &amp;&amp; eq(a[key], b[key], aStack, bStack))) <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;
}
}</pre></div></div>
</li>
<li id="section-135">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-135">&#182;</a>
</div>
<p>Remove the first object from the stack of traversed objects.</p>
</div>
<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>
</li>
<li id="section-136">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-136">&#182;</a>
</div>
<p>Perform a deep comparison to check if two objects are equal.</p>
</div>
<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>
</li>
<li id="section-137">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-137">&#182;</a>
</div>
<p>Is a given array, string, or object empty?
An “empty” object has no enumerable own-properties.</p>
</div>
<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) &amp;&amp; (_.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>
</li>
<li id="section-138">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-138">&#182;</a>
</div>
<p>Is a given value a DOM element?</p>
</div>
<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 &amp;&amp; obj.nodeType === <span class="hljs-number">1</span>);
};</pre></div></div>
</li>
<li id="section-139">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-139">&#182;</a>
</div>
<p>Is a given value an array?
Delegates to ECMA5’s native Array.isArray</p>
</div>
<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>;
};</pre></div></div>
</li>
<li id="section-140">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-140">&#182;</a>
</div>
<p>Is a given variable an object?</p>
</div>
<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> &amp;&amp; !!obj;
};</pre></div></div>
</li>
<li id="section-141">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-141">&#182;</a>
</div>
<p>Add some isType methods: isArguments, isFunction, isString, isNumber, isDate, isRegExp, isError.</p>
</div>
<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>
</li>
<li id="section-142">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-142">&#182;</a>
</div>
<p>Define a fallback version of the method in browsers (ahem, IE &lt; 9), where
there isn’t any inspectable “Arguments” type.</p>
</div>
<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>
</li>
<li id="section-143">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-143">&#182;</a>
</div>
<p>Optimize <code>isFunction</code> if appropriate. Work around some typeof bugs in old v8,
IE 11 (#1621), and in Safari 8 (#1929).</p>
</div>
<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> &amp;&amp; <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>;
};
}</pre></div></div>
</li>
<li id="section-144">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-144">&#182;</a>
</div>
<p>Is a given object a finite number?</p>
</div>
<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) &amp;&amp; !<span class="hljs-built_in">isNaN</span>(<span class="hljs-built_in">parseFloat</span>(obj));
};</pre></div></div>
</li>
<li id="section-145">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-145">&#182;</a>
</div>
<p>Is the given value <code>NaN</code>? (NaN is the only number which does not equal itself).</p>
</div>
<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) &amp;&amp; obj !== +obj;
};</pre></div></div>
</li>
<li id="section-146">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-146">&#182;</a>
</div>
<p>Is a given value a boolean?</p>
</div>
<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">&#182;</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">&#182;</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">&#182;</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> &amp;&amp; hasOwnProperty.call(obj, key);
};</pre></div></div>
</li>
<li id="section-150">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-150">&#182;</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">&#182;</a>
</div>
</div>
</li>
<li id="section-152">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-152">&#182;</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>
</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">&#182;</a>
</div>
<p>Keep the identity function around for default iteratees.</p>
</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">&#182;</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">&#182;</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">&#182;</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">&#182;</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 &lt; 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">&#182;</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">&#182;</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">&#182;</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">'&amp;'</span>: <span class="hljs-string">'&amp;amp;'</span>,
<span class="hljs-string">'&lt;'</span>: <span class="hljs-string">'&amp;lt;'</span>,
<span class="hljs-string">'&gt;'</span>: <span class="hljs-string">'&amp;gt;'</span>,
<span class="hljs-string">'"'</span>: <span class="hljs-string">'&amp;quot;'</span>,
<span class="hljs-string">"'"</span>: <span class="hljs-string">'&amp;#x27;'</span>,
<span class="hljs-string">'`'</span>: <span class="hljs-string">'&amp;#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">&#182;</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">&#182;</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">&#182;</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">&#182;</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">&#182;</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">/&lt;%([\s\S]+?)%&gt;/g</span>,
interpolate : <span class="hljs-regexp">/&lt;%=([\s\S]+?)%&gt;/g</span>,
<span class="hljs-built_in">escape</span> : <span class="hljs-regexp">/&lt;%-([\s\S]+?)%&gt;/g</span>
};</pre></div></div>
</li>
<li id="section-166">
<div class="annotation">
<div class="pilwrap ">
<a class="pilcrow" href="#section-166">&#182;</a>
</div>
<p>When customizing <code>templateSettings</code>, if you don’t want to define an
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">&#182;</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">&#182;</a>
</div>
<p>JavaScript micro-templating, similar to John Resig’s implementation.
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 &amp;&amp; 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">&#182;</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">&#182;</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">&#182;</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">&#182;</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">&#182;</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">&#182;</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">&#182;</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">&#182;</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">&#182;</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">&#182;</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">&#182;</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">&#182;</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>) &amp;&amp; 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">&#182;</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">&#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">&#182;</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">&#182;</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> &amp;&amp; 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>
</li>
</ul>
</div>
</body>
</html>
Reference in a new issue View git blame Copy permalink