Lodash 中文文档 打开开发者工具，可以直接在控制台调试。

之前提到Object，我首先想到的是 {age:18,sex:'0'}这种形式，在loadsh中， {age:18,sex:'0'} 更贴近Collection,而Object中的函数对Function处理较多

-3 _.has(object, path)

检查 path 是否是object对象的直接属性。

var object = { 'a': { 'b': 2 } };
var other = _.create({ 'a': _.create({ 'b': 2 }) });
 
_.has(object, 'a');
// => true
 
_.has(object, 'a.b');
// => true
 
_.has(object, ['a', 'b']);
// => true
 
_.has(other, 'a');
// => false

_.hasIn 检查 path 是否是object对象的直接或继承属性。

-2 .transform(object, [iteratee=.identity], [accumulator])

_.reduce的替代方法;此方法将转换object对象为一个新的accumulator对象，结果来自iteratee处理自身可枚举的属性。 每次调用可能会改变 accumulator 对象。如果不提供accumulator，将使用与[[Prototype]]相同的新对象。iteratee调用4个参数：(accumulator, value, key, object)。如果返回 false，iteratee 会提前退出。

_.transform([2, 3, 4], function(result, n) {
  result.push(n *= n);
  return n % 2 == 0;
}, []);
// => [4, 9]
 
_.transform({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) {
  (result[value] || (result[value] = [])).push(key);
}, {});
// => { '1': ['a', 'c'], '2': ['b'] }

-1 _.defaults(object, [sources])

分配来源对象的可枚举属性到目标对象所有解析为 undefined 的属性上。 来源对象从左到右应用。 一旦设置了相同属性的值，后续的将被忽略掉。

注意: 这方法会改变 object.

_.defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });
// => { 'a': 1, 'b': 2 }

_.defaultsDeep 个方法类似 _.defaults，除了它会递归分配默认属性。

0 _.get(object, path, [defaultValue])

对于后台返回数据的取值可以简化许多，可以防止一些属性没有导致的报错，还可以设置默认值

根据 object对象的path路径获取值。 如果解析 value 是 undefined 会以 defaultValue 取代。

var object = { 'a': [{ 'b': { 'c': 3 } }] };
 
_.get(object, 'a[0].b.c');
// => 3
 
_.get(object, ['a', '0', 'b', 'c']);
// => 3
 
_.get(object, 'a.b.c', 'default');
// => 'default'

1 _.at(object, [paths])

对于后台返回数据的取值可以简化许多，可以防止一些属性没有导致的报错。

创建一个数组，值来自 object 的paths路径相应的值。

.at([{age:'19'}],"0.age");
// ["19"]



_.at([{age:'19'}],"0.name.age");
// [undefined]

_.at([{age:'19'}],"0.name.age","0.age");
// (2) [undefined, "19"]

3 _.set(object, path, value)

设置 object对象中对应 path 属性路径上的值，如果path不存在，则创建。 缺少的索引属性会创建为数组，而缺少的属性会创建为对象。

_.set({}, 'a[0].b.c', 4);
// {a:[{b:{c:4}}]}

var object = { 'a': [{ 'b': { 'c': 3 } }] };
 
_.set(object, 'a[0].b.c', 4);
console.log(object.a[0].b.c);
// => 4
 
_.set(object, ['x', '0', 'y', 'z'], 5);
console.log(object.x[0].y.z);
// => 5

_.setWith 接受一个 customizer，调用生成对象的 path

4 _.unset(object, path)

移除object对象 path 路径上的属性。

var object = { 'a': [{ 'b': { 'c': 7 } }] };
_.unset(object, 'a[0].b.c');
// => true
 
console.log(object);
// => { 'a': [{ 'b': {} }] };
 
_.unset(object, ['a', '0', 'b', 'c']);
// => true
 
console.log(object);
// => { 'a': [{ 'b': {} }] };

5 _.update(object, path, updater)

该方法类似 _.set，除了接受updater以生成要设置的值。

var object = { 'a': [{ 'b': { 'c': 3 } }] };
 
_.update(object, 'a[0].b.c', function(n) { return n * n; });
console.log(object.a[0].b.c);
// => 9
 
_.update(object, 'x[0].y.z', function(n) { return n ? n + 1 : 0; });
console.log(object.x[0].y.z);
// => 0

_.updateWith 它接受customizer，调用来生成新的对象的path

6 .findKey(object, [predicate=.identity])

这个方法类似 _.find 。 除了它返回最先被 predicate 判断为真值的元素 key，而不是元素本身

var users = {
  'barney':  { 'age': 36, 'active': true },
  'fred':    { 'age': 40, 'active': false },
  'pebbles': { 'age': 1,  'active': true }
};
 
_.findKey(users, function(o) { return o.age < 40; });
// => 'barney' (iteration order is not guaranteed)
 
// The `_.matches` iteratee shorthand.
_.findKey(users, { 'age': 1, 'active': true });
// => 'pebbles'
 
// The `_.matchesProperty` iteratee shorthand.
_.findKey(users, ['active', false]);
// => 'fred'
 
// The `_.property` iteratee shorthand.
_.findKey(users, 'active');
// => 'barney'

_.findLastKey 这个方法类似 _.findKey。 不过它是反方向开始遍历的。

7 .forOwn(object, [iteratee=.identity])

使用 iteratee 遍历自身的可枚举属性。 iteratee 会传入3个参数：(value, key, object)。 如果返回 false，iteratee 会提前退出遍历。

function Foo() {
  this.a = 1;
  this.b = 2;
}
 
Foo.prototype.c = 3;
 
_.forOwn(new Foo, function(value, key) {
  console.log(key);
});
// => 输出 'a' 然后 'b' (无法保证遍历的顺序)。

