js的数组方法整理(26)-牛翰网

一、数组有哪些方法？

1.数组创建与初始化

Array()构造函数：用于创建新数组

const arr1 = new Array() //创建空数组
const arr2 = new Array(5) //创建包含个空位的数组
const arr3 = new Array(1,2,3) //创建包含元素1，2，3的数组

Array.of()：创建包含任意数量参数的新数组

const arr = Array.of(1, 2, 3); // [1, 2, 3]

Array.from()：从类数组对象或可迭代的对象创建新数组

const str = 'hello';
const arr = Array.from(str); // ['h', 'e', 'l', 'l', 'o']

2.数组元素操作

push()：在数组末尾添加一个或多个元素，并返回新的长度

const arr = [1, 2, 3];
const newLength = arr.push(4, 5); // arr 变为 [1, 2, 3, 4, 5]，newLength 为 5

pop()：移除数组的最后一个元素，并返回该元素

const arr = [1, 2, 3];
const lastElement = arr.pop(); // arr 变为 [1, 2]，lastElement 为 3

unshift()：在数组开头添加一个或多个元素，并返回新的长度

const arr = [1, 2, 3];
const newLength = arr.unshift(0); // arr 变为 [0, 1, 2, 3]，newLength 为 4

shift()：移除数组的第一个元素，并返回该元素

const arr = [1, 2, 3];
const firstElement = arr.shift(); // arr 变为 [2, 3]，firstElement 为 1

splice()：可用于添加、删除或替换数组中的元素。splice()会改变原数组。

/*
    数组.splice(n,m,x):对数组进行增/删/改操作
    @params:
        n:从索引n开始（必填）
        m:向后截取m个元素，没有填写则默认截取到数组末尾（非必填）。
        x:代替截取掉的部分（非必填）
    @return:将截取到的部分以新数组的方式返回
*/
 
//增：
let arr = [0,1,2,3,4,5,6],
    newArr = arr.splice(arr.length-1,0,7); //从数组末尾开始向后截取0个元素，并在此插入新元素7
console.log(newArr,arr)// => [],[0,1,2,3,4,5,7,6]
 
//删：
let arr2 = [0,1,2,3,4,5,6],
    newArr2 = arr2.splice(0,1);//从索引0开始向后截取1个元素
console.log(newArr2,arr2)// => [0],[1,2,3,4,5,6]
 
//改：
let arr3 = [0,1,2,3,4,5,6],
    newArr3 = arr3.splice(0,1,0.5)//从索引0开始向后截取1个元素，并在此插入元素0.5
console.log(newArr3,arr3)// => [0],[0.5,1,2,3,4,5,6]

slice()：返回一个新的数组，包含从开始到结束（不包括结束）的元素

/*
    数组.slice(n,m)：查询数组
    @params:
        n:从索引n开始（必填）
        m:查询到索引m为止，不包含m，如果m不填或大于arr.length，默认查询到末尾（非必填）
    @return:将查找到的元素以新数组的方式返回，如果没有查找到，返回空数组
*/
 
//1.当n和m都为正整数：
let arr = [0,1,2,3,4,5],
    newArr = arr.slice(0,arr.length);//从索引0开始查询到数组末尾的后一项（复制数组）
console.log(newArr,arr)// => [0,1,2,3,4,5],[0,1,2,3,4,5]
 
//2.当n和m为小数时，会先通过parseInt转换为整数在进行查询操作
let arr2 = [0,1,2,3,4,5],
    newArr2 = arr2.slice(1.9,2.1);//从索引1开始查询到索引为2的元素
console.log(newArr2,arr2)// => [1],[0,1,2,3,4,5]
 
//3.当n是负数时，m不能大于n 否则返回空数组；表示从数组的末尾开始查找，数组最后一项索引为-1，越往前越小（原正数索引-arr.length=当前的负数索引）
let arr3 = [0,1,2,3,4,5],
    newArr3 = arr3.slice(-3,-1);//从索引-2开始向前查找到索引为-1的元素
console.log(newArr3,arr3);// => [3,4],[0,1,2,3,4,5],
 
