Lodash 常用方法

Array

.compact(array)

创建一个新数组，包含原数组中所有的非假值元素。例如false, null, 0, "", undefined, 和NaN都是被认为是“假值”。
不修改原数组，返回过滤掉假值的新数组。

_.difference(array, [values])

创建一个新数组，这个数组中的值，为第一个参数排除了给定数组中的值。结果值的顺序是由第一个数组中的顺序确定。
不像 _.pullAll，该方法不修改原数组，返回一个过滤值后的新数组。

_.difference([2, 1], [2, 3]);
// => [1]

_.union([arrays])

数组的并集，按顺序返回，返回数组的元素是唯一的。
返回一个新的联合数组。

_.union([2], [1, 2]);
// => [2, 1]

_.uniq(array)

创建一个去重后的数组副本（注：即数组去重）。
不修改原数组，返回新的去重后的数组。

**_.uniq([2, 1, 2]);**
// => [2, 1]

_.zip([arrays])

创建一个分组元素的数组，数组的第一个元素包含所有给定数组的第一个元素，数组的第二个元素包含所有给定数组的第二个元素，以此类推（注：即数组转置）。
返回分组元素的新数组。

_.zip(['fred', 'barney'], [30, 40], [true, false]);
// => [['fred', 30, true], ['barney', 40, false]]

_.zipObject([props=[]], [values=[]])

它接受2个数组，第一个数组中的值作为属性名，第二个数组中的值作为相应的属性值（注：即将两个数组用键值对关联）。
返回一个新的对象。

_.zipObject(['a', 'b'], [1, 2]);
// => { 'a': 1, 'b': 2 }

_.last(array)
获取数组中最后一个元素

let arr = [1, 2, 3, 4, 5]
let lastElement = _.last(arr) 
console.log(lastElement) // 5

Object

_.pick(object, [props])

创建一个从 object 中选中的属性的对象。
var object = { 'a': 1, 'b': '2', 'c': 3 }; 
_.pick(object, ['a', 'c']);
// => { 'a': 1, 'c': 3 }

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

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

Collection (Array|Object)

.filter(collection, [predicate=.identity])
遍历 collection（集合）元素，返回 predicate（断言函数）返回真值 的所有元素的数组。 predicate（断言函数）调用三个参数：(value, index|key, collection)。

var users = [
  { 'user': 'barney', 'age': 36, 'active': true },
  { 'user': 'fred',   'age': 40, 'active': false }
]; 
_.filter(users, function(o) { return !o.active; });
// => objects for ['fred'] 
// The `_.matches` iteratee shorthand.
_.filter(users, { 'age': 36, 'active': true });
// => objects for ['barney'] 
// The `_.matchesProperty` iteratee shorthand.
_.filter(users, ['active', false]);
// => objects for ['fred'] 
// The `_.property` iteratee shorthand.
_.filter(users, 'active');
// => objects for ['barney']

_.groupBy(collection, [iteratee=*.identity])

创建一个集合对象，对象的键是经过迭代函数（iteratee）执行处理集合中每个元素后返回的结果，每个键对应的值负责生成键的元素组成的数组。
返回一个新的集合对象。

_.groupBy([6.1, 4.2, 6.3], Math.floor);
// => { '4': [4.2], '6': [6.1, 6.3] }

// The `_.property` iteratee shorthand.
_.groupBy(['one', 'two', 'three'], 'length');
// => { '3': ['one', 'two'], '5': ['three'] }

_.orderBy(collection, [iteratees=[*.identity]], [orders])

对集合通过迭代函数来进行排序，若没指定orders，所有值以升序排序。 否则，指定为desc 降序，或者指定为asc升序。
返回排序后的新数组。

var users = [
  { 'user': 'fred',   'age': 48 },
  { 'user': 'barney', 'age': 34 },
  { 'user': 'fred',   'age': 40 },
  { 'user': 'barney', 'age': 36 }
];

// 以 `user` 升序排序 再  `age` 以降序排序。
_.orderBy(users, ['user', 'age'], ['asc', 'desc']);
// => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]]

Function

_.once(func)
创建一个只能调用 func 一次的函数。 重复调用返回第一次调用的结果。 func 调用时， this 绑定到创建的函数，并传入对应参数。

var initialize = _.once(createApplication);
initialize();
initialize();
// => `createApplication` is invoked once

_.throttle(func, [wait=0], [options={}])
创建一个节流函数，在 wait 秒内最多执行 func 一次的函数。

// 避免在滚动时过分的更新定位
jQuery(window).on('scroll', _.throttle(updatePosition, 100));

// 点击后就调用 `renewToken`，但5分钟内超过1次。
var throttled = _.throttle(renewToken, 300000, { 'trailing': false });
jQuery(element).on('click', throttled);

// 取消一个 trailing 的节流调用。
jQuery(window).on('popstate', throttled.cancel);

_.wrap(value, [wrapper=identity])
创建一个函数。提供的 value 包装在 wrapper 函数的第一个参数里。 任何附加的参数都提供给 wrapper 函数。 被调用时 this 绑定在创建的函数上。

var p = _.wrap(_.escape, function(func, text) {
  return '<p>' + func(text) + '</p>';
});

p('fred, barney, & pebbles');
// => '<p>fred, barney, &amp; pebbles</p>'