lodash

_.chunk(3.0.0)

_.chunk(array,[size=1]):将一个数组分成相同长度的几个数组，不够均匀分配的单独成为一个数组。

参数：

 array(Array):要进行拆分的数组

 [size=1](number):指定每块的长度

返回：

 (Array):返回新的数组

例子：

_.chunk([‘a’,’b’,’c’,’d’],2) //[[‘a’,’b’],[‘c’,’d’]]

_.chunk([‘a’,’b’,’c’,’d’],3) //[[‘a’,’b’,’c’],[‘d’]]

_.compact(0.1.0)

_.compact(array):过滤调数组中的false，null，0，””,nudefined,NaN值。

参数：

array(Array):要compact的数组

返回：

(Array):返回一个过滤后的数组。

例子：

_.compact([0,1,false,2,’’,3])  //[1,2,3]

_.concat(4.0.0)

_.concat(array,[values]):将一个数组和另一个数组或value连接起来

参数：

array(Array):要连接的数组

[values](….*):要连接的数组或value

返回：

(Array):返回一个连接后的新的数组

例子：

var array = [1];

var other=_.concat(array,2,[3],[[4]]); //[1,2,3,[4]]

_.difference(0.1.0)

­_.difference(array,[values]):两个数组进行比较，排除相同值。结果值得顺序和引用由第一个数组决定。

参数：

 array(Array):要检查的数组

 [values](…Array):要排除的值

返回：

 (Array):返回一个过滤后的新数组

例子：

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

 _.differenceBy（4.0.0）(difference:差异，不同)

_.differenceBy(array,[values],[iteratee=_.identity]):这个方法跟_.difference差不多，不同的是，它会接收一个iteratee的参数，该参数会被没一个数组和值得元素调用，以生成与它们相比较的标准。结果值得顺序和引用由第一个数组决定。

参数：

 array(Array):要检查的数组。

 [value](...Array):要排除的值。

 [iteratee=_.identity](function):每个元素都调用

返回值：

　　（Array）:返回过滤后的新数组

例子：

  _.differenceBy([2.1,1.2],[2.3,3.4],Math.floor);//[1.2] 。两个数组经过Math.floor比较之后变成 _.differenceBy([2,1],[2,3],Math.floor)所以最后返回1.2。

_.differenceBy([{'x':2},{'x':1}],[{'x':1}],'x'); //[{'x':2}]

_.differenceWith（4.0.0）

_.differenceWith(array,[values],[comparator]):这个方法跟_.difference差不多。不同的是它接受一个比较器来比较数组和值得元素。结果值得顺序和引用由第一个数组决定。两个参数都会调用这个比较器

参数：

    array(Array):要检查的数组

　 [values](...Array):要比较的值

　 [comparator](function):每个元素都调用的比较器

返回：

    (Array):过滤后新的数组

例子：

　　var objects=[{'x':1,'y':2}，{'x':2,'y':1}];

　　_.differenceWith(objects,[{'x':1,'y':2}],_.isEqual) //经过isEqual的比较过滤调相同的返回[{'x':2,'y':1}]

_.drop(0.5.0)

_.drop(array,[n=1]):删除数组中从第一个到第n个元素，n不写时，默认删除第一个

参数：

   array(Array):用来被操作的数组

　[n=1]（number）:　要删除元素的数量

返回：

  （Array）返回删除后的数组

例子:

  _.drop([1,2,3]) //[2,3]

  _.drop([1,2,3],2) //[3]

  _.drop([1,2,3],5) //[]

  _.drop([1,2,3],0) //[1,2,3]

_.dropRight（3.0.0）

_.dropRight(array,[n=1]) :从数组末尾开始指定删除的元素，不写默认删除末尾的那个

参数：

array(Array):被操作的数组

[n=1](number):指定删除几个元素

返回：

（Array）：返回被删除后剩下的元素

例子：

_.dropRight([1,2,3]) // [1,2]

_.dropRight([1,2,3],2) //[1]

_.dropRight([1,2,3],5) //[]

_.dropRight([1,2,3],0) //[1,2,3]

_.dropRightWhile(3.0.0)

_.dropRightWhile(array,[predicate=_.identity])：从右向左删除满足条件的元素

参数：

array(Array):被操作的数组

[predicate=_.identity](Function):每个迭代调用的函数

返回：

(Array):返回被删除后剩下的元素

例子：

var users = [

{'user':'b','active':true},

{'user':'f','active':false},

{'user':'p','active':false}

]

_.dropRightWhile(users,function(o){return !o.active}) //objects for ['b']

_.dropRightWhile(users,{'user':'p','active':false}) //objects for ['b','f']

_.dropRightWhile(users,['active',false]) // objects for ['b']

_.dropRightWhile(users,'active') // objects for ['b','f','p']

_.dropWhile(3.0.0)

_.dropWhile(array,[predicate=_.identity]):从左到右删除根据条件删除元素

参数：

array(Array):被操作的数组

[predicate=_.identity](Function):每个迭代调用的函数

返回：

(Array):返回被删除后剩下的元素

例子：

var users = [

{'user':'b','active':true},

{'user':'f','active':false},

{'user':'p','active':false}

]

_.dropWhile(users,function(o){return !o.active}) //objects for ['b']

_.dropWhile(users,{'user':'p','active':false}) //objects for ['b','f']

_.dropWhile(users,['active',false]) // objects for ['b']

_.dropWhile(users,'active') // objects for ['b','f','p']

_.fill(3.2.0)(填满)

_.fill(array,value,[start=0],[end=array.length]):改变数组的中的元素。

参数：

array(Array):要被改变的数组

value(*):要改变成的值

[start=0](number):开始改变的位置

[end=array.length](number):结束改变的位置

返回：

（Array）:返回改变后的数组

例子：

var array = [1,2,3]    _.fill(array,'a') //['a','a','a']

_.fill(Array(3) ,2) //[2,2,2]

_.fill([4,6,8,10],'*',1,3) //[4,'*','*',10]

_.findIndex(1.1.0)    _.findLastIndex(2.0.0)从右向左

_.findIndex(array,[predicate=_.identity],[fromIndex=0])：跟_.find差不多，只不过它返回元素所在的索引的位置，而不是元素的本身。

参数：

array(Array):被检查的元素

[predicate=_.identity](function):每次迭代调用的函数

[fromIndex=0](number):要搜索的索引

返回：

（number）:返回这个元素的下标 ，没找到返回-1

例子：

var users=[{'user':'b','active':false},{'user':'f','active':false},{'user':'p','active':true}]

_.findIndex(users,{'user':'f','active':false}) // 1

_.findIndex(users,function(o){return 0.user=='b'})

_.findIndex(users,['active',false]);

_.findIndex(users,'active');

 _.head(_.first  0.1.0)

_.head(array):取出数组中的第一个元素

参数：

array(Array):被查找的元素

返回：

（*）：返回当前数组的第一个元素

例子：

_.head([1,2,3]) //1

_.head([])//undefined

_.flatten(0.1.0)

_.flatten(array):将数组中被嵌套的数组解析出来

参数：

array(Array):要被解析的数组

返回：

（ Array）：返回解析后的新数组

例子

_.flatten([1, [2, [3, [4]], 5]])  //[1, 2, [3, [4]], 5]

_.flatten([1, 2, [3, [4]], 5]) //[1, 2, 3, [4], 5]

_.flatten([1, 2, 3, [4], 5]) //[1, 2, 3, 4, 5]

_.flattenDeep(3.0.0)

_flattenDeep:跟_.flatten差不多，但是它会一次性的把数组中的子数组解析出来

参数：

array(Array):要被解析的数组

返回：