//4.当n或m不是有效数字时，先通过parseInt转换为有效数字，转换为NaN则默认为0
let arr4 = [0,1,2,3,4,5],
    newArr4 = arr4.slice('1.9','哈哈哈');//从索引1开始向后查询到索引为0的元素，返回空数组
console.log(newArr4,arr4)// => [],[0,1,2,3,4,5]
 
let arr5 = [0,1,2,3,4,5],
    newArr5 = arr4.slice('1.9','3.1');//从索引1开始向后查询到索引为3的元素，返回空数组
console.log(newArr4,arr4)// => [1,2],,[0,1,2,3,4,5]

3.数组查找与过滤

indexOf()：返回指定元素在数组中第一次出现的索引，如果不存在则返回-1

const arr = [1, 2, 3, 2];
const index = arr.indexOf(2); // index 为 1

lastIndexOf()：返回指定元素在数组中最后一次出现的索引，如果不存在则返回-1

const arr = [1, 2, 3, 2];
const lastIndex = arr.lastIndexOf(2); // lastIndex 为 3

includes()：判断数组是否包含指定元素，返回布尔值

const arr = [1, 2, 3];
const hasTwo = arr.includes(2); //  为 true

find()：数组的循环，查找符合条件的值，并打断循环返回找到的值

let arr = ['张三','李四','王五','马六']; 
let str = arr.find(item => item == '李四'); 
console.log(str); // -> '李四'

findIndex()：返回数组中满足测试的函数的第一个索引，否则返回-1

const arr = [1, 2, 3, 4, 5];
const foundIndex = arr.findIndex(item => item > 3); // foundIndex 为 3

filter()：

(1) 同forEach功能；

(2) filter的回调函数需要返回布尔值，当为true时，将本次数组的数据返回给filter，最后filter将所有回调函数的返回值组成新数组返回（此功能可理解为“过滤”）

// 注意：filter(callback);callback默认有三个参数，分别为value，index，self。 
let arr = [1,2,3,4,5,6]; 
let arr1 = arr.filter((item,index,self)=>{ 
    console.log(item) // -> 1,2,3,4,5,6 
    console.log(index) // -> 0,1,2,3,4,5 
    console.log(self) // -> [1,2,3,4,5,6] 
    return item > 3 
}) 
 
console.log(arr1) // -> [4,5,6]

every()：判断数组中是否每一项都满足条件，只有所有项都满足条件，才返回true

// 注意： every()接收一个回调函数作为参数，这个回调函数需要有返回值，
// every(callback);callback默认有三个参数，分别为value，index，self。 
let arr = [1,2,3,4,5,6]; 
let bool = arr.every(item => item > 0); 
console.log(bool); // -> true; 
 
let bool = arr.every(item => item > 3); 
console.log(bool); // -> false;

some()：判断数组中是否存在满足条件的项，只要有一项满足条件，就会返回true，否则返回false

// 注意： some()接收一个回调函数作为参数，这个回调函数需要有返回值，
// some(callback);callback默认有三个参数，分别为value，index，self。 
 
let arr = [1,2,3,4,5,6]; 
let bool = arr.some(item => item > 3); 
console.log(bool) // -> true; 
 
let bool = arr.some(item => item > 6); 
console.log(bool) // -> false;

4.数组排序与反转

sort()：对数组的元素进行排序，并返回排序后的数组。默认按字符串unicode编码排序

/*
    数组.sort(fn => fn()):将数组按照指定的顺序进行排序
    @params:
        函数（可有可无），如果需要实现多位数正常排序，需要传递函数，并使返回值为a-b(升序)或者b-a（降序），属于冒泡排序机制
    @return:
        排序后的新数组
*/
 
let arr = [12,45,6,21,51,81],
    //升序：
    newArr = arr.sort((a,b) => (a-b));
console.log(newArr,arr)

reverse()：反转数组中元素的顺序，会改变原数组

/*
    数组.reverse():将数组的元素倒过来排序
    @params:
    @return:重新排序后的新数组
*/
 
let arr = [1,2,5,4,3,6,7],
    newArr = arr.reverse();
console.log(newArr,arr)

5.数组迭代与映射

forEach()：遍历数组，没有返回值

