数组相关代码片段

数组生成

生成一维数组

生成一个长度为 length 的一维数组,用元素 ele 填充。

原理

Array.from({length: 5}, (v, i) => i); // [0, 1, 2, 3, 4]
Array.from([1, 2, 3], x => x + x);   // [2, 4, 6]
Array(5).fill(4) // [4, 4, 4, 4, 4]

初始化指定范围和值的数组

const initArray = (length, ele) =>
	Array.from({length}).map(e => e = ele)
// or
const initArray = (n, value = 0) => Array(n).fill(value)
initArray(5, 2) // [2, 2, 2, 2, 2]

传入自定义处理方法

const initArray = (length, fun) =>
	Array.from({length}).map((e, i) => fun(i))
initArray(5, e => e * 2) // [0, 2, 4, 6, 8]

生成特定范围的数组

使用 Array(end-start) 创建所需长度的数组,使用 Array.map() 在一个范围内填充所需的值。 您可以省略 start ,默认值 0。

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

生成二维数组

生成一个 row * column 的二维数组,用元素 e 填充。

const init2DArray = (row, column, ele) =>
  Array.from({length: row}).map((_, i) =>
  Array.from({length: column}).map((e, j) => e = ele))
init2DArray(2, 4, 0)

数组排序

随机排列

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

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

升序排列

const asc = arr => arr.sort((a, b) => a - b); // 升序
asc([1,2,3,8,1,5,6]) // [1, 1, 2, 3, 5, 6, 8]

降序排列

const desc = arr => arr.sort((a, b) => b - a); // 降序
desc([1,2,3,8,1,5,6]) // [8, 6, 5, 3, 2, 1, 1]

数组去重

通过 Set() 去重

使用 ES6 的 Set 和 ...rest 操作符剔除重复的值。

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

排序后去重

let arr = [1,2,1,2,3,5,4,5,3,4,4,4,4];
let result = arr.sort().reduce((init, current)=>{
    if(init.length===0 || init[init.length-1]!==current){
        init.push(current);
    }
    return init;
}, []);
console.log(result); // [1,2,3,4,5]

数组平铺

深度平铺数组

使用递归。 通过空数组([]) 使用 Array.concat() ,结合 展开运算符( ... ) 来平铺数组。 递归平铺每个数组元素。

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

根据指定的 depth 平铺数组

每次递归,使 depth 减 1 。使用 Array.reduce() 和 Array.concat() 来合并元素或数组。默认情况下, depth 等于 1 时停递归。省略第二个参数 depth ,只能平铺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]

获取元素

获取数组的最后一个元素

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

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

获取数组的第N个元素

使用 Array.slice() 获取数组的第 n 个元素。如果索引超出范围,则返回 [] 。省略第二个参数 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'], -3) // 'a'

数组取样随机,获取数组中的1个元素

使用 Math.random() 生成一个随机数,乘以 length,并使用 Math.floor() 舍去小数获得到最接近的整数。这个方法也适用于字符串。

const arraySample = arr => arr[Math.floor(Math.random() * arr.length)]
arraySample([3, 7, 9, 11])

数组元素计算

最大值

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

最小值

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

数组求和

const sum = arr => arr.reduce( (acc, cur) => acc + cur, 0 )
sum([5,6,8,4]) // 23

求数字数组的平均数

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

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

获取数字数组的中值

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

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

数组过滤

从数组中排除给定值

使用 Array.filter() 创建一个排除所有给定值的数组。

const arrayWithout = (arr, ...args) => arr.filter(v => args.indexOf(v) === -1);
arrayWithout([2, 1, 2, 3], 1, 2) // [3]
arrayWithout([2, 1, 2, 3, 4, 5, 5, 5, 3, 2, 7, 7], 3, 1, 5, 2) // [ 4, 7, 7 ]

删除数组中的元素 (返回原数组)

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

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

删除数组中的元素 (返回被删除的数组)

使用 Array.filter() 和 Array.reduce() 来查找返回真值的数组元素,使用 Array.splice() 来移除元素。 func 有三个参数(value, index, array)。

const arrayRemove = (arr, func) =>
Array.isArray(arr) ? arr.filter(func).reduce((acc, val) => {
  arr.splice(arr.indexOf(val), 1); return acc.concat(val);
  }, [])
: [];
let arr = [1, 2, 3, 4]
arrayRemove(arr, n => n % 2 == 0) // 移除的元素: [2, 4]
arr // 原数组: [1, 3]

过滤掉数组中所有假值元素

使用 Array.filter() 过滤掉数组中所有 假值元素(false, null, 0, "", undefined, and NaN)。

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

过滤出数组中的非唯一值 (返回唯一值数组)

使用 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]

数组分组

创建一个分组元素数组

