JavaScript中的数组方法总结

总结：

顺序	方法名	功能
01	push()	(在结尾)向数组添加一或多个元素
02	unshift()	(在开头)向数组添加一或多个元素
03	pop()	删除数组的最后一位
04	shift()	移除数组的第一项
05	reverse()	反转数组中的元素
06	sort()	以字母顺序(字符串Unicode码点)对数组进行排序
07	splice()	在指定位置删除指定个数元素再增加任意个数元素（实现数组任意位置的增删改)
08	concat()	通过合并（连接）现有数组来创建一个新数组
09	join()	用特定的字符,将数组拼接形成字符串 (默认",")
10	slice()	裁切指定位置的数组
11	toString()	将数组转换为字符串
12	valueOf()	查询数组原始值
13	indexOf()	查询某个元素在数组中第一次出现的位置
14	lastIdexOf()	反向查询数组某个元素在数组中第一次出现的位置
15	forEach()	(迭代) 遍历数组,每次循环中执行传入的回调函数
16	map()	(迭代) 遍历数组, 每次循环时执行传入的回调函数,根据回调函数的返回值,生成一个新的数组
17	filter()	(迭代) 遍历数组, 每次循环时执行传入的回调函数,回调函数返回一个条件,把满足条件的元素筛选出来放到新数组中
18	every()	(迭代) 判断数组中所有的元素是否满足某个条件
19	some()	(迭代) 判断数组中是否存在,满足某个条件的元素
20	reduce()	(归并)遍历数组, 每次循环时执行传入的回调函数,回调函数会返回一个值,将该值作为初始值prev,传入到下一次函数中
21	find()	遍历数组,执行回调函数,回调函数执行一个条件,返回满足条件的第一个元素,不存在返回undefined
22	findIndex()	遍历数组,执行回调函数,回调函数接受一个条件,返回满足条件的第一个元素下标,不存在返回-1

用法：

push()

let arr = [1,2,3]
let newarr = arr.push(4,5,6)
console.log(arr)  // [1,2,3,4,5,6]
console.log(newarr)   // 6

unshift()

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

pop()

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

shift()

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

reverse()

let arr = [1,2,3]
let newarr = arr.reverse()
console.log(arr)  // [3,2,1]
console.log(newarr)   //[3,2,1]

sort()

let arr = [7,4,1,8,9,6,2,3,5]
arr.sort()
console.log(arr)   //[1,2,3,4,5,6,7,8,9]

语法:arr.sort(function(a,b))

用法：

如果 function(a, b) {return: a - b;} ，=> a - b > 0 那么 a 会被排列到 b 之前; (从小到大排序) 如果 function(a, b) {return: b - a;} ，=> b - a > 0 那么b会被排列到 a 之前； (从大到小排序)

let arr = [7,5,3,4,6,8,1,2,9]
arr.sort(function (a,b){
    return a - b;
})
console.log(arr)   // [1,2,3,4,5,6,7,8,9]

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

splice()

**功能：**向数组中添加，或从数组删除，或替换数组中的元素，然后返回被删除/替换的元素所组成的数组。可以实现数组的增删改

语法：arrayObject.splice(index,howmany,item1,…,itemX)

let arr = [1,2,3,4,5,6]
let newarr = arr.splice(2,1,7,8,9)
console.log(arr)   // [1,2,7,8,9,4,5,6]
console.log(newarr)   // [3]

let arr = [1,2,3,4,5,6]
let newarr = arr.splice(0,1)
console.log(arr)   // [2,3,4,5,6]
console.log(newarr)   // [1]

concat()

let arr1 = [1,2,3]
let arr2 = [4,5,6]
let arr3 = [7,8,9]
let newarr = arr.concat(arr2,arr3)
console.log(newarr)   // [1,2,3,4,5,6,7.8,9]
console.log(arr1)   // [1,2,3]

join()

**功能：**用特定的字符,将数组拼接形成字符串 (默认",")

let arr = ['a','b','c','d']
let arr1 = arr.join("-")   // "a-b-c-d"
let arr2 = arr.join("/")   // "a/b/c/d"
let arr3 = arr.join()   // "a,b,c,d"

slice()

**功能：**裁切指定位置的数组，返回值为被裁切的元素形成的新数组，不改变原数组

语法：arr[].slice(startIndex,endIndex)

**注：**起始下标和终止下标的区间是左闭右开 [ a ，b) ；能取到起始，取不到终止

let arr = ['a','b','c','d','e']
let arr1 = arr.slice(1,4)
console.log(arr1)   // ['b','c','d']

toString()