(Array):返回被解析后的新数组

例子

_.flattenDeep([1,[2,[3,[4]],5]])  //[1,2,3,4,5]

_.flattenDepth(4.4.0)

_.flattenDepth(array,[depth=1]):跟_.flatten差不多，只是可以自己定义解析几层后停止解析

参数：

array(Array):要被解析的数组

[depth=1](number):指定解析的层数

返回：

（Array）：解析后的新数组

例子：

var array = [1,[2,[3,[4]],5]]

_.flattenDepth(array,1) //[1,2,[3,[4]],5]

_.flattenDepth(array,2) //[1,2,3,[4],5]

_.fromPairs(4.0.0)

_.fromPairs(pairs):将数组解析成对象

参数：

pairs(Array):键值对的数组

返回：

（Object）：返回新的键值对

参数：

_.fromPairs([['a',1],['b',2]]) //{'a':1,'b':2}

_.indexOf(0.1.0)

_.indexOf(array,value,[fromIndex=0])：获取当前元素所在的下标

参数：

array(Array):被检查的数组

value（*）：要搜索的元素

[fromIndex=0](number):从第几个下标开始搜索

返回：

（number）：寻找到返回该元素所在的下标，未找到返回-1

例子：

_.indexOf([1,2,1,2],2); //1

_.indexOf([1,2,1,2],2,2); //3

_.initial(0.1.0)

_.initial(array):去掉数组的最后一个元素

参数：

array(Array):被查找的数组

返回：

（Array）：被删除最后一个元素后的数组

例子：

_.initial([1,2,3]) //[1,2]

_.intersection(0.1.0)

_.intersection([arrays]):筛选出数组中的交叉值，筛选后的值得顺序和引用由第一个数组决定。

参数：

[array](...Array):要被检查的数组

返回：

（Array）：返回一个包含交叉值得新数组

例子：

_.intersection([2,1],[2,3]) //[2]

_.intersectionBy(4.0.0)

_.intersectionBy([arrays],[iteratee=_.identity])：跟_.intersection差不多，但是它可以添加第二个参数通过方法，每个元素通过这个方法进行某些操作后再进行比较。筛选后的值得顺序和引用由第一个数组决定。

参数：

[arrays](...Array):要被检查的数组

[iteratee=_.identity](function):iteratee 调用每个元素

返回：

（Array）：返回一个新数组（包含所有相交的值）

例子：

_.intersectionBy([2.1,1.2],[2.3,3.4],Math.floor);[2.1]

_intersectionBy([{'x':1}],[{'x':2},{'x':1}],'x');[{'x':1}]

_.intersectionWith(4.0.0)

_.intersectionWith([arrays],[comparator]):跟_.intersection差不多，除了它接收比较器比较元素的引用.结果值的顺序和引用由第一个数组决定。比较两个参数调用：（arrval，othval）

参数：

[arrays](...Array):要被检查的数组

[comparator](Function):每个元素调用的比较器

返回：

（Array）：返回一个新数组（包含所有相交的值）

例子：

var objects=[{'x':1,'y':2},{'x':2,'y':1}];

var others=[{'x':1,'y':2},{'x':1,'y':1}];

_.intersectionWidth(objects,others,_.isEqual) //[{'x':1,'y':2}]

_.join(4.0.0)

_.join(array,[separator=',']):将数组中的所有元素转换为分隔符分隔的字符串。

参数：

array(Array):要被转换的数组

[separator=','](string):以什么字符来分割

返回：

（string）：返回转换后的string字符串

例子：

_.join(['a','b','c'],'~') //'a~b~c'

_.last(0.1.0)

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

参数：

array（Array）：被检查的数组

返回：

（*）：返回数组中的最后一个元素

例子：

_.last([1,2,3])  //3

_.lastIndexOf(0.1.0)

_.lastIndexOf(array,value,[fromIndex=array.length-1]):跟_.indexOf差不多，但是它是从右向左遍历数组的

参数：

array(Array)：被操作的数组

value(*)：被查找的值

[fromIndex=array.length-1](number):从下标为几的开始查询

返回：返回匹配值得索引，否则返回-1

(number):

例子：

_.lastIndexOf([1,2,1,2],2) //3

_.lastIndexOf([1,2,1,2],2,2)  //1

_.nth(4.11.0)

_.nth(array,[n=0]):获取数组下标n处的元素。如果n是负值，则从结束处返回nth元素

参数：

array(Array):被检索的数组

[n=0](number): 要返回的元素索引

返回：

(*):返回下标所对应的元素值

例子：

var array=['a','b','c','d']

_.nth(array,1) // 'b'

_.nth(array,-2) //'c'

_.pull(2.0.0)

_.pull(array,[values]) : 从数组中删除values值

 参数：

array(Array):要被修改的数组

[values](...*):要删除的value

返回：

（Array）：返回删除后的数组

例子：

var array=['a','b','c','a','b','c']

_.pull(array,'a','c') // ['b','b']

_.pullAll(4.0.0)

_.pullAll(array,values):跟_.pull差不多，但是它接收的value是数组

参数：

array(Array):要被修改的数组

values(Array):要删除的值

返回:

(Array):删除后的数组

例子：

var  array = ['a','b','c','a','b','c']

_.pullAll(array,['a','c'])  //['b','b']

_.pullAllBy(4.0.0)

_.pullAllBy(array,values,[iteratee=_.identity])

参数：

array(Array):要被修改的数组

values(Array):要被删除的值

[iteratee=_.identity](function):要操作数组的没一个元素的方法

返回：

（Array）：删除后的数组

例子：

var array=[{'x',1},{'x',2},{'x',3},{'x',1}]

_.pullAllBy(array,[{'x',3},{'x',1}],'x')   // [{'x',2}]

_.pullAllWith(4.6.0)

_.pullAllWith(array,values,[comparator]):它的特性在于，它接受的比较器来比较数组元素的值。比较两个参数调用：（arrval，othval）。

参数：

array(Array):要被修改的数组

values(Array):要被删除的值

[comparator](function):通过该方法比较没一个元素

返回：

（Array）：被删除后的元素

例子：

var array = [{ 'x': 1, 'y': 2 }, { 'x': 3, 'y': 4 }, { 'x': 4, 'y': 3 }];

_.pullAllWith(array, [{ 'x': 3, 'y': 4 }], _.isEqual); //[{ 'x': 1, 'y': 2 }, { 'x': 4, 'y': 3 }]

_pullAt(3.0.0)

_pullAt(array,[indexes]):从数组中移除对应于索引的元素，并返回一个移除元素数组。

参数：

array(Array):被修改的元素

[index](...(number/number[])):移动下标对应的元素

返回：

（Array）：返回一个新的数组（移除元素后）

栗子：

var array=['d','c','b','a']

var pulled = _.pullAt(array,[1,2])  //['d','a']

_.remove(2.0.0)

_.remove(array,[predicate=_.identity]):从数组中移除满足条件的元素

参数：

array(Array):被操作的数组

[predicate=_.identity](function):这个方法会调用每个元素

返回：

（Array）:返回一个新的数组

栗子：

var array =[1,2,3,4];

var evens =_.remove(array,n=>n%2==0) 

//array[1,3]   //evens[2,4]

_.reverse(4.0.0)

_.reverse(array)：反转元素，让第一个成为最后一个，第二个成为倒数第二个，一次类推

参数:

array（Array）:被操作的方法

返回：

（Array）：返回数组

栗子：

var array = [1,2,3]

_.reverse(array) [3,2,1]

_.slice(3.0.0)

_.slice(array,[start=0],[end=array.length]):对数组进行切割，参数包前不包后

参数：

array(Array):要切片的数组

