// Underscore.js // (c) 2009 Jeremy Ashkenas, DocumentCloud Inc. // Underscore is freely distributable under the terms of the MIT license. // Portions of Underscore are inspired by or borrowed from Prototype.js, // Oliver Steele's Functional, and John Resig's Micro-Templating. // For all details and documentation: // http://documentcloud.github.com/underscore/ (function() { /*------------------------- Baseline setup ---------------------------------*/ // Establish the root object, "window" in the browser, or "global" on the server. var root = this; // Save the previous value of the "_" variable. var previousUnderscore = root._; // 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. var wrapper = function(obj) { this._wrapped = obj; }; // Establish the object that gets thrown to break out of a loop iteration. var breaker = typeof StopIteration !== 'undefined' ? StopIteration : '__break__'; // Create a safe reference to the Underscore object for reference below. var _ = root._ = function(obj) { return new wrapper(obj); }; // Export the Underscore object for CommonJS. if (typeof exports !== 'undefined') exports._ = _; // Current version. _.VERSION = '0.4.5'; /*------------------------ Collection Functions: ---------------------------*/ // The cornerstone, an each implementation. // Handles objects implementing forEach, arrays, and raw objects. _.each = function(obj, iterator, context) { var index = 0; try { if (obj.forEach) { obj.forEach(iterator, context); } else if (obj.length) { for (var i=0, l = obj.length; i= result.computed && (result = {value : value, computed : computed}); }); return result.value; }; // Return the minimum element (or element-based computation). _.min = function(obj, iterator, context) { if (!iterator && _.isArray(obj)) return Math.min.apply(Math, obj); var result = {computed : Infinity}; _.each(obj, function(value, index, list) { var computed = iterator ? iterator.call(context, value, index, list) : value; computed < result.computed && (result = {value : value, computed : computed}); }); return result.value; }; // Sort the object's values by a criteria produced by an iterator. _.sortBy = function(obj, iterator, context) { return _.pluck(_.map(obj, function(value, index, list) { return { value : value, criteria : iterator.call(context, value, index, list) }; }).sort(function(left, right) { var a = left.criteria, b = right.criteria; return a < b ? -1 : a > b ? 1 : 0; }), 'value'); }; // Use a comparator function to figure out at what index an object should // be inserted so as to maintain order. Uses binary search. _.sortedIndex = function(array, obj, iterator) { iterator = iterator || _.identity; var low = 0, high = array.length; while (low < high) { var mid = (low + high) >> 1; iterator(array[mid]) < iterator(obj) ? low = mid + 1 : high = mid; } return low; }; // Convert anything iterable into a real, live array. _.toArray = function(iterable) { if (!iterable) return []; if (_.isArray(iterable)) return iterable; return _.map(iterable, function(val){ return val; }); }; // Return the number of elements in an object. _.size = function(obj) { return _.toArray(obj).length; }; /*-------------------------- Array Functions: ------------------------------*/ // Get the first element of an array. Passing "n" will return the first N // values in the array. Aliased as "head". _.first = function(array, n) { return n ? Array.prototype.slice.call(array, 0, n) : array[0]; }; // Returns everything but the first entry of the array. Aliased as "tail". // Especially useful on the arguments object. Passing an "index" will return // the rest of the values in the array from that index onward. _.rest = function(array, index) { return Array.prototype.slice.call(array, _.isUndefined(index) ? 1 : index); }; // Get the last element of an array. _.last = function(array) { return array[array.length - 1]; }; // Trim out all falsy values from an array. _.compact = function(array) { return _.select(array, function(value){ return !!value; }); }; // Return a completely flattened version of an array. _.flatten = function(array) { return _.reduce(array, [], function(memo, value) { if (_.isArray(value)) return memo.concat(_.flatten(value)); memo.push(value); return memo; }); }; // Return a version of the array that does not contain the specified value(s). _.without = function(array) { var values = _.rest(arguments); return _.select(array, function(value){ return !_.include(values, value); }); }; // Produce a duplicate-free version of the array. If the array has already // been sorted, you have the option of using a faster algorithm. _.uniq = function(array, isSorted) { return _.reduce(array, [], function(memo, el, i) { if (0 == i || (isSorted ? _.last(memo) != el : !_.include(memo, el))) memo.push(el); return memo; }); }; // Produce an array that contains every item shared between all the // passed-in arrays. _.intersect = function(array) { var rest = _.rest(arguments); return _.select(_.uniq(array), function(item) { return _.all(rest, function(other) { return _.indexOf(other, item) >= 0; }); }); }; // Zip together multiple lists into a single array -- elements that share // an index go together. _.zip = function() { var args = _.toArray(arguments); var length = _.max(_.pluck(args, 'length')); var results = new Array(length); for (var i=0; i= 0; i--) { arguments = [funcs[i].apply(this, arguments)]; } return arguments[0]; }; }; /* ------------------------- Object Functions: ---------------------------- */ // Retrieve the names of an object's properties. _.keys = function(obj) { return _.map(obj, function(value, key){ return key; }); }; // Retrieve the values of an object's properties. _.values = function(obj) { return _.map(obj, _.identity); }; // Extend a given object with all of the properties in a source object. _.extend = function(destination, source) { for (var property in source) destination[property] = source[property]; return destination; }; // Create a (shallow-cloned) duplicate of an object. _.clone = function(obj) { if (_.isArray(obj)) return obj.slice(0); return _.extend({}, obj); }; // Perform a deep comparison to check if two objects are equal. _.isEqual = function(a, b) { // Check object identity. if (a === b) return true; // Different types? var atype = typeof(a), btype = typeof(b); if (atype != btype) return false; // Basic equality test (watch out for coercions). if (a == b) return true; // One of them implements an isEqual()? if (a.isEqual) return a.isEqual(b); // Both are NaN? if (_.isNumber(a) && _.isNumber(b) && isNaN(a) && isNaN(b)) return true; // If a is not an object by this point, we can't handle it. if (atype !== 'object') return false; // Nothing else worked, deep compare the contents. var aKeys = _.keys(a), bKeys = _.keys(b); // Different object sizes? if (aKeys.length != bKeys.length) return false; // Recursive comparison of contents. for (var key in a) if (!_.isEqual(a[key], b[key])) return false; return true; }; // Is a given array or object empty? _.isEmpty = function(obj) { return (_.isArray(obj) ? obj : _.values(obj)).length == 0; }; // Is a given value a DOM element? _.isElement = function(obj) { return !!(obj && obj.nodeType == 1); }; // Is a given value a real Array? _.isArray = function(obj) { return Object.prototype.toString.call(obj) == '[object Array]'; }; // Is a given value a Function? _.isFunction = function(obj) { return Object.prototype.toString.call(obj) == '[object Function]'; }; // Is a given value a String? _.isString = function(obj) { return Object.prototype.toString.call(obj) == '[object String]'; }; // Is a given value a Number? _.isNumber = function(obj) { return Object.prototype.toString.call(obj) == '[object Number]'; }; // Is a given variable undefined? _.isUndefined = function(obj) { return typeof obj == 'undefined'; }; /* -------------------------- Utility Functions: -------------------------- */ // Run Underscore.js in noConflict mode, returning the '_' variable to its // previous owner. Returns a reference to the Underscore object. _.noConflict = function() { root._ = previousUnderscore; return this; }; // Keep the identity function around for default iterators. _.identity = function(value) { return value; }; // Break out of the middle of an iteration. _.breakLoop = function() { throw breaker; }; // Generate a unique integer id (unique within the entire client session). // Useful for temporary DOM ids. var idCounter = 0; _.uniqueId = function(prefix) { var id = idCounter++; return prefix ? prefix + id : id; }; // Return a sorted list of the function names available in Underscore. _.functions = function() { var functions = []; for (var key in _) if (Object.prototype.hasOwnProperty.call(_, key)) functions.push(key); return _.without(functions, 'VERSION', 'prototype', 'noConflict').sort(); }; // JavaScript templating a-la ERB, pilfered from John Resig's // "Secrets of the JavaScript Ninja", page 83. _.template = function(str, data) { var fn = new Function('obj', 'var p=[],print=function(){p.push.apply(p,arguments);};' + 'with(obj){p.push(\'' + str .replace(/[\r\t\n]/g, " ") .split("<%").join("\t") .replace(/((^|%>)[^\t]*)'/g, "$1\r") .replace(/\t=(.*?)%>/g, "',$1,'") .split("\t").join("');") .split("%>").join("p.push('") .split("\r").join("\\'") + "');}return p.join('');"); return data ? fn(data) : fn; }; /*------------------------------- Aliases ----------------------------------*/ _.forEach = _.each; _.foldl = _.inject = _.reduce; _.foldr = _.reduceRight; _.filter = _.select; _.every = _.all; _.some = _.any; _.head = _.first; _.tail = _.rest; _.methods = _.functions; /*------------------------ Setup the OOP Wrapper: --------------------------*/ // Helper function to continue chaining intermediate results. var result = function(obj, chain) { return chain ? _(obj).chain() : obj; }; // Add all of the Underscore functions to the wrapper object. _.each(_.functions(), function(name) { wrapper.prototype[name] = function() { Array.prototype.unshift.call(arguments, this._wrapped); return result(_[name].apply(_, arguments), this._chain); }; }); // Add all mutator Array functions to the wrapper. _.each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(name) { wrapper.prototype[name] = function() { Array.prototype[name].apply(this._wrapped, arguments); return result(this._wrapped, this._chain); }; }); // Add all accessor Array functions to the wrapper. _.each(['concat', 'join', 'slice'], function(name) { wrapper.prototype[name] = function() { return result(Array.prototype[name].apply(this._wrapped, arguments), this._chain); }; }); // Start chaining a wrapped Underscore object. wrapper.prototype.chain = function() { this._chain = true; return this; }; // Extracts the result from a wrapped and chained object. wrapper.prototype.value = function() { return this._wrapped; }; })();