_.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