[start=0](number):开始的位置

[end=array.length](number):结束的位置

返回：

（Array）：数组的切片

栗子：

_.slice([1,2,3,4,5,6],0,3) //[1,2,3]

_.sortedIndex(0.1.0)

_.sortedIndex(array,value):使用二进制搜索来确定应将值插入数组中的最低索引，以保持其排序顺序。

参数：

array(Array):要检查的排序数组

value(*):要检查的值

返回：

(number):返回将值插入数组的索引

栗子：

_.sortedIndex([30,50],40) //1

_.sortedIndexBy(4.0.0)

_.sortedIndexBy(array,value,[iteratee=_.identity]):与上类同，除了它会加一个方法来操作每一个元素

参数：

array(Array):要检查的排序数组

value（*）：要插入的值

[iteratee=_.identity](function):调用每个元素的方法

返回：

(number):返回将值插入数组的索引

栗子：

var objects=[{'x':4},{'x':5}]

_.sortedIndexBy(objects,{'x':4},o=>o.x) //0

_.sortedIndexBy(objects,{'x':4},'x') //0

_.sortedIndexOf(4.0.0)

_.sortedIndexOf(array,value):跟_.indexOf差不多，但是它会对排序的数组进行二进制搜索

参数：

array(Array):被检查的数组

value(*):要查询的值

返回：

(number):该值所在的下标，没有查到返回-1

栗子：

_.sortedIndexOf([4, 5, 5, 5, 6], 5);  //1

_.sortedLastIndex(3.0.0)

_.sortedLastIndex(array,value)跟_.sortedIndex差不多，但是它会返回该值所在该数组的最高的位置

参数：

array(Array):被操作的数组

value(*)：要查找的值

返回：

(number):返回该值的最大索引值

_.sortedLastIndex([4, 5, 5, 5, 6], 5); //4

_.sortedLastIndexBy(4.0.0)

_.sortedLastIndexBy(array,value,[iteratee=_.identity]):它跟上面唯一不同的地方是它会接收一个方法

参数：

array(Array):被检查的数组

value(*):要插入的值

[iteratee=_.identity](function):操作每个元素的方法

返回：

（number）：将值插入数组的索引。

栗子：

var object = [{'x':4},{'x':5}]

_.sortedLastIndexBy(objects,{'x':4},o=>o.x) //1

_.sortedLastIndexBy(objects,{'x':4},'x') //1

_.sortedLastIndexOf (4.0.0)

_.sortedLastIndexOf(array,value):这个方法像_.lastIndexOf,除了它会对排序数组进行二进制搜索

参数：

array(Array):被搜索的数组

value（*）:要查找的值

返回：

（number）:返回这个被查找的值得下标，没有返回-1

栗子：

_.sortedLastIndexOf([4,5,5,5,6],5)  //3

_.sortedUniq(4.0.0)

_.sortedUniq(array):这个方法像_.uniq除了它是为排序数组而设计和优化的

参数：

array(Array):要被检查的数组

返回：

（Array）：返回一个新的去除重复的数组

栗子：

_.sortedUniq([1,1,2]) // [1,2]

_.sortedUniqBy(4.0.0)

_.sortedUniqBy(array,[iteratee])

 参数：

array(Array):被检查的数组

[iteratee](function):操作每个元素的方法

返回：

(Array):返回一个新的去重后的数组

栗子：

_.sortedUniqBy([1.1,1.2,2.3,2.4],Math.floor) //[1.1,2.3]

_.tail(4.0.0)

_.tail(array):删除数组的第一个元素

参数：

array(Array):被查询的数组

返回：

(Array):切片后的数组

栗子：

_.tail([1,2,3]) //[2,3]

_.take(0.1.0)

_.take(array,[n=1]):获取指定个数的数组

参数：

array(Array):被检查的数组

[n=1](number):要接受的元素个数

返回：

（array）：被切片后的数组

栗子：

_.take([1,2,3]) //[1]

_.take([1,2,3],2) //[1,2]

_.take([1,2,3],5) //[1,2,3]

_.take([1,2,3],0) //[]

 _takeRight(3.0.0)

_takeRight(array,[n=1]):从右向左切取想要的值

参数：
array(Array):被操作的数组

[n=1](number):要切取的元素个数

返回：

（Array）:返回切取的元素数组

栗子：

_.takeRight([1,2,3]) //[3]

_.takeRight([1,2,3],2) // [2,3]

_.takeRight([1,2,3],5) //[1,2,3]

_.takeRight([1,2,3],0) //[]

 _.takeRightWhile(3.0.0)

_.takeRightWhile(array,[predicate=_.identity])

参数：

array(Array):被操作的数组

[predicate=_.identity](function):每次迭代被操作的数组

返回：

(Array):被切片后的数组

栗子：

var users = [
{'user':'a','active':true},
{'user':'b','active':false},
{'user':'c','active':false}
]

_.takeRightWhile(users,(o)=>!o.active)  // objects for['b','c']

_.takeRightWhile(users,{'user':'pebbles','active':false})//object for ['c']

_.takeRightWhile(users,['active',false]) //object for ['b','c']

_.takeRightWhile(users,'active') //[]

takeWhile(3.0.0)

takeWhile(array,[predicate=_.identity])

参数：

array(Array):被查找的数组

[predicate=_.identity](Function):每次迭代调用的函数

返回：

(Array):返回过滤后的数组

栗子：

var users =[
{'user':'b','active':false},
{'user':'f','active':false},
{'user':'p','active':true}
]

_.takeWhile(users,(o)=>!o.active); // objects for['b','f']
_.takeWhile(users,{'user':'b',active:false}) //object for['b']
_.takeWhile(users,['active',false]) // object for['b','f']
_.takeWhile(users,'active')  //[]

_.union(0.1.0)

_.union([arrays])：合并数组并去重

参数：

[arrays](...Array)：被检查的数组

返回：

（Array）：返回合并后的数组

栗子：

_.union([2],[1,2])  //[2,1]

_.unionBy(4.0.0)

_.unionBy([arrays],[iteratee=_.identity]):跟union差不多，只是它可以接收方法来操作每一个元素后，再进行合并

参数：

[array](...Array):被检查的元素

[iteratee=_.identity](function):迭代每个元素的方法

返回：

(Array):返回合并后的新数组

栗子：

_.unionBy([2.1],[1.2,2.3],Math.floor) // [2.1,1.2]

_.unionBy([{'x':1}],[{'x':2},{'x':1}],'x') // [{'x':1},{'x':2}]

_.unionWith(4.0.0)

_.unionWith([arrays],[comparator])：这个方法跟union很像，另外它接受比较器。比较后的结果值是从第一个数组中选择的。比较器需传两个参数（arrVal，othVal）

参数：

[arrays](...array):被检查的数组

（comparator ）（Function）:每个元素调用的比较器

返回值：

(Array):返回一个合并后的新的数组

栗子：

var obj = [{'x':1,'y':2},{'x':2,'y':1}]
var oth = [{'x':1,'y':1},{'x':1,'y':2}]
_.unionWith(obj,oth,_.isEqual) //[{'x':1,'y':2},{'x':2,'y':1},{'x':1,'y':1}]

_.unzip(1.2.0)

_.unzip(array):这个方法跟_.zip很像，除此之外，它接收一组分组元素，并穿件一个数组，将元素重新组合到其预ZIP配置中。

参数：

array(Array):要处理的分组元素数组

返回：

(Array):返回重新组合的新数组

栗子：

var zipped = _.zip(['a','b'],[1,2],[true,false]) //['a',1,true],['b',2,false]
_.unzip(zipped) //[['a','b'],[1,2],[true,false]]