**功能：**直接将数组转换为字符串,并返回转换后的新数组,不改变原数组。与join()方法不添加任何参数时用法相同

let arr = ['a','b','c','d','e']
let arr1 = arr.toString()
console.log(arr1)   // "a,b,c,d,e"

valueOf()

**功能：**返回数组的原始值

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

indexOf()

**功能：**查询某个元素在数组中第一次出现的位置存在该元素,返回索引；不存在返回 -1

let arr = [1,2,3,4,3]
let arr1 = arr.indexOf(3)   // 2
let arr2 = arr.indexOf("3")   // -1

lastIndexOf()

**功能：**查询某个元素在数组中最后一次出现的位置。存在该元素,返回索引,不存在返回 -1

let arr = [1,2,3,4,3]
let arr1 = arr.lastIndexOf(3)   // 4
let arr2 = arr.lastIndexOf("3")   // -1

forEach()

**功能：**遍历数组,每次循环中执行传入的回调函数。没有返回值,或理解为返回值为undefined,不改变原数组.

let arr = [1,2,3,4,5,6]
arr.forEach(function(item,index,array){
    console.log(index,item,array)
})
// 0 1 [1,2,3,4,5,6]
// 1 2 [1,2,3,4,5,6]
// 2 3 [1,2,3,4,5,6]
// 3 4 [1,2,3,4,5,6]
// 4 5 [1,2,3,4,5,6]
// 5 6 [1,2,3,4,5,6]

let arr = [12,23,34,45,56,67]
let sum = 0
arr.forEach(function(item){
    sum += item
})
console.log(sum)   // 237

map()

**功能：**遍历数组, 每次循环时执行传入的回调函数,根据回调函数的返回值,生成一个新的数组 , 同forEach() 方法,但是map()方法有返回值,可以return出来;

**参数：**item:每次循环的当前元素, index:当前项的索引, array:原始数组；

let arr = [1,2,3,4,5,6]
let newarr = arr.map(function(item,index,array){
    return item + 2
})
console.log(arr)   // [1,2,3,4,5,6]
console.log(newarr)   // [3,4,5,6,7,8]

filter()

功能： 遍历数组, 每次循环时执行传入的回调函数,回调函数返回一个条件,把满足条件的元素筛选出来放到新数组中.

**参数：**item:每次循环的当前元素, index:当前项的索引, array:原始数组；

let arr = [1,2,3,4,5,6]
let newarr = arr.filter(function(item,index,array){
    return item % 2 == 0
})
console.log(arr)   // [1,2,3,4,5,6]
console.log(newarr)   / [2,4,6]

every()

**功能：**判断数组中所有的元素是否满足某个条件

let arr = [1,2,3,4,5,6]
let arr1 = arr.every(function(item,index,array){
    return item < 6
})
let arr2 = arr.every(function(item,index,array){
    return item <= 6
})
console.log(arr1)   // false
console.log(arr2)   // true

some()

**功能：**判断数组中是否存在,满足某个条件的元素

let arr = [1,2,3,4,5,6]
let arr1 = arr.some(function(item,index,array){
    return item > 6
})
let arr2 = arr.some(function(item,index,array){
    return item >= 6
})
console.log(arr1)   // false
console.log(arr2)   // true

reduce()

功能：遍历数组, 每次循环时执行传入的回调函数,回调函数会返回一个值,将该值作为初始值prev,传入到下一次函数中, 返回最终操作的结果

let arr = [2,3,4,5]
let sum = arr.reduce(function(prev,item,index,arraay){
    console.log(prev,item,index)
    return qrev + item
})
console.log(arr,sum)
// 2 3 1
// 5 4 2
// 9 5 3
// [2,3,4,5] 14

find()

**功能：**遍历数组每次循环执行回调函数,回调函数接受一个条件返回满足条件的第一个元素,不存在则返回undefined

let arr = [1,2,3,4,5,6]
let newarr = arr.find(function(item,index,array){
    return item > 4
})
console.log(newarr)   // 5

findIndex()

**功能：**遍历数组,执行回调函数,回调函数接受一个条件,返回满足条件的第一个元素索引,不存在则返回-1

let arr = [1,2,3,4,5,6]
let newarr = arr.findIndex(function(item,index,array){
    return item > 4
})
console.log(newarr)   // 3

fill()

**功能：**用给定的值填充一个数组

let arr = ['a','b','c','d']
let newarr = arr.fill('sss',1,2)
console.log(newarr)   // ['a','sss','c',d]

flat()

**功能：**用于将嵌套的数组“拉平”，成为一堆数组

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

js常用的数组方法总结