tools/vulcanize/node_modules/vulcanize/node_modules/cheerio/node_modules/underscore/index.html - Issue 125733002: Add vulcanize to tools.

Unified Diff: tools/vulcanize/node_modules/vulcanize/node_modules/cheerio/node_modules/underscore/index.html

Issue 125733002: Add vulcanize to tools. (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src

Patch Set: Created 6 years, 11 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

« no previous file with comments | « tools/vulcanize/node_modules/vulcanize/node_modules/cheerio/node_modules/underscore/favicon.ico ('k') | tools/vulcanize/node_modules/vulcanize/node_modules/cheerio/node_modules/underscore/index.js » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Hide Comments ('s')

Index: tools/vulcanize/node_modules/vulcanize/node_modules/cheerio/node_modules/underscore/index.html

diff --git a/tools/vulcanize/node_modules/vulcanize/node_modules/cheerio/node_modules/underscore/index.html b/tools/vulcanize/node_modules/vulcanize/node_modules/cheerio/node_modules/underscore/index.html

new file mode 100644

index 0000000000000000000000000000000000000000..8c5793ab4ff59153b84dbe73575b8bb1820ce7c3

--- /dev/null

+++ b/tools/vulcanize/node_modules/vulcanize/node_modules/cheerio/node_modules/underscore/index.html

@@ -0,0 +1,2467 @@

+<!DOCTYPE HTML>

+<html>

+<head>

+ <meta http-equiv="content-type" content="text/html;charset=UTF-8" />

+ <meta http-equiv="X-UA-Compatible" content="chrome=1" />

+ <meta name="viewport" content="width=device-width" />

+ <link rel="canonical" href="http://underscorejs.org" />

+ <link rel="shortcut icon" href="favicon.ico" type="image/x-icon" />

+ <title>Underscore.js</title>

+ <style>

+ body {

+ font-size: 14px;

+ line-height: 22px;

+ background: #f4f4f4 url(docs/images/background.png);

+ color: #000;

+ font-family: Helvetica Neue, Helvetica, Arial;

+ }

+ .interface {

+ font-family: "Lucida Grande", "Lucida Sans Unicode", Helvetica, Arial, sans-serif !important;

+ }

+ div#sidebar {

+ background: #fff;

+ position: fixed;

+ top: 0; left: 0; bottom: 0;

+ width: 200px;

+ overflow-y: auto;

+ overflow-x: hidden;

+ -webkit-overflow-scrolling: touch;

+ padding: 15px 0 30px 30px;

+ border-right: 1px solid #bbb;

+ box-shadow: 0 0 20px #ccc; -webkit-box-shadow: 0 0 20px #ccc; -moz-box-shadow: 0 0 20px #ccc;

+ }

+ a.toc_title, a.toc_title:visited {

+ display: block;

+ color: black;

+ font-weight: bold;

+ margin-top: 15px;

+ }

+ a.toc_title:hover {

+ text-decoration: underline;

+ }

+ #sidebar .version {

+ font-size: 10px;

+ font-weight: normal;

+ }

+ ul.toc_section {

+ font-size: 11px;

+ line-height: 14px;

+ margin: 5px 0 0 0;

+ padding-left: 0px;

+ list-style-type: none;

+ font-family: Lucida Grande;

+ }

+ .toc_section li {

+ cursor: pointer;

+ margin: 0 0 3px 0;

+ }

+ .toc_section li a {

+ text-decoration: none;

+ color: black;

+ }

+ .toc_section li a:hover {

+ text-decoration: underline;

+ }

+ div.container {

+ width: 550px;

+ margin: 40px 0 50px 260px;

+ }

+ img#logo {

+ width: 396px;

+ height: 69px;

+ }

+ div.warning {

+ margin-top: 15px;

+ font: bold 11px Arial;

+ color: #770000;

+ }

+ p {

+ margin: 20px 0;

+ width: 550px;

+ }

+ a, a:visited {

+ color: #444;

+ }

+ a:active, a:hover {

+ color: #000;

+ }

+ h1, h2, h3, h4, h5, h6 {

+ padding-top: 20px;

+ }

+ h2 {

+ font-size: 20px;

+ }

+ b.header {

+ font-size: 16px;

+ line-height: 30px;

+ }

+ span.alias {

+ font-size: 14px;

+ font-style: italic;

+ margin-left: 20px;

+ }

+ table, tr, td {

+ margin: 0; padding: 0;

+ }

+ td {

+ padding: 2px 12px 2px 0;

+ }

+ table .rule {

+ height: 1px;

+ background: #ccc;

+ margin: 5px 0;

+ }

+ ul {

+ list-style-type: circle;

+ padding: 0 0 0 20px;

+ }

+ li {

+ width: 500px;

+ margin-bottom: 10px;

+ }

+ code, pre, tt {

+ font-family: Monaco, Consolas, "Lucida Console", monospace;

+ font-size: 12px;

+ line-height: 18px;

+ font-style: normal;

+ }

+ tt {

+ padding: 0px 3px;

+ background: #fff;

+ border: 1px solid #ddd;

+ zoom: 1;

+ }

+ code {

+ margin-left: 20px;

+ }

+ pre {

+ font-size: 12px;

+ padding: 2px 0 2px 15px;

+ border-left: 5px solid #bbb;

+ margin: 0px 0 30px;

+ }

+ @media only screen and (-webkit-min-device-pixel-ratio: 1.5) and (max-width: 640px),

+ only screen and (-o-min-device-pixel-ratio: 3/2) and (max-width: 640px),

+ only screen and (min-device-pixel-ratio: 1.5) and (max-width: 640px) {

+ img {

+ max-width: 100%;

+ }

+ div#sidebar {

+ -webkit-overflow-scrolling: initial;

+ position: relative;

+ width: 90%;

+ height: 120px;

+ left: 0;

+ top: -7px;

+ padding: 10px 0 10px 30px;

+ border: 0;

+ }

+ img#logo {

+ width: auto;

+ height: auto;

+ }

+ div.container {

+ margin: 0;

+ width: 100%;

+ }

+ p, div.container ul {

+ max-width: 98%;

+ overflow-x: scroll;

+ }

+ pre {

+ overflow: scroll;

+ }

+ </style>

+</head>

+<body>

+ <div id="sidebar" class="interface">

+ <a class="toc_title" href="#">

+ Underscore.js (1.4.4)

+ </a>

+ <ul class="toc_section">

+ <li>» <a href="http://github.com/documentcloud/underscore">GitHub Repository</a></li>

+ <li>» <a href="docs/underscore.html">Annotated Source</a></li>

+ </ul>

+ <a class="toc_title" href="#">

+ Introduction

+ </a>

+ <a class="toc_title" href="#collections">

+ Collections

+ </a>

+ <ul class="toc_section">

+ <li>- <a href="#each">each</a></li>

+ <li>- <a href="#map">map</a></li>

+ <li>- <a href="#reduce">reduce</a></li>

+ <li>- <a href="#reduceRight">reduceRight</a></li>

+ <li>- <a href="#find">find</a></li>

+ <li>- <a href="#filter">filter</a></li>

+ <li>- <a href="#where">where</a></li>

+ <li>- <a href="#findWhere">findWhere</a></li>

+ <li>- <a href="#reject">reject</a></li>

+ <li>- <a href="#every">every</a></li>

+ <li>- <a href="#some">some</a></li>

+ <li>- <a href="#contains">contains</a></li>

+ <li>- <a href="#invoke">invoke</a></li>

+ <li>- <a href="#pluck">pluck</a></li>

+ <li>- <a href="#max">max</a></li>

+ <li>- <a href="#min">min</a></li>

+ <li>- <a href="#sortBy">sortBy</a></li>

+ <li>- <a href="#groupBy">groupBy</a></li>

+ <li>- <a href="#countBy">countBy</a></li>

+ <li>- <a href="#shuffle">shuffle</a></li>

+ <li>- <a href="#toArray">toArray</a></li>

+ <li>- <a href="#size">size</a></li>

+ </ul>

+ <a class="toc_title" href="#arrays">

+ Arrays

+ </a>

+ <ul class="toc_section">

+ <li>- <a href="#first">first</a></li>

+ <li>- <a href="#initial">initial</a></li>

+ <li>- <a href="#last">last</a></li>

+ <li>- <a href="#rest">rest</a></li>

+ <li>- <a href="#compact">compact</a></li>

+ <li>- <a href="#flatten">flatten</a></li>

+ <li>- <a href="#without">without</a></li>

+ <li>- <a href="#union">union</a></li>

+ <li>- <a href="#intersection">intersection</a></li>

+ <li>- <a href="#difference">difference</a></li>

+ <li>- <a href="#uniq">uniq</a></li>

+ <li>- <a href="#zip">zip</a></li>

+ <li>- <a href="#object">object</a></li>

+ <li>- <a href="#indexOf">indexOf</a></li>

+ <li>- <a href="#lastIndexOf">lastIndexOf</a></li>

+ <li>- <a href="#sortedIndex">sortedIndex</a></li>

+ <li>- <a href="#range">range</a></li>

+ </ul>

+ <a class="toc_title" href="#functions">

+ Functions

+ </a>

+ <ul class="toc_section">

+ <li>- <a href="#bind">bind</a></li>

+ <li>- <a href="#bindAll">bindAll</a></li>

+ <li>- <a href="#partial">partial</a></li>

+ <li>- <a href="#memoize">memoize</a></li>

+ <li>- <a href="#delay">delay</a></li>

+ <li>- <a href="#defer">defer</a></li>

+ <li>- <a href="#throttle">throttle</a></li>

+ <li>- <a href="#debounce">debounce</a></li>

+ <li>- <a href="#once">once</a></li>

+ <li>- <a href="#after">after</a></li>

+ <li>- <a href="#wrap">wrap</a></li>

+ <li>- <a href="#compose">compose</a></li>

+ </ul>

+ <a class="toc_title" href="#objects">

+ Objects

+ </a>

+ <ul class="toc_section">

+ <li>- <a href="#keys">keys</a></li>

+ <li>- <a href="#values">values</a></li>

+ <li>- <a href="#pairs">pairs</a></li>

+ <li>- <a href="#invert">invert</a></li>

+ <li>- <a href="#object-functions">functions</a></li>

