Array篇（数组）

Array concatenation (合并参数)

使用Array.concat() 来连接参数中的任何数组或值。

const arrayConcat = (arr, ...args) => arr.concat(...args);
// arrayConcat([1], 2, [3], [[4]]) -> [1,2,3,[4]]

Array difference (取数组不同项)

以b创建Set，然后使用 Array.filter() 过滤，只保留 b 中不包含的值。

const difference = (a, b) => { const s = new Set(b); return a.filter(x => !s.has(x)); };
// difference([1,2,3], [1,2]) -> [3]

Array intersection (取数组相同项)

以 b 创建 Set，然后使用 Array.filter()过滤，只保留 b 中包含的值。

const intersection = (a, b) => { const s = new Set(b); return a.filter(x => s.has(x)); };
// intersection([1,2,3], [4,3,2]) -> [2,3]

Array union (合并数组去重)

用 a和b 的所有值创建一个 Set并转换成一个数组。

const union = (a, b) => Array.from(new Set([...a, ...b]));
// union([1,2,3], [4,3,2]) -> [1,2,3,4]

Average of array of numbers (通过数组取平均值)

使用 Array.reduce()将每个值添加到一个累加器，用值 0初始化，除以数组的长度。

const average = arr => arr.reduce((acc, val) => acc + val, 0) / arr.length;
// average([1,2,3]) -> 2

Chunk array (数组切块)

使用 Array.from() 创建一个满足块的数量的新的数组。
使用 Array.slice() 将新数组的每个元素映射到 size 长度的块。
如果原始数组不能均匀分割，最后的块将包含剩余的元素。

const chunk = (arr, size) =>
  Array.from({length: Math.ceil(arr.length / size)}, (v, i) => arr.slice(i * size, i * size + size));
// chunk([1,2,3,4,5], 2) -> [[1,2],[3,4],5]

Compact (压缩)

使用 Array.filter() 去过滤掉假值（false, null, 0, "", undefined和 NaN）。

const compact = (arr) => arr.filter(v => v);
// compact([0, 1, false, 2, '', 3, 'a', 'e'*23, NaN, 's', 34]) -> [ 1, 2, 3, 'a', 's', 34 ]

Count occurrences of a value in array (计算数组中指定值出现的次数)

使用Array.reduce()去迭代数组，当值相同时，递增计数器。

const countOccurrences = (arr, value) => arr.reduce((a, v) => v === value ? a + 1 : a + 0, 0);
// countOccurrences([1,1,2,1,2,3], 1) -> 3

Deep flatten array (深度展开数组)

使用递归。
使用 Array.reduce()获取所有不是数组的值，并将数组展开。

const deepFlatten = arr =>
  arr.reduce((a, v) => a.concat(Array.isArray(v) ? deepFlatten(v) : v), []);
// deepFlatten([1,[2],[[3],4],5]) -> [1,2,3,4,5]

Drop elements in array (删除数组中的元素)

循环访问数组，使用 Array.shift() 删除数组的第一个元素，直到函数的返回值为 true，返回其余的元素。

const dropElements = (arr, func) => {
  while (arr.length > 0 && !func(arr[0])) arr.shift();
  return arr;
};
// dropElements([1, 2, 3, 4], n => n >= 3) -> [3,4]

Fill array (填充数组)

使用 Array.map() 将 start（包含）和 end（不包含）之间的值映射为 value。
省略start 将从第一个元素开始／省略 end 将在数组最后结束。

const fillArray = (arr, value, start = 0, end = arr.length) =>
  arr.map((v, i) => i >= start && i < end ? value : v);
// fillArray([1,2,3,4],'8',1,3) -> [1,'8','8',4]

Filter out non-unique values in an array (过滤掉数组中重复的值)

使用 Array.filter()保证数组仅包含唯一值。

const filterNonUnique = arr => arr.filter(i => arr.indexOf(i) === arr.lastIndexOf(i));
// filterNonUnique([1,2,2,3,4,4,5]) -> [1,3,5]

Flatten array up to depth (展开指定深度的数组)

使用递归去递减深度。
使用 Array.reduce()和 Array.concat()来合并元素或数组。
基本情况下，当深度为1时停止递归。
省略第二个参数，展开深度为 1。

const flattenDepth = (arr, depth = 1) =>
  depth != 1 ? arr.reduce((a, v) => a.concat(Array.isArray(v) ? flattenDepth(v, depth - 1) : v), [])
  : arr.reduce((a, v) => a.concat(v), []);
// flattenDepth([1,[2],[[[3],4],5]], 2) -> [1,2,[3],4,5]

Flatten array (拼合数组)

使用 Array.reduce() 来获取内部所有元素并用 concat()合并它们。

const flatten = arr => arr.reduce((a, v) => a.concat(v), []);
// flatten([1,[2],3,4]) -> [1,2,3,4]

Get max value from array (获取数组中的最大值)

使用 Math.max() 配合 ...扩展运算符去获取数组中的最大值。