使用 Math.max.apply() 获取参数中最长的数组。 创建一个长度为返回值的数组,并使用 Array.from() 和 map-function 来创建一个分组元素数组。 如果参数数组的长度不同,则在未找到值的情况下使用 undefined 。

const arrayZip = (...arrays) => {
  const maxLength = Math.max.apply(null, arrays.map(a => a.length));
  return Array.from({length: maxLength}).map((_, i) => {
   return Array.from({length: arrays.length}, (_, k) => arrays[k][i]);
  })
}
arrayZip(['a', 'b'], [1, 2], [true, false]); // [['a', 1, true], ['b', 2, false]]
arrayZip(['a'], [1, 2], [true, false]); // [['a', 1, true], [undefined, 2, false]]

根据传入的方法进行分组

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

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']}

数组分块

使用 Array.from() 创建一个新的数组,它的长度与将要生成的 chunk(块) 数量相匹配。 使用 Array.slice() 将新数组的每个元素映射到长度为 size 的 chunk 中。 如果原始数组不能均匀分割,最后的 chunk 将包含剩余的元素。

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

数组集合运算

数组交集

根据数组 b 创建一个 Set 对象,然后在数组 a 上使用 Array.filter() 方法,只保留数组 b 中也包含的值。

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

或者

使用 filter() 移除不在 values 中的值,使用 includes() 确定。

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

数组合集

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

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

幂集

使用 Array.reduce() 与 Array.map() 结合来遍历元素,并将其组合成一个包含所有排列组合的数组。

const powerset = arr =>
  arr.reduce((a, v) => a.concat(a.map(r => [v].concat(r))), [[]]);
powerset([1,2]) // [[], [1], [2], [2,1]]

删除操作

删除指定位置指定数量的元素

如果不指定删除元素的长度,默认为 1

const removeItems = (arr, pos, len = 1) => arr.splice(pos, len)
let arr = [0, 1, 2, 3, 4]
removeItems(arr, 2) // arr is [0, 1, 3, 4]
let arr2 = [0, 1, 2, 3, 4]
removeItems(arr2, 2, 2) // arr2 is [0, 1, 4]

排除数组中最后一个元素

使用 arr.slice(0,-1) 返回排除了最后一个元素的数组,原数组不改变,返回改变后的数组。

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

如果使用 pop,原数组改变,返回移除的元素。

const initial = arr => arr.pop();
let arr = [1,2,3]
let popItem = initial(arr) // arr is [1,2]
popItem // 3

返回剔除第一个元素后的数组

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

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

从一个给定的数组中创建一个后N个元素的数组

使用 Array.slice() 来创建一个从第 n 个元素开始从末尾的数组。

const takeRight = (arr, n = 1) => arr.slice(arr.length - n, arr.length);
takeRight([1, 2, 3], 2) // [ 2, 3 ]
takeRight([1, 2, 3]) // [3]

从一个给定的数组中创建一个前N个元素的数组

使用 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) // []

添加操作

向指定位置添加元素

需要传递一个数组,即便只添加一个元素

const addItems = (arr, pos, items) => arr.splice(pos, 0, ...items)
let arr = [0, 1, 2, 3, 4]
addItems(arr, 2, [5]) // arr is [0, 1, 5, 2, 3, 4]
let arr2 = [0, 1, 2, 3, 4]
addItems(arr2, 2, [5, 6, 9, 1]) // arr2 is [0, 1, 5, 6, 9, 1, 2, 3, 4]

数组其他方法

填充数组

使用 Array.map() 将指定值映射到 start(包含)和 end (排除)之间。省略 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]

数组拼接

使用 Array.prototype.concat() ,通过在 args 中附加任何数组 和/或 值来拼接一个数组。

const arrayConcatenation = (arr, ...args) => [].concat(arr, ...args)
arrayConcatenation([1], [1, 2, 3, [4]], [5, 8, 9]) // [1, 1, 2, 3, Array(1), 5, 8, 9]

数组比较

根据数组 b 创建一个 Set 对象,然后在数组 a 上使用 Array.filter() 方法,过滤出数组 b 中不包含的值。

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

数组包含

使用 slice() 来抵消数组/字符串,并且使用 indexOf() 来检查是否包含该值。如果省略最后一个参数 fromIndex ,则会检查整个数组/字符串。

const arrayIncludes = (collection, val, fromIndex=0) => collection.slice(fromIndex).indexOf(val) != -1
arrayIncludes("30-seconds-of-code", "30") // true
arrayIncludes("30-seconds-of-code", "30", 1) // false
arrayIncludes([1, 2, 3, 4], 2) // true
arrayIncludes([1, 2, 3, 4], 2, 3) // false

MIT Licensed | Copyright © 2018-present 滇ICP备16006294号

Design by Quanzaiyu | Power by VuePress