js数组常用的方法

最新推荐文章于 2024-10-02 05:39:15 发布

wan_da

最新推荐文章于 2024-10-02 05:39:15 发布

阅读量264

点赞数

文章标签： javascript

本文链接：https://blog.csdn.net/wan_da/article/details/114896374

版权

9.indexOf()和lastIndexOf()

1.join()

join,将数组转换成字符串，括号中规定每个字符的连接符，默认是 ,

书写格式：join(" ")

let arr = [1,2,3];

console.log(arr.join());
//1,2,3

console.log(arr.join("-"));
//1-2-3


//此方法只能获取每一个字符添加连接符，并不能改变原数组

2.push()和pop()

push() : 从数组的尾部向其添加内容，返回值是新数组的长度

pop() : 从数组的尾部删除数组的最后一项，返回值是被移除的元素

let arr = [4,3,2];
let con = [7,8,9];

console.log(arr.push(1));
//  4
console.log(arr)
//[4,3,2,1]
//如果插入的内容是字符串则括号内需要加 " "


console.log(con.pop())
//  9
console.log(con)
//[7,8]

3.shift()和unshift()

shift()：删除原数组第一项，并返回删除元素的值；如果数组为空则返回undefined

unshift:将参数添加到原数组开头，并返回数组的长度

let arr = [4,3,2];
let con = [7,8,9];

console.log(arr.shift());
console.log(arr)
//[3,2]
//如果插入的内容是字符串则括号内需要加 " "


console.log(con.unshift(1,2))
//  5
console.log(con)
//[7,8,9,1,2]

4.sort(参数)

参数：可选如果省略则按照Unicode编码进行排序

该方法比较字符串，如果要实现数值排序则需要在方法中创建一个函数

有两种情况

let arr = [7,8,9,1,2,3,4,5,6];



arr.sort((a,b)=>a-b);//升序、
console.log(arr)
//[1,2,3,4,5,6,7,8,9]


arr.sort((a,b)=>b-a);//降序
console.log(arr);
//[ 9, 8, 7, 6, 5, 4, 3, 2, 1 ]

5.reverse()

颠倒数组

返回值是颠倒后的数组

let arr = [1, 2, 3];

console.log(arr.reverse());
//[3,2,1]

6.concat()

将参数添加到原数组中这个方法会先创建当前数组一个副本，然后将接收到的参数添加到这个副本的末尾，最后返回新构建的数组。在没有给 concat()方法传递参数的情况下，它只是复制当前数组并返回副本。

let arr = [1,3,5,7];

let arrCopy = arr.concat(9,[11,13]);

console.log(arrCopy); 　
//[1, 3, 5, 7, 9, 11, 13]


console.log(arr); 　
// [1, 3, 5, 7](原数组未被修改)

7.slice()

slice(参数1,参数2)

参数1：必须开始截取的位置，可以为负数

参数2：可选结束截取的位置，可以为负数，如果省略则截取到数组的末尾

返回值：截取的数组

字符串对象也是用此方法

let arr = [1,3,5,7,9,11];
let arr1 = arr.slice(1);
let arr2 = arr.slice(1,4);
let arr3 = arr.slice(1,-2);
let arr4 = arr.slice(-4,-1);


console.log(arr); 　　　　　　　　　
//[1, 3, 5, 7, 9, 11](原数组没变)

console.log(arr1); 　　　　　　
//[3, 5, 7, 9, 11]

console.log(arr2); 　　　
//[3, 5, 7]

console.log(arr3); 　　　　　
//[3, 5, 7]

console.log(arr4); 　　　　
//[5, 7, 9]

8.splice()

splice(参数1,参数2,参数3)

参数1 ：必须开始删除添加的索引，可以为负数

参数2 ：必须删除元素的个数，不删除则为零

参数3 ：可选添加的元素多个元素之间用逗号隔开

删除：返回值是删除掉的元素组成的新数组

let arr = [1, 2, 3, 4, 5, 6];

console.log(arr.splice(1, 3));
//[ 2, 3, 4 ]

console.log(arr)
//[ 1, 5, 6 ]

插入：

let arr = [1, 2, 3, 4, 5, 6];
    