+ <li>- <a href="#extend">extend</a></li>

+ <li>- <a href="#pick">pick</a></li>

+ <li>- <a href="#omit">omit</a></li>

+ <li>- <a href="#defaults">defaults</a></li>

+ <li>- <a href="#clone">clone</a></li>

+ <li>- <a href="#tap">tap</a></li>

+ <li>- <a href="#has">has</a></li>

+ <li>- <a href="#isEqual">isEqual</a></li>

+ <li>- <a href="#isEmpty">isEmpty</a></li>

+ <li>- <a href="#isElement">isElement</a></li>

+ <li>- <a href="#isArray">isArray</a></li>

+ <li>- <a href="#isObject">isObject</a></li>

+ <li>- <a href="#isArguments">isArguments</a></li>

+ <li>- <a href="#isFunction">isFunction</a></li>

+ <li>- <a href="#isString">isString</a></li>

+ <li>- <a href="#isNumber">isNumber</a></li>

+ <li>- <a href="#isFinite">isFinite</a></li>

+ <li>- <a href="#isBoolean">isBoolean</a></li>

+ <li>- <a href="#isDate">isDate</a></li>

+ <li>- <a href="#isRegExp">isRegExp</a></li>

+ <li>- <a href="#isNaN">isNaN</a></li>

+ <li>- <a href="#isNull">isNull</a></li>

+ <li>- <a href="#isUndefined">isUndefined</a></li>

+ </ul>

+ <a class="toc_title" href="#utility">

+ Utility

+ </a>

+ <ul class="toc_section">

+ <li>- <a href="#noConflict">noConflict</a></li>

+ <li>- <a href="#identity">identity</a></li>

+ <li>- <a href="#times">times</a></li>

+ <li>- <a href="#random">random</a></li>

+ <li>- <a href="#mixin">mixin</a></li>

+ <li>- <a href="#uniqueId">uniqueId</a></li>

+ <li>- <a href="#escape">escape</a></li>

+ <li>- <a href="#unescape">unescape</a></li>

+ <li>- <a href="#result">result</a></li>

+ <li>- <a href="#template">template</a></li>

+ </ul>

+ <a class="toc_title" href="#chaining">

+ Chaining

+ </a>

+ <ul class="toc_section">

+ <li>- <a href="#chain">chain</a></li>

+ <li>- <a href="#value">value</a></li>

+ </ul>

+ <a class="toc_title" href="#links">

+ Links

+ </a>

+ <a class="toc_title" href="#changelog">

+ Change Log

+ </a>

+ </div>

+ <div class="container">

+

+ <img id="logo" src="docs/images/underscore.png" alt="Underscore.js" />

+

+

+ <a href="http://github.com/documentcloud/underscore/">Underscore</a> is a

+ utility-belt library for JavaScript that provides a lot of the

+ functional programming support that you would expect in

+ <a href="http://prototypejs.org/doc/latest/">Prototype.js</a>

+ (or <a href="http://www.ruby-doc.org/core/classes/Enumerable.html">Ruby</a>),

+ but without extending any of the built-in JavaScript objects. It's the

+ tie to go along with <a href="http://docs.jquery.com">jQuery</a>'s tux,

+ and <a href="http://backbonejs.org">Backbone.js</a>'s suspenders.

+

+

+ Underscore provides 80-odd functions that support both the usual

+ functional suspects: map, select, invoke —

+ as well as more specialized helpers: function binding, javascript

+ templating, deep equality testing, and so on. It delegates to built-in

+ functions, if present, so modern browsers will use the

+ native implementations of forEach, map, reduce,

+ filter, every, some and indexOf.

+

+

+ A complete <a href="test/">Test & Benchmark Suite</a>

+ is included for your perusal.

+

+

+ You may also read through the <a href="docs/underscore.html">annotated source code</a>.

+

+

+ The project is

+ <a href="http://github.com/documentcloud/underscore/">hosted on GitHub</a>.

+ You can report bugs and discuss features on the

+ <a href="http://github.com/documentcloud/underscore/issues">issues page</a>,

+ on Freenode in the <tt>#documentcloud</tt> channel,

+ or send tweets to <a href="http://twitter.com/documentcloud">@documentcloud</a>.

+

+

+ Underscore is an open-source component of <a href="http://documentcloud.org/">DocumentCloud</a>.

+

+ <h2>Downloads (Right-click, and use "Save As")</h2>

+ <table>

+ <tr>

+ <td><a href="underscore.js">Development Version (1.4.4)</a></td>

+ <td>40kb, Uncompressed with Plentiful Comments</td>

+ </tr>

+ <tr>

+ <td><a href="underscore-min.js">Production Version (1.4.4)</a></td>

+ <td>4kb, Minified and Gzipped</td>

+ </tr>

+ <tr>

+ <td colspan="2"><div class="rule"></div></td>

+ </tr>

+ <tr>

+ <td><a href="https://raw.github.com/documentcloud/underscore/master/underscore.js">Edge Version</a></td>

+ <td>Unreleased, current <tt>master</tt>, use at your own risk</td>

+ </tr>

+ </table>

+ <div id="documentation">

+ <h2 id="collections">Collection Functions (Arrays or Objects)</h2>

+

+ each<code>_.each(list, iterator, [context])</code>

+ Alias: forEach

+

+ Iterates over a list of elements, yielding each in turn to an iterator

+ function. The iterator is bound to the context object, if one is

+ passed. Each invocation of iterator is called with three arguments:

+ <tt>(element, index, list)</tt>. If list is a JavaScript object, iterator's

+ arguments will be <tt>(value, key, list)</tt>. Delegates to the native

+ forEach function if it exists.

+

+ <pre>

+_.each([1, 2, 3], alert);

+=> alerts each number in turn...

+_.each({one : 1, two : 2, three : 3}, alert);

+=> alerts each number value in turn...</pre>

+

+ map<code>_.map(list, iterator, [context])</code>

+ Alias: collect

+

+ Produces a new array of values by mapping each value in list

+ through a transformation function (iterator). If the native map method

+ exists, it will be used instead. If list is a JavaScript object,

+ iterator's arguments will be <tt>(value, key, list)</tt>.

+

+ <pre>

+_.map([1, 2, 3], function(num){ return num * 3; });

+=> [3, 6, 9]

+_.map({one : 1, two : 2, three : 3}, function(num, key){ return num * 3; });

+=> [3, 6, 9]</pre>

+

+ reduce<code>_.reduce(list, iterator, memo, [context])</code>

+ Aliases: inject, foldl

+

+ Also known as inject and foldl, reduce boils down a

+ list of values into a single value. Memo is the initial state

+ of the reduction, and each successive step of it should be returned by

+ iterator. The iterator is passed four arguments: the <tt>memo</tt>,

+ then the <tt>value</tt> and <tt>index</tt> (or key) of the iteration,

+ and finally a reference to the entire <tt>list</tt>.

+

+ <pre>

+var sum = _.reduce([1, 2, 3], function(memo, num){ return memo + num; }, 0);

+=> 6

+</pre>

+

+ reduceRight<code>_.reduceRight(list, iterator, memo, [context])</code>

+ Alias: foldr

+

+ The right-associative version of reduce. Delegates to the

+ JavaScript 1.8 version of reduceRight, if it exists. Foldr

+ is not as useful in JavaScript as it would be in a language with lazy

+ evaluation.

+

+ <pre>

+var list = [[0, 1], [2, 3], [4, 5]];

+var flat = _.reduceRight(list, function(a, b) { return a.concat(b); }, []);

+=> [4, 5, 2, 3, 0, 1]

+</pre>

+

+ find<code>_.find(list, iterator, [context])</code>

+ Alias: detect

+

+ Looks through each value in the list, returning the first one that

+ passes a truth test (iterator). The function returns as

+ soon as it finds an acceptable element, and doesn't traverse the

+ entire list.

+

+ <pre>

+var even = _.find([1, 2, 3, 4, 5, 6], function(num){ return num % 2 == 0; });

+=> 2

+</pre>

+

+ filter<code>_.filter(list, iterator, [context])</code>

+ Alias: select

+

+ Looks through each value in the list, returning an array of all

+ the values that pass a truth test (iterator). Delegates to the

+ native filter method, if it exists.

+

+ <pre>

+var evens = _.filter([1, 2, 3, 4, 5, 6], function(num){ return num % 2 == 0; });

+=> [2, 4, 6]

+</pre>

+

+ where<code>_.where(list, properties)</code>

+

+ Looks through each value in the list, returning an array of all

+ the values that contain all of the key-value pairs listed in properties.

+

+ <pre>

+_.where(listOfPlays, {author: "Shakespeare", year: 1611});

+=> [{title: "Cymbeline", author: "Shakespeare", year: 1611},

+ {title: "The Tempest", author: "Shakespeare", year: 1611}]

+</pre>

+

+ findWhere<code>_.findWhere(list, properties)</code>

+

+ Looks through the list and returns the first value that matches

+ all of the key-value pairs listed in properties.

+

+ <pre>

+_.findWhere(publicServicePulitzers, {newsroom: "The New York Times"});

