+ Functions
+
+ bind, bindAll, delay,
+ defer, wrap
+
Objects
@@ -113,13 +120,6 @@
- Functions
-
- bind, bindAll, delay,
- defer, wrap
-
Utility
@@ -127,7 +127,8 @@
each_.each(list, iterator, [context])
@@ -135,8 +136,9 @@
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. If list is a Javascript object, a pair with key
- and value properties will be yielded. Delegates to the native
- forEach method if it exists.
+ and value properties will be yielded. If the list has an each
+ method of its own defined, it will be used. Delegates to the native
+ forEach function if it exists.
_.each([1, 2, 3], function(num){ alert(num); });
@@ -216,7 +218,7 @@ _.all([true, 1, null, 'yes']);
- any_.any(list, iterator, [context])
+ any_.any(list, [iterator], [context])
Returns true if any of the values in the list pass the
iterator truth test. Short-circuits and stops traversing the list
@@ -241,7 +243,7 @@ _.include([1, 2, 3], 3);
- invoke_.invoke(list, methodName)
+ invoke_.invoke(list, methodName, [*arguments])
Calls the method named by methodName on each value in the list.
Any extra arguments passed to invoke will be forwarded on to the
@@ -314,21 +316,318 @@ _.sortedIndex([10, 20, 30, 40, 50], 35);
=> 3
-
- toArray_.(list, iterator, [context])
+
+ toArray_.toArray(list)
+ Converts the list (anything that can be iterated over), into a
+ real Array. Useful for transmuting the arguments object.
+
+(function(){ return _.toArray(arguments).slice(0); })(1, 2, 3);
+=> [1, 2, 3]
+
+
+ size_.size(list)
+
+ Return the number of values in the list.
+
+_.size({one : 1, two : 2, three : 3});
+=> 3
+
+
+
+ first_.first(array)
+
+ Convenience to return the first element of an array (identical to array[0]).
+
+_.first([3, 2, 1]); +=> 3 ++ +
+ last_.last(array)
+
+ Returns the last element of an array.
+
+_.last([3, 2, 1]); +=> 1 ++ +
+ compact_.compact(array)
+
+ Returns a copy of the array with all falsy values removed.
+ In Javascript, false, null, 0, "",
+ undefined and NaN are all falsy.
+
+_.compact([0, 1, false, 2, '', 3]); +=> [1, 2, 3] ++ +
+ flatten_.flatten(array)
+
+ Flattens a nested array (the nesting can be to any depth).
+
+_.flatten([1, [2], [3, [[[4]]]]]); +=> [1, 2, 3, 4]; ++ +
+ without_.without(array, [*values])
+
+ Returns a copy of the array with all instances of the values
+ removed. == is used for the equality test.
+
+_.without([1, 2, 1, 0, 3, 1, 4], 0, 1); +=> [2, 3, 4] ++ +
+ uniq_.uniq(array, [isSorted])
+
+ 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.
+
+_.uniq([1, 2, 1, 3, 1, 4]); +=> [1, 2, 3, 4] ++ +
+ intersect_.intersect(*arrays)
+
+ 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.
+
+_.intersect([1, 2, 3], [101, 2, 1, 10], [2, 1]); +=> [1, 2] ++ +
+ zip_.zip(*arrays)
+
+ 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.
+
+_.zip(['moe', 'larry', 'curly'], [30, 40, 50], [true, false, false]); +=> [["moe", 30, true], ["larry", 40, false], ["curly", 50, false]] ++ +
+ indexOf_.indexOf(array, value)
+
+ 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.
+
+_.indexOf([1, 2, 3], 2); +=> 1 ++ +
+ bind_.bind(function, context, [*arguments])
+
+ Bind a function to a context object, meaning that whenever
+ the function is called, the value of this will be the context.
+ Optionally, bind arguments to the function to pre-fill them,
+ also known as currying.
+
+var func = function(greeting){ return greeting + ': ' + this.name };
+func = _.bind(func, {name : 'moe'}, 'hi');
+func();
+=> 'hi: moe'
+
+
+
+ bindAll_.bindAll(*methodNames, context)
+
+ Binds a number of methods on the context 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.
+
+var buttonView = {
+ label : 'underscore',
+ onClick : function(){ alert('clicked: ' + this.label); },
+ onHover : function(){ console.log('hovering: ' + this.label); }
+};
+_.bindAll('onClick', 'onHover', buttonView);
+jQuery('#underscore_button').bind('click', buttonView.onClick);
+=> When the button is clicked, this.label will have the correct value...
+
+
+
+ delay_.delay(function, wait, [*arguments])
+
+ 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.
+
+var log = _.bind(console.log, console); +_.delay(log, 1000, 'logged later'); +=> 'logged later' // Appears after one second. ++ +
+ defer_.defer(function)
+
+ 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.
+
+_.defer(function(){ alert('deferred'); });
+// Returns from the function before the alert runs.
+
+
+
+ wrap_.wrap(function, wrapper)
+
+ 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.
+
+var hello = function(name) { return "hello: " + name; };
+hello = _.wrap(hello, function(func) {
+ return "before, " + func("moe") + ", after";
+});
+hello();
+=> before, hello: moe, after
+
+
+
+ keys_.keys(object)
+
+ Retrieve all the names of the object's properties.
+
+_.keys({one : 1, two : 2, three : 3});
+=> ["one", "two", "three"]
+
+
+
+ values_.values(object)
+
+ Return all of the values of the object's properties.
+
+_.values({one : 1, two : 2, three : 3});
+=> [1, 2, 3]
+
+
+
+ extend_.extend(destination, source)
+
+ Copy all of the properties in the source object over to the
+ destination object.
+
+_.extend({name : 'moe'}, {age : 50});
+=> {name : 'moe', age : 50}
+
+
+
+ clone_.clone(object)
+
+ Create a shallow-copied clone of the object. Any nested objects
+ or arrays will be copied by reference, not duplicated.
+
+_.clone({name : 'moe'});
+=> {name : 'moe'};
+
+
+
+ isEqual_.isEqual(object, other)
+
+ Performs an optimized deep comparison between the two objects, to determine
+ if they should be considered equal.
+
+var moe = {name : 'moe', luckyNumbers : [13, 27, 34]};
+var clone = {name : 'moe', luckyNumbers : [13, 27, 34]};
+moe == clone;
+=> false
+_.isEqual(moe, clone);
+=> true
+
+
+
+ isElement_.()
+
- size_.(list, iterator, [context])
+ isArray_.()
-
+ +
+ isFunction_.()
+
+
++ +
+ isUndefined_.()
+
+
++ +
+ toString_.()
+
+
++ +
+ uniqueId_.()
+
+
++ +
+ template_.()
+
+
+