Object

keys

_.keys(object)

检索对象自己可枚举属性的所有名称。

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

allKeys

_.allKeys(object)

检索对象自己的和继承的属性的所有名称。

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

值

_.values(object)

返回对象自己属性的所有值。

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

mapObject

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

像地图一样，但是用于对象。依次转换每个属性的值。

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

pairs

_.pairs(object)

将对象转换为键值对的列表。

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

invert

_.invert(object)

返回键成为键值的对象的副本。为此，所有对象的值都应该是唯一的，并且是可串行化的。

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

create

_.create(prototype, props)

用给定的原型创建一个新对象，可选地将道具作为自己的属性。基本上，Object.create，但没有所有的属性描述符爵士乐。

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

函数

_.functions(object) Alias: methods

返回对象中每个方法的名称的排序列表 - 也就是说，该对象的每个函数属性的名称。

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

findKey

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

与_.findIndex类似，但是用于对象中的键。返回键在断言真相测试通过或不确定。

extend_.extend(destination, *sources)

将源对象中的所有属性复制到目标对象，然后返回目标对象。它是有序的，所以最后一个源将在先前的参数中覆盖相同名称的属性。

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

extendOwn

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

像扩展一样，但只将自己的属性复制到目标对象。

pick_.pick(object, *keys)

返回对象的副本，过滤为只有已列入白名单的键（或有效键数组）的值。或者接受一个谓词，指出要选择哪些键。

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

返回对象的副本，过滤以省略黑名单键（或键列数组）。或者接受一个谓词，指出要省略哪些键。

_.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(object, *defaults)

使用以下默认对象列表中的第一个值填充对象中未定义的属性。

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

clone

_.clone(object)

创建提供的普通 对象的浅拷贝克隆。任何嵌套的对象或数组将被引用复制，而不是重复。

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

tap

_.tap(object, interceptor)

用对象调用拦截器，然后返回对象。该方法的主要目的是“挖掘”方法链，以便对链中的中间结果执行操作。

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

has

_.has(object, key)

对象是否包含给定的键？与object.hasOwnProperty（key）相同，但对hasOwnProperty函数使用安全引用，以防意外覆盖。

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

property

_.property(key)

返回一个函数，它本身将返回任何传入对象的key属性。

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

propertyOf

_.propertyOf(object)

_.property的反转。接受一个对象并返回一个函数，该函数将返回提供的属性的值。

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

matcher

_.matcher(attrs) Alias: matches

返回一个谓词函数，它会告诉您传入的对象是否包含attrs中存在的所有键/值属性。

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

isEqual

_.isEqual(object, other)

执行两个对象之间的优化深度比较，以确定它们是否应该被视为相等。

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)

告诉你属性中的键和值是否包含在对象中。

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

isEmpty

_.isEmpty(object)

如果可枚举对象不包含任何值（不可枚举自己的属性），则返回true。对于字符串和类似数组的对象，_.isEmpty检查length属性是否为0。

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

isElement

_.isElement(object)

如果object是一个DOM元素，则返回true。

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

isArray

_.isArray(object)

如果object是一个Array，则返回true。

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

isObject

_.isObject(value)

如果value是一个Object，则返回true。请注意，JavaScript数组和函数是对象，而（普通）字符串和数字则不是。

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

isArguments

_.isArguments(object)

如果object是一个Arguments对象，则返回true。

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

isFunction

_.isFunction(object)

如果object是一个Function，则返回true。

_.isFunction(alert);
=> true

isString

_.isString(object)

如果object是一个String，则返回true。

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

isNumber

_.isNumber(object)

如果 object 是一个 Number（包括NaN），则返回true。

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

isFinite

_.isFinite(object)

如果对象是有限数字，则返回 true。

_.isFinite(-101);
=> true

_.isFinite(-Infinity);
=> false

isBoolean

_.isBoolean(object)

如果object为true或false，则返回true。

_.isBoolean(null);
=> false

isDate

_.isDate(object)

如果object是Date，则返回true。

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

isRegExp

_.isRegExp(object)

如果对象是RegExp，则返回true。

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

isError

_.isError(object)

如果对象从Error继承，则返回true。

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

isNaN

_.isNaN(object)

如果对象是NaN，则返回true。

注意：这与本地 isNaN 函数不同，它也会为许多其他非数值（例如未定义）返回true。

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

isNull

_.isNull(object)

如果object的值为null，则返回true。

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

isUndefined

_.isUndefined(value)

返回真，如果值是不确定的。

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