+=> {year: 1918, newsroom: "The New York Times",

+ reason: "For its public service in publishing in full so many official reports,

+ documents and speeches by European statesmen relating to the progress and

+ conduct of the war."}

+</pre>

+

+ reject<code>_.reject(list, iterator, [context])</code>

+

+ Returns the values in list without the elements that the truth

+ test (iterator) passes. The opposite of filter.

+

+ <pre>

+var odds = _.reject([1, 2, 3, 4, 5, 6], function(num){ return num % 2 == 0; });

+=> [1, 3, 5]

+</pre>

+

+ every<code>_.every(list, iterator, [context])</code>

+ Alias: all

+

+ Returns true if all of the values in the list pass the iterator

+ truth test. Delegates to the native method every, if present.

+

+ <pre>

+_.every([true, 1, null, 'yes'], _.identity);

+=> false

+</pre>

+

+ some<code>_.some(list, [iterator], [context])</code>

+ Alias: any

+

+ Returns true if any of the values in the list pass the

+ iterator truth test. Short-circuits and stops traversing the list

+ if a true element is found. Delegates to the native method some,

+ if present.

+

+ <pre>

+_.some([null, 0, 'yes', false]);

+=> true

+</pre>

+

+ contains<code>_.contains(list, value)</code>

+ Alias: include

+

+ Returns true if the value is present in the list.

+ Uses indexOf internally, if list is an Array.

+

+ <pre>

+_.contains([1, 2, 3], 3);

+=> true

+</pre>

+

+ invoke<code>_.invoke(list, methodName, [*arguments])</code>

+

+ Calls the method named by methodName on each value in the list.

+ Any extra arguments passed to invoke will be forwarded on to the

+ method invocation.

+

+ <pre>

+_.invoke([[5, 1, 7], [3, 2, 1]], 'sort');

+=> [[1, 5, 7], [1, 2, 3]]

+</pre>

+

+ pluck<code>_.pluck(list, propertyName)</code>

+

+ A convenient version of what is perhaps the most common use-case for

+ map: extracting a list of property values.

+

+ <pre>

+var stooges = [{name : 'moe', age : 40}, {name : 'larry', age : 50}, {name : 'curly', age : 60}];

+_.pluck(stooges, 'name');

+=> ["moe", "larry", "curly"]

+</pre>

+

+ max<code>_.max(list, [iterator], [context])</code>

+

+ Returns the maximum value in list. If iterator is passed,

+ it will be used on each value to generate the criterion by which the

+ value is ranked.

+

+ <pre>

+var stooges = [{name : 'moe', age : 40}, {name : 'larry', age : 50}, {name : 'curly', age : 60}];

+_.max(stooges, function(stooge){ return stooge.age; });

+=> {name : 'curly', age : 60};

+</pre>

+

+ min<code>_.min(list, [iterator], [context])</code>

+

+ Returns the minimum value in list. If iterator is passed,

+ it will be used on each value to generate the criterion by which the

+ value is ranked.

+

+ <pre>

+var numbers = [10, 5, 100, 2, 1000];

+_.min(numbers);

+=> 2

+</pre>

+

+ sortBy<code>_.sortBy(list, iterator, [context])</code>

+

+ Returns a sorted copy of list, ranked in ascending order by the

+ results of running each value through iterator. Iterator may

+ also be the string name of the property to sort by (eg. <tt>length</tt>).

+

+ <pre>

+_.sortBy([1, 2, 3, 4, 5, 6], function(num){ return Math.sin(num); });

+=> [5, 4, 6, 3, 1, 2]

+</pre>

+

+ groupBy<code>_.groupBy(list, iterator, [context])</code>

+

+ Splits a collection into sets, grouped by the result of running each

+ value through iterator. If iterator is a string instead of

+ a function, groups by the property named by iterator on each of

+ the values.

+

+ <pre>

+_.groupBy([1.3, 2.1, 2.4], function(num){ return Math.floor(num); });

+=> {1: [1.3], 2: [2.1, 2.4]}

+_.groupBy(['one', 'two', 'three'], 'length');

+=> {3: ["one", "two"], 5: ["three"]}

+</pre>

+

+ countBy<code>_.countBy(list, iterator, [context])</code>

+

+ Sorts a list into groups and returns a count for the number of objects

+ in each group.

+ Similar to <tt>groupBy</tt>, but instead of returning a list of values,

+ returns a count for the number of values in that group.

+

+ <pre>

+_.countBy([1, 2, 3, 4, 5], function(num) {

+ return num % 2 == 0 ? 'even' : 'odd';

+});

+=> {odd: 3, even: 2}

+</pre>

+

+ shuffle<code>_.shuffle(list)</code>

+

+ Returns a shuffled copy of the list, using a version of the

+ <a href="http://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle">Fisher-Yates shuffle</a>.

+

+ <pre>

+_.shuffle([1, 2, 3, 4, 5, 6]);

+=> [4, 1, 6, 3, 5, 2]

+</pre>

+

+ toArray<code>_.toArray(list)</code>

+

+ Converts the list (anything that can be iterated over), into a

+ real Array. Useful for transmuting the arguments object.

+

+ <pre>

+(function(){ return _.toArray(arguments).slice(1); })(1, 2, 3, 4);

+=> [2, 3, 4]

+</pre>

+

+ size<code>_.size(list)</code>

+

+ Return the number of values in the list.

+

+ <pre>

+_.size({one : 1, two : 2, three : 3});

+=> 3

+</pre>

+ <h2 id="arrays">Array Functions</h2>

+

+

+ Note: All array functions will also work on the arguments object.

+ However, Underscore functions are not designed to work on "sparse" arrays.

+

+

+

+ first<code>_.first(array, [n])</code>

+ Alias: head, take

+

+ Returns the first element of an array. Passing n will

+ return the first n elements of the array.

+

+ <pre>

+_.first([5, 4, 3, 2, 1]);

+=> 5

+</pre>

+

+ initial<code>_.initial(array, [n])</code>

+

+ Returns everything but the last entry of the array. Especially useful on

+ the arguments object. Pass n to exclude the last n elements

+ from the result.

+

+ <pre>

+_.initial([5, 4, 3, 2, 1]);

+=> [5, 4, 3, 2]

+</pre>

+

+ last<code>_.last(array, [n])</code>

+

+ Returns the last element of an array. Passing n will return

+ the last n elements of the array.

+

+ <pre>

+_.last([5, 4, 3, 2, 1]);

+=> 1

+</pre>

+

+ rest<code>_.rest(array, [index])</code>

+ Alias: tail, drop

+

+ Returns the rest of the elements in an array. Pass an index

+ to return the values of the array from that index onward.

+

+ <pre>

+_.rest([5, 4, 3, 2, 1]);

+=> [4, 3, 2, 1]

+</pre>

+

+ compact<code>_.compact(array)</code>

+

+ Returns a copy of the array with all falsy values removed.

+ In JavaScript, false, null, 0, "",

+ undefined and NaN are all falsy.

+

+ <pre>

+_.compact([0, 1, false, 2, '', 3]);

+=> [1, 2, 3]

+</pre>

+

+ flatten<code>_.flatten(array, [shallow])</code>

+

+ Flattens a nested array (the nesting can be to any depth). If you

+ pass shallow, the array will only be flattened a single level.

+

+ <pre>

+_.flatten([1, [2], [3, [[4]]]]);

+=> [1, 2, 3, 4];

+_.flatten([1, [2], [3, [[4]]]], true);

+=> [1, 2, 3, [[4]]];

+</pre>

+

+ without<code>_.without(array, [*values])</code>

+

+ Returns a copy of the array with all instances of the values

+ removed.

+

+ <pre>

+_.without([1, 2, 1, 0, 3, 1, 4], 0, 1);

+=> [2, 3, 4]

+</pre>

+

+ union<code>_.union(*arrays)</code>

+

+ Computes the union of the passed-in arrays: the list of unique items,

+ in order, that are present in one or more of the arrays.

+

+ <pre>

+_.union([1, 2, 3], [101, 2, 1, 10], [2, 1]);

+=> [1, 2, 3, 101, 10]

+</pre>

+

+ intersection<code>_.intersection(*arrays)</code>

+

+ Computes the list of values that are the intersection of all the arrays.

+ Each value in the result is present in each of the arrays.

+

+ <pre>

+_.intersection([1, 2, 3], [101, 2, 1, 10], [2, 1]);

+=> [1, 2]

+</pre>

+

+ difference<code>_.difference(array, *others)</code>

+

+ Similar to without, but returns the values from array that

+ are not present in the other arrays.

+

+ <pre>

+_.difference([1, 2, 3, 4, 5], [5, 2, 10]);

+=> [1, 3, 4]

+</pre>

+

+ uniq<code>_.uniq(array, [isSorted], [iterator])</code>

+ Alias: unique

+

+ Produces a duplicate-free version of the array, using === to test

+ object equality. If you know in advance that the array is sorted,

+ passing true for isSorted will run a much faster algorithm.

+ If you want to compute unique items based on a transformation, pass an

+ iterator function.

+

+ <pre>

+_.uniq([1, 2, 1, 3, 1, 4]);

+=> [1, 2, 3, 4]

+</pre>

+

+ zip<code>_.zip(*arrays)</code>

+

+ Merges together the values of each of the arrays with the

+ values at the corresponding position. Useful when you have separate

+ data sources that are coordinated through matching array indexes.

+ If you're working with a matrix of nested arrays, zip.apply

+ can transpose the matrix in a similar fashion.

+

+ <pre>

+_.zip(['moe', 'larry', 'curly'], [30, 40, 50], [true, false, false]);

+=> [["moe", 30, true], ["larry", 40, false], ["curly", 50, false]]

+</pre>

+

+ object<code>_.object(list, [values])</code>

+

+ Converts arrays into objects. Pass either a single list of

+ <tt>[key, value]</tt> pairs, or a list of keys, and a list of values.

+

+ <pre>

+_.object(['moe', 'larry', 'curly'], [30, 40, 50]);

+=> {moe: 30, larry: 40, curly: 50}

+_.object([['moe', 30], ['larry', 40], ['curly', 50]]);

+=> {moe: 30, larry: 40, curly: 50}

+</pre>

+

+ indexOf<code>_.indexOf(array, value, [isSorted])</code>

+

+ Returns the index at which value can be found in the array,

+ or -1 if value is not present in the array. Uses the native

+ indexOf function unless it's missing. If you're working with a

+ large array, and you know that the array is already sorted, pass <tt>true</tt>

+ for isSorted to use a faster binary search ... or, pass a number as

+ the third argument in order to look for the first matching value in the

+ array after the given index.

+

+ <pre>

+_.indexOf([1, 2, 3], 2);

+=> 1

+</pre>

+

+ lastIndexOf<code>_.lastIndexOf(array, value, [fromIndex])</code>

+

+ Returns the index of the last occurrence of value in the array,

+ or -1 if value is not present. Uses the native lastIndexOf

+ function if possible. Pass fromIndex to start your search at a

+ given index.

+

+ <pre>

+_.lastIndexOf([1, 2, 3, 1, 2, 3], 2);

+=> 4

+</pre>

+

+ sortedIndex<code>_.sortedIndex(list, value, [iterator], [context])</code>

+

+ Uses a binary search to determine the index at which the value

+ should be inserted into the list in order to maintain the list's

+ sorted order. If an iterator is passed, it will be used to compute

+ the sort ranking of each value, including the value you pass.

+

+ <pre>

+_.sortedIndex([10, 20, 30, 40, 50], 35);

+=> 3

+</pre>

+

+ range<code>_.range([start], stop, [step])</code>

+

+ A function to create flexibly-numbered lists of integers, handy for

+ <tt>each</tt> and <tt>map</tt> loops. start, if omitted, defaults

+ to 0; step defaults to 1. Returns a list of integers

+ from start to stop, incremented (or decremented) by step,

+ exclusive.

+

+ <pre>

+_.range(10);

+=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

+_.range(1, 11);

+=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

+_.range(0, 30, 5);

+=> [0, 5, 10, 15, 20, 25]

+_.range(0, -10, -1);

+=> [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]

+_.range(0);

+=> []

+</pre>

+ <h2 id="functions">Function (uh, ahem) Functions</h2>

+

+ bind<code>_.bind(function, object, [*arguments])</code>

+

+ Bind a function to an object, meaning that whenever

+ the function is called, the value of this will be the object.

+ Optionally, pass arguments to the function to pre-fill them,

+ also known as partial application.

+

+ <pre>

+var func = function(greeting){ return greeting + ': ' + this.name };

+func = _.bind(func, {name : 'moe'}, 'hi');

+func();

+=> 'hi: moe'

+</pre>

+

+ bindAll<code>_.bindAll(object, [*methodNames])</code>

+

+ Binds a number of methods on the object, specified by

+ methodNames, to be run in the context of that object whenever they

+ are invoked. Very handy for binding functions that are going to be used

+ as event handlers, which would otherwise be invoked with a fairly useless

+ this. If no methodNames are provided, all of the object's

+ function properties will be bound to it.

+

+ <pre>

+var buttonView = {

+ label : 'underscore',

+ onClick : function(){ alert('clicked: ' + this.label); },

+ onHover : function(){ console.log('hovering: ' + this.label); }

+};

+_.bindAll(buttonView);

+jQuery('#underscore_button').bind('click', buttonView.onClick);

+=> When the button is clicked, this.label will have the correct value...

+</pre>

+

+ partial<code>_.partial(function, [*arguments])</code>

+

+ Partially apply a function by filling in any number of its arguments,

+ without changing its dynamic <tt>this</tt> value. A close cousin

+ of <a href="#bind">bind</a>.

+

+ <pre>

+var add = function(a, b) { return a + b; };

+add5 = _.partial(add, 5);

+add5(10);

+=> 15

+</pre>

+

+ memoize<code>_.memoize(function, [hashFunction])</code>

+

+ Memoizes a given function by caching the computed result. Useful

+ for speeding up slow-running computations. If passed an optional

+ hashFunction, it will be used to compute the hash key for storing

+ the result, based on the arguments to the original function. The default

+ hashFunction just uses the first argument to the memoized function

+ as the key.

+

+ <pre>

+var fibonacci = _.memoize(function(n) {

+ return n < 2 ? n : fibonacci(n - 1) + fibonacci(n - 2);

+});

+</pre>

+

+ delay<code>_.delay(function, wait, [*arguments])</code>

+

+ Much like setTimeout, invokes function after wait

+ milliseconds. If you pass the optional arguments, they will be

+ forwarded on to the function when it is invoked.

+

+ <pre>

+var log = _.bind(console.log, console);

+_.delay(log, 1000, 'logged later');

+=> 'logged later' // Appears after one second.

+</pre>

+

+ defer<code>_.defer(function, [*arguments])</code>

+

+ Defers invoking the function until the current call stack has cleared,

+ similar to using setTimeout with a delay of 0. Useful for performing

+ expensive computations or HTML rendering in chunks without blocking the UI thread

+ from updating. If you pass the optional arguments, they will be

+ forwarded on to the function when it is invoked.

+

+ <pre>

+_.defer(function(){ alert('deferred'); });

+// Returns from the function before the alert runs.

+</pre>

+

+ throttle<code>_.throttle(function, wait)</code>

+

+ Creates and returns a new, throttled version of the passed function,

+ that, when invoked repeatedly, will only actually call the original function

+ at most once per every wait

+ milliseconds. Useful for rate-limiting events that occur faster than you

+ can keep up with.

+

+ <pre>

+var throttled = _.throttle(updatePosition, 100);

+$(window).scroll(throttled);

+</pre>

+

+ debounce<code>_.debounce(function, wait, [immediate])</code>

+

+ Creates and returns a new debounced version of the passed function that

+ will postpone its execution until after

+ wait milliseconds have elapsed since the last time it

+ was invoked. Useful for implementing behavior that should only happen

+ after the input has stopped arriving. For example: rendering a

+ preview of a Markdown comment, recalculating a layout after the window

+ has stopped being resized, and so on.

+

+

+ Pass <tt>true</tt> for the immediate parameter to cause

+ debounce to trigger the function on the leading instead of the

+ trailing edge of the wait interval. Useful in circumstances like

+ preventing accidental double-clicks on a "submit" button from firing a

+ second time.

+

+ <pre>

+var lazyLayout = _.debounce(calculateLayout, 300);

+$(window).resize(lazyLayout);

+</pre>

+

+ once<code>_.once(function)</code>

+

+ Creates a version of the function that can only be called one time.

+ Repeated calls to the modified function will have no effect, returning

+ the value from the original call. Useful for initialization functions,

+ instead of having to set a boolean flag and then check it later.

+

+ <pre>

+var initialize = _.once(createApplication);

+initialize();

+// Application is only created once.

+</pre>

+

+ after<code>_.after(count, function)</code>

+

+ Creates a version of the function that will only be run after first

+ being called count times. Useful for grouping asynchronous responses,

+ where you want to be sure that all the async calls have finished, before

+ proceeding.

+

+ <pre>

+var renderNotes = _.after(notes.length, render);

+_.each(notes, function(note) {

+ note.asyncSave({success: renderNotes});

+});

+// renderNotes is run once, after all notes have saved.

+</pre>

+

+ wrap<code>_.wrap(function, wrapper)</code>

+

+ Wraps the first function inside of the wrapper function,

+ passing it as the first argument. This allows the wrapper to

+ execute code before and after the function runs, adjust the arguments,

+ and execute it conditionally.

+

+ <pre>

+var hello = function(name) { return "hello: " + name; };

+hello = _.wrap(hello, function(func) {

+ return "before, " + func("moe") + ", after";

+});

+hello();

+=> 'before, hello: moe, after'

+</pre>

+

+ compose<code>_.compose(*functions)</code>

+

+ Returns the composition of a list of functions, where each function

+ consumes the return value of the function that follows. In math terms,

+ composing the functions f(), g(), and h() produces

+ f(g(h())).

+

+ <pre>

+var greet = function(name){ return "hi: " + name; };

+var exclaim = function(statement){ return statement + "!"; };

+var welcome = _.compose(exclaim, greet);

+welcome('moe');

+=> 'hi: moe!'

+</pre>

+ <h2 id="objects">Object Functions</h2>

+

+ keys<code>_.keys(object)</code>

+

+ Retrieve all the names of the object's properties.

+

+ <pre>

+_.keys({one : 1, two : 2, three : 3});

+=> ["one", "two", "three"]

+</pre>

+

+ values<code>_.values(object)</code>

+

+ Return all of the values of the object's properties.

+

+ <pre>

+_.values({one : 1, two : 2, three : 3});

+=> [1, 2, 3]

+</pre>

+

+ pairs<code>_.pairs(object)</code>

+

+ Convert an object into a list of <tt>[key, value]</tt> pairs.

+

+ <pre>

+_.pairs({one: 1, two: 2, three: 3});

+=> [["one", 1], ["two", 2], ["three", 3]]

+</pre>

+

+ invert<code>_.invert(object)</code>

+

+ Returns a copy of the object where the keys have become the values

+ and the values the keys. For this to work, all of your object's values

+ should be unique and string serializable.

+

+ <pre>

+_.invert({Moe: "Moses", Larry: "Louis", Curly: "Jerome"});

+=> {Moses: "Moe", Louis: "Larry", Jerome: "Curly"};

+</pre>

+

+ functions<code>_.functions(object)</code>

+ Alias: methods

+

+ Returns a sorted list of the names of every method in an object —

+ that is to say, the name of every function property of the object.

+

+ <pre>

+_.functions(_);

+=> ["all", "any", "bind", "bindAll", "clone", "compact", "compose" ...

+</pre>

+

+ extend<code>_.extend(destination, *sources)</code>

+

+ Copy all of the properties in the source objects over to the

+ destination object, and return the destination object.

+ It's in-order, so the last source will override properties of the same

+ name in previous arguments.

+

+ <pre>

+_.extend({name : 'moe'}, {age : 50});

+=> {name : 'moe', age : 50}

+</pre>

+

+ pick<code>_.pick(object, *keys)</code>

+

+ Return a copy of the object, filtered to only have values for

+ the whitelisted keys (or array of valid keys).

+

+ <pre>

+_.pick({name : 'moe', age: 50, userid : 'moe1'}, 'name', 'age');

+=> {name : 'moe', age : 50}

+</pre>

+

+ omit<code>_.omit(object, *keys)</code>

+

+ Return a copy of the object, filtered to omit the blacklisted

+ keys (or array of keys).

+

+ <pre>

+_.omit({name : 'moe', age : 50, userid : 'moe1'}, 'userid');

+=> {name : 'moe', age : 50}

+</pre>

+

+ defaults<code>_.defaults(object, *defaults)</code>

+

+ Fill in null and undefined properties in object with values from the

+ defaults objects, and return the object. As soon as the

+ property is filled, further defaults will have no effect.

+

+ <pre>

+var iceCream = {flavor : "chocolate"};

+_.defaults(iceCream, {flavor : "vanilla", sprinkles : "lots"});

+=> {flavor : "chocolate", sprinkles : "lots"}

+</pre>

+

+ clone<code>_.clone(object)</code>

+

+ Create a shallow-copied clone of the object. Any nested objects

+ or arrays will be copied by reference, not duplicated.

+

+ <pre>

+_.clone({name : 'moe'});

+=> {name : 'moe'};

+</pre>

+

+ tap<code>_.tap(object, interceptor)</code>

+

+ Invokes interceptor with the object, and then returns object.

+ The primary purpose of this method is to "tap into" a method chain, in order to perform operations on intermediate results within the chain.

+

+ <pre>

+_.chain([1,2,3,200])

+ .filter(function(num) { return num % 2 == 0; })

+ .tap(alert)

+ .map(function(num) { return num * num })

+ .value();

+=> // [2, 200] (alerted)

+=> [4, 40000]

+</pre>

+

+ has<code>_.has(object, key)</code>

+

+ Does the object contain the given key? Identical to

+ <tt>object.hasOwnProperty(key)</tt>, but uses a safe reference to the

+ <tt>hasOwnProperty</tt> function, in case it's been

+ <a href="http://www.devthought.com/2012/01/18/an-object-is-not-a-hash/">overridden accidentally</a>.

+

+ <pre>

+_.has({a: 1, b: 2, c: 3}, "b");

+=> true

+</pre>

+

+ isEqual<code>_.isEqual(object, other)</code>

+

+ Performs an optimized deep comparison between the two objects, to determine

+ if they should be considered equal.

+

+ <pre>

+var moe = {name : 'moe', luckyNumbers : [13, 27, 34]};

+var clone = {name : 'moe', luckyNumbers : [13, 27, 34]};

+moe == clone;

+=> false

+_.isEqual(moe, clone);

+=> true

+</pre>

+

+ isEmpty<code>_.isEmpty(object)</code>

+

+ Returns true if object contains no values.

+

+ <pre>

+_.isEmpty([1, 2, 3]);

+=> false

+_.isEmpty({});

+=> true

+</pre>

+

+ isElement<code>_.isElement(object)</code>

+

+ Returns true if object is a DOM element.

+

+ <pre>

+_.isElement(jQuery('body')[0]);

+=> true

+</pre>

+

+ isArray<code>_.isArray(object)</code>

+

+ Returns true if object is an Array.

+

+ <pre>

+(function(){ return _.isArray(arguments); })();

+=> false

+_.isArray([1,2,3]);

+=> true

+</pre>

+

+ isObject<code>_.isObject(value)</code>

+

+ Returns true if value is an Object. Note that JavaScript

+ arrays and functions are objects, while (normal) strings and numbers are not.

+

+ <pre>

+_.isObject({});

+=> true

+_.isObject(1);

+=> false

+</pre>

+

+ isArguments<code>_.isArguments(object)</code>

+

+ Returns true if object is an Arguments object.

+

+ <pre>

+(function(){ return _.isArguments(arguments); })(1, 2, 3);

+=> true

+_.isArguments([1,2,3]);

+=> false

+</pre>

+

+ isFunction<code>_.isFunction(object)</code>

+

+ Returns true if object is a Function.

+

+ <pre>

+_.isFunction(alert);

+=> true

+</pre>

+

+ isString<code>_.isString(object)</code>

+

+ Returns true if object is a String.

+

+ <pre>

+_.isString("moe");

+=> true

+</pre>

+

+ isNumber<code>_.isNumber(object)</code>

+

+ Returns true if object is a Number (including <tt>NaN</tt>).

+

+ <pre>

+_.isNumber(8.4 * 5);

+=> true

+</pre>

+

+ isFinite<code>_.isFinite(object)</code>

+

+ Returns true if object is a finite Number.

+

+ <pre>

+_.isFinite(-101);

+=> true

+_.isFinite(-Infinity);

+=> false

+</pre>

+

+ isBoolean<code>_.isBoolean(object)</code>

+

+ Returns true if object is either true or false.

+

+ <pre>

+_.isBoolean(null);

+=> false

+</pre>

+

+ isDate<code>_.isDate(object)</code>

+

+ Returns true if object is a Date.

+

+ <pre>

+_.isDate(new Date());

+=> true

+</pre>

+

+ isRegExp<code>_.isRegExp(object)</code>

+

+ Returns true if object is a RegExp.

+

+ <pre>

+_.isRegExp(/moe/);

+=> true

+</pre>

+

+ isNaN<code>_.isNaN(object)</code>

+

+ Returns true if object is NaN. Note: this is not

+ the same as the native isNaN function, which will also return

+ true if the variable is undefined.

+

+ <pre>

+_.isNaN(NaN);

+=> true

+isNaN(undefined);

+=> true

+_.isNaN(undefined);

+=> false

+</pre>

+

+ isNull<code>_.isNull(object)</code>

+

+ Returns true if the value of object is null.

+

+ <pre>

+_.isNull(null);

+=> true

+_.isNull(undefined);

+=> false

+</pre>

+

+ isUndefined<code>_.isUndefined(value)</code>

+

+ Returns true if value is undefined.

+

+ <pre>

+_.isUndefined(window.missingVariable);

+=> true

+</pre>

+ <h2 id="utility">Utility Functions</h2>

+

+ noConflict<code>_.noConflict()</code>

+

+ Give control of the "_" variable back to its previous owner. Returns

+ a reference to the Underscore object.

+

+ <pre>

+var underscore = _.noConflict();</pre>

+

+ identity<code>_.identity(value)</code>

+

+ Returns the same value that is used as the argument. In math:

+ <tt>f(x) = x</tt>

+ This function looks useless, but is used throughout Underscore as

+ a default iterator.

+

+ <pre>

+var moe = {name : 'moe'};

+moe === _.identity(moe);

+=> true</pre>

+

+ times<code>_.times(n, iterator, [context])</code>

+

+ Invokes the given iterator function n times. Each invocation of

+ iterator is called with an <tt>index</tt> argument.

+

+ Note: this example uses the <a href="#chaining">chaining syntax</a>.

+

+ <pre>

+_(3).times(function(n){ genie.grantWishNumber(n); });</pre>

+

+ random<code>_.random(min, max)</code>

+

+ Returns a random integer between min and max, inclusive.

+ If you only pass one argument, it will return a number between <tt>0</tt>

+ and that number.

+

+ <pre>

+_.random(0, 100);

+=> 42</pre>

+

+ mixin<code>_.mixin(object)</code>

+

+ Allows you to extend Underscore with your own utility functions. Pass

+ a hash of <tt>{name: function}</tt> definitions to have your functions

+ added to the Underscore object, as well as the OOP wrapper.

+

+ <pre>

+_.mixin({

+ capitalize : function(string) {

+ return string.charAt(0).toUpperCase() + string.substring(1).toLowerCase();

+ }

+});

+_("fabio").capitalize();

+=> "Fabio"

+</pre>

+

+ uniqueId<code>_.uniqueId([prefix])</code>

+

+ Generate a globally-unique id for client-side models or DOM elements

+ that need one. If prefix is passed, the id will be appended to it.

+

+ <pre>

+_.uniqueId('contact_');

+=> 'contact_104'</pre>

+

+ escape<code>_.escape(string)</code>

+

+ Escapes a string for insertion into HTML, replacing

+ <tt>&</tt>, <tt><</tt>, <tt>></tt>, <tt>"</tt>, <tt>'</tt>, and <tt>/</tt> characters.

+

+ <pre>

+_.escape('Curly, Larry & Moe');

+=> "Curly, Larry &amp; Moe"</pre>

+

+ unescape<code>_.unescape(string)</code>

+

+ The opposite of <a href="#escape">escape</a>, replaces

+ <tt>&amp;</tt>, <tt>&lt;</tt>, <tt>&gt;</tt>,

+ <tt>&quot;</tt>, <tt>&#x27;</tt>, and <tt>&#x2F;</tt>

+ with their unescaped counterparts.

+

+ <pre>

+_.unescape('Curly, Larry &amp; Moe');

+=> "Curly, Larry & Moe"</pre>

+

+ result<code>_.result(object, property)</code>

+

+ If the value of the named property is a function then invoke it; otherwise, return it.

+

+ <pre>

+var object = {cheese: 'crumpets', stuff: function(){ return 'nonsense'; }};

+_.result(object, 'cheese');

+=> "crumpets"

+_.result(object, 'stuff');

+=> "nonsense"</pre>

+

+ template<code>_.template(templateString, [data], [settings])</code>

+

+ Compiles JavaScript templates into functions that can be evaluated

+ for rendering. Useful for rendering complicated bits of HTML from JSON

+ data sources. Template functions can both interpolate variables, using

+ <tt><%= … %></tt>, as well as execute arbitrary JavaScript code, with

+ <tt><% … %></tt>. If you wish to interpolate a value, and have

+ it be HTML-escaped, use <tt><%- … %></tt> When you evaluate a template function, pass in a

+ data object that has properties corresponding to the template's free

+ variables. If you're writing a one-off, you can pass the data

+ object as the second parameter to template in order to render

+ immediately instead of returning a template function. The settings argument

+ should be a hash containing any <tt>_.templateSettings</tt> that should be overridden.

+

+ <pre>

+var compiled = _.template("hello: <%= name %>");

+compiled({name : 'moe'});

+=> "hello: moe"

+var list = "<% _.each(people, function(name) { %> <li><%= name %></li> <% }); %>";

+_.template(list, {people : ['moe', 'curly', 'larry']});

+=> "<li>moe</li><li>curly</li><li>larry</li>"

+var template = _.template("<%- value %>");

+template({value : '<script>'});

+=> "&lt;script&gt;"</pre>

+

+ You can also use <tt>print</tt> from within JavaScript code. This is

+ sometimes more convenient than using <tt><%= ... %></tt>.

+

+ <pre>

+var compiled = _.template("<% print('Hello ' + epithet); %>");

+compiled({epithet: "stooge"});

+=> "Hello stooge."</pre>

+

+ If ERB-style delimiters aren't your cup of tea, you can change Underscore's

+ template settings to use different symbols to set off interpolated code.

+ Define an interpolate regex to match expressions that should be

+ interpolated verbatim, an escape regex to match expressions that should

+ be inserted after being HTML escaped, and an evaluate regex to match

+ expressions that should be evaluated without insertion into the resulting

+ string. You may define or omit any combination of the three.

+ For example, to perform

+ <a href="http://github.com/janl/mustache.js#readme">Mustache.js</a>

+ style templating:

+

+ <pre>

+_.templateSettings = {

+ interpolate : /\{\{(.+?)\}\}/g

+};

+var template = _.template("Hello {{ name }}!");

+template({name : "Mustache"});

+=> "Hello Mustache!"</pre>

+

+ By default, template places the values from your data in the local scope

+ via the <tt>with</tt> statement. However, you can specify a single variable name

+ with the variable setting. This can significantly improve the speed

+ at which a template is able to render.

+

+ <pre>

+_.template("Using 'with': <%= data.answer %>", {answer: 'no'}, {variable: 'data'});

+=> "Using 'with': no"</pre>

+

+ Precompiling your templates can be a big help when debugging errors you can't

+ reproduce. This is because precompiled templates can provide line numbers and

+ a stack trace, something that is not possible when compiling templates on the client.

+ The source property is available on the compiled template

+ function for easy precompilation.

+

+ <pre><script>

+ JST.project = <%= _.template(jstText).source %>;

+</script></pre>

+ <h2 id="chaining">Chaining</h2>

+

+ You can use Underscore in either an object-oriented or a functional style,

+ depending on your preference. The following two lines of code are

+ identical ways to double a list of numbers.

+

+ <pre>

+_.map([1, 2, 3], function(n){ return n * 2; });

+_([1, 2, 3]).map(function(n){ return n * 2; });</pre>

+

+ Calling <tt>chain</tt> will cause all future method calls to return

+ wrapped objects. When you've finished the computation, use

+ <tt>value</tt> to retrieve the final value. Here's an example of chaining

+ together a map/flatten/reduce, in order to get the word count of

+ every word in a song.

+

+<pre>

+var lyrics = [

+ {line : 1, words : "I'm a lumberjack and I'm okay"},

+ {line : 2, words : "I sleep all night and I work all day"},

+ {line : 3, words : "He's a lumberjack and he's okay"},

+ {line : 4, words : "He sleeps all night and he works all day"}

+];

+_.chain(lyrics)

+ .map(function(line) { return line.words.split(' '); })

+ .flatten()

+ .reduce(function(counts, word) {

+ counts[word] = (counts[word] || 0) + 1;

+ return counts;

+ }, {})

+ .value();

+=> {lumberjack : 2, all : 4, night : 2 ... }</pre>

+

+ In addition, the

+ <a href="https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/prototype">Array prototype's methods</a>

+ are proxied through the chained Underscore object, so you can slip a

+ <tt>reverse</tt> or a <tt>push</tt> into your chain, and continue to

+ modify the array.

+

+

+ chain<code>_.chain(obj)</code>

+

+ Returns a wrapped object. Calling methods on this object will continue

+ to return wrapped objects until <tt>value</tt> is used.

+

+ <pre>

+var stooges = [{name : 'curly', age : 25}, {name : 'moe', age : 21}, {name : 'larry', age : 23}];

+var youngest = _.chain(stooges)

+ .sortBy(function(stooge){ return stooge.age; })

+ .map(function(stooge){ return stooge.name + ' is ' + stooge.age; })

+ .first()

+ .value();

+=> "moe is 21"

+</pre>

+

+ value<code>_(obj).value()</code>

+

+ Extracts the value of a wrapped object.

+

+ <pre>

+_([1, 2, 3]).value();

+=> [1, 2, 3]

+</pre>

+ <h2 id="links">Links & Suggested Reading</h2>

+

+ The Underscore documentation is also available in

+ <a href="http://learning.github.com/underscore/">Simplified Chinese</a>.

+

+

+ <a href="http://mirven.github.com/underscore.lua/">Underscore.lua</a>,

+ a Lua port of the functions that are applicable in both languages.

+ Includes OOP-wrapping and chaining.

+ (<a href="http://github.com/mirven/underscore.lua">source</a>)

+

+

+ <a href="http://underscorem.org">Underscore.m</a>, an Objective-C port

+ of many of the Underscore.js functions, using a syntax that encourages

+ chaining.

+ (<a href="https://github.com/robb/Underscore.m">source</a>)

+

+

+ <a href="http://kmalakoff.github.com/_.m/">_.m</a>, an alternative

+ Objective-C port that tries to stick a little closer to the original

+ Underscore.js API.

+ (<a href="https://github.com/kmalakoff/_.m">source</a>)

+

+

+ <a href="http://brianhaveri.github.com/Underscore.php/">Underscore.php</a>,

+ a PHP port of the functions that are applicable in both languages.

+ Includes OOP-wrapping and chaining.

+ (<a href="http://github.com/brianhaveri/Underscore.php">source</a>)

+

+

+ <a href="http://vti.github.com/underscore-perl/">Underscore-perl</a>,

+ a Perl port of many of the Underscore.js functions,

+ aimed at on Perl hashes and arrays.

+ (<a href="https://github.com/vti/underscore-perl/">source</a>)

+

+

+ <a href="http://russplaysguitar.github.com/UnderscoreCF/">Underscore.cfc</a>,

+ a Coldfusion port of many of the Underscore.js functions.

+ (<a href="https://github.com/russplaysguitar/underscorecf">source</a>)

+

+

+ <a href="https://github.com/edtsech/underscore.string">Underscore.string</a>,

+ an Underscore extension that adds functions for string-manipulation:

+ <tt>trim</tt>, <tt>startsWith</tt>, <tt>contains</tt>, <tt>capitalize</tt>,

+ <tt>reverse</tt>, <tt>sprintf</tt>, and more.

+

+

+ Ruby's <a href="http://ruby-doc.org/core/classes/Enumerable.html">Enumerable</a> module.

+

+

+ <a href="http://www.prototypejs.org/">Prototype.js</a>, which provides

+ JavaScript with collection functions in the manner closest to Ruby's Enumerable.

+

+

+ Oliver Steele's

+ <a href="http://osteele.com/sources/javascript/functional/">Functional JavaScript</a>,

+ which includes comprehensive higher-order function support as well as string lambdas.

+

+

+ Michael Aufreiter's <a href="http://github.com/michael/data">Data.js</a>,

+ a data manipulation + persistence library for JavaScript.

+

+

+ Python's <a href="http://docs.python.org/library/itertools.html">itertools</a>.

+

+ <h2 id="changelog">Change Log</h2>

+

+ 1.4.4 — Jan. 30, 2013 — <a href="https://github.com/documentcloud/underscore/compare/1.4.3...1.4.4">Diff</a>

+ <ul>

+ <li>

+ Added <tt>_.findWhere</tt>, for finding the first element in a list

+ that matches a particular set of keys and values.

+ </li>

+ <li>

+ Added <tt>_.partial</tt>, for partially applying a function without

+ changing its dynamic reference to <tt>this</tt>.

+ </li>

+ <li>

+ Simplified <tt>bind</tt> by removing some edge cases involving

+ constructor functions. In short: don't <tt>_.bind</tt> your

+ constructors.

+ </li>

+ <li>

+ A minor optimization to <tt>invoke</tt>.

+ </li>

+ <li>

+ Fix bug in the minified version due to the minifier incorrectly

+ optimizing-away <tt>isFunction</tt>.

+ </li>

+ </ul>

+

+

+ 1.4.3 — Dec. 4, 2012 — <a href="https://github.com/documentcloud/underscore/compare/1.4.2...1.4.3">Diff</a>

+ <ul>

+ <li>

+ Improved Underscore compatibility with Adobe's JS engine that can be

+ used to script Illustrator, Photoshop, and friends.

+ </li>

+ <li>

+ Added a default <tt>_.identity</tt> iterator to <tt>countBy</tt> and

+ <tt>groupBy</tt>.

+ </li>

+ <li>

+ The <tt>uniq</tt> function can now take <tt>array, iterator, context</tt>

+ as the argument list.

+ </li>

+ <li>

+ The <tt>times</tt> function now returns the mapped array of iterator

+ results.

+ </li>

+ <li>

+ Simplified and fixed bugs in <tt>throttle</tt>.

+ </li>

+ </ul>

+

+

+ 1.4.2 — Oct. 1, 2012 — <a href="https://github.com/documentcloud/underscore/compare/1.4.1...1.4.2">Diff</a>

+ <ul>

+ <li>

+ For backwards compatibility, returned to pre-1.4.0 behavior when

+ passing <tt>null</tt> to iteration functions. They now become no-ops

+ again.

+ </li>

+ </ul>

+

+

+ 1.4.1 — Oct. 1, 2012 — <a href="https://github.com/documentcloud/underscore/compare/1.4.0...1.4.1">Diff</a>

+ <ul>

+ <li>

+ Fixed a 1.4.0 regression in the <tt>lastIndexOf</tt> function.

+ </li>

+ </ul>

+

+

+ 1.4.0 — Sept. 27, 2012 — <a href="https://github.com/documentcloud/underscore/compare/1.3.3...1.4.0">Diff</a>

+ <ul>

+ <li>

+ Added a <tt>pairs</tt> function, for turning a JavaScript object

+ into <tt>[key, value]</tt> pairs ... as well as an <tt>object</tt>

+ function, for converting an array of <tt>[key, value]</tt> pairs

+ into an object.

+ </li>

+ <li>

+ Added a <tt>countBy</tt> function, for counting the number of objects

+ in a list that match a certain criteria.

+ </li>

+ <li>

+ Added an <tt>invert</tt> function, for performing a simple inversion

+ of the keys and values in an object.

+ </li>

+ <li>

+ Added a <tt>where</tt> function, for easy cases of filtering a list

+ for objects with specific values.

+ </li>

+ <li>

+ Added an <tt>omit</tt> function, for filtering an object to remove

+ certain keys.

+ </li>

+ <li>

+ Added a <tt>random</tt> function, to return a random number in a

+ given range.

+ </li>

+ <li>

+ <tt>_.debounce</tt>'d functions now return their last updated value,

+ just like <tt>_.throttle</tt>'d functions do.

+ </li>

+ <li>

+ The <tt>sortBy</tt> function now runs a stable sort algorithm.

+ </li>

+ <li>

+ Added the optional <tt>fromIndex</tt> option to <tt>indexOf</tt> and

+ <tt>lastIndexOf</tt>.

+ </li>

+ <li>

+ "Sparse" arrays are no longer supported in Underscore iteration

+ functions. Use a <tt>for</tt> loop instead (or better yet, an object).

+ </li>

+ <li>

+ The <tt>min</tt> and <tt>max</tt> functions may now be called on

+ very large arrays.

+ </li>

+ <li>

+ Interpolation in templates now represents <tt>null</tt> and

+ <tt>undefined</tt> as the empty string.

+ </li>

+ <li>

+ <del>Underscore iteration functions no longer accept <tt>null</tt> values

+ as a no-op argument. You'll get an early error instead.</del>

+ </li>

+ <li>

+ A number of edge-cases fixes and tweaks, which you can spot in the

+ <a href="https://github.com/documentcloud/underscore/compare/1.3.3...1.4.0">diff</a>.

+ Depending on how you're using Underscore, 1.4.0 may be more

+ backwards-incompatible than usual — please test when you upgrade.

+ </li>

+ </ul>

+

+

+ 1.3.3 — April 10, 2012

+ <ul>

+ <li>

+ Many improvements to <tt>_.template</tt>, which now provides the

+ <tt>source</tt> of the template function as a property, for potentially

+ even more efficient pre-compilation on the server-side. You may now

+ also set the <tt>variable</tt> option when creating a template,

+ which will cause your passed-in data to be made available under the

+ variable you named, instead of using a <tt>with</tt> statement —

+ significantly improving the speed of rendering the template.

+ </li>

+ <li>

+ Added the <tt>pick</tt> function, which allows you to filter an

+ object literal with a whitelist of allowed property names.

+ </li>

+ <li>

+ Added the <tt>result</tt> function, for convenience when working

+ with APIs that allow either functions or raw properties.

+ </li>

+ <li>

+ Added the <tt>isFinite</tt> function, because sometimes knowing that

+ a value is a number just ain't quite enough.

+ </li>

+ <li>

+ The <tt>sortBy</tt> function may now also be passed the string name

+ of a property to use as the sort order on each object.

+ </li>

+ <li>

+ Fixed <tt>uniq</tt> to work with sparse arrays.

+ </li>

+ <li>

+ The <tt>difference</tt> function now performs a shallow flatten

+ instead of a deep one when computing array differences.

+ </li>

+ <li>

+ The <tt>debounce</tt> function now takes an <tt>immediate</tt>

+ parameter, which will cause the callback to fire on the leading

+ instead of the trailing edge.

+ </li>

+ </ul>

+

+

+ 1.3.1 — Jan. 23, 2012

+ <ul>

+ <li>

+ Added an <tt>_.has</tt> function, as a safer way to use <tt>hasOwnProperty</tt>.

+ </li>

+ <li>

+ Added <tt>_.collect</tt> as an alias for <tt>_.map</tt>. Smalltalkers, rejoice.

+ </li>

+ <li>

+ Reverted an old change so that <tt>_.extend</tt> will correctly copy

+ over keys with undefined values again.

+ </li>

+ <li>

+ Bugfix to stop escaping slashes within interpolations in <tt>_.template</tt>.

+ </li>

+ </ul>

+

+

+ 1.3.0 — Jan. 11, 2012

+ <ul>

+ <li>

+ Removed AMD (RequireJS) support from Underscore. If you'd like to use

+ Underscore with RequireJS, you can load it as a normal script, wrap

+ or patch your copy, or download a forked version.

+ </li>

+ </ul>

+

+

+ 1.2.4 — Jan. 4, 2012

+ <ul>

+ <li>

+ You now can (and probably should, as it's simpler)

+ write <tt>_.chain(list)</tt>

+ instead of <tt>_(list).chain()</tt>.

+ </li>

+ <li>

+ Fix for escaped characters in Underscore templates, and for supporting

+ customizations of <tt>_.templateSettings</tt> that only define one or

+ two of the required regexes.

+ </li>

+ <li>

+ Fix for passing an array as the first argument to an <tt>_.wrap</tt>'d function.

+ </li>

+ <li>

+ Improved compatibility with ClojureScript, which adds a <tt>call</tt>

+ function to <tt>String.prototype</tt>.

+ </li>

+ </ul>

+

+

+ 1.2.3 — Dec. 7, 2011

+ <ul>

+ <li>

+ Dynamic scope is now preserved for compiled <tt>_.template</tt> functions,

+ so you can use the value of <tt>this</tt> if you like.

+ </li>

+ <li>

+ Sparse array support of <tt>_.indexOf</tt>, <tt>_.lastIndexOf</tt>.

+ </li>

+ <li>

+ Both <tt>_.reduce</tt> and <tt>_.reduceRight</tt> can now be passed an

+ explicitly <tt>undefined</tt> value. (There's no reason why you'd

+ want to do this.)

+ </li>

+ </ul>

+

+

+ 1.2.2 — Nov. 14, 2011

+ <ul>

+ <li>

+ Continued tweaks to <tt>_.isEqual</tt> semantics. Now JS primitives are

+ considered equivalent to their wrapped versions, and arrays are compared

+ by their numeric properties only (#351).

+ </li>

+ <li>

+ <tt>_.escape</tt> no longer tries to be smart about not double-escaping

+ already-escaped HTML entities. Now it just escapes regardless (#350).

+ </li>

+ <li>

+ In <tt>_.template</tt>, you may now leave semicolons out of evaluated

+ statements if you wish: <tt><% }) %></tt> (#369).

+ </li>

+ <li>

+ <tt>_.after(callback, 0)</tt> will now trigger the callback immediately,

+ making "after" easier to use with asynchronous APIs (#366).

+ </li>

+ </ul>

+

+

+ 1.2.1 — Oct. 24, 2011

+ <ul>

+ <li>

+ Several important bug fixes for <tt>_.isEqual</tt>, which should now

+ do better on mutated Arrays, and on non-Array objects with

+ <tt>length</tt> properties. (#329)

+ </li>

+ <li>

+ jrburke contributed Underscore exporting for AMD module loaders,

+ and tonylukasavage for Appcelerator Titanium.

+ (#335, #338)

+ </li>

+ <li>

+ You can now <tt>_.groupBy(list, 'property')</tt> as a shortcut for

+ grouping values by a particular common property.

+ </li>

+ <li>

+ <tt>_.throttle</tt>'d functions now fire immediately upon invocation,

+ and are rate-limited thereafter (#170, #266).

+ </li>

+ <li>

+ Most of the <tt>_.is[Type]</tt> checks no longer ducktype.

+ </li>

+ <li>

+ The <tt>_.bind</tt> function now also works on constructors, a-la

+ ES5 ... but you would never want to use <tt>_.bind</tt> on a

+ constructor function.

+ </li>

+ <li>

+ <tt>_.clone</tt> no longer wraps non-object types in Objects.

+ </li>

+ <li>

+ <tt>_.find</tt> and <tt>_.filter</tt> are now the preferred names for

+ <tt>_.detect</tt> and <tt>_.select</tt>.

+ </li>

+ </ul>

+

+

+ 1.2.0 — Oct. 5, 2011

+ <ul>

+ <li>

+ The <tt>_.isEqual</tt> function now

+ supports true deep equality comparisons, with checks for cyclic structures,

+ thanks to Kit Cambridge.

+ </li>

+ <li>

+ Underscore templates now support HTML escaping interpolations, using

+ <tt><%- ... %></tt> syntax.

+ </li>

+ <li>

+ Ryan Tenney contributed <tt>_.shuffle</tt>, which uses a modified

+ Fisher-Yates to give you a shuffled copy of an array.

+ </li>

+ <li>

+ <tt>_.uniq</tt> can now be passed an optional iterator, to determine by

+ what criteria an object should be considered unique.

+ </li>

+ <li>

+ <tt>_.last</tt> now takes an optional argument which will return the last

+ N elements of the list.

+ </li>

+ <li>

+ A new <tt>_.initial</tt> function was added, as a mirror of <tt>_.rest</tt>,

+ which returns all the initial values of a list (except the last N).

+ </li>

+ </ul>

+

+

+ 1.1.7 — July 13, 2011

+ Added <tt>_.groupBy</tt>, which aggregates a collection into groups of like items.

+ Added <tt>_.union</tt> and <tt>_.difference</tt>, to complement the

+ (re-named) <tt>_.intersection</tt>.

+ Various improvements for support of sparse arrays.

+ <tt>_.toArray</tt> now returns a clone, if directly passed an array.

+ <tt>_.functions</tt> now also returns the names of functions that are present

+ in the prototype chain.

+

+

+ 1.1.6 — April 18, 2011

+ Added <tt>_.after</tt>, which will return a function that only runs after

+ first being called a specified number of times.

+ <tt>_.invoke</tt> can now take a direct function reference.

+ <tt>_.every</tt> now requires an iterator function to be passed, which

+ mirrors the ECMA5 API.

+ <tt>_.extend</tt> no longer copies keys when the value is undefined.

+ <tt>_.bind</tt> now errors when trying to bind an undefined value.

+

+

+ 1.1.5 — Mar 20, 2011

+ Added an <tt>_.defaults</tt> function, for use merging together JS objects

+ representing default options.

+ Added an <tt>_.once</tt> function, for manufacturing functions that should

+ only ever execute a single time.

+ <tt>_.bind</tt> now delegates to the native ECMAScript 5 version,

+ where available.

+ <tt>_.keys</tt> now throws an error when used on non-Object values, as in

+ ECMAScript 5.

+ Fixed a bug with <tt>_.keys</tt> when used over sparse arrays.

+

+

+ 1.1.4 — Jan 9, 2011

+ Improved compliance with ES5's Array methods when passing <tt>null</tt>

+ as a value. <tt>_.wrap</tt> now correctly sets <tt>this</tt> for the

+ wrapped function. <tt>_.indexOf</tt> now takes an optional flag for

+ finding the insertion index in an array that is guaranteed to already

+ be sorted. Avoiding the use of <tt>.callee</tt>, to allow <tt>_.isArray</tt>

+ to work properly in ES5's strict mode.

+

+

+ 1.1.3 — Dec 1, 2010

+ In CommonJS, Underscore may now be required with just:

+ <tt>var _ = require("underscore")</tt>.

+ Added <tt>_.throttle</tt> and <tt>_.debounce</tt> functions.

+ Removed <tt>_.breakLoop</tt>, in favor of an ECMA5-style un-break-able

+ each implementation — this removes the try/catch, and you'll now have

+ better stack traces for exceptions that are thrown within an Underscore iterator.

+ Improved the isType family of functions for better interoperability

+ with Internet Explorer host objects.

+ <tt>_.template</tt> now correctly escapes backslashes in templates.

+ Improved <tt>_.reduce</tt> compatibility with the ECMA5 version:

+ if you don't pass an initial value, the first item in the collection is used.

+ <tt>_.each</tt> no longer returns the iterated collection, for improved

+ consistency with ES5's <tt>forEach</tt>.

+

+

+ 1.1.2

+ Fixed <tt>_.contains</tt>, which was mistakenly pointing at

+ <tt>_.intersect</tt> instead of <tt>_.include</tt>, like it should

+ have been. Added <tt>_.unique</tt> as an alias for <tt>_.uniq</tt>.

+

+

+ 1.1.1

+ Improved the speed of <tt>_.template</tt>, and its handling of multiline

+ interpolations. Ryan Tenney contributed optimizations to many Underscore

+ functions. An annotated version of the source code is now available.

+

+

+ 1.1.0

+ The method signature of <tt>_.reduce</tt> has been changed to match

+ the ECMAScript 5 signature, instead of the Ruby/Prototype.js version.

+ This is a backwards-incompatible change. <tt>_.template</tt> may now be

+ called with no arguments, and preserves whitespace. <tt>_.contains</tt>

+ is a new alias for <tt>_.include</tt>.

+

+

+ 1.0.4

+ <a href="http://themoell.com/">Andri Möll</a> contributed the <tt>_.memoize</tt>

+ function, which can be used to speed up expensive repeated computations

+ by caching the results.

+

+

+ 1.0.3

+ Patch that makes <tt>_.isEqual</tt> return <tt>false</tt> if any property

+ of the compared object has a <tt>NaN</tt> value. Technically the correct

+ thing to do, but of questionable semantics. Watch out for NaN comparisons.

+

+

+ 1.0.2

+ Fixes <tt>_.isArguments</tt> in recent versions of Opera, which have

+ arguments objects as real Arrays.

+

+

+ 1.0.1

+ Bugfix for <tt>_.isEqual</tt>, when comparing two objects with the same

+ number of undefined keys, but with different names.

+

+

+ 1.0.0

+ Things have been stable for many months now, so Underscore is now

+ considered to be out of beta, at 1.0. Improvements since 0.6

+ include <tt>_.isBoolean</tt>, and the ability to have <tt>_.extend</tt>

+ take multiple source objects.

+

+

+ 0.6.0

+ Major release. Incorporates a number of

+ <a href="http://github.com/ratbeard">Mile Frawley's</a> refactors for

+ safer duck-typing on collection functions, and cleaner internals. A new

+ <tt>_.mixin</tt> method that allows you to extend Underscore with utility

+ functions of your own. Added <tt>_.times</tt>, which works the same as in

+ Ruby or Prototype.js. Native support for ECMAScript 5's <tt>Array.isArray</tt>,

+ and <tt>Object.keys</tt>.

+

+

+ 0.5.8

+ Fixed Underscore's collection functions to work on

+ <a href="https://developer.mozilla.org/En/DOM/NodeList">NodeLists</a> and

+ <a href="https://developer.mozilla.org/En/DOM/HTMLCollection">HTMLCollections</a>

+ once more, thanks to

+ <a href="http://github.com/jmtulloss">Justin Tulloss</a>.

+

+

+ 0.5.7

+ A safer implementation of <tt>_.isArguments</tt>, and a

+ faster <tt>_.isNumber</tt>, thanks to

+ <a href="http://jedschmidt.com/">Jed Schmidt</a>.

+

+

+ 0.5.6

+ Customizable delimiters for <tt>_.template</tt>, contributed by

+ <a href="http://github.com/iamnoah">Noah Sloan</a>.

+

+

+ 0.5.5

+ Fix for a bug in MobileSafari's OOP-wrapper, with the arguments object.

+

+

+ 0.5.4

+ Fix for multiple single quotes within a template string for

+ <tt>_.template</tt>. See:

+ <a href="http://www.west-wind.com/Weblog/posts/509108.aspx">Rick Strahl's blog post</a>.

+

+

+ 0.5.2

+ New implementations of <tt>isArray</tt>, <tt>isDate</tt>, <tt>isFunction</tt>,

+ <tt>isNumber</tt>, <tt>isRegExp</tt>, and <tt>isString</tt>, thanks to

+ a suggestion from

+ <a href="http://www.broofa.com/">Robert Kieffer</a>.

+ Instead of doing <tt>Object#toString</tt>

+ comparisons, they now check for expected properties, which is less safe,

+ but more than an order of magnitude faster. Most other Underscore

+ functions saw minor speed improvements as a result.

+ <a href="http://dolzhenko.org/">Evgeniy Dolzhenko</a>

+ contributed <tt>_.tap</tt>,

+ <a href="http://ruby-doc.org/core-1.9/classes/Object.html#M000191">similar to Ruby 1.9's</a>,

+ which is handy for injecting side effects (like logging) into chained calls.

+

+

+ 0.5.1

+ Added an <tt>_.isArguments</tt> function. Lots of little safety checks

+ and optimizations contributed by

+ <a href="http://github.com/iamnoah/">Noah Sloan</a> and

+ <a href="http://themoell.com/">Andri Möll</a>.

+

+

+ 0.5.0

+ [API Changes] <tt>_.bindAll</tt> now takes the context object as

+ its first parameter. If no method names are passed, all of the context

+ object's methods are bound to it, enabling chaining and easier binding.

+ <tt>_.functions</tt> now takes a single argument and returns the names

+ of its Function properties. Calling <tt>_.functions(_)</tt> will get you

+ the previous behavior.

+ Added <tt>_.isRegExp</tt> so that <tt>isEqual</tt> can now test for RegExp equality.

+ All of the "is" functions have been shrunk down into a single definition.

+ <a href="http://github.com/grayrest/">Karl Guertin</a> contributed patches.

+

+

+ 0.4.7

+ Added <tt>isDate</tt>, <tt>isNaN</tt>, and <tt>isNull</tt>, for completeness.

+ Optimizations for <tt>isEqual</tt> when checking equality between Arrays

+ or Dates. <tt>_.keys</tt> is now 25%–2X faster (depending on your

+ browser) which speeds up the functions that rely on it, such as <tt>_.each</tt>.

+

+

+ 0.4.6

+ Added the <tt>range</tt> function, a port of the

+ <a href="http://docs.python.org/library/functions.html#range">Python

+ function of the same name</a>, for generating flexibly-numbered lists

+ of integers. Original patch contributed by

+ <a href="http://github.com/kylichuku">Kirill Ishanov</a>.

+

+

+ 0.4.5

+ Added <tt>rest</tt> for Arrays and arguments objects, and aliased

+ <tt>first</tt> as <tt>head</tt>, and <tt>rest</tt> as <tt>tail</tt>,

+ thanks to <a href="http://github.com/lukesutton/">Luke Sutton</a>'s patches.

+ Added tests ensuring that all Underscore Array functions also work on

+ arguments objects.

+

+

+ 0.4.4

+ Added <tt>isString</tt>, and <tt>isNumber</tt>, for consistency. Fixed

+ <tt>_.isEqual(NaN, NaN)</tt> to return true (which is debatable).

+

+

+ 0.4.3

+ Started using the native <tt>StopIteration</tt> object in browsers that support it.

+ Fixed Underscore setup for CommonJS environments.

+

+

+ 0.4.2

+ Renamed the unwrapping function to <tt>value</tt>, for clarity.

+

+

+ 0.4.1

+ Chained Underscore objects now support the Array prototype methods, so

+ that you can perform the full range of operations on a wrapped array

+ without having to break your chain. Added a <tt>breakLoop</tt> method

+ to break in the middle of any Underscore iteration. Added an

+ <tt>isEmpty</tt> function that works on arrays and objects.

+

+

+ 0.4.0

+ All Underscore functions can now be called in an object-oriented style,

+ like so: <tt>_([1, 2, 3]).map(...);</tt>. Original patch provided by

+ <a href="http://macournoyer.com/">Marc-André Cournoyer</a>.

+ Wrapped objects can be chained through multiple

+ method invocations. A <a href="#object-functions"><tt>functions</tt></a> method

+ was added, providing a sorted list of all the functions in Underscore.

+

+

+ 0.3.3

+ Added the JavaScript 1.8 function <tt>reduceRight</tt>. Aliased it

+ as <tt>foldr</tt>, and aliased <tt>reduce</tt> as <tt>foldl</tt>.

+

+

+ 0.3.2

+ Now runs on stock <a href="http://www.mozilla.org/rhino/">Rhino</a>

+ interpreters with: <tt>load("underscore.js")</tt>.

+ Added <a href="#identity"><tt>identity</tt></a> as a utility function.

+

+

+ 0.3.1

+ All iterators are now passed in the original collection as their third

+ argument, the same as JavaScript 1.6's forEach. Iterating over

+ objects is now called with <tt>(value, key, collection)</tt>, for details

+ see <a href="#each"><tt>_.each</tt></a>.

+

+

+ 0.3.0

+ Added <a href="http://github.com/dmitryBaranovskiy">Dmitry Baranovskiy</a>'s

+ comprehensive optimizations, merged in

+ <a href="http://github.com/kriskowal/">Kris Kowal</a>'s patches to make Underscore

+ <a href="http://wiki.commonjs.org/wiki/CommonJS">CommonJS</a> and

+ <a href="http://narwhaljs.org/">Narwhal</a> compliant.

+

+

+ 0.2.0

+ Added <tt>compose</tt> and <tt>lastIndexOf</tt>, renamed <tt>inject</tt> to

+ <tt>reduce</tt>, added aliases for <tt>inject</tt>, <tt>filter</tt>,

+ <tt>every</tt>, <tt>some</tt>, and <tt>forEach</tt>.

+

+

+ 0.1.1

+ Added <tt>noConflict</tt>, so that the "Underscore" object can be assigned to

+ other variables.

+

+

+ 0.1.0

+ Initial release of Underscore.js.

+

+

+ <a href="http://documentcloud.org/" title="A DocumentCloud Project" style="background:none;">

+ <img src="http://jashkenas.s3.amazonaws.com/images/a_documentcloud_project.png" alt="A DocumentCloud Project" />

+ </a>

+

+ </div>

+

+ <script type="text/javascript" src="underscore.js"></script>

+</body>

+</html>