arr.splice(2,0,10,20)

console.log(arr)
//[ 1, 2, 10, 20, 3, 4, 5, 6 ]

替换：返回值是被替换的元素组成的数组

let arr = [1, 2, 3, 4, 5, 6];


console.log(arr.splice(1, 1, 10, 20));
//2 

console.log(arr)
// [ 1, 10, 20, 3, 4, 5, 6 ]

9.indexOf()和lastIndexOf()

indexOf(参数1,参数2)

参数1 ：必须要查找的元素

参数2：可选开始查找的位置，如果省略不写默认从索引为0(开头)的位置开始查找

返回值;数字如果找不到元素返回 -1

let arr = [1, 2, 3, 4, 5, 6];


console.log(arr.indexOf(6, 2));
//5 可以找到则返回从2到6的元素的个数

console.log(arr.indexOf(1, 2));
//-1 从索引为2的位置开始查找1 未找到返回 -1

lastIndexOf()

参数1 ：必须要查找的元素

参数2：可选开始查找的位置，如果省略不写默认从尾部的位置开始查找

返回值;数字如果找不到元素返回 -1

10.forEach()

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

语法：

arr.forEach(function(res,index,arr){
...
});

res代表数组中的每一个元素

index代表每一个元素对应的索引

arr代表原数组

let arr = [1, 2, 3, 4, 5];
arr.forEach(function(x, index, a){
console.log(x,index,a);
});
// 输出为：
//1 0  [ 1, 2, 3, 4, 5 ]

//2 1  [ 1, 2, 3, 4, 5 ]

//3 2  [ 1, 2, 3, 4, 5 ]

//4 3  [ 1, 2, 3, 4, 5 ]

//5 4 [ 1, 2, 3, 4, 5 ]

11.map()

map()：映射

语法：

arr.map(function(res,index,arr){
...
});

res代表数组中每一个元素
index代表数组中每一个元素的索引
arr代表数组

let arr = [1, 2, 3, 4, 5];
        var arr2 = arr.map(function(item, index, a) {
            console.log(item, index, a)
            return item * item;
        });

//1 0  [ 1, 2, 3, 4, 5 ]

//2 1 [ 1, 2, 3, 4, 5 ]

//3 2  [ 1, 2, 3, 4, 5 ]

//4 3  [ 1, 2, 3, 4, 5 ]

//5 4  [ 1, 2, 3, 4, 5 ]


console.log(arr2);　　　　　　　　 
// [ 1, 4, 9, 16, 25 ]

12.filter()

filter() 过滤

语法

arr.reduce(function(res,index,arr){
...
});

res代表数组中每一个元素
index代表数组中每一个元素的索引
arr代表数组

let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

 var arr2 = arr.filter(function(res, index, a) {
        return index % 3 === 0 || res > 8
 })


console.log(arr2);
//[1,4,7,9,10]

13.reduce()

arr.reduce(function(prev,cur,index,arr){
...
}, init);

arr 表示原数组；
prev 表示上一次调用回调时的返回值，或者初始值 init;
cur 表示当前正在处理的数组元素；
index 表示当前正在处理的数组元素的索引，若提供 init 值，则索引为0，否则索引为1；
init 表示初始值。

13.1求数组项之和

let sum = arr.reduce(function (prev, cur) {
    return prev + cur;
},0);

13.2求数组项最大值

let max = arr.reduce(function (prev, cur) {
    return Math.max(prev,cur);
});

13.3数组去重

let newArr = arr.reduce(function (prev, cur) {
    prev.indexOf(cur) === -1 && prev.push(cur);
    return prev;
},[]);

实现的基本原理如下：

1>初始化一个空数组
2> 将需要去重处理的数组中的第1项在初始化数组中查找，如果找不到（空数组中肯定找不到），就将该项添加到初始化数组中
3> 将需要去重处理的数组中的第2项在初始化数组中查找，如果找不到，就将该项继续添加到初始化数组中
4>……
5> 将需要去重处理的数组中的第n项在初始化数组中查找，如果找不到，就将该项继续添加到初始化数组中
6> 将这个初始化数组返回