JavaScript中数组常用方法整理

1.Array.splice(开始位置，删除的个数，元素) ——可以实现增删改

let arr=[1,2,3,4,5];
let arr1 = arr.splice(2,0,'haha');
let arr2 = arr.splice(2,3);
let arr3 = arr.splice(2,1,'haha');
console.log(arr1);  //[1,2,'haha',3,4,5]  新增一个元素
console.log(arr2);  //[1,2]  删除三个元素
console.log(arr3);  //[1,2,'haha',4,5] 替换一个元素

2.Array.join()——将数组转换为字符串

let arr = [1, 2, 3, 4, 5];
let str1 = arr.toString()
let str2 = arr.join(',')
let str3 = arr.join('##')
let str4 = arr.join('')
console.log(str1)// 1,2,3,4,5
console.log(str2)// 1,2,3,4,5
console.log(str3)// 1##2##3##4##5
console.log(str4)// 12345

3.Array.toString()——将数组转换为字符串

let arr = [1, 2, 3, 4, 5];
let str = arr.toString()
console.log(str)  // 1,2,3,4,5

4.Array.concat()——将多个数组拼接成一个新数组返回，不影响原来的数组

let arr1 = [1, 2, 3]
let arr2 = [4, 5]
let arr = arr1.concat(arr2)
console.log(arr)  //[1, 2, 3, 4, 5]

5.Array.isArray()——判断一个对象是否为数组，返回true/false

6.Array.shift()——删除数组第一个元素，返回删除的元素，改变了原数组的长度

let arr = [1, 2, 3, 4, 5]
arr.shift()
console.log(arr)   //[2, 3, 4, 5]
console.log(arr.length)   //4 

7.Array.unshift()——将一个或多个元素添加到数组的开头，并返回新数组的长度

let arr = [1, 2, 3, 4, 5]
arr.unshift(6, 7)
console.log(arr) //[6, 7, 1，2, 3, 4, 5]
console.log(arr.length) //7 

8.Array.push()——将一个或多个元素添加到数组的结尾，并返回新数组的长度

9.Array.pop()——删除数组最后一个元素，返回删除的元素，改变了原数组的长度

let arr = [1, 2, 3, 4, 5]
arr.pop()
console.log(arr)    //[1, 2, 3, 4]
console.log(arr.length)   //4

10.Array.reduce()——所有元素调用返回函数，返回值为最后结果，传入的值必须是函数类型

let arr=[1,2,3,4,5];
const add = (a,b)=>a+b;
let sum = arr.reduce(add);
//sum=15 相当于累加的效果
//与之对应的还有一个Array.reduceRight()方法，区别是这个是从右向左操作的

11.Array.every()——将所有元素进行判断并返回一个布尔值，如果所有元素都满足判断条件，则返回true，否则返回false

let arr = [1,2,3,4,5];
const isLessThan4 => value => value<4;
const isLessThan6 => value => value<6;
arr.every(isLessThan4);  //false
arr.every(isLessThan6);  //true

12.Array.some()——将所有元素判断并返回一个布尔值，如果存在元素满足判断条件，则返回true；若所有元素都不满足判读条件，则返回false

let arr = [1,2,3,4,5];
const isLessThan4 => value => value<4;
const isMoreThan6 => value => value>6;
arr.some(isLessThan4);    //true
arr.some(isMoreThan6);    //false

13.Array.map()——此方法将数组中的每个元素调用一个提供的函数，结果作为一个新的数组返回，并没有改变原来的数组

let arr = [1,2,3,4,5];
let newArr = arr.map(x =>x*2)；
//arr= [1, 2, 3, 4, 5]   原数组保持不变
//newArr = [2, 4, 6, 8, 10] 返回新数组

14.Array.forEach()——数组中的每个元素执行提供传递的函数，没有返回值，直接改变原数组，注意和map方法区分

let arr = [1, 2, 3, 4, 5]
num.forEach(x => x*2)
// arr = [2, 4, 6, 8, 10]  数组改变,注意和map区分