// 注意：forEach(callback);callback默认有三个参数，
// 分别为value(遍历到的数组的数据)，index(对应的索引)，self(数组自身)。 
 
let arr = ['张三','李四','王五','马六'] 
let a = arr.forEach((item,index,self)=>{ 
    console.log(item + "--" + index + "--" + (arr === self)); 
}) 
// 打印结果为： 
// 张三--0--true 
// 李四--1--true 
// 王五--2--true 
// 马六--3--true 
console.log(a); // -> undefined---forEach没有返回值 //该方法为遍历方法，不会修改原数组

map()：map的回调函数会将执行结果返回，最后将所有回调函数的返回值组成新数组返回，同forEach

//注意：map(callback);callback默认有三个参数，
// 分别为value，index，self。
// 跟上面的forEach()的参数一样 
let arr = ['张三','李四','王五','马六']; 
let arr1 = arr.map(item => { 
    return '你好：'+item 
}) 
console.log(arr1) // -> ['你好：张三', '你好：李四', '你好：王五', '你好：马六']

？reduce()：数组的第一项开始，逐个遍历到最后，迭代数组的所有项，然后构建一个最终返回的值

// 注意：　参数：reduce()接收一个或两个参数：
// 第一个是回调函数，表示在数组的每一项上调用的函数；
// 第二个参数（可选的）作为归并的初始值，被回调函数第一次执行时的第一个参数接收。
// reduce(callback,initial);
// callback默认有四个参数，分别为prev，now，index，self。
// callback返回的任何值都会作为下一次执行的第一个参数。 
// 如果initial参数被省略，那么第一次迭代发生在数组的第二项上，
// 因此callback的第一个参数是数组的第一项，第二个参数就是数组的第二项。 
 
let arr = [10,20,30,40,50]; 
let sum = arr.reduce((prev,now) => prev+now) 
console.log(sum); // -> 150; 
 
let sum = arr.reduce((prev,now) => prev+now,110) 
console.log(sum) // 260

6.数组合并与扁平化

concat()：合并两个或多个数组，返回一个新数组

/*
    数组.concat(): 在指定数组后面将多个元素拼接成一个新数组
    @params:多个任意类型值
    @return:返回拼接后的新数组
*/
 
let arr = [1,2,3,4],
    arr2 = [5,6,7],
    newArr = arr.concat(arr2,'morning',{name:"Zack"})
console.log(newArr,arr,arr2)

flat()：创建一个新数组，将所有子数组元素递归连接到该数组中。

注意事项
如果原数组的元素不是数组（即没有子数组），则 flat() 方法将返回原数组的浅拷贝。
如果指定的深度小于 1，则 flat() 方法将不会进行任何扁平化操作，并返回原数组的浅拷贝。
如果数组中的某个元素是空数组，则扁平化时该空数组会被忽略（即不会作为结果数组的元素）。
flat() 方法不会改变原数组，而是返回一个新的扁平化后的数组

let arr = [1, 2, [3, 4], [5, [6, 7]]];  
  
// 不指定深度，默认深度为 1  
let flatArr1 = arr.flat();  
console.log(flatArr1); // 输出: [1, 2, 3, 4, [5, [6, 7]]]  
  
// 指定深度为 2  
let flatArr2 = arr.flat(2);  
console.log(flatArr2); // 输出: [1, 2, 3, 4, 5, [6, 7]]  
  
// 指定深度为 Infinity，完全扁平化  
let flatArr3 = arr.flat(Infinity);  
console.log(flatArr3); // 输出: [1, 2, 3, 4, 5, 6, 7]

7.数组转字符串

toString()：不改变原数组

/*
    数组.toString:将数组转换为字符串
    @params:
    @return:转换后的字符串
*/
 
let arr = [1,'2',undefined,{name:"Zack"}],
    newArr = arr.toString();

join()：不改变原数组

/*
    数组.join([string]):将数组以指定分隔符的形式分隔成字符串
    @params:指定的分隔符（字符串格式）
    @return:转换后的字符串
*/
 
let arr = [0,1,2,3,4,5],
    newArr = arr.join('|');
console.log(newArr,arr) // 0|1|2|3|4|5，[0,1,2,3,4,5]

二、其中比较常用的？