# Lo-Dash v0.1.0 ## `_` * [`_`](#_) * [`_.VERSION`](#_.VERSION) * [`_.after`](#_.after) * [`_.bind`](#_.bind) * [`_.bindAll`](#_.bindAll) * [`_.chain`](#_.chain) * [`_.chain`](#_.chain) * [`_.clone`](#_.clone) * [`_.compact`](#_.compact) * [`_.compose`](#_.compose) * [`_.contains`](#_.contains) * [`_.debounce`](#_.debounce) * [`_.defaults`](#_.defaults) * [`_.defer`](#_.defer) * [`_.delay`](#_.delay) * [`_.difference`](#_.difference) * [`_.escape`](#_.escape) * [`_.every`](#_.every) * [`_.extend`](#_.extend) * [`_.filter`](#_.filter) * [`_.find`](#_.find) * [`_.first`](#_.first) * [`_.flatten`](#_.flatten) * [`_.forEach`](#_.forEach) * [`_.functions`](#_.functions) * [`_.groupBy`](#_.groupBy) * [`_.has`](#_.has) * [`_.identity`](#_.identity) * [`_.indexOf`](#_.indexOf) * [`_.initial`](#_.initial) * [`_.intersection`](#_.intersection) * [`_.invoke`](#_.invoke) * [`_.isArguments`](#_.isArguments) * [`_.isArray`](#_.isArray) * [`_.isBoolean`](#_.isBoolean) * [`_.isDate`](#_.isDate) * [`_.isElement`](#_.isElement) * [`_.isEmpty`](#_.isEmpty) * [`_.isEqual`](#_.isEqual) * [`_.isFinite`](#_.isFinite) * [`_.isFunction`](#_.isFunction) * [`_.isNaN`](#_.isNaN) * [`_.isNull`](#_.isNull) * [`_.isNumber`](#_.isNumber) * [`_.isObject`](#_.isObject) * [`_.isRegExp`](#_.isRegExp) * [`_.isString`](#_.isString) * [`_.isUndefined`](#_.isUndefined) * [`_.keys`](#_.keys) * [`_.last`](#_.last) * [`_.lastIndexOf`](#_.lastIndexOf) * [`_.map`](#_.map) * [`_.max`](#_.max) * [`_.memoize`](#_.memoize) * [`_.min`](#_.min) * [`_.mixin`](#_.mixin) * [`_.noConflict`](#_.noConflict) * [`_.once`](#_.once) * [`_.pick`](#_.pick) * [`_.pluck`](#_.pluck) * [`_.range`](#_.range) * [`_.reduce`](#_.reduce) * [`_.reduceRight`](#_.reduceRight) * [`_.reject`](#_.reject) * [`_.rest`](#_.rest) * [`_.result`](#_.result) * [`_.shuffle`](#_.shuffle) * [`_.size`](#_.size) * [`_.some`](#_.some) * [`_.sortBy`](#_.sortBy) * [`_.sortedIndex`](#_.sortedIndex) * [`_.tap`](#_.tap) * [`_.template`](#_.template) * [`_.throttle`](#_.throttle) * [`_.times`](#_.times) * [`_.toArray`](#_.toArray) * [`_.union`](#_.union) * [`_.uniq`](#_.uniq) * [`_.uniqueId`](#_.uniqueId) * [`_.value`](#_.value) * [`_.values`](#_.values) * [`_.without`](#_.without) * [`_.wrap`](#_.wrap) * [`_.zip`](#_.zip) ## `_.templateSettings` * [`_.templateSettings`](#_.templateSettings) * [`_.templateSettings.escape`](#_.templateSettings.escape) * [`_.templateSettings.evaluate`](#_.templateSettings.evaluate) * [`_.templateSettings.interpolate`](#_.templateSettings.interpolate) ## `_` ### `_(value)` The `lodash` function. [▲][1] #### Arguments 1. `value` *(Mixed)*: The value to wrap in a `Lodash` instance. #### Returns *(Object)*: Returns a `Lodash` instance. ## `_` ### `_(value)` The `lodash` function. [▲][1] ### `_.VERSION` *(String)*: The semantic version number. [▲][1] ### `_.after(times, func)` Creates a new function that is restricted to executing only after it is called a given number of `times`. [▲][1] #### Arguments 1. `times` *(Number)*: The number of times the function must be called before it is executed. 2. `func` *(Function)*: The function to restrict. #### Returns *(Function)*: Returns the new restricted function. #### Example ~~~ js var renderNotes = _.after(notes.length, render); _.forEach(notes, function(note) { note.asyncSave({ 'success': renderNotes }); }); // renderNotes is run once, after all notes have saved. ~~~ ### `_.bind(func [, arg1, arg2, ...])` Creates a new function that, when called, invokes `func` with the `this` binding of `thisArg` and prepends additional arguments to those passed to the bound function. [▲][1] #### Arguments 1. `func` *(Function)*: The function to bind. 2. `[arg1, arg2, ...]` *(Mixed)*: Arguments to prepend to those passed to the bound function. #### Returns *(Function)*: Returns the new bound function. #### Example ~~~ js var func = function(greeting) { return greeting + ': ' + this.name; }; func = _.bind(func, { 'name': 'moe' }, 'hi'); func(); // => 'hi: moe' ~~~ ### `_.bindAll(object [, methodName1, methodName2, ...])` Binds methods on the `object` to the object, overwriting the non-bound method. If no method names are provided, all the function properties of the `object` will be bound. [▲][1] #### Arguments 1. `object` *(Object)*: The object to bind and assign the bound methods to. 2. `[methodName1, methodName2, ...]` *(Mixed)*: Method names on the object to bind. #### Returns *(Object)*: Returns the `object`. #### Example ~~~ js var buttonView = { 'label': 'lodash', 'onClick': function() { alert('clicked: ' + this.label); }, 'onHover': function() { console.log('hovering: ' + this.label); } }; _.bindAll(buttonView); jQuery('#lodash_button').on('click', buttonView.onClick); // => When the button is clicked, `this.label` will have the correct value ~~~ ### `_.chain()` Extracts the value from a wrapped chainable object. [▲][1] #### Returns *(Mixed)*: Returns the wrapped object. #### Example ~~~ js _([1, 2, 3]).value(); // => [1, 2, 3] ~~~ ### `_.chain(value)` Wraps the value in a `lodash` chainable object. [▲][1] #### Arguments 1. `value` *(Mixed)*: The value to wrap. #### Returns *(Object)*: Returns the `lodash` chainable object. #### Example ~~~ js var stooges = [ { 'name': 'moe', 'age': 40 }, { 'name': 'larry', 'age': 50 }, { 'name': 'curly', 'age': 60 } ]; var youngest = _.chain(stooges) .sortBy(function(stooge) { return stooge.age; }) .map(function(stooge) { return stooge.name + ' is ' + stooge.age; }) .first() .value(); // => 'moe is 40' ~~~ ### `_.clone(value)` Create a shallow clone of the `value`. Any nested objects or arrays will be assigned by reference and not cloned. [▲][1] #### Arguments 1. `value` *(Mixed)*: The value to clone. #### Returns *(Mixed)*: Returns the cloned `value`. #### Example ~~~ js _.clone({ 'name': 'moe' }); // => { 'name': 'moe' }; ~~~ ### `_.compact(array)` Produces a new array with all falsey values of `array` removed. The values `false`, `null`, `0`, `""`, `undefined` and `NaN` are all falsey. [▲][1] #### Arguments 1. `array` *(Array)*: The array to compact. #### Returns *(Array)*: Returns a new filtered array. #### Example ~~~ js _.compact([0, 1, false, 2, '', 3]); // => [1, 2, 3] ~~~ ### `_.compose([func1, func2, ...])` Creates a new function that is the composition of the passed functions, where each function consumes the return value of the function that follows. In math terms, composing thefunctions `f()`, `g()`, and `h()` produces `f(g(h()))`. [▲][1] #### Arguments 1. `[func1, func2, ...]` *(Mixed)*: Functions to compose. #### Returns *(Function)*: Returns the new composed function. #### Example ~~~ js var greet = function(name) { return 'hi: ' + name; }; var exclaim = function(statement) { return statement + '!'; }; var welcome = _.compose(exclaim, greet); welcome('moe'); // => 'hi: moe!' ~~~ ### `_.contains(collection, target)` Checks if a given `target` value is present in a `collection` using strict equality for comparisons, i.e. `===`. [▲][1] #### Arguments 1. `collection` *(Array|Object)*: The collection to iterate over. 2. `target` *(Mixed)*: The value to check for. #### Returns *(Boolean)*: Returns `true` if `target` value is found, else `false`. #### Example ~~~ js _.contains([1, 2, 3], 3); // => true ~~~ ### `_.debounce(func, wait, immediate)` Creates a new function that will postpone its execution until after `wait` milliseconds have elapsed since the last time it was invoked. Pass `true` for `immediate` to cause debounce to invoke the function on the leading, instead of the trailing, edge of the `wait` timeout. [▲][1] #### Arguments 1. `func` *(Function)*: The function to debounce. 2. `wait` *(Number)*: The number of milliseconds to postone. 3. `immediate` *(Boolean)*: A flag to indicate execution is on the leading edge of the timeout. #### Returns *(Function)*: Returns the new debounced function. #### Example ~~~ js var lazyLayout = _.debounce(calculateLayout, 300); jQuery(window).on('resize', lazyLayout); ~~~ ### `_.defaults(object [, defaults1, defaults2, ..])` Assigns missing properties in `object` with default values from the defaults objects. As soon as a property is set, additional defaults of the same property will be ignored. [▲][1] #### Arguments 1. `object` *(Object)*: The object to populate. 2. `[defaults1, defaults2, ..]` *(Object)*: The defaults objects to apply to `object`. #### Returns *(Object)*: Returns `object`. #### Example ~~~ js var iceCream = { 'flavor': 'chocolate' }; _.defaults(iceCream, { 'flavor': 'vanilla', 'sprinkles': 'lots' }); // => { 'flavor': 'chocolate', 'sprinkles': 'lots' } ~~~ ### `_.defer(func [, arg1, arg2, ...])` Defers invoking the `func` function until the current call stack has cleared. Additional arguments are passed to `func` when it is invoked. [▲][1] #### Arguments 1. `func` *(Function)*: The function to defer. 2. `[arg1, arg2, ...]` *(Mixed)*: Arguments to invoke the function with. #### Returns *(Number)*: Returns the `setTimeout` timeout id. #### Example ~~~ js _.defer(function() { alert('deferred'); }); // Returns from the function before the alert runs. ~~~ ### `_.delay(func, wait [, arg1, arg2, ...])` Invokes the `func` function after `wait` milliseconds. Additional arguments are passed `func` when it is invoked. [▲][1] #### Arguments 1. `func` *(Function)*: The function to delay. 2. `wait` *(Number)*: The number of milliseconds to delay execution. 3. `[arg1, arg2, ...]` *(Mixed)*: Arguments to invoke the function with. #### Returns *(Number)*: Returns the `setTimeout` timeout id. #### Example ~~~ js var log = _.bind(console.log, console); _.delay(log, 1000, 'logged later'); // => 'logged later' (Appears after one second.) ~~~ ### `_.difference(array [, array1, array2, ...])` Produces a new array of `array` values not present in the other arrays using strict equality for comparisons, i.e. `===`. [▲][1] #### Arguments 1. `array` *(Array)*: The array to process. 2. `[array1, array2, ...]` *(Mixed)*: Arrays to check. #### Returns *(Array)*: Returns a new array of `array` values not present in the other arrays. #### Example ~~~ js _.difference([1, 2, 3, 4, 5], [5, 2, 10]); // => [1, 3, 4] ~~~ ### `_.escape(string)` Escapes a string for insertion into HTML, replacing `&`, `<`, `>`, `"`, `'`, and `/` characters. [▲][1] #### Arguments 1. `string` *(String)*: The string to escape. #### Returns *(String)*: Returns the escaped string. #### Example ~~~ js _.escape('Curly, Larry & Moe'); // => "Curly, Larry & Moe" ~~~ ### `_.every(collection, callback [, thisArg])` Checks if the `callback` returns truthy for **all** values of a `collection`. The `callback` is invoked with `3` arguments; for arrays they are *(value, index, array)* and for objects they are *(value, key, object)*. [▲][1] #### Arguments 1. `collection` *(Array|Object)*: The collection to iterate over. 2. `callback` *(Function)*: The function called per iteration. 3. `[thisArg]` *(Mixed)*: The `this` binding for the callback. #### Returns *(Boolean)*: Returns `true` if all values pass the callback check, else `false`. #### Example ~~~ js _.every([true, 1, null, 'yes'], Boolean); => false ~~~ ### `_.extend(object [, source1, source2, ..])` Copies enumerable properties from the source objects to the `destination` object. Subsequent sources will overwrite propery assignments of previous sources. [▲][1] #### Arguments 1. `object` *(Object)*: The destination object. 2. `[source1, source2, ..]` *(Object)*: The source objects. #### Returns *(Object)*: Returns the destination object. #### Example ~~~ js _.extend({ 'name': 'moe' }, { 'age': 40 }); // => { 'name': 'moe', 'age': 40 } ~~~ ### `_.filter(collection, callback [, thisArg])` Examines each value in a `collection`, returning an array of all values the `callback` returns truthy for. The `callback` is invoked with `3` arguments; for arrays they are *(value, index, array)* and for objects they are *(value, key, object)*. [▲][1] #### Arguments 1. `collection` *(Array|Object)*: The collection to iterate over. 2. `callback` *(Function)*: The function called per iteration. 3. `[thisArg]` *(Mixed)*: The `this` binding for the callback. #### Returns *(Array)*: Returns a new array of values that passed callback check. #### Example ~~~ js var evens = _.filter([1, 2, 3, 4, 5, 6], function(num) { return num % 2 == 0; }); // => [2, 4, 6] ~~~ ### `_.find(collection, callback [, thisArg])` Examines each value in a `collection`, returning the first one the `callback` returns truthy for. The function returns as soon as it finds an acceptable value, and does not iterate over the entire `collection`. The `callback` is invoked with `3` arguments; for arrays they are *(value, index, array)* and for objects they are *(value, key, object)*. [▲][1] #### Arguments 1. `collection` *(Array|Object)*: The collection to iterate over. 2. `callback` *(Function)*: The function called per iteration. 3. `[thisArg]` *(Mixed)*: The `this` binding for the callback. #### Returns *(Mixed)*: Returns the value that passed the callback check, else `undefined`. #### Example ~~~ js var even = _.find([1, 2, 3, 4, 5, 6], function(num) { return num % 2 == 0; }); // => 2 ~~~ ### `_.first(array [, n, guard])` Gets the first value of the `array`. Pass `n` to return the first `n` values of the `array`. [▲][1] #### Arguments 1. `array` *(Array)*: The array to query. 2. `[n]` *(Number)*: The number of elements to return. 3. `[guard]` *(Object)*: Internally used to allow this method to work with others like `_.map` without using their callback `index` argument for `n`. #### Returns *(Mixed)*: Returns the first value or an array of the first `n` values of the `array`. #### Example ~~~ js _.first([5, 4, 3, 2, 1]); // => 5 ~~~ ### `_.flatten(array, shallow)` Flattens a nested array *(the nesting can be to any depth)*. If `shallow` is truthy, `array` will only be flattened a single level. [▲][1] #### Arguments 1. `array` *(Array)*: The array to compact. 2. `shallow` *(Boolean)*: A flag to indicate only flattening a single level. #### Returns *(Array)*: Returns a new flattened array. #### Example ~~~ js _.flatten([1, [2], [3, [[4]]]]); // => [1, 2, 3, 4]; _.flatten([1, [2], [3, [[4]]]], true); // => [1, 2, 3, [[4]]]; ~~~ ### `_.forEach(collection, callback [, thisArg])` Iterates over a `collection`, executing the `callback` for each value in the `collection`. The `callback` is bound to the `thisArg` value, if one is passed. The `callback` is invoked with `3` arguments; for arrays they are *(value, index, array)* and for objects they are *(value, key, object)*. [▲][1] #### Arguments 1. `collection` *(Array|Object)*: The collection to iterate over. 2. `callback` *(Function)*: The function called per iteration. 3. `[thisArg]` *(Mixed)*: The `this` binding for the callback. #### Returns *(Array, Object)*: Returns the `collection`. #### Example ~~~ js _.forEach([1, 2, 3], function(num) { alert(num); }); // => alerts each number in turn... _.forEach({ 'one': 1, 'two': 2, 'three': 3}, function(num) { alert(num); }); // => alerts each number in turn... ~~~ ### `_.functions(object)` Produces a sorted array of the properties, own and inherited, of `object` that have function values. [▲][1] #### Arguments 1. `object` *(Object)*: The object to inspect. #### Returns *(Array)*: Returns a new array of property names that have function values. #### Example ~~~ js _.functions(_); // => ['all', 'any', 'bind', 'bindAll', 'clone', 'compact', 'compose', ...] ~~~ ### `_.groupBy(collection, callback [, thisArg])` Splits a `collection` into sets, grouped by the result of running each value through `callback`. The `callback` is invoked with `3` arguments; for arrays they are *(value, index, array)* and for objects they are *(value, key, object)*. The `callback` argument may also be the name of a property to group by. [▲][1] #### Arguments 1. `collection` *(Array|Object)*: The collection to iterate over. 2. `callback` *(Function|String)*: The function called per iteration or property name to group by. 3. `[thisArg]` *(Mixed)*: The `this` binding for the callback. #### Returns *(Object)*: Returns an object of grouped values. #### Example ~~~ js _.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'] } ~~~ ### `_.has(object, property)` Checks if the specified object `property` exists and is a direct property, instead of an inherited property. [▲][1] #### Arguments 1. `object` *(Object)*: The object to check. 2. `property` *(String)*: The property to check for. #### Returns *(Boolean)*: Returns `true` if key is a direct property, else `false`. #### Example ~~~ js _.has({ 'a': 1, 'b': 2, 'c': 3 }, 'b'); // => true ~~~ ### `_.identity(value)` This function simply returns the first argument passed to it. Note: It is used throughout Lo-Dash as a default callback. [▲][1] #### Arguments 1. `value` *(Mixed)*: Any value. #### Returns *(Mixed)*: Returns `value`. #### Example ~~~ js var moe = { 'name': 'moe' }; moe === _.identity(moe); // => true ~~~ ### `_.indexOf(array, value [, isSorted=false])` Gets the index at which the first occurrence of `value` is found using strict equality for comparisons, i.e. `===`. If the `array` is already sorted, passing `true` for `isSorted` will run a faster binary search. [▲][1] #### Arguments 1. `array` *(Array)*: The array to search. 2. `value` *(Mixed)*: The value to search for. 3. `[isSorted=false]` *(Boolean)*: A flag to indicate that the `array` is already sorted. #### Returns *(Number)*: Returns the index of the matched value or `-1`. #### Example ~~~ js _.indexOf([1, 2, 3], 2); // => 1 ~~~ ### `_.initial(array [, n, guard])` Gets all but the last value of the `array`. Pass `n` to exclude the last `n` values from the result. [▲][1] #### Arguments 1. `array` *(Array)*: The array to query. 2. `[n]` *(Number)*: The number of elements to return. 3. `[guard]` *(Object)*: Internally used to allow this method to work with others like `_.map` without using their callback `index` argument for `n`. #### Returns *(Array)*: Returns all but the last value or `n` values of the `array`. #### Example ~~~ js _.initial([5, 4, 3, 2, 1]); // => [5, 4, 3, 2] ~~~ ### `_.intersection([array1, array2, ...])` Computes the intersection of all the passed-in arrays. [▲][1] #### Arguments 1. `[array1, array2, ...]` *(Mixed)*: Arrays to process. #### Returns *(Array)*: Returns a new array of unique values, in order, that are present in **all** of the arrays. #### Example ~~~ js _.intersection([1, 2, 3], [101, 2, 1, 10], [2, 1]); // => [1, 2] ~~~ ### `_.invoke(array, methodName [, arg1, arg2, ...])` Calls the method named by `methodName` for each value of the `collection`. Additional arguments will be passed to each invoked method. [▲][1] #### Arguments 1. `array` *(Array)*: The array to iterate over. 2. `methodName` *(String)*: The name of the method to invoke. 3. `[arg1, arg2, ...]` *(Mixed)*: Arguments to invoke the method with. #### Returns *(Array)*: Returns a new array of values returned from each invoked method. #### Example ~~~ js _.invoke([[5, 1, 7], [3, 2, 1]], 'sort'); // => [[1, 5, 7], [1, 2, 3]] ~~~ ### `_.isArguments(value)` Checks if a `value` is an `arguments` object. [▲][1] #### Arguments 1. `value` *(Mixed)*: The value to check. #### Returns *(Boolean)*: Returns `true` if the `value` is an `arguments` object, else `false`. #### Example ~~~ js (function() { return _.isArguments(arguments); })(1, 2, 3); // => true _.isArguments([1, 2, 3]); // => false ~~~ ### `_.isArray(value)` Checks if a `value` is an array. [▲][1] #### Arguments 1. `value` *(Mixed)*: The value to check. #### Returns *(Boolean)*: Returns `true` if the `value` is an array, else `false`. #### Example ~~~ js (function() { return _.isArray(arguments); })(); // => false _.isArray([1, 2, 3]); // => true ~~~ ### `_.isBoolean(value)` Checks if a `value` is a boolean *(`true` or `false`)* value. [▲][1] #### Arguments 1. `value` *(Mixed)*: The value to check. #### Returns *(Boolean)*: Returns `true` if the `value` is a boolean value, else `false`. #### Example ~~~ js _.isBoolean(null); // => false ~~~ ### `_.isDate(value)` Checks if a `value` is a date. [▲][1] #### Arguments 1. `value` *(Mixed)*: The value to check. #### Returns *(Boolean)*: Returns `true` if the `value` is a date, else `false`. #### Example ~~~ js _.isDate(new Date); // => true ~~~ ### `_.isElement(value)` Checks if a `value` is a DOM element. [▲][1] #### Arguments 1. `value` *(Mixed)*: The value to check. #### Returns *(Boolean)*: Returns `true` if the `value` is a DOM element, else `false`. #### Example ~~~ js _.isElement(document.body); // => true ~~~ ### `_.isEmpty(value)` Checks if a `value` is empty. Arrays or strings with a length of `0` and objects with no enumerable own properties are considered "empty". [▲][1] #### Arguments 1. `value` *(Mixed)*: The value to check. #### Returns *(Boolean)*: Returns `true` if the `value` is empty, else `false`. #### Example ~~~ js _.isEmpty([1, 2, 3]); // => false _.isEmpty({}); // => true ~~~ ### `_.isEqual(a, b [, stack])` Performs a deep comparison between two values to determine if they are equivalent to each other. [▲][1] #### Arguments 1. `a` *(Mixed)*: The value to compare. 2. `b` *(Mixed)*: The other value to compare. 3. `[stack]` *(Array)*: Internally used to keep track of "seen" objects to avoid circular references. #### Returns *(Boolean)*: Returns `true` if the values are equvalent, else `false`. #### Example ~~~ js var moe = { 'name': 'moe', 'luckyNumbers': [13, 27, 34] }; var clone = { 'name': 'moe', 'luckyNumbers': [13, 27, 34] }; moe == clone; // => false _.isEqual(moe, clone); // => true ~~~ ### `_.isFinite(value)` Checks if a `value` is a finite number. [▲][1] #### Arguments 1. `value` *(Mixed)*: The value to check. #### Returns *(Boolean)*: Returns `true` if the `value` is a finite number, else `false`. #### Example ~~~ js _.isFinite(-101); // => true _.isFinite('10'); // => false _.isFinite(Infinity); // => false ~~~ ### `_.isFunction(value)` Checks if a `value` is a function. [▲][1] #### Arguments 1. `value` *(Mixed)*: The value to check. #### Returns *(Boolean)*: Returns `true` if the `value` is a function, else `false`. #### Example ~~~ js _.isFunction(''.concat); // => true ~~~ ### `_.isNaN(value)` Checks if a `value` is `NaN`. Note: this is not the same as native `isNaN`, which will return true for `undefined` and other values. See http://es5.github.com/#x15.1.2.4. [▲][1] #### Arguments 1. `value` *(Mixed)*: The value to check. #### Returns *(Boolean)*: Returns `true` if the `value` is `NaN`, else `false`. #### Example ~~~ js _.isNaN(NaN); // => true _.isNaN(new Number(NaN)); // => true isNaN(undefined); // => true _.isNaN(undefined); // => false ~~~ ### `_.isNull(value)` Checks if a `value` is `null`. [▲][1] #### Arguments 1. `value` *(Mixed)*: The value to check. #### Returns *(Boolean)*: Returns `true` if the `value` is `null`, else `false`. #### Example ~~~ js _.isNull(null); // => true _.isNull(undefined); // => false ~~~ ### `_.isNumber(value)` Checks if a `value` is a number. [▲][1] #### Arguments 1. `value` *(Mixed)*: The value to check. #### Returns *(Boolean)*: Returns `true` if the `value` is a number, else `false`. #### Example ~~~ js _.isNumber(8.4 * 5; // => true ~~~ ### `_.isObject(value)` Checks if a `value` is an object. [▲][1] #### Arguments 1. `value` *(Mixed)*: The value to check. #### Returns *(Boolean)*: Returns `true` if the `value` is an object, else `false`. #### Example ~~~ js _.isObject({}); // => true _.isObject(1); // => false ~~~ ### `_.isRegExp(value)` Checks if a `value` is a regular expression. [▲][1] #### Arguments 1. `value` *(Mixed)*: The value to check. #### Returns *(Boolean)*: Returns `true` if the `value` is a regular expression, else `false`. #### Example ~~~ js _.isRegExp(/moe/); // => true ~~~ ### `_.isString(value)` Checks if a `value` is a string. [▲][1] #### Arguments 1. `value` *(Mixed)*: The value to check. #### Returns *(Boolean)*: Returns `true` if the `value` is a string, else `false`. #### Example ~~~ js _.isString('moe'); // => true ~~~ ### `_.isUndefined(value)` Checks if a `value` is `undefined`. [▲][1] #### Arguments 1. `value` *(Mixed)*: The value to check. #### Returns *(Boolean)*: Returns `true` if the `value` is `undefined`, else `false`. #### Example ~~~ js _.isUndefined(void 0); // => true ~~~ ### `_.keys(object)` Produces an array of the `object`'s enumerable own property names. [▲][1] #### Arguments 1. `object` *(Object)*: The object to inspect. #### Returns *(Array)*: Returns a new array of property names. #### Example ~~~ js _.keys({ 'one': 1, 'two': 2, 'three': 3 }); // => ['one', 'two', 'three'] ~~~ ### `_.last(array [, n, guard])` Gets the last value of the `array`. Pass `n` to return the lasy `n` values of the `array`. [▲][1] #### Arguments 1. `array` *(Array)*: The array to query. 2. `[n]` *(Number)*: The number of elements to return. 3. `[guard]` *(Object)*: Internally used to allow this method to work with others like `_.map` without using their callback `index` argument for `n`. #### Returns *(Array)*: Returns all but the last value or `n` values of the `array`. #### Example ~~~ js _.last([5, 4, 3, 2, 1]); // => 1 ~~~ ### `_.lastIndexOf(array, value)` Gets the index at which the last occurrence of `value` is found using strict equality for comparisons, i.e. `===`. [▲][1] #### Arguments 1. `array` *(Array)*: The array to search. 2. `value` *(Mixed)*: The value to search for. #### Returns *(Number)*: Returns the index of the matched value or `-1`. #### Example ~~~ js _.lastIndexOf([1, 2, 3, 1, 2, 3], 2); // => 4 ~~~ ### `_.map(collection, callback [, thisArg])` Produces a new array of values by mapping each value in the `collection` through a transformation `callback`. The `callback` is bound to the `thisArg` value, if one is passed. The `callback` is invoked with `3` arguments; for arrays they are *(value, index, array)* and for objects they are *(value, key, object)*. [▲][1] #### Arguments 1. `collection` *(Array|Object)*: The collection to iterate over. 2. `callback` *(Function)*: The function called per iteration. 3. `[thisArg]` *(Mixed)*: The `this` binding for the callback. #### Returns *(Array)*: Returns a new array of values returned by the callback. #### Example ~~~ js _.map([1, 2, 3], function(num) { return num * 3; }); // => [3, 6, 9] _.map({ 'one': 1, 'two': 2, 'three': 3 }, function(num) { return num * 3; }); // => [3, 6, 9] ~~~ ### `_.max(collection [, callback, thisArg])` Retrieves the maximum value of a `collection`. If `callback` is passed, it will be executed for each value in the `collection` to generate the criterion by which the value is ranked. The `callback` is invoked with `3` arguments; for arrays they are *(value, index, array)* and for objects they are *(value, key, object)*. [▲][1] #### Arguments 1. `collection` *(Array|Object)*: The collection to iterate over. 2. `[callback]` *(Function)*: The function called per iteration. 3. `[thisArg]` *(Mixed)*: The `this` binding for the callback. #### Returns *(Mixed)*: Returns the maximum value. #### Example ~~~ js 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 }; ~~~ ### `_.memoize(func [, resolver])` Creates a new function that memoizes the result of `func`. If `resolver` is passed, it will be used to determine the cache key for storing the result based on the arguments passed to the memoized function. By default, the first argument passed to the memoized function is used as the cache key. [▲][1] #### Arguments 1. `func` *(Function)*: The function to have its output memoized. 2. `[resolver]` *(Function)*: A function used to resolve the cache key. #### Returns *(Function)*: Returns the new memoizing function. #### Example ~~~ js var fibonacci = _.memoize(function(n) { return n < 2 ? n : fibonacci(n - 1) + fibonacci(n - 2); }); ~~~ ### `_.min(collection [, callback, thisArg])` Retrieves the minimum value of a `collection`. If `callback` is passed, it will be executed for each value in the `collection` to generate the criterion by which the value is ranked. The `callback` is invoked with `3` arguments; for arrays they are *(value, index, array)* and for objects they are *(value, key, object)*. [▲][1] #### Arguments 1. `collection` *(Array|Object)*: The collection to iterate over. 2. `[callback]` *(Function)*: The function called per iteration. 3. `[thisArg]` *(Mixed)*: The `this` binding for the callback. #### Returns *(Mixed)*: Returns the minimum value. #### Example ~~~ js _.min([10, 5, 100, 2, 1000]); // => 2 ~~~ ### `_.mixin(object)` Adds functions properties of `object` to the `lodash` function and chainable wrapper. [▲][1] #### Arguments 1. `object` *(Object)*: The object of function properties to add to `lodash`. #### Example ~~~ js _.mixin({ 'capitalize': function(string) { return string.charAt(0).toUpperCase() + string.slice(1).toLowerCase(); } }); _.capitalize('curly'); // => 'Curly' _('larry').capitalize(); // => 'Larry' ~~~ ### `_.noConflict()` Reverts the '_' variable to its previous value and returns a reference to the `lodash` function. [▲][1] #### Returns *(Function)*: Returns the `lodash` function. #### Example ~~~ js var lodash = _.noConflict(); ~~~ ### `_.once(func)` Creates a new function that is restricted to one execution. Repeat calls to the function will return the value of the first call. [▲][1] #### Arguments 1. `func` *(Function)*: The function to restrict. #### Returns *(Function)*: Returns the new restricted function. #### Example ~~~ js var initialize = _.once(createApplication); initialize(); initialize(); // Application is only created once. ~~~ ### `_.pick(object [, prop1, prop2, ..])` Creates an object composed of the specified properties. Property names may be specified as individual arguments or as arrays of property names. [▲][1] #### Arguments 1. `object` *(Object)*: The object to pluck. 2. `[prop1, prop2, ..]` *(Object)*: The properties to pick. #### Returns *(Object)*: Returns an object composed of the picked properties. #### Example ~~~ js _.pick({ 'name': 'moe', 'age': 40, 'userid': 'moe1' }, 'name', 'age'); // => { 'name': 'moe', 'age': 40 } ~~~ ### `_.pluck(collection, property)` Retrieves the value of a specified property from all values in a `collection`. [▲][1] #### Arguments 1. `collection` *(Array|Object)*: The collection to iterate over. 2. `property` *(String)*: The property to pluck. #### Returns *(Array)*: Returns a new array of property values. #### Example ~~~ js var stooges = [ { 'name': 'moe', 'age': 40 }, { 'name': 'larry', 'age': 50 }, { 'name': 'curly', 'age': 60 } ]; _.pluck(stooges, 'name'); // => ['moe', 'larry', 'curly'] ~~~ ### `_.range([start=0], end [, step=1])` Creates an array of numbers *(positive and/or negative)* progressing from `start` up to but not including `stop`. This method is a port of Python's `range()` function. See http://docs.python.org/library/functions.html#range. [▲][1] #### Arguments 1. `[start=0]` *(Number)*: The start of the range. 2. `end` *(Number)*: The end of the range. 3. `[step=1]` *(Number)*: The value to increment or descrement by. #### Returns *(Array)*: Returns a new range array. #### Example ~~~ js _.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); // => [] ~~~ ### `_.reduce(collection, callback [, accumulator, thisArg])` Boils down a `collection` to a single value. The initial state of the reduction is `accumulator` and each successive step of it should be returned by the `callback`. The `callback` is bound to the `thisArg` value, if one is passed. The `callback` is invoked with `4` arguments; for arrays they are *(accumulator, value, index, array)* and for objects they are *(accumulator, value, key, object)*. [▲][1] #### Arguments 1. `collection` *(Array|Object)*: The collection to iterate over. 2. `callback` *(Function)*: The function called per iteration. 3. `[accumulator]` *(Mixed)*: Initial value of the accumulator. 4. `[thisArg]` *(Mixed)*: The `this` binding for the callback. #### Returns *(Mixed)*: Returns the accumulated value. #### Example ~~~ js var sum = _.reduce([1, 2, 3], function(memo, num) { return memo + num; }); // => 6 ~~~ ### `_.reduceRight(collection, callback [, accumulator, thisArg])` The right-associative version of `_.reduce`. The `callback` is bound to the `thisArg` value, if one is passed. The `callback` is invoked with `4` arguments; for arrays they are *(accumulator, value, index, array)* and for objects they are *(accumulator, value, key, object)*. [▲][1] #### Arguments 1. `collection` *(Array|Object)*: The collection to iterate over. 2. `callback` *(Function)*: The function called per iteration. 3. `[accumulator]` *(Mixed)*: Initial value of the accumulator. 4. `[thisArg]` *(Mixed)*: The `this` binding for the callback. #### Returns *(Mixed)*: Returns the accumulated value. #### Example ~~~ js 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] ~~~ ### `_.reject(collection, callback [, thisArg])` The opposite of `_.filter`, this method returns the values of a `collection` that `callback` does **not** return truthy for. The `callback` is invoked with `3` arguments; for arrays they are *(value, index, array)* and for objects they are *(value, key, object)*. [▲][1] #### Arguments 1. `collection` *(Array|Object)*: The collection to iterate over. 2. `callback` *(Function)*: The function called per iteration. 3. `[thisArg]` *(Mixed)*: The `this` binding for the callback. #### Returns *(Array)*: Returns a new array of values that did **not** pass the callback check. #### Example ~~~ js var odds = _.reject([1, 2, 3, 4, 5, 6], function(num) { return num % 2 == 0; }); // => [1, 3, 5] ~~~ ### `_.rest(array [, n, guard])` The opposite of `_.initial`, this method gets all but the first value of the `array`. Pass `n` to exclude the first `n` values from the result. [▲][1] #### Arguments 1. `array` *(Array)*: The array to query. 2. `[n]` *(Number)*: The number of elements to return. 3. `[guard]` *(Object)*: Internally used to allow this method to work with others like `_.map` without using their callback `index` argument for `n`. #### Returns *(Array)*: Returns all but the first value or `n` values of the `array`. #### Example ~~~ js _.rest([5, 4, 3, 2, 1]); // => [4, 3, 2, 1] ~~~ ### `_.result(object, property)` Resolves the value of `property` on `object`. If the property is a function it will be invoked and its result returned, else the property value is returned. [▲][1] #### Arguments 1. `object` *(Object)*: The object to inspect. 2. `property` *(String)*: The property to get the result of. #### Returns *(Mixed)*: Returns the resolved. #### Example ~~~ js var object = { 'cheese': 'crumpets', 'stuff': function() { return 'nonsense'; } }; _.result(object, 'cheese'); // => 'crumpets' _.result(object, 'stuff'); // => 'nonsense' ~~~ ### `_.shuffle(collection)` Produces a new array of shuffled `collection` values, using a version of the Fisher-Yates shuffle. See http://en.wikipedia.org/wiki/Fisher-Yates_shuffle. [▲][1] #### Arguments 1. `collection` *(Array|Object)*: The collection to shuffle. #### Returns *(Array)*: Returns a new shuffled array. #### Example ~~~ js _.shuffle([1, 2, 3, 4, 5, 6]); // => [4, 1, 6, 3, 5, 2] ~~~ ### `_.size(collection)` Gets the number of values in the `collection`. [▲][1] #### Arguments 1. `collection` *(Array|Object)*: The collection inspect. #### Returns *(Number)*: Returns the number of values in the collection. #### Example ~~~ js _.size({ 'one': 1, 'two': 2, 'three': 3 }); // => 3 ~~~ ### `_.some(collection, callback [, thisArg])` Checks if the `callback` returns truthy for **any** value of a `collection`. The function returns as soon as it finds passing value, and does not iterate over the entire `collection`. The `callback` is invoked with `3` arguments; for arrays they are *(value, index, array)* and for objects they are *(value, key, object)*. [▲][1] #### Arguments 1. `collection` *(Array|Object)*: The collection to iterate over. 2. `callback` *(Function)*: The function called per iteration. 3. `[thisArg]` *(Mixed)*: The `this` binding for the callback. #### Returns *(Boolean)*: Returns `true` if any value passes the callback check, else `false`. #### Example ~~~ js _.some([null, 0, 'yes', false]); // => true ~~~ ### `_.sortBy(collection, callback [, thisArg])` Produces a new sorted array, ranked in ascending order by the results of running each value of a `collection` through `callback`. The `callback` is invoked with `3` arguments; for arrays they are *(value, index, array)* and for objects they are *(value, key, object)*. The `callback` argument may also be the name of a property to sort by *(e.g. 'length')*. [▲][1] #### Arguments 1. `collection` *(Array|Object)*: The collection to iterate over. 2. `callback` *(Function|String)*: The function called per iteration or property name to sort by. 3. `[thisArg]` *(Mixed)*: The `this` binding for the callback. #### Returns *(Array)*: Returns a new array of sorted values. #### Example ~~~ js _.sortBy([1, 2, 3, 4, 5, 6], function(num) { return Math.sin(num); }); // => [5, 4, 6, 3, 1, 2] ~~~ ### `_.sortedIndex(array, value [, callback])` Uses a binary search to determine the smallest index at which the `value` should be inserted into the `collection` in order to maintain the sort order of the `collection`. If `callback` is passed, it will be executed for each value in the `collection` to compute their sort ranking. The `callback` is invoked with `1` argument. [▲][1] #### Arguments 1. `array` *(Array)*: The array to iterate over. 2. `value` *(Mixed)*: The value to evaluate. 3. `[callback]` *(Function)*: The function called per iteration. #### Returns *(Number)*: Returns the index at which the value should be inserted into the collection. #### Example ~~~ js _.sortedIndex([10, 20, 30, 40, 50], 35); // => 3 ~~~ ### `_.tap(value, interceptor)` Invokes `interceptor` with the `value` as the first argument, and then returns `value`. The primary purpose of this method is to "tap into" a method chain, in order to performoperations on intermediate results within the chain. [▲][1] #### Arguments 1. `value` *(Mixed)*: The value to pass to `callback`. 2. `interceptor` *(Function)*: The function to invoke. #### Returns *(Mixed)*: Returns `value`. #### Example ~~~ js _.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] ~~~ ### `_.template(text, data, options)` A JavaScript micro-templating method, similar to John Resig's implementation. Lo-Dash templating handles arbitrary delimiters, preserves whitespace, and correctly escapes quotes within interpolated code. [▲][1] #### Arguments 1. `text` *(String)*: The template text. 2. `data` *(Obect)*: The data object used to populate the text. 3. `options` *(Object)*: The options object. #### Returns *(Function, String)*: Returns a compiled function when no `data` object is given, else it returns the interpolated text. #### Example ~~~ js // using compiled template var compiled = _.template('hello: <%= name %>'); compiled({ 'name': 'moe' }); // => 'hello: moe' var list = '% _.forEach(people, function(name) { %>