lodash

1._.map(collection, [iteratee=_.identity])：创建一个经过 iteratee 处理的集合中每一个元素的结果数组。 iteratee 会传入3个参数：(value, index|key, collection),返回处理过后的新数组

function square(n) {
  return n * n;
}

_.map([4, 8], square);
// => [16, 64]

_.map({ 'a': 4, 'b': 8 }, square);
// => [16, 64] (无法保证遍历的顺序)

var users = [
  { 'user': 'barney' },
  { 'user': 'fred' }
];

// 使用了 `_.property` 的回调结果
_.map(users, 'user');
// => ['barney', 'fred']

2.lodash.reduce(collection, [iteratee=_.identity], [accumulator])：通过 iteratee 遍历集合中的每个元素。 每次返回的值会作为下一次 iteratee 使用，返回累加后的值。

_.reduce([1, 2], function(sum, n) {
  return sum + n;
}, 0);
// => 3



const arr = [{status: 1, optTime: '2019-10-22'}, {status: 2, optTime: '2019-10-23'}, {status: 3, optTime: '2019-10-24'}];
        const result = _.reduce(arr, (meno, {status, optTime}) => {
            console.log('meno', meno) 
            // {} -> {1: '2019-10-22'} -> {1: '2019-10-22', 2: '2019-10-23'} -> {1: "2019-10-22", 2: "2019-10-23", 3: '2019-10-24'}
            meno[status] = optTime;
            return meno;
        }, {});
        console.log(result);
        // {1: "2019-10-22", 2: "2019-10-23", 3: "2019-10-24"}

3.lodash.isArray(value)：检查 value 是否是 Array 类对象,返回true或者false

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

_.isArray('abc')

// => false

4.lodash.find(collection, [predicate=_.identity])：遍历集合中的元素，返回最先经 predicate 检查为真值的元素。 predicate 会传入3个元素：(value, index|key, collection)。返回匹配元素，否则返回 undefined

 const arr = [1, 2];
 const statusArray = {1: 'mon', 2: 'key'};
 const result = _.find(arr, s => {
    return statusArray[s];
 });
 console.log(result); // 1
 console.log(statusArray[result]) // mon




 const users = [
  { 'user': 'barney',  'age': 36, 'active': true },
  { 'user': 'fred',    'age': 40, 'active': false },
  { 'user': 'pebbles', 'age': 1,  'active': true }
];

const result = _.find(users, function(o) { return o.age < 40; });

console.log(result) // {user: "barney", age: 36, active: true}

5.lodash.some(collection, [predicate=_.identity])：通过 predicate 检查集合中的元素是否存在任意真值的元素，只要 predicate 返回一次真值，遍历就停止，并返回 true。 predicate 会传入3个参数：(value, index|key, collection)。

_.some([null, 0, 'yes', false], Boolean);
// => true

var users = [
  { 'user': 'barney', 'active': true },
  { 'user': 'fred',   'active': false }
];

_.some(users, { 'user': 'barney', 'active': false });
// => false

6.lodash.sortBy(collection, [iteratees=[_.identity]])：创建一个元素数组。 以 iteratee 处理的结果升序排序。 这个方法执行稳定排序，也就是说相同元素会保持原始排序。 iteratees 会传入1个参数：(value) 返回排序后的数组

const a = [
    {name: 'd', age: 2},
    {name: 'a', age: 2},
    {name: 'a', age: 1},
    {name: 'b', age: 1},
    ]
    console.log(_.sortBy(a, o => {
        return o.name;
    }))

// => [
//{name: "a", age: 2},
//{name: "a", age: 1},
//{name: "b", age: 1},
//{name: "d", age: 2}
// ]