数组常用方法临记

concat

作用：连接两个或多个数组，并返回连接后的结果

不改变数组

let arr1 = [1, 2, 3];
let arr2 = [4, 5, 6];
let arr3 = arr1.concat(arr2);
console.log(arr1, arr2, arr3);

slice

作用：返回一个新数组，包含从 start 到 end （不包括该元素）的数组元素

不改变原数组

let arr4 = [1, 2, 3, 4, 5];
let arr5 = arr4.slice(1, 2);
console.log(arr4, arr5);

splice

作用：从数组中添加或删除元素

改变原数组

let arr6 = [1, 2, 3, 4, 5];
// let arr7 = arr6.splice(1, 2);
let arr8 = arr6.splice(1, 2, 8);
console.log(arr6, arr8);

push

作用： 向数组的末尾添加一个或更多元素，并返回新的长度

改变原数组

let arr9 = [1, 2, 3];
let arr10 = arr9.push(4);
console.log(arr9, arr10);

pop

作用： 删除数组的最后一个元素并返回该元素

改变原数组

let arr11 = [1, 2, 3];
let arr12 = arr11.pop();
console.log(arr11, arr12);

unshift

作用： 向数组的开头添加一个或更多元素，并返回新的长度

改变原数组

let arr13 = [1, 2, 3];
let arr14 = arr13.unshift(0);
console.log(arr13, arr14);

shift

作用： 删除数组的第一个元素并返回该元素

改变原数组

let arr15 = [1, 2, 3];
let arr16 = arr15.shift();
console.log(arr15, arr16);

sort

作用： 对数组的元素进行排序

改变原数组

let arr17 = [1, 3, 2];
// let arr18 = arr17.sort();
let arr18 = arr17.sort((a, b) => a - b);
console.log(arr17, arr18);

reverse

作用： 颠倒数组中元素的顺序

改变原数组

let arr19 = [1, 2, 3];
let arr20 = arr19.reverse();
console.log(arr19, arr20);

forEach

作用： 遍历数组的每个元素, 无返回

不改变原数组

let arr21 = [1, 2, 3];
arr21.forEach((item, index) => {
  console.log(item, index);
});
console.log(arr21);

map

作用：遍历数组的每个元素, 并返回新数组

不改变原数组

let arr22 = [1, 2, 3];
let arr23 = arr22.map((item, index) => {
  return item + 1;
});

filter

作用： 遍历数组的每个元素, 并返回符合条件的元素组成的新数组

不改变原数组

let arr24 = [1, 2, 3];
let arr25 = arr24.filter((item, index) => {
  return item > 1;
});
console.log(arr24, arr25);

every

作用：遍历数组的每个元素, 并返回每个是否符合条件

不改变原数组

let arr26 = [1, 2, 3];
let arr27 = arr26.every((item, index) => {
  return item > 0;
});
console.log(arr26, arr27);

some

作用： 遍历数组的每个元素, 并返回是否有一个符合条件

不改变原数组

let arr28 = [1, 2, 3];
let arr29 = arr28.some((item, index) => {
  return item > 2;
});
console.log(arr28, arr29);

indexOf

作用： 返回数组中第一个匹配元素的索引

不改变原数组

let arr30 = [1, 2, 3];
let index1 = arr30.indexOf(2); // 1
console.log(arr30, index1);

lastIndexOf

作用： 返回数组中逆向匹配第一个元素的索引

不改变原数组

let arr31 = [1, 2, 3, 2];
let index2 = arr31.lastIndexOf(2); // 3
console.log(arr31, index2);

reduce

作用： 叠加后的效果

不改变原数组

let arr32 = [1, 2, 3];
let sum = arr32.reduce((prev, cur, index, arr) => {
  return prev + cur;
}, 0);
console.log(arr32, sum);

Object.values(obj).reduce((pre, item) => {
  return { ...pre, ...item };
}, {});

reduceRight

作用： 逆向叠加后的效果

不改变原数组

let arr33 = [1, 2, 3];
let sum1 = arr33.reduceRight((prev, cur, index, arr) => {
  return prev + cur;
}, 0);
console.log(arr33, sum1);

join

作用： 把数组的所有元素放入一个字符串

不改变原数组

let arr34 = [1, 2, 3];
let str = arr34.join("-");
console.log(arr34, str);

toString

作用： 把数组的所有元素放入一个字符串

不改变原数组 Function 重写的 toString

let arr35 = [1, 2, 3];
let str1 = arr35.toString();
console.log(arr35, str1);

find

作用： 返回数组中满足提供的测试函数的第一个元素

不改变原数组

let arr37 = [1, 2, 3];
let value1 = arr37.find((item, index) => {
  return item > 1;
});
console.log(arr37, value1);

findIndex

作用： 返回数组中满足提供的测试函数的第一个元素的索引

不改变原数组

let arr38 = [1, 2, 3];
let index3 = arr38.findIndex((item, index) => {
  return item > 1;
});

fill

作用： 用一个固定值填充数组

改变原数组

let arr39 = [1, 2, 3];
let arr40 = arr39.fill(0);
console.log(arr39, arr40);

copyWithin

作用： 从数组的指定位置拷贝元素到数组的另一个指定位置

改变数组

let arr41 = [1, 2, 3, 4, 5];
let arr42 = arr41.copyWithin(0, 3);
console.log(arr41, arr42); // 4 5 3  4  5

includes

作用： 判断数组是否包含某个元素

不改变原数组

let arr43 = [1, 2, 3];
let flag = arr43.includes(2);
console.log(arr43, flag);

flat

作用：扁平化

不改变原数组

let arr46 = [1, 2, [3, 4]];
let arr47 = arr46.flat();
console.log(arr46, arr47);

flatMap

作用：对数组的每个元素执行一个函数，然后对返回值组成的数组拉平

不改变数组

let arr48 = [1, 2, 3];
let arr49 = arr48.filterMap((item, index) => {
  return [item, item * 2];
});
console.log(arr48, arr49); // [ [ 1, 2 ], [ 2, 4 ], [ 3, 6 ] ] ---> [ 1, 2, 2, 4, 3, 6 ]

Array.isArray

作用： 判断是否是数组

Array.of

作用： 将参数转为数组

Array.from

作用： 将类数组转为数组

let arr52 = Array.from({ 0: 1, 1: 2, 2: 3, length: 3 });
console.log(arr52);