javascript数组的方法

数组的方法

改变元素组的方法

unshift

向数组的开头添加一个或更多元素，并返回新的长度

var a = [1, 2, 3];
a.unshift(6); // 4
a // [6, 1, 2, 3]

shift

删除并返回数组的第一个元素

var a = [1, 2, 3];
a.shift(); // 1
a // [2, 3]

push

向数组的末尾添加一个或更多元素，并返回新的长度

var a = [1, 2, 3];
a.push(); // 1
a // [2, 3]

pop

删除数组的最后一个元素并返回删除的元素

var a = [1, 2, 3];
a.pop(); // 3
a // [1, 2]

reverse

反转数组的元素顺序。

var a = [1, 2, 3];
a.reverse(); // [3, 2, 1]
a // [3, 2, 1]

sort

排序。

// 升序
var a = [1, 3, 2];
a.sort(function (a, b){ return a - b }); // [1, 2, 3]
a // [1, 2, 3]
// 降序
var a = [1, 3, 2];
a.sort(function (a, b){ return b - a }); // [3, 2, 1]
a // [3, 2, 1]

splice

从数组中删除或添加元素，第一个参数开始位置下标，第二个参数删除数量，为定义则从开始位置全部删除，第三个参数及之后为添加项。返回删除的元素

var a = [1, 3, 2];
a.splice(2); // [2]
a // [1, 3]
var b = [1, 2, 4];
b.splice(1, 1) // [2]
b // [1, 4]
var c = [2, 3, 4];
c.splice(1, 2, 5, 6, 7); // [3, 4]
c // [2, 5, 6, 7]

copyWithin

从数组的指定位置复制元素到另一个指定位置，第一个参数指插入元素的位置，第二个参数指插入开始位置，第三个参数指插入结束位置，第二第三个参数可省略。

var a = [1, 2, 3, 4, 5, 6]
a.copyWithin(2, 1, 3) //[1, 2, 2, 3, 5, 6]
a // [1, 2, 2, 3, 5, 6]
var b = [1, 2, 3, 4, 5, 6];
a.copyWithin(2) // [1, 2, 1, 2, 3, 4]
a // [1, 2, 1, 2, 3, 4]

fill

填充数组，第一个参数是填充值，第二个参数是开始位置，第三个参数是结束位置，二三可选。

// 升序
var a = [];
var b = [1, 2, 3];
a.fill(1); // []
a.fill(1, 0, 5); // []
b.fill(1); // [1, 1, 1]
b // [1, 1, 1]
b.fill(2, 1, 2); // [1, 2, 1]

不改变原数组的方法

concat

连接两个或更多的数组，并返回拼接好的数组

var a = [1, 2, 3];
var b = ["1", "2", "3"];
var c = ["a"]
console.log(a.concat(b, c)) // [1, 2, 3, '1', '2', '3', 'a']

entries

返回数组的可迭代对象

var a = [1, 2, 3];
a.entries()// Array Iterator {}

keys()

返回数组的可迭代对象，包含原始数组的键

var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.keys(); // Array Iterator {}

every

判断是否数组每一项都符合

var a = [1, 2, 3];
a.every(function (f) { return f === 2 }) // false

some

判断是否数组是否有一项符合

var a = [1, 2, 3];
a.some(function (f) { return f === 2 }) // true

filter

判断并返回符合条件的数组

var a = [1, 2, 3, 4, 4, 5, 4]
a.filter(function (f) {
    return f > 3
}) // [4, 4, 5, 4]

find

查找并返回符合条件的第一个元素，没有则返回Undefined

var a = [1, 2, 3, 4, 4, 5, 4]
a.find(function (f) {
    return f > 1
}) // 2

findIndex

查找并返回符合条件的第一个元素索引，没有则返回-1

var a = [1, 2, 3, 4, 4, 5, 4]
a.findIndex(function (f) {
    return f > 1
}) // 1

indexOf

查找并返回符合条件的第一个元素索引，没有则返回-1

var a = [1, 2, 3, 4, 4, 5, 4]
a.indexOf(3) // 2

lastIndexOf

向前查找并返回符合条件的第一个元素索引，没有则返回-1

var a = [1, 2, 3, 4, 4, 5, 4]
a.lastIndexOf(3) // 2

includes

判断数组是否包含指定项，第一个参数为查找元素，第二个参数是开始位置，可选

var a = [1, 3, 4, 5, 6]
a.includes(4) // true
a.includes(4, 3) // false

forEach

调用数组的每一个元素，并将元素传递给回调函数，forEach不支持continue, break

var a = [1, 2, 3]
var b = a.forEach(function (f) {
    console.log(f++)
}) // 2 3 4

map

调用数组的每一个元素，并将元素传递给回调函数，返回处理后的数组

var a = [1, 2, 3, 4, 4, 5, 4]
var b = a.map(function (f) {
    return ++f
}) // [2, 3, 4, 5, 5, 6, 5]

var c = [1, 2, 3, 4, 4, 5, 4]
var d = a.map(function (f) {
    if (f > 3) return f
})
d // [undefined, undefined, undefined, 4, 4, 5, 4]

from

通过拥有length属性或可迭代属性的对象来返回一个数组,第一个参数，要转换为数组的对象，第二个参数，每个元素要调用的回调，帝骖个参数，回调函数中的this对象。

var obj = {"1": 1, 2: 2, length: 3}
Array.from(obj) // [undefined, 1, 2]
var obj1 = {"0": 0, "1": 1, "2": 2, "length": 3}
Array.from(obj, f => f)
// [0, 1, 2]

join

数组拼接成字符串，第二个参数指定连接符

[1, 2, 3].join() // '1,2,3'
[1, 2, 3].join(" + ") // '1 + 2 + 3'

toString

把数组转换为字符串

[1, 2, 3].toString() // '1,2,3'

reduce

计算数组元素相加后的总和

[1, 2, 3, 4, 5, "0"].reduce(function (total, num) {
    return total + num;
}) // '150'

reduceRight

计算数组元素相加后的总和，从右向左

[1, 2, 3, 4, 5, "0"].reduceRight(function (total, num) {
    return total + num;
}) // '054321'

flat

多维数组扁平化，默认扁平化一层，可以指定层数

[1, [2, [3, [4, 5]]], 6].flat() // [1, 2, Array(2), 6]
[1, [2, [3, [4, 5]]], 6].flat(2) // [1, 2, 3, Array(2), 6]
[1, [2, [3, [4, 5]]], 6].flat(3) // [1, 2, 3, 4, 5, 6]

flatMap

遍历原数组的每一个元素，为每一个元素传入一个回调函数，并将结果压缩为一个新数组。

["I'm ZhangKai", "I'm 20 years old!"].flatMap(f => {
    return f.split(" ")
})
// ["I'm", 'ZhangKai', "I'm", '20', 'years', 'old!']