数组方法
文章目录
- 数组方法
- **1 arr.push() **
- 2 arr.pop()
- 3 arr.shift()
- 4 arr.unshift()
- 5 arr.splice(i,n)
- **6 arr.concat()**
- **7 str.split() **
- 8 arr.sort()
- **9 arr.reverse() **
- **10 arr.slice(start,end) **
- **11 arr.forEach(callback) **
- **12 arr.map(callback) **
- 13 arr.filter(callback)
- **14 arr.every(callback) **
- **15 arr.some() **
- **16 arr.reduce(callback, initialValue) **
- **17 arr.reduceRight(callback, initialValue) **
- **18 arr.indexOf() **
- **19 arr.lastIndexOf() **
- 20 Array.from()
- **21 Array.of() **
- **22 arr.copyWithin() **
- **23 arr.find(callback)**
- **25 arr.fill(target, start, end)**
- 26 arr.includes()
- 27 arr.keys()
- 28 arr.values()
- 29 arr.entries()
- 30 arr.flat()
- **31 arr.flatMap()**
- Array 方法(表格版)
- arr[实例方法](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array#实例方法)(链接版)
**1 arr.push() **
从后面添加元素,返回值为添加完后的数组的长度
let arr = [1,2,3,4,5]
console.log(arr.push(5)) // 6
console.log(arr) // [1,2,3,4,5,5]
2 arr.pop()
从后面删除元素,只能是一个,返回值是删除的元素*
let arr = [1,2,3,4,5]
console.log(arr.pop()) // 5
console.log(arr) //[1,2,3,4]
3 arr.shift()
从前面删除元素,只能删除一个 返回值是删除的元素
let arr = [1,2,3,4,5]
console.log(arr.shift()) // 1
console.log(arr) // [2,3,4,5]
4 arr.unshift()
从前面添加元素, 返回值是添加完后的数组的长度
let arr = [1,2,3,4,5]
console.log(arr.unshift(2)) // 6
console.log(arr) //[2,1,2,3,4,5]
5 arr.splice(i,n)
删除从i(索引值)开始之后的那个元素。返回值是删除的元素*
参数: i 索引值 n 个数
let arr = [1,2,3,4,5]
console.log(arr.splice(2,2)) //[3,4]
console.log(arr) // [1,2,5]
6 arr.concat()
连接两个数组 返回值为连接后的新数组
let arr = [1,2,3,4,5]
console.log(arr.concat([1,2])) // [1,2,3,4,5,1,2]
console.log(arr) // [1,2,3,4,5]
**7 str.split() **
将字符串转化为数组
let str = '123456'
console.log(str.split('')) // ["1", "2", "3", "4", "5", "6"]
8 arr.sort()
将数组进行排序,返回值是排好的数组,默认是按照最左边的数字进行排序,不是按照数字大小排序的,见例子。
let arr = [2,10,6,1,4,22,3]
console.log(arr.sort()) // [1, 10, 2, 22, 3, 4, 6]
let arr1 = arr.sort((a, b) =>a - b)
console.log(arr1) // [1, 2, 3, 4, 6, 10, 22]
let arr2 = arr.sort((a, b) =>b-a)
console.log(arr2) // [22, 10, 6, 4, 3, 2, 1]
**9 arr.reverse() **
将数组反转,返回值是反转后的数组
let arr = [1,2,3,4,5]
console.log(arr.reverse()) // [5,4,3,2,1]
console.log(arr) // [5,4,3,2,1]
**10 arr.slice(start,end) **
切去索引值start到索引值end的数组,不包含end索引的值,返回值是切出来的数组
let arr = [1,2,3,4,5]
console.log(arr.slice(1,3)) // [2,3]
console.log(arr) // [1,2,3,4,5]
**11 arr.forEach(callback) **
遍历数组,无return
*注意:(伪数组转成真数组才能遍历 Array.prototype.slice.call(伪数组) )
callback的参数: value --当前索引的值
index --索引
array --原数组
let arr = [1,2,3,4,5]
arr.forEach( (value,index,array)=>{
console.log(`value:${value} index:${index} array:${array}`)
})
// value:1 index:0 array:1,2,3,4,5
// value:2 index:1 array:1,2,3,4,5
// value:3 index:2 array:1,2,3,4,5
// value:4 index:3 array:1,2,3,4,5
// value:5 index:4 array:1,2,3,4,5
let arr = [1,2,3,4,5]
arr.forEach( (value,index,array)=>{
value = value * 2
console.log(`value:${value} index:${index} array:${array}`)
})
console.log(arr)
// value:2 index:0 array:1,2,3,4,5
// value:4 index:1 array:1,2,3,4,5
// value:6 index:2 array:1,2,3,4,5
// value:8 index:3 array:1,2,3,4,5
// value:10 index:4 array:1,2,3,4,5
// [1, 2, 3, 4, 5]
**12 arr.map(callback) **
映射数组(遍历数组),有return 返回一个新数组
callback的参数: value --当前索引的值
index --索引
array --原数组
let arr = [1,2,3,4,5]
arr.map( (value,index,array)=>{
value = value * 2
console.log(`value:${value} index:${index} array:${array}`)
})
console.log(arr)
ps: arr.forEach()和arr.map()的区别
\1. arr.forEach()是和for循环一样,是代替for。arr.map()是修改数组其中的数据,并返回新的数据。
\2. arr.forEach() 没有return arr.map() 有return
13 arr.filter(callback)
过滤数组,返回一个满足要求的数组\
例如做搜索功能
let arr = [1,2,3,4,5]
let arr1 = arr.filter( (i, v) => i < 3)
console.log(arr1) // [1, 2]
**14 arr.every(callback) **
依据判断条件,数组的元素是否全满足,若满足则返回ture
let arr = [1,2,3,4,5]
let arr1 = arr.every( (i, v) => i < 3)
console.log(arr1) // false
let arr2 = arr.every( (i, v) => i < 10)
console.log(arr2) // true
**15 arr.some() **
依据判断条件,数组的元素是否有一个满足,若有一个满足则返回ture
*可以做元素在不在数组中的验证
let arr = [1,2,3,4,5]
let arr1 = arr.some( (i, v) => i < 3)
console.log(arr1) // true
let arr2 = arr.some( (i, v) => i > 10)
console.log(arr2) // false
**16 arr.reduce(callback, initialValue) **
迭代数组的所有项,累加器,数组中的每个值(从左到右)合并,最终计算为一个值
参数: callback: previousValue 必选 --上一次调用回调返回的值,或者是提供的初始值(initialValue)
currentValue 必选 --数组中当前被处理的数组项
index 可选 --当前数组项在数组中的索引值
array 可选 --原数组
initialValue: 可选 --初始值
实行方法:回调函数第一次执行时,preValue 和 curValue 可以是一个值,如果 initialValue 在调用 reduce() 时被提供,那么第一个 preValue 等于 initialValue ,并且curValue 等于数组中的第一个值;如果initialValue 未被提供,那么preValue 等于数组中的第一个值.
let arr = [0,1,2,3,4]
let arr1 = arr.reduce((preValue, curValue) =>
preValue + curValue
)
console.log(arr1) // 10
let arr2 = arr.reduce((preValue,curValue)=>preValue + curValue,5)
console.log(arr2) // 15
**17 arr.reduceRight(callback, initialValue) **
与arr.reduce()功能一样,不同的是,reduceRight()从数组的末尾向前将数组中的数组项做累加。
实行方法:reduceRight()首次调用回调函数callbackfn时,prevValue 和 curValue 可以是两个值之一。如果调用 reduceRight() 时提供了 initialValue 参数,则 prevValue 等于 initialValue,curValue 等于数组中的最后一个值。如果没有提供 initialValue 参数,则 prevValue 等于数组最后一个值, curValue 等于数组中倒数第二个值。
let arr = [0,1,2,3,4]
let arr1 = arr.reduceRight((preValue, curValue) =>preValue + curValue)
console.log(arr1) // 10
let arr2 = arr.reduceRight((preValue,curValue)=>preValue + curValue,5)
console.log(arr2) // 15
ps:(如果对这两个方法不明白,可以查看大漠老师的实例 http://www.w3cplus.com/javascript/array-part-8.html)
**18 arr.indexOf() **
查找某个元素的索引值,若有重复的,则返回第一个查到的索引值若不存在,则返回 -1
let arr = [1,2,3,4,5,2]
let arr1 = arr.indexOf(2)
console.log(arr1) // 1
let arr2 = arr.indexOf(9)
console.log(arr2) // -1
**19 arr.lastIndexOf() **
** 和arr.indexOf()的功能一样,不同的是从后往前查找******
let arr = [1,2,3,4,5,2]
let arr1 = arr.lastIndexOf(2)
console.log(arr1) // 5
let arr2 = arr.lastIndexOf(9)
console.log(arr2) // -1
20 Array.from()
将伪数组变成数组,就是只要有length的就可以转成数组。 —es6
let str = '12345'
console.log(Array.from(str)) // ["1", "2", "3", "4", "5"]
let obj = {0:'a',1:'b',length:2}
console.log(Array.from(obj)) // ["a", "b"]
**21 Array.of() **
将一组值转换成数组,类似于声明数组 —es6
let str = '11'
console.log(Array.of(str)) // ['11']
等价于
console.log(new Array('11')) // ['11]
ps:
但是new Array()有缺点,就是参数问题引起的重载
console.log(new Array(2)) //[empty × 2] 是个空数组
console.log(Array.of(2)) // [2]
**22 arr.copyWithin() **
在当前数组内部,将制定位置的数组复制到其他位置,会覆盖原数组项,返回当前数组
参数: target --必选 索引从该位置开始替换数组项
start --可选 索引从该位置开始读取数组项,默认为0.如果为负值,则从右往左读。
end --可选 索引到该位置停止读取的数组项,默认是Array.length,如果是负值,表示倒数
let arr = [1,2,3,4,5,6,7]
let arr1 = arr.copyWithin(1)
console.log(arr1) // [1, 1, 2, 3, 4, 5, 6]
let arr2 = arr.copyWithin(1,2)
console.log(arr2) // [1, 3, 4, 5, 6, 7, 7]
let arr3 = arr.copyWithin(1,2,4)
console.log(arr3) // [1, 3, 4, 4, 5, 6, 7]
23 arr.find(callback)
找到第一个符合条件的数组成员
let arr = [1,2,3,4,5,2,4]
let arr1 = arr.find((value, index, array) =>value > 2)
console.log(arr1) // 3
24 arr.findIndex(callback)
找到第一个符合条件的数组成员的索引值
let arr = [1,2,3,4,5]
let arr1 = arr.findIndex((value, index, array) => value > 3)
console.log(arr1) // 3
25 arr.fill(target, start, end)
使用给定的值,填充一个数组,ps:填充完后会改变原数组
参数: target – 待填充的元素
start – 开始填充的位置-索引
end – 终止填充的位置-索引(不包括该位置)
let arr = [1,2,3,4,5]
let arr1 = arr.fill(5)
console.log(arr1) // [5, 5, 5, 5, 5]
console.log(arr) // [5, 5, 5, 5, 5]
let arr2 = arr.fill(5,2)
console.log(arr2)
let arr3 = arr.fill(5,1,3)
console.log(arr3)
26 arr.includes()
判断数中是否包含给定的值
let arr = [1,2,3,4,5]
let arr1 = arr.includes(2)
console.log(arr1) // ture
let arr2 = arr.includes(9)
console.log(arr2) // false
let arr3 = [1,2,3,NaN].includes(NaN)
console.log(arr3) // true
ps:与indexOf()的区别:
1 indexOf()返回的是数值,而includes()返回的是布尔值
2 indexOf() 不能判断NaN,返回为-1 ,includes()则可以判断
27 arr.keys()
遍历数组的键名
let arr = [1,2,3,4]
let arr2 = arr.keys()
for (let key of arr2) {
console.log(key); // 0,1,2,3
}
28 arr.values()
遍历数组键值
let arr = [1,2,3,4]
let arr1 = arr.values()
for (let val of arr1) {
console.log(val); // 1,2,3,4
}
29 arr.entries()
遍历数组的键名和键值
let arr = [1,2,3,4]
let arr1 = arr.entries()
for (let e of arr1) {
console.log(e); // 1,2,3,4
}
30 arr.flat()
会按照一个可指定的深度递归遍历数组,并将所有元素与遍历到的子数组中的元素合并为一个新数组返回。
flat()
和flatMap()
本质上就是是归纳(reduce) 与 合并(concat)的操作。
//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]
31 arr.flatMap()
方法首先使用映射函数映射每个元素,然后将结果压缩成一个新数组。它与 map 和 深度值1的 flat 几乎相同,但 flatMap 通常在合并成一种方法的效率稍微高一些。 这里我们拿map方法与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]]
Array 方法(表格版)
方法 | 描述 |
---|---|
concat() | 连接两个或多个数组,并返回已连接数组的副本。 |
copyWithin() | 将数组中的数组元素复制到指定位置或从指定位置复制。 |
entries() | 返回键/值对数组迭代对象。 |
every() | 检查数组中的每个元素是否通过测试。 |
fill() | 用静态值填充数组中的元素。 |
filter() | 使用数组中通过测试的每个元素创建新数组。 |
find() | 返回数组中第一个通过测试的元素的值。 |
findIndex() | 返回数组中通过测试的第一个元素的索引。 |
forEach() | 为每个数组元素调用函数。 |
from() | 从对象创建数组。 |
includes() | 检查数组是否包含指定的元素。 |
indexOf() | 在数组中搜索元素并返回其位置。 |
isArray() | 检查对象是否为数组。 |
join() | 将数组的所有元素连接成一个字符串。 |
keys() | 返回 Array Iteration 对象,包含原始数组的键. |
lastIndexOf() | 在数组中搜索元素,从末尾开始,并返回其位置。 |
map() | 使用为每个数组元素调用函数的结果创建新数组。 |
pop() | 删除数组的最后一个元素,并返回该元素。 |
push() | 将新元素添加到数组的末尾,并返回新的长度。 |
reduce() | 将数组的值减为单个值(从左到右)。 |
reduceRight() | 将数组的值减为单个值(从右到左)。 |
reverse() | 反转数组中元素的顺序。 |
shift() | 删除数组的第一个元素,并返回该元素。 |
slice() | 选择数组的一部分,并返回新数组。 |
some() | 检查数组中的任何元素是否通过测试。 |
sort() | 对数组的元素进行排序。默认排序顺序是在将元素转换为字符串,然后比较它们的UTF-16代码单元值序列时构建的 |
splice() | 从数组中添加/删除元素。添加时可以后面可以添加多个,不限量 |
toString() | 将数组转换为字符串,并返回结果。 |
unshift() | 将新元素添加到数组的开头,并返回新的长度。 |
valueOf() | 返回数组的原始值。 |
arr实例方法(链接版)
-
Returns the array item at the given index. Accepts negative integers, which count back from the last item.
返回给定索引处的数组项. 接受负整数,从最后一项开始计数.
-
用于合并两个或多个数组。此方法不会更改现有数组,而是返回一个新数组
-
浅复制数组的一部分到同一数组中的另一个位置,并返回它,不会改变原数组的长度
-
对一个类似数组或可迭代对象创建一个新的,浅拷贝的数组实例
-
返回一个新的
Array Iterator
对象,该对象包含数组中每个索引的键/值对 -
创建一个具有可变数量参数的新数组实例,而不考虑参数的数量或类型
-
测试一个数组内的所有元素是否都能通过某个指定函数的测试。它返回一个布尔值
-
用一个固定值填充一个数组中从起始索引到终止索引内的全部元素
-
创建一个新数组,其包含通过所提供函数实现的测试的所有元素
-
返回数组中满足提供的测试函数的第一个元素的值。否则返回
undefined
-
返回数组中满足提供的测试函数的第一个元素的索引。若没有找到对应元素则返回
-1
-
按照一个可指定的深度递归遍历数组,并将所有元素与遍历到的子数组中的元素合并为一个新数组返回
-
使用映射函数映射每个元素,然后将结果压缩成一个新数组
-
对数组的每个元素执行一次给定的函数
-
判断一个数组是否包含一个指定的值,如果包含则返回
true
,否则返回false
-
返回在数组中可以找到一个给定元素的第一个索引,如果不存在,则返回
-1
-
将一个数组的所有元素连接成一个字符串并返回这个字符串
-
返回一个包含数组中每个索引键的
Array Iterator
对象 -
返回指定元素在数组中的最后一个的索引,如果不存在则返回
-1
-
返回一个新数组,其结果是该数组中的每个元素是调用一次提供的函数后的返回值
-
从数组中删除最后一个元素,并返回该元素的值
-
将一个或多个元素添加到数组的末尾,并返回该数组的新长度
-
对数组中的每个元素执行一个由您提供的 reducer 函数(升序执行),将其结果汇总为单个返回值
-
接受一个函数作为累加器(accumulator)和数组的每个值(从右到左)将其减少为单个值
-
将数组中元素的位置颠倒,并返回该数组。该方法会改变原数组
-
从数组中删除第一个元素,并返回该元素的值
-
提取源数组的一部分并返回一个新数组
-
测试数组中是不是至少有一个元素通过了被提供的函数测试
-
对数组元素进行原地排序并返回此数组
-
通过删除或替换现有元素或者原地添加新的元素来修改数组,并以数组形式返回被修改的内容
-
Array.prototype.toLocaleString()
返回一个字符串表示数组中的元素。数组中的元素将使用各自的
Object.prototype.toLocaleString()
方法转成字符串 -
返回一个字符串表示指定的数组及其元素。数组中的元素将使用各自的
Object.prototype.toString()
方法转成字符串 -
将一个或多个元素添加到数组的头部,并返回该数组的新长度
-
返回一个新的
Array Iterator 对象
,该对象包含数组每个索引的值 -
返回一个新的
Array Iterator 对象
,该对象包含数组每个索引的值