keys

_.keys(object) source

Retrieve all the names of the object‘s own enumerable properties.

_.keys({one: 1, two: 2, three: 3});
=> ["one", "two", "three"]

allKeys

_.allKeys(object) source

Retrieve all the names of object‘s own and inherited properties.

function Stooge(name) {
this.name = name;
}
Stooge.prototype.silly = true;
_.allKeys(new Stooge("Moe"));
=> ["name", "silly"]

values

_.values(object) source

Return all of the values of the object‘s own properties.

_.values({one: 1, two: 2, three: 3});
=> [1, 2, 3]

mapObject

_.mapObject(object, iteratee, [context]) source

Like map, but for objects. Transform the value of each property in turn.

_.mapObject({start: 5, end: 12}, function(val, key) {
return val + 5;
});
=> {start: 10, end: 17}

pairs

_.pairs(object) source

Convert an object into a list of [key, value] pairs. The opposite of object.

_.pairs({one: 1, two: 2, three: 3});
=> [["one", 1], ["two", 2], ["three", 3]]

invert

_.invert(object) source

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.

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

create

_.create(prototype, props) source

Creates a new object with the given prototype, optionally attaching props as own properties. Basically, Object.create, but without all of the property descriptor jazz.

var moe = _.create(Stooge.prototype, {name: "Moe"});

functions

_.functions(object) Alias: methods source

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.

_.functions(_);
=> ["all", "any", "bind", "bindAll", "clone", "compact", "compose" ...

findKey

_.findKey(object, predicate, [context]) source

Similar to _.findIndex but for keys in objects. Returns the key where the predicate truth test passes or undefined. predicate is transformed through iteratee to facilitate shorthand syntaxes.

extend

_.extend(destination, *sources) source

Shallowly copy all of the properties in the source objects over to the destination object, and return the destination object. Any nested objects or arrays will be copied by reference, not duplicated. It’s in-order, so the last source will override properties of the same name in previous arguments.

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

extendOwn

_.extendOwn(destination, *sources) Alias: assign source

Like extend, but only copies own properties over to the destination object.

pick

_.pick(object, *keys) source

Return a copy of the object, filtered to only have values for the allowed keys (or array of valid keys). Alternatively accepts a predicate indicating which keys to pick.

_.pick({name: 'moe', age: 50, userid: 'moe1'}, 'name', 'age');
=> {name: 'moe', age: 50}
_.pick({name: 'moe', age: 50, userid: 'moe1'}, function(value, key, object) {
return _.isNumber(value);
});
=> {age: 50}

omit

_.omit(object, *keys) source

Return a copy of the object, filtered to omit the disallowed keys (or array of keys). Alternatively accepts a predicate indicating which keys to omit.

_.omit({name: 'moe', age: 50, userid: 'moe1'}, 'userid');
=> {name: 'moe', age: 50}
_.omit({name: 'moe', age: 50, userid: 'moe1'}, function(value, key, object) {
return _.isNumber(value);
});
=> {name: 'moe', userid: 'moe1'}

defaults

_.defaults(object, *defaults) source

Returns object after filling in its undefined properties with the first value present in the following list of defaults objects.

var iceCream = {flavor: "chocolate"};
_.defaults(iceCream, {flavor: "vanilla", sprinkles: "lots"});
=> {flavor: "chocolate", sprinkles: "lots"}

clone

_.clone(object) source

Create a shallow-copied clone of the provided plain object. Any nested objects or arrays will be copied by reference, not duplicated.

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

tap

_.tap(object, interceptor) source

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.

_.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]

toPath

_.toPath(path) source

Ensures that path is an array. If path is a string, it is wrapped in a single-element array; if it is an array already, it is returned unmodified.

_.toPath('key');
=> ['key']
_.toPath(['a', 0, 'b']);
=> ['a', 0, 'b'] // (same array)

_.toPath is used internally in has, get, invoke, property, propertyOf and result, as well as in iteratee and all functions that depend on it, in order to normalize deep property paths. You can override _.toPath if you want to customize this behavior, for example to enable Lodash-like string path shorthands. Be advised that altering _.toPath will unavoidably cause some keys to become unreachable; override at your own risk.

// Support dotted path shorthands.
var originalToPath = _.toPath;
_.mixin({
toPath: function(path) {
return _.isString(path) ? path.split('.') : originalToPath(path);
}
});
_.get({a: [{b: 5}]}, 'a.0.b');
=> 5

get

_.get(object, path, [default]) source

Returns the specified property of object. path may be specified as a simple key, or as an array of object keys or array indexes, for deep property fetching. If the property does not exist or is undefined, the optional default is returned.

_.get({a: 10}, 'a');
=> 10
_.get({a: [{b: 2}]}, ['a', 0, 'b']);
=> 2
_.get({a: 10}, 'b', 100);
=> 100

has

_.has(object, key) source

Does the object contain the given key? Identical to object.hasOwnProperty(key), but uses a safe reference to the hasOwnProperty function, in case it’s been overridden accidentally.

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

property

_.property(path) source

Returns a function that will return the specified property of any passed-in object. path may be specified as a simple key, or as an array of object keys or array indexes, for deep property fetching.