15.Array.filter()——将所有元素进行判断，将满足条件的元素作为一个新的数组返回

let arr = [1,2,3,4,5];
const isBigEnough => value => value>=3;
let newArr = arr.filter(isBigEnough);
//newArr = [3,4,5]  满足条件的元素返回为一个新的数组

16.Array.flat()——flat() 方法会按照一个可指定的深度递归遍历数组，并将所有元素与遍历到的子数组中的元素合并为一个新数组返回

//flat()方法最基本的作用就是数组降维
 
var arr1 = [1, 2, [3, 4]];
arr1.flat(); 
// [1, 2, 3, 4]
 
var arr2 = [1, 2, [3, 4, [5, 6]]];
arr2.flat();
// [1, 2, 3, 4, [5, 6]]
 
var arr3 = [1, 2, [3, 4, [5, 6]]];
arr3.flat(2);
// [1, 2, 3, 4, 5, 6]
 
//使用 Infinity 作为深度，展开任意深度的嵌套数组
arr3.flat(Infinity); 
// [1, 2, 3, 4, 5, 6]

17. Array.flatMap()——flatMap() 方法首先使用映射函数映射每个元素，然后将结果压缩成一个新数组。它与 map 和 深度值1的 flat 几乎相同，但 flatMap 通常在合并成一种方法的效率稍微高一些。 

var arr1 = [1, 2, 3, 4];
 
arr1.map(x => [x * 2]); 
// [[2], [4], [6], [8]]
 
arr1.flatMap(x => [x * 2]);
// [2, 4, 6, 8]
 
// 只会将 flatMap 中的函数返回的数组 “压平” 一层
arr1.flatMap(x => [[x * 2]]);
// [[2], [4], [6], [8]]

flat()和flatMap()本质上就是是归纳（reduce） 与 合并（concat）的操作。

18. Array.from()——Array.from()方法就是将一个类数组对象或者可遍历对象转换成一个真正的数组。

所谓类数组对象，最基本的要求就是具有length属性的对象。

(1) 将类数组对象转换为真正数组:

let arrayLike = {
    0: 'tom', 
    1: '65',
    2: '男',
    3: ['jane','john','Mary'],
    'length': 4
}

let arr = Array.from(arrayLike)
console.log(arr) // ['tom','65','男',['jane','john','Mary']]

let arrayLike = {
    'name': 'tom', 
    'age': '65',
    'sex': '男',
    'friends': ['jane','john','Mary'],
    length: 4
}
let arr = Array.from(arrayLike)
console.log(arr)  // [ undefined, undefined, undefined, undefined ]

要将一个类数组对象转换为一个真正的数组，必须具备以下条件：

　　1)、该类数组对象必须具有length属性，用于指定数组的长度。如果没有length属性，那么转换后的数组是一个空数组。

　　2)、该类数组对象的属性名必须为数值型或字符串型的数字

　　ps: 该类数组对象的属性名可以加引号，也可以不加引号

(2)将Set结构的数据转换为真正的数组：

let arr = [12,45,97,9797,564,134,45642]
let set = new Set(arr)
console.log(Array.from(set))  // [ 12, 45, 97, 9797, 564, 134, 45642 ]

　Array.from还可以接受第二个参数，作用类似于数组的map方法，用来对每个元素进行处理，将处理后的值放入返回的数组。如下：

let arr = [12,45,97,9797,564,134,45642]
let set = new Set(arr)
console.log(Array.from(set, item => item + 1)) // [ 13, 46, 98, 9798, 565, 135, 45643 ]

(3) 将字符串转换为数组

let  str = 'hello world!';
console.log(Array.from(str)) // ["h", "e", "l", "l", "o", " ", "w", "o", "r", "l", "d", "!"]

(4)Array.from参数是一个真正的数组：

console.log(Array.from([12,45,47,56,213,4654,154]))

像这种情况，Array.from会返回一个一模一样的新数组