官方文档：[www.lodashjs.com/]www.lodashjs.com/docs/lodash…
_.slice(array, [start=0], [end=array.length]) start 开始位置，end 结束位置（但不包含结束位置） 原数组不改变，返回一个新数组（裁剪的部分）
var array = [1, 2, 3, 1, 2, 3, 4];
var ary = _.slice(array, 2, 4);
console.log(array, 'slice', ary, 'ary'); // => [1, 2, 3, 1, 2, 3, 4] 'slice' (2) [3, 1] 'ary'
_.sortedIndex(array, value)不改变原数组，利用二进制的机制将value插入到已排序数组中索引较小的位置，返回该位置索引index
var array = [1, 4, 2, 5];
var ary = _.sortedIndex(array, 3);
console.log(ary, 'ary'); // => 3 'ary'
_.sortedIndexOf(array, value) 在已经排序的数组array上执行二进制检索，返回查找到第一个匹配值的索引index，找不到返回-1
var array1 = [2, 1, 3, 4, 2];
var sortedIndexOf = _.sortedIndexOf(array1, 4);
console.log(sortedIndexOf, 'sortedIndexOf'); // => -1 'sortedIndexOf'
array1 = array1.sort((a, b) => a-b) // 先由小到大排序，倒序无法查找
console.log(array1, '=array1.sort');
var sortedIndexOf = _.sortedIndexOf(array1, 4);
console.log(sortedIndexOf, 'sortedIndexOf'); // => 4 'sortedIndexOf'
_.sortedUniq(array)类似_.uniq()，返回一个数组去重后的数组，原数组不变
var array = [1.1, 1.2, 3, 2, 2];
var sortedUniq = _.sortedUniq(array);
console.log(sortedUniq, 'sortedUniq'); // => [1.1, 1.2, 3, 2] 'sortedUniq'
var uniq = _.uniq(array);
console.log(uniq, 'uniq'); // => [1.1, 1.2, 3, 2] 'uniq'
console.log(array, 'array'); // => [1.1, 1.2, 3, 2, 2] 'array'
_.tail(array) 结果同 _.drop（arr, 1）返回除数组第一个元素以外的所有元素
_.take(array, [n=1]) 同理_.drop（），后者是移除n个元素，保留剩余元素；前者是保留n个元素，移除其他元素
_.take([1, 2, 3]);
// => [1]
_.take([1, 2, 3], 5);
// => [1, 2, 3]
_.take([1, 2, 3], 0);
// => []
_.takeRight(array, [n=1]) 反向数组切片_.take()
_.union([arrays]) 按给定顺序排列，并返回去重后的新数组
var union = _.union([3, 2], [4, 1, 2, 3, 2]);
console.log(union, 'union'); // => [3, 2, 4, 1] 'union'
_.uniq(array) 数组去重，返回新数组
var array = [1, 3, 2, 3, 1];
var uniq = _.uniq(array);
console.log(array, 'array'); // => [1, 3, 2, 3, 1] 'array'
console.log(uniq, 'uniq'); // => [1, 3, 2] 'uniq'
_.unzip(array) 类似于_.zip， 将数组拆分成打包前的数据结构
var zipped = _.zip(['fred', 'barney'], [30, 40], [true, false]);
// => [['fred', 30, true], ['barney', 40, false]]
_.unzip(zipped);
// => [['fred', 'barney'], [30, 40], [true, false]]
_.unzipWith(array, [iteratee=_.identity])接收一个迭代器，指定重组数组值如何被组合
var zipped = _.zip([1, 2], [10, 20], [100, 200]);
// => [[1, 10, 100], [2, 20, 200]]
_.unzipWith(zipped, _.add);
// => [3, 30, 300]
_.zip([arrays])创建一个分组元素的数组，数组的第一个元素包含所有给定数组的第一个元素，数组的第二个元素包含所有给定数组的第二个元素，以此类推
_.zip(['fred', 'barney'], [30, 40], [true, false]);
// => [['fred', 30, true], ['barney', 40, false]]
_.zipObject([props=[]], [values=[]])类似_.fromPairs（），第一个数组中的值作为属性标识符（key），第二个数组中的值作为相应的属性值（value）
_.zipObject(['a', 'b'], [1, 2]);
// => { 'a': 1, 'b': 2 }
_.zipObjectDeep([props=[]], [values=[]])类似_.zipObject，除了它支持属性路径
_.zipObjectDeep(['a.b[0].c', 'a.b[1].d'], [1, 2]);
// => { 'a': { 'b': [{ 'c': 1 }, { 'd': 2 }] } }
_.zipWith([arrays], [iteratee=_.identity])类似于_.zip,迭代函数来指定分组的值应该如何被组合
_.zipWith([1, 2], [10, 20], [100, 200], function(a, b, c) {
return a + b + c;
});
// => [111, 222]
_.without(array, [values])类似_.pull, pull会改变原数组，without返回一个新数组
_.without([2, 1, 2, 3], 1, 2);
// => [3]
_.xor([arrays])创建一个给定数组唯一值的数组，返回值的顺序取决于他们数组的出现顺序。
_.xor([2, 1], [2, 3]);
// => [1, 3]