var stooge = {name: 'moe'};
'moe' === _.property('name')(stooge);
=> true
var stooges = {moe: {fears: {worst: 'Spiders'}}, curly: {fears: {worst: 'Moe'}}};
var curlysWorstFear = _.property(['curly', 'fears', 'worst']);
curlysWorstFear(stooges);
=> 'Moe'

propertyOf

_.propertyOf(object) source

Inverse of _.property. Takes an object and returns a function which will return the value of a provided property.

var stooge = {name: 'moe'};
_.propertyOf(stooge)('name');
=> 'moe'

matcher

_.matcher(attrs) Alias: matches source

Returns a predicate function that will tell you if a passed in object contains all of the key/value properties present in attrs.

var ready = _.matcher({selected: true, visible: true});
var readyToGoList = _.filter(list, ready);

isEqual

_.isEqual(object, other) source

Performs an optimized deep comparison between the two objects, to determine if they should be considered equal.

var stooge = {name: 'moe', luckyNumbers: [13, 27, 34]};
var clone  = {name: 'moe', luckyNumbers: [13, 27, 34]};
stooge == clone;
=> false
_.isEqual(stooge, clone);
=> true

isMatch

_.isMatch(object, properties) source

Tells you if the keys and values in properties are contained in object.

var stooge = {name: 'moe', age: 32};
_.isMatch(stooge, {age: 32});
=> true

isEmpty

_.isEmpty(collection) source

Returns true if collection has no elements. For strings and array-like objects _.isEmpty checks if the length property is 0. For other objects, it returns true if the object has no enumerable own-properties. Note that primitive numbers, booleans and symbols are always empty by this definition.

_.isEmpty([1, 2, 3]);
=> false
_.isEmpty({});
=> true

isElement

_.isElement(object) source

Returns true if object is a DOM element.

_.isElement(jQuery('body')[0]);
=> true

isArray

_.isArray(object) source

Returns true if object is an Array.

(function(){ return _.isArray(arguments); })();
=> false
_.isArray([1,2,3]);
=> true

isObject

_.isObject(value) source

Returns true if value is an Object. Note that JavaScript arrays and functions are objects, while (normal) strings and numbers are not.

_.isObject({});
=> true
_.isObject(1);
=> false

isArguments

_.isArguments(object) source

Returns true if object is an Arguments object.

(function(){ return _.isArguments(arguments); })(1, 2, 3);
=> true
_.isArguments([1,2,3]);
=> false

isFunction

_.isFunction(object) source

Returns true if object is a Function.

_.isFunction(alert);
=> true

isString

_.isString(object) source

Returns true if object is a String.

_.isString("moe");
=> true

isNumber

_.isNumber(object) source

Returns true if object is a Number (including NaN).

_.isNumber(8.4 * 5);
=> true

isFinite

_.isFinite(object) source

Returns true if object is a finite Number.

_.isFinite(-101);
=> true
_.isFinite(-Infinity);
=> false

isBoolean

_.isBoolean(object) source

Returns true if object is either true or false.

_.isBoolean(null);
=> false

isDate

_.isDate(object) source

Returns true if object is a Date.

_.isDate(new Date());
=> true

isRegExp

_.isRegExp(object) source

Returns true if object is a RegExp.

_.isRegExp(/moe/);
=> true

isError

_.isError(object) source

Returns true if object inherits from an Error.

try {
  throw new TypeError("Example");
} catch (o_O) {
  _.isError(o_O);
}
=> true

isSymbol

_.isSymbol(object) source

Returns true if object is a Symbol.

_.isSymbol(Symbol());
=> true

isMap

_.isMap(object) source

Returns true if object is a Map.

_.isMap(new Map());
=> true

isWeakMap

_.isWeakMap(object) source

Returns true if object is a WeakMap.

_.isWeakMap(new WeakMap());
=> true

isSet

_.isSet(object) source

Returns true if object is a Set.

_.isSet(new Set());
=> true

isWeakSet

_.isWeakSet(object) source

Returns true if object is a WeakSet.

_.isWeakSet(WeakSet());
=> true

isArrayBuffer

_.isArrayBuffer(object) source

Returns true if object is an ArrayBuffer.

_.isArrayBuffer(new ArrayBuffer(8));
=> true

isDataView

_.isDataView(object) source

Returns true if object is a DataView.

_.isDataView(new DataView(new ArrayBuffer(8)));
=> true

isTypedArray

_.isTypedArray(object) source

Returns true if object is a TypedArray.

_.isTypedArray(new Int8Array(8));
=> true

isNaN

_.isNaN(object) source

Returns true if object is NaN.

Note: this is not the same as the native isNaN function, which will also return true for many other not-number values, such as undefined.

_.isNaN(NaN);
=> true
isNaN(undefined);
=> true
_.isNaN(undefined);
=> false

isNull

_.isNull(object) source

Returns true if the value of object is null.

_.isNull(null);
=> true
_.isNull(undefined);
=> false

isUndefined

_.isUndefined(value) source

Returns true if value is undefined.

_.isUndefined(window.missingVariable);
=> true