标签：
Lodash用来操作对象和集合，比Underscore拥有更多的功能和更好的性能。
官网：https://lodash.com/
引用：<script src="//cdnjs.cloudflare.com/ajax/libs/lodash.js/2.4.1/lodash.min.js"></script>
安装：npm install lodash
首先通过npm安装lodash:
npm i --save lodash
在js文件中引用lodash:
var _ = require(‘lodash‘);
■ 遍历
【forEach】
_.forEach(collection, function(name){}); _.forEach(collection, function(name, index){})
■ 字符串排序
【sortBy】
【排序，字段字符串】
var strSortResult = _.sortBy(‘cda‘).join(‘ ‘); console.log(strSortResult);
■ 根据数组元素的某个字段排序
● 在匿名函数中声明排序字段
【sortBy】
【排序，匿名函数】
var arr = [ {name: ‘aa‘,age:22}, {name: ‘bb‘,age:23} ]; var arrSortResult = _.sortBy(arr, function(item){ return item.name; }) _.forEach(arrSortResult, function(item){ console.log(item.name); });
● 通过字符串声明排序字段
_.sortBy(arr, ‘name‘);
● 通过字符串数组声明排序字段
【sortBy】
【排序，字段字符串数组】
_.sortBy(arr, [‘name‘,‘age‘]);
■ 向一个集合中插入某个元素而不改变固有的顺序
【sortedIndex】
var collection = [‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘f‘]; console.log(‘before: ‘ + collection.join(‘ ‘)); //要插入的值 var toBeInserted = ‘e‘; //要插入值再数组中的索引 var sortedIndex = _.sortedIndex(collection, toBeInserted); //插入 splice中数组的指定索引位置插入元素，0表示有0个元数组元素删除 collection.splice(sortedIndex, 0, toBeInserted); console.log(‘after：‘ + collection.join(‘ ‘));
■ 通过where方法过滤集合，传入对象
【where】
var collection1 = [ {name: ‘aa‘, age:20, gender: ‘m‘}, {name: ‘bb‘, age:21, gender: ‘f‘}, {name: ‘cc‘, age:22, gender: ‘m‘} ]; var result1 = _.where(collection1, {age:20, gender:‘m‘}); _.forEach(result1, function(item){ console.log(item.name); });
■ 通过filter方法过滤集合，传入字符串
【filter】
【过滤，字段字符串】
var collection2=[ {name: ‘aa‘, enabled: false}, {name:‘bb‘, enabled:true} ]; var result2 = _.filter(collection2, ‘enabled‘); _.forEach(result2, function(item){ console.log(item.name); });
■ 通过filter方法过滤集合，传入匿名函数
【filter】
【过滤，匿名函数】
var collection3 = [ {name: ‘aa‘, size: ‘L‘}, {name: ‘bb‘, size: ‘M‘} ]; var result3 = _.filter(collection3, function(item){ return item.size === ‘L‘; }); _.forEach(result3, function(item){ console.log(item.name); });
■ 通过reject方法过滤到不需要的集合元素，传入对象
【reject】
【过滤不要的，过滤条件为对象】
var collection4 = [ {name:‘soccer‘, enabled: true}, {name: ‘basketball‘, enabled: false} ]; var result4 = _.reject(collection4,{enabled:false}); _.forEach(result4, function(item){ console.log(item.name); });
■ 找到特定的元素
【find, findLast】
【搜寻，过滤条件为对象】
//只要找打一个就返回结果 _.find(collection, {age:20}); _.findLast(collection,{age:20});
■ 从前到后从数组中获取一些
【take】
【数组，获取一些】
var array = []; _.take(array, 2);
■ 从前到后从字符串中获取一些
【take】
【字符串，获取一些】
_.take(‘hello‘,2).join(‘ ‘);
■ 从后到前从数组中获取一些
【takeRight】
【数组，获取一些，从后面开始】
var arr = []; _.takeRight(array, 2);
■ 从后到前从字符串中获取一些
【takeRight】
【字符串，获取一些，从后面开始】
_.takeRight(‘hello‘, 2).join(‘ ‘);
■ 把大数据分成多份分批处理
【chunks,isUndefined,last,defer,partial】
var collection1 = _.range(10000), chunks = _.chunk(collection1,50);//每一份50个，总共分为20份 //处理chunks，无限递归 function process(chunks, index){ //找到需要被处理的chunk var chunk = chunks[index]; //判断chunk是否为undefined if(_.isUndefined(chunk)){ return; } console.log(‘working ‘ + _.last(chunk)); //defer让堆栈上有足够的时间作清理，defer接受一个回调函数 //partial让某个函数执行 _.defer(_.partial(process, chunks, ++index)); } process(chunks,0);
以上，使用range方法生成了一个比较大的集合，再使用chunk方法分隔成多份。使用process无限递归处理完所有的份数。
还可以根据集合长度来进行份数划分。
var collection _.range(10), size = Math.ceil(0.25 * collection.length); _.chunk(collection, size);
■ 去除集合中的重复部分
【uniq】
/去除字符串数组中的重复部分 var collection = [‘‘,‘‘]; _.uniq(collection); //uniq接受匿名函数 var collection = [ {firstName: ‘‘, lastName: ‘‘}, ... ]; _.uniq(collection, function(item){ return item.firstName + item.lastName; })
■ 根据对象字段分组
【groupBy】
【分组，根据字段】
var collection = [ {name:‘‘,size:‘‘}, ... ]; _.groupBy(collection, ‘size‘);
■ 根据匿名函数分组
【groupBy】
【分组，根据匿名函数】
var collection = [ {name: ‘‘, age:20}, ... ]; _.groupBy(collection, function(item){ return item.age > 20 ? ‘old‘ : ‘young‘; })
■ 获取最小，根据字段
【min】
_.min(collectin, ‘age‘);
■ 获取最大，根据匿名函数
【max】
【最大值，根据匿名函数】
_.max(collecion, function(item){ return item.age + item.workinghours; })
■ 获取集合大小
【size】
var collection = [ {name: ‘‘}, ... ]; var first = _.first(collection); _.size(collection); _.size(first.name);//获取字符串的长度
■ 提取嵌套集合中的有用部分
【pluck,flatten】
以下想获取所有集合元素中的employees下的所有对象，即[ { name: ‘b‘ }, { name: ‘c‘ }, { name: ‘e‘ }, { name: ‘f‘ } ]。
第一步通过pluck方法获取[ [ { name: ‘b‘ }, { name: ‘c‘ } ],[ { name: ‘e‘ }, { name: ‘f‘ } ] ]。
第二步通过flatten方法获取想要的结果。
var collection = [ {employer: ‘a‘, employees: [{name:‘b‘},{name:‘c‘}]}, {employer: ‘d‘, employees: [{name:‘e‘},{name:‘f‘}]} ]; //pluck找出符合条件的字段, //[ [ { name: ‘b‘ }, { name: ‘c‘ } ],[ { name: ‘e‘ }, { name: ‘f‘ } ] ] var tempResult = _.pluck(collection, ‘employees‘); console.log(tempResult); //[ { name: ‘b‘ }, { name: ‘c‘ }, { name: ‘e‘ }, { name: ‘f‘ } ] var employees = _.flatten(tempResult); console.log(employees); var result = _.filter(employees, function(item){ return (/^[bx]/i).test(item.name);//找出name值以b或x开头的 }); console.log(result);
另外，falttenDeep方法可以使多层嵌套扁平化成一层。
■ 去除集合中的无效元素，比如null, 0, undefined等。
【compact】
var collection = [ {name: ‘aa‘}, 0, {name: ‘bb‘}, null, {name:‘cc‘}, undefined, {name:‘dd‘} ]; var letters = [‘a‘, ‘b‘],//过滤条件 compactResult = _.compact(collection), result = []; //遍历打印 _.forEach(compactResult, function(item){ console.log(item.name); }); //操作某个元素 _.each(letters, function(letter){ var filterResult = _.filter(compactResult, function(item){ return _.startsWith(item.name.toLowerCase(), letter); }); //合并数组 result = result.concat(filterResult); }); //[ { name: ‘aa‘ }, { name: ‘bb‘ } ] console.log(result);
■ 去除集合中不符合某种规律的元素
【pluck, compact, startsWith】
以下，除去不包含name字段的集合元素。
var collection = [ {name: ‘a‘}, {name: ‘b‘}, {name: ‘c‘}, {}, true, 1 ]; //先筛选出包含name字段的值，不包含的显示undefined var pluckResult = _.pluck(collection, ‘name‘); //[ ‘a‘, ‘b‘, ‘c‘, undefined, undefined, undefined ] console.log(pluckResult); var letters = [‘a‘, ‘b‘], //再去除undefined compactResult = _.compact(pluckResult), result = []; //[ ‘a‘, ‘b‘, ‘c‘ ] console.log(compactResult); _.each(letters, function(letter){ var filterResult = _.filter(compactResult, function(item){ return _.startsWith(item.toLowerCase(), letter); }); result = result.concat(filterResult); }); console.log(result);
■ 所有集合元素满足条件或部分集合元素满足条件
【every】
判断所有集合元素哟啊满足某种条件。
var _ = require(‘lodash‘); var collection = [ {name: ‘a‘}, {name: ‘b‘}, {name: ‘c‘} ]; if(!_.every(collection, ‘name‘)){ console.log("有集合元素不包含name字段"); }
判断部分集合元素满足条件。
_.some(collection, ‘name‘)
■ 并集、交集、补集
【union, interseciton, xor】
var a = []; var b = []; var c = []; _.union(a, b, c); _.intersection(a, b, c); _.xor(a, b);
未完待续~~
标签：
原文地址：http://www.cnblogs.com/darrenji/p/5011241.html