const arrayMax = arr => Math.max(...arr);
// arrayMax([10, 1, 5]) -> 10

Get min value from array (获取数组中的最小值)

使用 Math.max() 配合 ... 扩展运算符去获取数组中的最小值。

const arrayMin = arr => Math.min(...arr);
// arrayMin([10, 1, 5]) -> 1

Group by (条件分组)

使用 Array.map()将数组的值映射到函数或属性名称。
使用 Array.reduce() 创建一个对象，其中的键是从映射的结果中产生的。

const groupBy = (arr, func) =>
  arr.map(typeof func === 'function' ? func : val => val[func])
    .reduce((acc, val, i) => { acc[val] = (acc[val] || []).concat(arr[i]); return acc; }, {});
// 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']}

Head of list (获取数组的首个元素)

使用 arr[0] 返回传递数组的第一个元素。

const head = arr => arr[0];
// head([1,2,3]) -> 1

Initial of list（去除数组最后一个元素）

使用 arr,slice(0, -1) 去返回去除最后一个元素的数组。

const initial = arr => arr.slice(0, -1);
// initial([1,2,3]) -> [1,2]

Initialize array with range (使用指定范围来定义数组)

使用 Array(end-start)创建一个所需长度的数组，使用Array.map()来填充范围中的所需值。
你可以省略start，默认值为0。

const initializeArrayRange = (end, start = 0) =>
  Array.apply(null, Array(end - start)).map((v, i) => i + start);
// initializeArrayRange(5) -> [0,1,2,3,4]

Initialize array with values (使用指定值来定义数组)

使用 Array(n)创建一个所需长度的数组，使用 fill(v)去填充所需要的值。
亦可以省略 value，默认值为0。

const initializeArray = (n, value = 0) => Array(n).fill(value);
// initializeArray(5, 2) -> [2,2,2,2,2]

Last of list (获取数组的结尾)

使用 arr.slice(-1)[0]获得给定数组的最后一个元素。

const last = arr => arr.slice(-1)[0];
// last([1,2,3]) -> 3

Median of array of numbers (获取数组的中间值)

找到数组的中间，使用 Array.sort()对值进行排序。
如果长度是奇数，则返回中点处的数字，否则返回两个中间数字的平均值。

const median = arr => {
  const mid = Math.floor(arr.length / 2), nums = arr.sort((a, b) => a - b);
  return arr.length % 2 !== 0 ? nums[mid] : (nums[mid - 1] + nums[mid]) / 2;
};
// median([5,6,50,1,-5]) -> 5
// median([0,10,-2,7]) -> 3.5

Nth element of array (获取数组的第 N 个元素)

使用 Array.slice()得到一个包含第一个元素的数组。
如果索引超出范围，则返回 []。（译者注：超过索引返回 undefind）
省略第二个参数 n来获取数组的第一个元素。

const nth = (arr, n=0) => (n>0? arr.slice(n,n+1) : arr.slice(n))[0];
// nth(['a','b','c'],1) -> 'b'
// nth(['a','b','b'],-2) -> 'a'

Pick (挑选)

使用 Array.reduce() 去过滤／挑选存在于 obj中的 key值，并转换回相应的键值对的对象。

const pick = (obj, arr) =>
  arr.reduce((acc, curr) => (curr in obj && (acc[curr] = obj[curr]), acc), {});
// pick({ 'a': 1, 'b': '2', 'c': 3 }, ['a', 'c']) -> { 'a': 1, 'c': 3 }
// pick(object, ['a', 'c'])['a'] -> 1

Shuffle array (随机数组)

使用 Array.sort() 在比较器中使用 Math.random()重新排序元素。

const shuffle = arr => arr.sort(() => Math.random() - 0.5);
// shuffle([1,2,3]) -> [2,3,1]

Similarity between arrays (获取数组的交集)

使用 filter()移除不是values 的一部分的值，使用 includes() 确定。

const similarity = (arr, values) => arr.filter(v => values.includes(v));
// similarity([1,2,3], [1,2,4]) -> [1,2]

Sum of array of numbers (数组的总和)

使用 Array.reduce() 去迭代值并计算累计器，初始值为0。

const sum = arr => arr.reduce((acc, val) => acc + val, 0);
// sum([1,2,3,4]) -> 10

Tail of list (列表的尾巴)

如果数组的长度大于1，则返回 arr.slice(1)，否则返回整个数组。

const tail = arr => arr.length > 1 ? arr.slice(1) : arr;
// tail([1,2,3]) -> [2,3]
// tail([1]) -> [1]

Take (抽取)

使用 Array.slice()从头开始创建 n 个元素的数组。

const take = (arr, n = 1) => arr.slice(0, n);
// take([1, 2, 3], 5) -> [1, 2, 3]
// take([1, 2, 3], 0) -> []

Unique values of array (数组去重)

使用ES6 Set 和 ...rest 运算符去除所有重复的值。

const unique = arr => [...new Set(arr)];
// unique([1,2,2,3,4,4,5]) -> [1,2,3,4,5]