Underscore.JS-处理集合

Underscore.JS是一个JavaScript实用库，提供了一系列函数来帮助我们简化开发过程中的操作，尤其是针对集合数据类型的处理操作。

集合操作

Underscore.JS提供了一系列用于处理集合数据类型的函数，包括数组、对象等。下面来介绍一些常用的函数。

each

_.each(list, iteratee, [context])

each函数用来遍历集合中的每一项，对于每一项都会执行iteratee函数。其中，list是集合，iteratee是函数，在每一项上执行。我们可以为iteratee传递三个参数：元素值，元素索引，集合本身。

_.each([1, 2, 3], function(num, index, list){
  console.log(num, index, list);
});

// output:
// 1 0 [1, 2, 3]
// 2 1 [1, 2, 3]
// 3 2 [1, 2, 3]

map

_.map(list, iteratee, [context])

map函数用来遍历集合中的每一个元素，并将它们转换为一个新的值。其中，list是集合，iteratee是函数，在每一项上执行。同样，我们可以为iteratee传递三个参数：元素值，元素索引，集合本身。

var nums = _.map([1, 2, 3], function(num){
  return num * 3;
});

console.log(nums); // output: [3, 6, 9]

find

_.find(list, predicate, [context])

find函数用来在集合中查找匹配的项，并返回该项。其中，list是集合，predicate是一个函数，用来检测每一项是否符合条件。函数每次执行，会接收三个参数：元素值，元素索引，集合本身。

var pets = [
  {name: 'cat', type: 'feline'},
  {name: 'dog', type: 'canine'},
  {name: 'elephant', type: 'mammal'},
  {name: 'monkey', type: 'primate'}
];

var canine = _.find(pets, function(pet){
  return pet.type === 'canine';
});

console.log(canine); 

// output:
// {name: 'dog', type: 'canine'}

filter

_.filter(list, predicate, [context])

filter函数用于筛选集合中符合条件的元素。其中，list是集合，predicate是一个函数，用来检测每一项是否符合条件。函数每次执行，会接收三个参数：元素值，元素索引，集合本身。

var pets = [
  {name: 'cat', type: 'feline'},
  {name: 'dog', type: 'canine'},
  {name: 'elephant', type: 'mammal'},
  {name: 'monkey', type: 'primate'}
];

var mammals = _.filter(pets, function(pet){
  return pet.type === 'mammal';
});

console.log(mammals); 

// output:
// [{name: 'elephant', type: 'mammal'}]

reduce

_.reduce(list, iteratee, [memo], [context])

reduce函数用于将集合中的元素归纳为单个值。其中，list是集合，iteratee是一个函数，用于处理每一个元素，memo则是处理的初始值。每次执行，iteratee函数会接收三个参数：memo、元素值、元素索引。

var nums = [1, 2, 3];

var sum = _.reduce(nums, function(memo, num){
  return memo + num;
}, 0);

console.log(sum); // output: 6

invoke

_.invoke(list, methodName, *arguments)

invoke函数用于调用集合中每个元素的指定方法。其中，list是集合，methodName是方法名，*arguments则是要传递的参数。

var nums = [[5, 1, 7], [4, 3, 6]];

var max = _.invoke(nums, 'max');

console.log(max); // output: [7, 6]

sortBy

_.sortBy(list, iteratee, [context])

sortBy函数用于将集合中的元素按指定规则排列。其中，list是集合，iteratee是一个函数，用于获取参与排序的值，context则是该函数的执行上下文。

var pets = [
  {name: 'cat'},
  {name: 'dog'},
  {name: 'elephant'},
  {name: 'monkey'}
];

var sorted = _.sortBy(pets, function(pet){
  return pet.name;
});

console.log(sorted);
// output:
// [{name: 'cat'}, {name: 'dog'}, {name: 'elephant'}, {name: 'monkey'}]

groupBy

_.groupBy(list, iteratee, [context])

groupBy函数用于将集合中的元素按指定规则分组。其中，list是集合，iteratee是一个函数，用于获取参与分组的值，context则是该函数的执行上下文。

var pets = [
  {name: 'cat', type: 'feline'},
  {name: 'dog', type: 'canine'},
  {name: 'elephant', type: 'mammal'},
  {name: 'monkey', type: 'primate'}
];

var groupType = _.groupBy(pets, function(pet){
  return pet.type;
});

console.log(groupType); 

// output:
// {
//   'feline': [{name: 'cat', type: 'feline'}], 
//   'canine': [{name: 'dog', type: 'canine'}], 
//   'mammal': [{name: 'elephant', type: 'mammal'}], 
//   'primate': [{name: 'monkey', type: 'primate'}]
// }

总结

Underscore.JS提供了一系列用于处理集合数据类型的函数，它们可以使我们的开发工作更加高效，代码更加简洁。以上函数仅仅是其中的一部分，更多函数可以参考Underscore.JS官方文档，相信你会有更多的收获。