_.unzipWith(3.8.0)

_.unzipWith(array,[iteratee=_.identity]):跟_.unzip很像，除此之外它接收一个方法来指定不重组的规则，该方法会调用每个组。

参数：

array(Array):要处理的分组元素数组

[iteratee=_.identity](function):操作每一个值指定重组规则

返回：

(array):重组后的新数组

栗子：

var zipped =_.zip([1,2],[10,20],[100,200]) //[[1,10,100],[2,20,200]]
_.unzipWith(zipped,_.add);//[3,30,300]

_.without(0.1.0)

_.without(array,[values]):在一个数组中指定要排除的元素，返回新的数组

参数：

array(Array):被检查的数组

[values](....):要排除的元素

返回：

(Array):返回一个过滤后的新的元素

栗子：

_.without([2,1,2,3],1,2) //[3]

_.xor(2.4.0)

_.xor([arrays]):创建一个唯一值数组，改数组是给定数组的对称差。结果值的顺序是由它们在数组中出现的顺序决定的

参数：

[array](...Array):被检查的数组

返回：

(Array):返回过滤后的新数组

栗子：

_.xor([2,1],[2,3]) //[1,3]

_xorBy(4.0.0)

_.xorBy([arrays],[iteratee=_.identity]):它增加了一个方法来指定过滤规则其它的都跟xor一样

参数：

[arrays](...array):被检查的数组

[iteratee=_.identity](Function):要操作每个元素的方法

返回：

(Array):返回过滤后的新数组

栗子：

_.xorBy([2.1,1.2],[2.3,3.4],Math.floor) //[1.2,3.4]
_.xorBy([{'x':1}]，[{'x':2}，{'x':1}]，'x') //[{'x':2}]

_.xorWith(4.0.0)

_.xorWith([arrays],[compatator])它接受的比较器比较数组元素的引用。结果值的顺序是由它们在数组中出现的顺序决定的。比较两个参数调用：（arrval，othval）。

参数：

[arrays](...array):被检查的数组

[comparator](function):操作每个元素的方法

返回：

(Array):返回过滤后的新数组

栗子：

var objects = [{'x':1,'y':2},{'x':2,'y':1}];
var others =  [{'x':1,'y':1},{'x':1,'y':2}];

_.xorWith(objects,others,_.isEqual) //[{'x':2,'y':1},{'x':1,'y':1}];

 _.zip

_.zip([array]):创建一个数组，其中第一个数组包含给定数组的第一个元素，第二个元素包含给定数组的第二个元素等。

 参数：

[arrays](...Array):被检查的数组

返回：

(Array):返回分组元素的新数组

栗子：

_.zip(['a','b'],[1,2],[true,false]) //[['a',1,true],['b',2,false]]

_.zipObject(0.4.0)

_.zipObject([props=[]],[values=[]]):这个方法像_.frompairs。除了它接受两个数组，一个属性标识符和一个相应的值。

参数：

[props=[]](Array):组成object后的key

[values=[]](Array):组成object后的value

返回：

（object）：返回一个新的object

栗子：

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

_.zipObjectDeep(4.1.0)

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

参数：

[props=[]](Array):组成object后的key

[values=[]](Array):组成object后的value

返回：

（object）：返回一个新的object

栗子：

_.zipObjectDeep(['a.b[0].c','a.b[1].d'],[1,2]) //{'a':{'b':[{'c':1},{'d':2}]}}

_.zipWith(3.8.0)

_.zipWith([arrays],[iteratee=_.identity])

 参数：

[arrays](...Array):被检查的数组

[iteratee=_.identity](Function):要操作每个元素的方法

返回：

（Array）：返回一个分组后的新数组

栗子：

_.zipWith([1,2],[10,20],[100,200],(a,b,c)=>a+b+c) //[111,222]

_.countBy(0.5.0)

_.countBy(collection,[iteratee=_.identity]):迭代每一个元素。最后返回符合条件的个数。

参数：

collection(Array/object):迭代的集合

[iteratee=_.identity](function):迭代每个元素的方法

返回：

(Object):返回组合的聚合对象

栗子：

_.countBy([6.1,4.2,6.3],Math.floor) //{'4':1,'6':2}  floor转换后4有1个，6有2个
_.countBy(['one','two','three'],'length')//{'3':2,'5':1} 长度为3的有2个，为5的有1个

_.every(0.1.0)

_.every(collection,[predicate=_.identity]):迭代每一个元素，遇到false的时候停止迭代返回false。对于空集合返回true。

参数：

collection(Array/object):迭代的集合

[predicate=_.identity](Function):迭代每个元素的方法

返回：

（boolean）:所有元素都通过检测则返回true，否则返回false

栗子：

_.every([true,1,null,'yes'],Boolean) //false

var users =[
   {'user':'b','age':36,'active':false}, 
   {'user':'f','age':40,'active':false}  
]

_.every(users,{'user':'b','active':false})   //false

_.every(users,['active',false])  //true

_.every(users,'active')  //false

_.filter(0.1.0)

_.filter(collection,[predicate=_.identity]):留下符合条件的元素

参数：

collection(Array/object):迭代的集合

[predicate=_.identity](Function):迭代每个元素的方法

返回：

(Array):返回一个新的过滤后的数组

栗子：

var users =[
   {'user':'b','age':36,'active':false}, 
   {'user':'f','age':40,'active':false}  
]

_.filter(users,(0)=>!o.active)  //['f']

_.filter(users,{'age':36,'active':true}) //['b']

_.filter(users,['active',false])  //['f']

_.filter(users,'active')  //['b']

_.find(0.1.0)

_.find(collection,[predicate=_.identity],[fromIndex=0]):寻找符合条件的元素

参数：

collection(Array/Object):被检查的集合

[predicate=_.identity](Function):迭代每个元素的方法

[fromIndex=0](number):被查找的下标

返回：

(*):返回匹配的元素，否则返回undefined

栗子：

var users =[
   {'user':'b','age':36,'active':true}, 
   {'user':'f','age':40,'active':false} ,
   {'user':'p',age:1,'active':true} 
]

_.find(users,(o)=>o.age<40)  //object for  'b'

_.find(users,{'age':1,'active':true}) // object for 'p'

_.find(users,['active':false])  // object for 'f'

_.find(users,'active') // object for 'b'

_.findLast(2.0.0)

_.findLast(collection,[predicate=_.identity],[fromIndex=collection.length-1]) //从右向左查找符合条件的元素

 参数：

collection(Array/Object): 被查找的集合

[predicate=_.identity](Function):迭代每个元素的方法

[fromIndex=collection.length-1](number):从指定的下标开始查询

返回：

(*):返回匹配的元素，否则返回undefined

栗子：

_.findLast([1,2,3,4],(n)=>n%2===1); // 3

_.flatMap(4.0.0)

_.flatMap(collection,[iteratee=_.identity])

参数：

collection(Array/Object):迭代的集合

[iteratee=_.identity](Function):每次迭代调用的方法

返回：

(Array):返回一个新的数组

栗子：

_.flatMap([1,2],(n)=>[n,n]) //[1,1,2,2]

_.flatMap([1,2],(n)=>n<2) //[true,false]

_.flatMapDeep(4.7.0)

_.flatMapDeep(collection,[iteratee=_.identity])

参数：

collection(Array/Object):迭代的集合

[iteratee=_.identity](Function):每次迭代调用的方法

返回：

(Array):返回一个新的数组

栗子：

_.flatMapDeep([1,2],(n)=>[[[n,n]]]) //[1,1,2,2]

_.flatMapDepth(4.7.0)

_.flatMapDepth(collection,[iteratee=_.identity],[depth=1])