_.forOwnRight 这个方法类似 _.forOwn。 除了它是反方向开始遍历object的。
_.forIn 使用 iteratee 遍历对象的自身和继承的可枚举属性
_.forInRight 这个方法类似 _.forOwn。 除了它是反方向开始遍历object的。

8 _.values(object)

相比与原生的方法增强了一些，比如可以遍历函数上的属性，貌似比较边缘

创建 object 自身可枚举属性的值为数组。

function Foo() {
  this.a = 1;
  this.b = 2;
}
 
 
Foo.prototype.c = 3;
 
_.values(new Foo);
// => [1, 2] (无法保证遍历的顺序)
 
_.values('hi');
// => ['h', 'i']

_.valuesIn 创建 object 自身和继承的可枚举属性的值为数组
_.keys 创建一个 object 的自身可枚举属性名为数组。
_.keysIn 创建一个 object 自身 和 继承的可枚举属性名为数组。

9 .mapValues(object, [iteratee=.identity])

创建一个对象，这个对象的key与object对象相同，值是通过 iteratee 运行 object 中每个自身可枚举属性名字符串产生的

var users = {
  'fred':    { 'user': 'fred',    'age': 40 },
  'pebbles': { 'user': 'pebbles', 'age': 1 }
};
 
_.mapValues(users, function(o) { return o.age; });
// => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)
 
// The `_.property` iteratee shorthand.
_.mapValues(users, 'age');
// => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)

10 .mapKeys(object, [iteratee=.identity])

这个方法创建一个对象，对象的值与object相同，并且 key 是通过 iteratee 运行 object 中每个自身可枚举属性名字符串 产生的

_.mapKeys({ 'a': 1, 'b': 2 }, function(value, key) {
  return key + value;
});
// => { 'a1': 1, 'b2': 2 }

11 _.invert(object)

创建一个object键值倒置后的对象。 如果 object 有重复的值，后面的值会覆盖前面的值。

var object = { 'a': 1, 'b': 2, 'c': 1 };
 
_.invert(object);
// => { '1': 'c', '2': 'b' }

_.invertBy 这个方法类似 _.invert，除了倒置对象 是 collection（集合）中的每个元素经过 iteratee（迭代函数） 处理后返回的结果。每个反转键相应反转的值是一个负责生成反转值key的数组。iteratee 会传入3个参数：(value) 。

12 _.assign(object, [sources])

注意: 这方法会改变 object，参考自 Object.assign.

分配来源对象的可枚举属性到目标对象上。 来源对象的应用规则是从左到右，随后的下一个对象的属性会覆盖上一个对象的属性。

function Foo() {
  this.a = 1;
}
 
function Bar() {
  this.c = 3;
}
 
Foo.prototype.b = 2;
Bar.prototype.d = 4;
 
_.assign({ 'a': 0 }, new Foo, new Bar);
// => { 'a': 1, 'c': 3 }

_.assignWith 除了它接受一个 customizer 决定如何分配值
_.assignIn 这个方法类似 _.assign， 除了它会遍历并继承来源对象的属性。
_.assignInWith 接受一 个 customizer ，被调用以产生所分配的值

13 _.merge(object, [sources])

该方法类似 _.assign， 除了它递归合
并 sources 来源对象自身和继承的可枚举属性到 object 目标对象。如果目标值存在，被解析为undefined的sources 来源对象属性将被跳过。数组和普通对象会递归合并，其他对象和值会被直接分配覆盖。源对象从从左到右分配。后续的来源对象属性会覆盖之前分配的属性。

var object = {
  'a': [{ 'b': 2 }, { 'd': 4 }]
};
 
var other = {
  'a': [{ 'c': 3 }, { 'e': 5 }]
};
 
_.merge(object, other);
// => { 'a': [{ 'b': 2, 'c': 3 }, { 'd': 4, 'e': 5 }] }

_.mergeWith 接受一个 customizer，调用以产生目标对象和来源对象属性的合并值。

14 _.pick(object, [props])

创建一个从 object 中选中的属性的对象。

var object = { 'a': 1, 'b': '2', 'c': 3 };
 
_.pick(object, ['a', 'c']);
// => { 'a': 1, 'c': 3 }

_.pickBy .pickBy(object, [predicate=.identity])

15 _.omit(object, [props])

这个对象由忽略属性之外的object自身和继承的可枚举属性组成。（可以理解为删除object对象的属性）。

var object = { 'a': 1, 'b': '2', 'c': 3 };
 
_.omit(object, ['a', 'c']);
// => { 'b': '2' }

_.omitBy 这个对象忽略 predicate（断言函数）判断不是真值的属性后，object自身和继承的可枚举属性组

16 _.toPairs(object)

创建一个object对象自身可枚举属性的键值对数组

function Foo() {
  this.a = 1;
  this.b = 2;
}
 
Foo.prototype.c = 3;
 
_.toPairs(new Foo);
// => [['a', 1], ['b', 2]] (iteration order is not guaranteed)

_.toPairsIn 创建一个object对象自身和继承的可枚举属性的键值对数组

17 _.functions(object)

创建一个函数属性名称的数组，函数属性名称来自object对象自身可枚举属性。

function Foo() {
  this.a = _.constant('a');
  this.b = _.constant('b');
}
 
Foo.prototype.c = _.constant('c');
 
_.functions(new Foo);
// => ['a', 'b']

_.functionsIn 创建一个函数属性名称的数组，函数属性名称来自object对象自身可枚举属性。

未提及的函数有:
_.create 创建一个继承 prototype 的对象。 如果提供了 prototype，它的可枚举属性会被分配到创建的对象上。
_.result 这个方法类似 _.get， 除了如果解析到的值是一个函数的话，就绑定 this 到这个函数并返回执行后的结果。