Loadash 让你的代码更简单-对象篇（二）

用户3377781622124
484 阅读5分钟

Loadash 对象篇（二） 文档：www.lodashjs.com/docs/lodash…

_.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.b.c', 'default');
// => 'default'

_.has(object, path) 检查 path 是否是object对象的直接属性，返回boolean值

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(object, path) 类似_.has(object, path)，检查 path 是否是object对象的直接或继承属性

_.invert(object) 返回一个object键值倒置后的对象（键、值位置互换），出现重复的值后者覆盖前者

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

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

_.invertBy(object, [iteratee=_.identity])类似_.invert,键值身份转换，数组包裹值，相同键合并到同一数组中；iteratee迭代函数中可以处理返回新结果

var object = { 'a': 1, 'b': 2, 'c': 1 };
 
_.invertBy(object);
// => { '1': ['a', 'c'], '2': ['b'] }
 
_.invertBy(object, function(value) {
  return 'group' + value;
});
// => { 'group1': ['a', 'c'], 'group2': ['b'] }

_.invoke(object, path, [args])调用object对象path上的方法,

var object = { 'a': [{ 'b': { 'c': [1, 2, 3, 4] } }] };
 
_.invoke(object, 'a[0].b.c.slice', 1, 3);
// => [2, 3]
console.log(invoke(object, 'a[0].b.c.indexOf', 3));
// => 2

_.keys(object)返回一个 object 的自身可枚举属性名为数组，object若为非对象会被强制转换为对象

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

_.keysIn(object) 类似_.keys（），自身和继承属性都会返回(数组)

_.mapValues(object, [iteratee=_.identity]) 返回一个对象，key与object的key相同，value通过迭代函数赋予。(结合mapKeys()学习)

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)

_.mapKeys(object, [iteratee=_.identity]) 反向版_.mapValues。 返回一个对象，对象的值与object相同，key通过迭代函数赋予

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

_.merge(object, [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 }] }

var other2 = {
  'a': [{ 'b': 3 }, { 'd': 5 }]
};
_.merge(object, other2);
// console.log({ 'a': [{ 'b': 3 }, { 'd': 5 }] })

mergeWith(object, sources, customizer)类似_.merge，多接受一个参数 customizer，调用以产生目标对象和来源对象属性的合并值。如果customizer 返回 undefined，将会由合并处理方法代替。customizer调用与7个参数： (objValue, srcValue, key, object, source, stack) 。

function customizer(objValue, srcValue) {
  if (_.isArray(objValue)) {
    return objValue.concat(srcValue);
  }
}
 
var object = { 'a': [1], 'b': [2] };
var other = { 'a': [3], 'b': [4] };
 
_.mergeWith(object, other, customizer);
// => { 'a': [1, 3], 'b': [2, 4] }

_.pick(object, [props])返回一个从 object 中选中的属性的对象。

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

_.pickBy(object, [predicate=_.identity])创建一个对象，这个对象组成为从 object 中经 predicate 判断为真值的属性。 predicate调用2个参数： (value, key) 。

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

_.omit(object, [props])反向版_.pick; 这个方法一个对象，这个对象由忽略属性之外的object自身和继承的可枚举属性组成。（注：可以理解为删除object对象的属性）。

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

_.omitBy(object, [predicate=_.identity])反向版_.pickBy；这个对象忽略 predicate（断言函数）判断不是真值的属性后，object自身和继承的可枚举属性组成。predicate调用与2个参数： (value, key) 。

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

_.result(object, path, [defaultValue])​这个方法类似_.get， 除了如果解析到的值是一个函数的话，就绑定 this 到这个函数并返回执行后的结果

var object = { 'a': [{ 'b': { 'c1': 3, 'c2': _.constant(4) } }] };
 
_.result(object, 'a[0].b.c1');
// => 3
 
_.result(object, 'a[0].b.c2');
// => 4
 
_.result(object, 'a[0].b.c3', 'default');
// => 'default'
 
_.result(object, 'a[0].b.c3', _.constant('default'));
// => 'default'

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

path: (Array|string) : 要设置的对象路径

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(object, path, value, [customizer])似_.set，除了它接受一个 customizer，调用生成对象的 path。 如果 customizer 返回 undefined 将会有它的处理方法代替。 customizer 调用3个参数：  (nsValue, key, nsObject) 。

var object = {};
 
_.setWith(object, '[0][1]', 'a', Object);
// => { '0': { '1': 'a' } }

_.toPairs(object)​创建一个object对象自身可枚举属性的键值对数组。这个数组可以通过_.fromPairs撤回。如果object 是 map 或 set，返回其条目。

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)​生成一个object对象自身和继承的可枚举属性的键值对数组。这个数组可以通过_.fromPairs撤回。如果object 是 map 或 set，返回其条目。

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

_.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': {} }] };

_.update(object, path, updater)​该方法类似_.set，除了接受updater以生成要设置的值。使用_.updateWith来自定义生成的新path。updater调用1个参数： (value) 。

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(object, path, updater, [customizer])​该方法类似_.update，不同之处在于它接受customizer，调用来生成新的对象的path。如果customizer返回undefined，路径创建由该方法代替。customizer调用有三个参数： (nsValue, key, nsObject)  。

var object = {};
 
_.updateWith(object, '[0][1]', _.constant('a'), Object);
// => { '0': { '1': 'a' } }

_.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)​创建 object 自身和继承的可枚举属性的值为数组

function Foo() {
  this.a = 1;
  this.b = 2;
}
 
Foo.prototype.c = 3;
 
_.valuesIn(new Foo);
// => [1, 2, 3] (无法保证遍历的顺序)
avatar
文章
阅读
粉丝