参数：

collection(Array/Object):迭代的集合

[iteratee=_.identity](Function):每次迭代调用的方法

[depth=1](number):最大递归深度

返回：

(Array):返回一个新的数组

栗子：

_.flatMapDepth([1,2],(n)=>[[[n,n]]],2) //[[1,1],[2,2]]

forEach（_.each）(0.1.0)

forEach(collection,[iteratee=_.identity]):循环迭代数组或对象

参数：

collection(Array/object):被迭代的集合

[iteratee=_.identity](Function):每次迭代调用的函数

返回：

（*）:返回集合

栗子：

_.forEach([1,2],(value)=>{console.log(value)}) //1,2

_.forEach({'a':1,'b':2},(value,key)=>{console.log(key)})  // a,b

_.forEachRight（_.eachRight）（2.0.0）

_.forEachRight(collection,[iteratee=_.identity]):从右向左迭代

参数：

collection(Array/object):被迭代的集合

[iteratee=_.identity](Function):每次迭代调用的函数

返回：

（*）:返回集合

栗子：

_.forEachRight([1,2],(value)=>{console.log(value)})  //2,1

_.groupBy(0.1.0)

_.groupBy(collection,[iteratee=_.identity]):对集合进行分组，分组后的顺序为它们原来的顺序

参数：

collection(Array/object):被迭代的集合

[iteratee=_.identity](Function):每次迭代调用的函数

返回：

(Object):返回分组后的对象

栗子：

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

_.groupBy(['one','two','three'],'length') // {'3':['one','two'],'5':['three']}

_.includes(0.1.0)

_.includes(collection,value,[fromIndex=0]):检查集合或字符串中是否存在该值

参数：

collection(Array/Object/string):被检查的集合

value(*)：要检查的值

[fromIndex=0](number):开始检测的下标

返回：

(boolean):检测到返回true否则返回false

栗子：

_.includes([1,2,3],1) //true

_.includes([1,2,3],1,2) //false

_.includes({'a':1,'b':2},1) //true

_.includes('avdc','c') //true

_.invokeMap(4.0.0)

_.invokeMap(collection,path,[args]):

参数：

collection(Array/Object):被迭代的集合

path(Array/Function/string):调用每个元素的方法

[args](....*):调用每个方法的参数

返回：

(Array):返回这个数组的结果

栗子：

_.invokeMap([[5,1,7],[3,2,1]],'sort')  //[[1,5,7],[1,2,3]]

_.invokeMap([123,456],String.prototype.split,'') //[['1','2','3'],['4','5','6']]

 _keyBy(4.0.0)

 _.keyBy(collection,[iteratee=_.identity])

参数：

collection(Array/Object):被迭代的集合

[iteratee=_.identity](Function):生产key的方法

返回：

（Object）：返回组合成的对象

栗子：

var array = [
  {'dir':'left','code':97},
  {'dir':'right','code':100}
]

_.keyBy(array,(o)=>String.fromCharCode(o.code)) //{'a':{'dir':'left','code':97},'d':{'dir':'right','code':100}}
_.keyBy(array,'dir') //{'left':{'dir':'left','code':97},'right':{'dir':'right','code':100}}

_.map(0.1.0)

_.map(collection,[iteratee=_.identity])

参数：

collection(Array/Object):迭代的集合

[iteratee=_.identity](Function):每次迭代调用的函数

返回：

(Array):返回一个新的数组

栗子：

_.map([4,8],(n)=>n*n) //[16,64]

_.map({'a':4,'b':8},(n)=>n*n)  //[16,64]

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

_.map(users,'user') //['barney','fred']

_.orderBy(4.0.0)

_.orderBy(collection,[iteratees=[_.identity]],[orders]):对元素进行排序，所有值按照升序排

参数：

collection(Array/Object):迭代的集合

[iteratees=[_.identity]](Array[]/Function[]/Object[]/string[]):排序的依据

[orders](string[]): 指定升序（asc）还是降序（desc）

返回：

(Array):返回一个新的排序后的数组

栗子：

var users = [
  { 'user': 'fred',   'age': 48 },
  { 'user': 'barney', 'age': 34 },
  { 'user': 'fred',   'age': 40 },
  { 'user': 'barney', 'age': 36 }
];
_.orderBy(users, ['user', 'age'], ['asc', 'desc']); 
//:
[{age:36,user:"barney"},{age:34,user:"barney"},{age:48,user:"fred"},{age:40,user:"fred"}]

_.partition(3.0.0)

_.partition(collection,[predicate=_.identity]):对数组元素按照一定的条件分组

参数：

collection(Array|Object):迭代的集合

[predicate=_.identity](Function):每次迭代调用的方法

返回：

（array）:返回分组后的数组

栗子：

var users = [
  {'user':'b','age':36,'active':false},
  {'user':'f','age':40,'active':true},
  {'user':'p','age':1,'active':false}   
]

_.partition(users,(0)=>o.active) // object for [['f'],['barney','pebbles']]

_.partition(users,{'age':1,'active':false}) // object for[['p'],['b','f']]

_.partition(users,['active',false]) // object for [['b','p'],['f']]

_.partition(users,'active') // object for [['f'],['b','p']]

 _.reduce(0.1.0)

_.reduce(collection,[iteratee=_.identity],[accumulator]):

参数：

collection(Array|object):被迭代的集合

[iteratee=_.identity](Function):迭代每个元素的方法

[accumulator](*):初始值

返回：

（*）:返回结果值

栗子：

_.reduce({'a':1,'b':2,'c':1},(result,value,key)=>{
  (result[value] || (result[value] = [])).push(key);
    return result;
},{}) //{'1':['a','c'],'2':['b']}

_.reduce([1,2],(sum,n)=>sum+n,0)  //3

 _.reduceRight(0.1.0)

_.reduceRight(collection,[iteratee=_.identity],[accumulator]):它是从右向左操作元素的

参数：

collection(Array|object):被迭代的集合

[iteratee=_.identity](Function):迭代每个元素的方法

[accumulator](*):初始值

返回：

（*）:返回结果值

栗子：

var array = [[0,1],[2,3],[4,5]]

_.reduceRight(array,(flattened,other)=>{flattened.concat(other)},[]) //[4,5,2,3,0,1]

_.reject(0.1.0)

_.reject(collection,[predicate=_.identity]):跟_.filter相反

参数：

collection(Array|Object):被操作的集合

[predicate=_.identity](Function):迭代每个元素的方法

返回：

(Array):返回过滤后的新的数组

栗子：

var users = [
  {'user':'b','age':36,'active':false},
  {'user':'f','age':40,'active':true}
]

_.reject(users,(o)=>{!o.active})  // object for ['f']

_.reject(users,{'age':40,'active':true})  // object for ['b']

_.reject(users,['active',false])  //object for ['f']

_.reject(users,'active')  //object for ['b']

_.sample(2.0.0)

_.sample(collection):随机获取数组的值

参数：

collection(Array|Object):取样的集合

返回：

(*):返回随机值

栗子：

_.sample([1,2,3,4])  //2

_.sampleSize(4.0.0)

_.sampleSize(collection,[n=1]):从集合的唯一键获取n个随机元素，直至集合大小

参数：

collection(Array|Object):取样的集合

[n=1](number):取样的个数

返回：

（Array）：返回随机元素

栗子：

_.sampleSize([1,2,3],2) // [3,1]

_.sampleSize([1,2,3],4)  // [2,3,1]

_.shuffle(0.1.0)

_.shuffle(collection):重新排序

参数：

collection(Array|Object): 被重新排序的集合

返回：

(Array): 返回重新排序后的集合

栗子：

_.shuffle([1,2,3,4])   //[4,1,3,2]

_.size(0.1.0)

_.size(collection):获取数组大小来判断数组的长度

参数：

collection(Array|object|string) : 被检查的集合

返回：

(number):返回集合的大小

栗子：

_.size([1,2,3])   //3

_.size({'a':1,'b':2})  //2

_.size('pebbles')   //7

_.some(0.1.0)

_.some(collection,[predicate=_.identity]):查找集合中是否包含相同的内容

参数：

collection(Array|object):迭代的集合

[predicate=_.identity](Function):迭代每个元素的方法

返回：

(boolean):找到返回true否则返回false

栗子：

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

var users = [{'user':'b','active':true},{'user':'f','active':false}]

_.some(users,{'user':'b','active':false})  //false

_.some(users,['active',false])  //true

_.some(users,'active')  //true

_.sortBy(0.1.0)

_.sortBy(collection,[iteratees=[_.identity])

参数：

collection(Array|object):迭代的集合

[iteratees=[_.identity]](...(Function|Function[])):排序的方法

返回：

（array）：返回一个新的排序后的数组

栗子：

var users = [
  { 'user': 'fred',   'age': 48 },
  { 'user': 'barney', 'age': 36 },
  { 'user': 'fred',   'age': 40 },
  { 'user': 'barney', 'age': 34 }
];
 
_.sortBy(users,[(o)=>o.user])//objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]]

_.sortBy(users, ['user', 'age']);// objects for [['barney', 34], ['barney', 36], ['fred', 40], ['fred', 48]]

_.now（2.4.0）

_.now():返回毫秒的时间戳

返回：

(number):返回时间戳

栗子：

_.defer((stamp)=>{
 console.log(_.now()-stamp)
},_.now())

 function

_.after(0.1.0)

_.after(n,func):被调用多次后出发的方法

参数：

n(number):被调用的次数

func(function):调用多次出发的方法

返回：

（function）：返回一个新的受限制的方法

栗子：

var  saves = ['profile','settings'];

var done = _.after(saves.length,()=>{
 console.log('done saving!')
})

_.forEach(saves,(type){
 asyncSave({'type':type,'complete':done})
})

end function

_.castArray(4.4.0)

_.castArray(value):如果不是一个数组则将值转换成数组

参数：

value(*):被检查的数组

返回：

(Array):返回转换后的数组

栗子：

_.castArray(1) //[1]

_.castArray({'a':1}) // [{'a':1}]

_.castArray('abc') //['abc']

_.castArray(null) //[null]

_.castArray(undefined) [undefined]

_.castArray() //[]

var array = [1,2,3] 
_.castArray(array) ===array //true

_.clone(0.1.0)

_.clone(value):克隆

参数：

value(*):要克隆的值

返回：

(*):返回克隆后的值

栗子：

var obj = [{'a':1},{'b':2}]
var shallow = _.clone(obj)
console.log(shallow[0] === objects[0])  //true

_.cloneDeep(1.0.0)

_.cloneDeep(value):深度克隆

参数：

value(*):被克隆的值

返回：

(*)：返回深度克隆后的值

栗子：

var  obj = [{'a':1},{'b':2}]

var  deep = _.cloneDeep(obj)

console.log(deep[0] === objects[0])  //false

_.cloneDeepWith(4.0.0)

_.cloneDeepWith(value,[customizer]):根据一定的条件去深度克隆

参数：

value(*):要克隆的值

[customizer](function):迭代每个元素的方法

返回：

(*):返回深度克隆后的值

栗子：

let el = _.cloneDeepWith(document.body,(value)=>{
  if(_.isElement(value)){
     return value.cloneNode(true)
   }
})

console.log(el===document.body)  //false

console.log(el.nodeName)  // 'BODY'

console.log(el.childNodes.length)   //20

_.cloneWith(value,[customizer])(4.0.0)

参数：

value(*):被克隆的值

[customizer](Function):定制克隆的方法

返回：

(*):返回克隆的值

栗子：

let el = _.cloneWith(document.body,(value)=>{
    if(_.isElement(value){
       return value.cloneNode(false);
    }) 
})

console.log(el === document.body)  //false

console.log(el.nodeName)  //BODY

console.log(el.childNOdes.length)  //0

_.conformsTo(4.14.0)

_.conformsTo(object,source):

参数：

object(Object):被检查的对象

source(object):被检查的源

返回：

(boolean):符合返回true否则返回false

栗子：

let object={'a':1,'b':2}

_.conformsTo(object,{'b':(n){return n>1;}})  //true

_.conformsTo(object,{'b':(n){return n>2}}) //false

_.eq(4.0.0)

_.eq(value,other):判断两值是否相等

参数：

value(*):去比较的值

other(*):其它去比较的值

返回：

(boolean):值相等返回true，否则返回false

栗子：

var object = {'a':1}
var other = {'a':1}

_.eq(object,object) //true

_.eq(object,other)  //true

_.eq('a','a')  //true

_.eq('a',Object('a'))  //false

_eq(NaN,NaN) //true

_.gt(3.9.0)

_.gt(value,other):比较该值是否大于其它值

参数：

value(*):要对比的值

other(*):被对于的值

返回：

(boolean):大于返回true，否则返回false

栗子：

_.gt(3,1)  //true

_.gt(3,3) //false

_.gt(1,3)  //false

_.gte(3.9.0)

_.gte(value,other):检测值是否大于或等于其它值

参数：

value(*):去比较的值

other(*):去比较的其它值

返回：

(boolean):大于或等于其它值返回true，否则返回false

栗子：

_.gte(3,1)  //true

_.gte(3,3)  //true

_.gte(1,3) //false

_.isArguments(0.1.0)

_.isArguments(value):判断该值是否是一个arguments对象

参数：

value(*):被检查的值

返回：

(boolean):是arguments对象返回true，否则返回false

栗子：

_.isArguments(()=>arguments;())  //true

_.isArguments([1,2,3])  //false

 _.isArray(0.1.0)

_.isArray(value):判断该值是否是一个数组对象

参数：

value(*): 被检查的值

返回：

(boolean):如果这个是数组返回true，否则返回false

栗子：

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

_.isArray(document.body.children) // false

_.isArray('abc') // false

_.isArray(_.noop) //false

 _.isArrayBuffer(4.3.0)

_.isArrayBuffer(value):检查这个值是不是类型化数组

参数：

value(*):被检查的值

返回：

(boolean):是返回true，不是返回false

栗子：

_.isArrayBuffer(new ArrayBuffer(2))   //true

_.isArrayBuffer(new Array(2))  // false

_.isArrayLike(4.0.0)http://www.cnblogs.com/silin6/p/ArrayLike.html#muddle

_.isArrayLike：Checks if value is array-like. A value is considered array-like if it's not a function and has a value.length that's an integer greater than or equal to 0 and less than or equal to Number.MAX_SAFE_INTEGER.

参数：

value(*):被检查的值

返回：

(boolean):是返回true不是返回false

栗子：

_.isArrayLike([1,2,3])  //true

_.isArrayLike(document.body.children)  //true

_.isArrrayLike('abc')  // true

_.isArrayLike(_.noop)  //false

 _.isArrayLikeObject(4.0.0)

_.isArrayLikeObject(value)

参数：

value(*):被检查的值

返回：

(boolean):是返回true，不是返回false

栗子：

_.isArrayLikeObject([1,2,3]) //true

_.isArrayLikeObject(document.body.children)  //true

_.isArrayLikeObject('abc')  //false

_.isArrayLikeObject(_.noop)  //false

_.isBoolean(0.1.0)

_.isBoolean(value):判断这个值是不是boolean类型

参数：

value(*):被检查的值

返回：

(boolean):是返回true否则返回false

栗子：

_.isBoolean(false)   //true

_.isBoolean(null)  //false

 _.isBuffer(4.3.0)

_.isBuffer(value):检查一个值是不是一个buffer

参数：

value(*):被检查的值

返回：

(boolean):是返回true，不是返回false

栗子：

_.isBuffer(new Buffer(2))  //true

_.isBuffer(new Unit8Array(2))  //false

_.isDate(0.0.1)

_.isDate(value):判断一个值是不是一个date对象

参数：

value(*):被检查的值

返回：

(boolean):是返回true否则返回false

栗子：

_.isDate(new Date)  //true

_.isDate('Mon April 23 2012')  //false

_.isElement(0.1.0)

_.isElement(value):判断一个值是不是一个dom元素

参数：

value(*):被检查的值

返回：

boolean:是返回true否则返回false

栗子：

_.isElement(document.body)  //true

_.isElement('<body>')  //false

_.isEmpty(0.1.0)

_.isEmpty(value):判断一个值是否为空(空对象，空集合，空字符串都视为空)

参数：

value(*):被检查的值

返回：

(boolean):是空返回true，否则返回false

栗子：

_.isEmpty(null)  //true

_.isEmpty(true)  //true

_.isEmpty(1) //true

_.isEmpty([1,2,3])  //false

_.isEmpty({'a':1}) //false

_.isEqual(0.1.0) 

_.isEqual(value,other):比较两个值是否相等。对所有常用的数据类型都有效

参数：

value(*):要比较的值

other(*):被比较的值

返回：

（boolean）:相等返回true否则返回false

let obj = {'a':1}
let thr = {'a':1}
_.isEqual(obj,thr)  //true

obj === thr  //false

 _.isEqualWith(4.0.0)

_.isEqualWith(value,other,[customizer]):根据一定的条件比较两值是否相等

参数：

value(*):要比较的值

other(*):要比较的其它值

[customizer](Function):比较的方法

返回:

（boolean）:相等返回true否则返回false

栗子：

isGreeting(value)=>{/^h(?:i|ello)$/.test(value);}

customizer(objValue, othValue)=> {
  if (isGreeting(objValue) && isGreeting(othValue)) {
    return true;
  }
}

const array = ['hello','goodbye']
const other =['hi','goodbye']

_.isEqualWith(arra,other,customizer)

_.isError(3.0.0)

_.isError(value):检查这个是否是Error,EvalError,RangeError,ReferenceError,SyntaxError,TypeError, URIError object

参数：

value(*):被检查的值

返回：

(boolean):是返回true否则返回false

栗子：

_.isError(new Error)  //true

_.isError(Error)  //false

_.isFinite(0.1.0)

_.isFinite(value):查看这个值是否是一个数值，改方法是基于Number.isFinite

参数：

value(*):被检查的方法

返回：

(boolean):是返回true否则返回false

栗子：

_.isFinite(3) //true

_.isFinite(Number.MIN_VALUE) //true

_.isFinite(Infinity)  //false

_.isFinite('2')  //false

_.isFunction（0.1.0）

_.isFunction(value):检查这个值是不是一个方法

参数:

value(*):被检查的值

返回：

（boolean）:是返回true否则返回false

栗子：

_.isFunction(test=()=>{}) //true

_.isFunction(/abc/)  //false

 _.isInteger(4.0.0)

_.isInteger(value):检查值是不是整型

参数：

value(*):被检查的值

返回：

(boolean):是返回true否则返回false

栗子：

_.isInteger(3) //true

_.isInteger(Number.MIN_VALUE) //false

_.isInteger(Infinity) //false

_.isInteger('3')  //false

_.isLength(4.0.0)

_.isLength(value):检查值是否有长度

参数：

value(*):被检查的值

返回：

(boolean):是返回true否则返回false

栗子：

_.isLength(3) //true

_.isLength(Number.MIN_VALUE)  //false

_.isLength(Infinity) //false

_.isLength('3')  //false

 _.isMap(4.3.0)

_.isMap(value):判断这个值是不是一个map对象

参数：

value(*):被检查的值

返回：

(boolean):是返回true否则返回false

栗子：

_.isMap(new Map)  //true

_.isMap(new WeakMap)  //false

_.isMatch(3.0.0)

_.isMatch(object,source):偏深度的比较一个值是否存在在另一个值中

参数：

object(Object):被检查的值

source(Object):要比较的值

返回：

(boolean):存在返回true否则返回false

栗子：

const  obj = {'a': 1,'b': 2}

_.isMatch(obj,{'b': 2})  //true

_.isMatch(obj,{'b': 1})  //false

 _.isMatchWith(4.0.0)

_.isMatchWith(obj,source,[customizer]):根据一定的方法比较一个值是否存在在另一个值中

参数：

object(Object):被检查的值

source(Object):要匹配的值

[customizer](Function):规定对比方法的值

返回：

（boolean）：存在返回true否则返回false

function isGreeting (value){
  return /^h(?:i|ello)$/.test(value)
}

function customizer(objval,srcval){
   if(isGreeting(objval) && isGreeting(srcval)){
      return true
  }  
}

var obj = {'greeting': 'hello'}

var source = {'greeting','hi'}

_.isMatchWith(obj,source,customizer)

_.isNaN(0.1.0)

_.isNaN(value):检查是不是一个NaN值

参数：

value(*):被检查的值

返回：

(boolean):是返回true否则返回false

栗子：

_.isNaN(NaN) //true

_.isNaN(new Number(NaN)) //true

_.isNaN(undefined) //true

_.isNaN(undefined)  //false

 _.isNative(3.0.0)

_.isNavtive(value):检查是不是js的原生方法

参数：

value（*）:被检查的值

返回：

boolean:是返回true否则返回false

栗子：

_.isNative(Array.prototype.push) //true

_.isNative(_)//false

_.isNil(4.0.0)

isNil(value):检查这个值是不是null 或者undefined

参数：

value(*):被检查的值

返回：

boolean：是返回true否则返回false

栗子：

_.isNil(null)  //true

_.isNil(void 0) //true

_isNil(NaN)  //false

 _.isNull(0.1.0)

_.isNull(value):检查这个值是否为null

参数：

value(*):被检查的值

返回：

（boolean）：是null返回true否则返回false

栗子：

_.isNull(null)  //true

_.isNull(void 0) //false

_.isNumber(0.1.0)

_.isNumber(value):检查这个值是否为number类型

参数：

value(*):被检查的值

返回：

(boolean):是number类型返回true否则返回false

栗子：

_.isNumber(3) //true

_.isNumber(Number.MIN_VALUE) //true

_.isNumber(Infinity) //true

_.isNumber('3')  //false

 _.isObject(0.1.0)

_.isObject(value):判断这个值是不是object类型

参数：

value(*):被检查的值

返回：

(boolean):是返回true否则返回false

栗子：

_.isObject({})  //true

_.isObject([1,2,3]) //true

_.isObject(_.noop)  //true

_.isObject(null)  //false

_.isObjectLike(4.0.0)

_.isObjectLike(value):如果一个值不是null并且它的typeof返回一个object那么它就是像object

参数：

value(*):被检查的值

返回：

（boolean）：是返回true否则返回false

栗子：

_.isObjectLike({})  //true

_.isObjectLike([1,2,3])  //true

_.isObjectLike(_.noop)  //false

_.isObjectLike(null)  //false

 _.isPlainObject(0.8.0)

_.isPlainObject(value):检查这个值是不是一个普通的object，也就是说它是不是通过对象构造函数创建的或者是一个原型为空的

参数：

value(*):被检查的值

返回：

（boolean）：是返回true否则返回false

栗子：

foo()=>{this.a = 1}

_.isPlainObject(new foo)  //false

_.isPlainObject([1,2,3]) //false

_.isPlainObject({'x':0,'y':0})  //true

_.isPlainObject(Object.create(null))  //true

_.isRegExp(0.1.0)

_.isRegExp(value):检查这个值是不是一个正则表达式

参数：

value(*):被检查的值

返回：

(boolean):是返回true否则返回false

栗子：

_.isRegExp(/abc/)  //true

_.isRegExp('/abc/')  //false

 _.isSafeInteger(4.0.0)

_.isSafeInteger(value):判断这个数是不是一个符合IEEE-754标准的双精度数（64位）

参数：

value(*):被检查的值

返回：

（boolean）：是返回true否则返回false

栗子：

_.isSafeInteger(3)  //true

_.isSafeInteger(Number.MIN_VALUE)  //false

_.isSafeInteger(Infinity)  //false

_.isSafeInteger('3')  //false

_.isSet(4.3.0)

_.isSet(value):检查值是否被划分为一个set对象

参数：

value(*):被检查的值

返回：

（boolean）：是返回true否则返回false

栗子：

_.isSet(new Set)  //true

_.isSet(new WeakSet)  //false

 _.isString(0.1.0)

_.isString(value):判断该值是不是一个string类型

参数：

value(*):被检查的值

返回：

(boolean):是返回true否则返回false

栗子：

_.isString('abc') //true

_.isString(1) //false

_.isSymbol(4.0.0)

_.isSymbol(value):判断这个值是不是一个Symbol类型

参数：

value(*):被检查的值

返回：

（boolean）:是返回true否则返回false

栗子：

_.isSymbol(Symbol.iterator)  //true

_.isSymbol('abc')  //false

_.isTypedArray(3.0.0)

_.isTypedArray(value):检查该值是否被归类为类型数组

 参数：

value(*):被检查的值

返回：

（boolean）:是返回true否则返回false

栗子：

_.isTypedArray(new Uint8Array)  //true

_.isTypedArray([]) //false

_.isUndefined(0.1.0)

_.isUndefined(value):检查这个值是否是undefined

参数：

value(*):被检查的值

返回：

（boolean）：是返回true否则返回false

栗子：

_.isUndefined(void 0) //true

_.isUndefined(null) //false

_.isWeakMap(4.3.0)

_.isWeakMap(value):检查该值是否是一个弱类型的map对象

参数：
value(*):被检查的值

返回：

（boolean）：是返回true否则返回false

栗子：

_.isWeakMap(new WeakMap) //true

_.isWeakMap(new Map)  //false

_.isWeakSet(4.3.0)

_.isWeakSet(value):检查该值是不是一个weakSet对象

参数：

value（*）：被检查的值

返回：

（boolean）：是返回true否则返回false

栗子：

_.isWeakSet(new WeakSet) //true

_.isWeakSet(new Set)  //false

_.It(3.9.0)

_.It(value,other):检查值是否小于其它值

参数：

value(*):被检查的值

other(*):要比较的值

返回：

(boolean):是返回true否则返回false

栗子：

_.lt(1,3) //true

_.lt(3,3)  //false

_.lt(3,1) //false

_.lte(3.9.0)

_.lte(value,other):检查值是否小于或等于其它值

参数：

value(*):被检查的值

other(*):要比较的值

返回：

(boolean):是返回true否则返回false

栗子：

_.lte(1,3)  //true

_.lte(3,3)  //true

_.lte(3,1)  //false

 _.toArray(0.1.0)

_.toArray(value):将值转换成数组

参数：

value(*):去转换的值

返回：

（Array）：返回一个转换后的数组

栗子：

_.toArray({'a':1,'b':2})  //[1,2]

_.toArray('abc')  //['a','b','c']

_.toArray(1) //[]

_.toArray(null)  //[]

_.toFinite(4.12.0)

_.toFinite(value):将值转换成有限的数字

参数：

value（*）：要转换的值

返回：

（number）：返回转换后的数字

栗子：

_.toFinite(3.2) //3.2

_.toFinite(Number.MIN_VALUE) // 5e-324

_.toFinite(Infinity) //1.7976931348623157e+308

_.toFinite('3.2') //3.2

 _.isFunction(0.1.0)

_.isFunction(value):判断这个值是不是一个方法

参数：

value(*):要检查的值

返回：

（boolean）：是返回true否则返回false

栗子：

_.isFunction(_)  //true

_.isFunction(/abc/)  //false

_.isInteger(4.0.0)

_.isInteger(value):判断这个值是不是一个整数

参数：

value(*):被检查的值

返回：

(boolean):是返回true否则返回false

栗子：

_.isInteger(3) //true

_.isInteger(Number.MIN_VALUE) //false

_.isInteger(Infinity)  //false

_.isInteger('3')  //false

 _.isLength(4.0.0)

_.isLength(value):检查这个值是否有长度

参数：
value(*):被检查的值

返回：

（boolean）：有长度返回true否则返回false

栗子：

_.isLength(3) //true

_.isLength(Number.MIN_VALUE) //false

_.isLength(Infinity)  //false

_.isLength('3')  //false

 _.isMap(4.3.0)

_.isMap(value):检查这个值是不是map类型

参数：

value(*):被检查的值

返回：

(boolean):是返回true否则返回false

栗子：

_.isMap(new Map)  //true

_.isMap(new WeakMap)  //false

_.isMatch(3.0.0)

_.isMatch(object,source):对象和源之间进行深度对比，查看是否包含等价的值

参数：

object(Object):被检查的值

source(Object):用于比较的值

返回：

(boolean):相同返回true，否则返回false

栗子：

var object = {'a':1,'b':2}

_.isMatch(object,{'b':2})  //true

_.isMatch(object,{'b':1})  //false

 _.isMatchWith(4.0.0)

_.isMatchWith(object,source,[customizer]):和isMatch差不多 但是它可以接收一个方法

参数：

object(Object):被检查的对象

source(Object):用于比较的对象

[customizer](Function):制定比较规则的方法

返回：

(boolean): 相同返回true否则返回false

栗子：

function isGreeting(value) {
  return /^h(?:i|ello)$/.test(value);
}
 
function customizer(objValue, srcValue) {
  if (isGreeting(objValue) && isGreeting(srcValue)) {
    return true;
  }
}
 
var object = { 'greeting': 'hello' };
var source = { 'greeting': 'hi' };
 
_.isMatchWith(object, source, customizer);
// => true

 _.isNaN(0.1.0)

_.isNaN(value):判断该值是不是一个NaN值

参数：

value(*):被检查的值

返回：

（boolean）：是返回true否则返回false

栗子：

_.isNaN(NaN) //true

_.isNaN(new Number(NaN))  //true

isNaN(undefined)  //true

_.isNaN(undefined)  //false

_.isNative(3.0.0)

_.isNative(value):判断该方法是不是原生封装好的方法

参数：

value(*):被检查的值

返回：

(boolean):是返回true否则返回false

_.isNative(Array.prototype.push)  //true

_.isNative(_) //false

 _.isNil(4.0.0)

_.isNil(value):检查这个值是不是null或者undefined

参数：

value（*）:被检查的值

返回：

(boolean):是返回true否则返回false

栗子：

_.isNil(null) //true

_.isNil(void 0) //true

_.isNil(NaN)  //false

_.isNull(0.1.0)

_.isNull(value):判断这个值是不是null

参数：

value(*):被检查的值

返回：

(boolean):是null返回true否则返回false

栗子：

_.isNull(null) //true

_.isNull(void 0)  //false