Array方法汇总

const a = [1,2,3];

new Array() 构造函数

接受可选参数，返回一个数组

一个参数时，为设定数组长度 new Array(size) 返回数组的length属性为size

多个参数时，为指定数组的内容 new Array(3,11,8) // [3,11,8]

concat()　<返回一个新数组>

将参数中的元素添加到原数组的后面（参数若是数组，拆成元素（只针对一阶数组））

a.concat(4,5) => [1,2,3,4,5]

a.concat([4,5]) => [1,2,3,4,5]

a.concat([4,5],[6,7,8]) => [1,2,3,4,5,6,7,8]

a.concat(4,[5,6],[7,[8,9]]) => [1,2,3,4,5,6,7,[8,9]]　　特殊（二阶数组）

forEach(ｆ)　<什么都不返回，仅仅是操作数据>

为数组的每个元素调用参数函数，该函数带有三个参数（ｆ（array[i], i, array）），后两个不用的话可不写

a.forEach(function(x, i, array){ //x: 数组的元素　i: 元素的索引值　array: ａ数组

a[i]++; //a : [2,3,4]

})

indexOf(value,start)　<返回一个数字>

查找值在数组中的索引值

vaule: 要查找的值　start: 开始查找的起始位置(可能数组中有重复的值)

返回匹配成功的第一个该值在数组中的索引值，失败返回 '-1'

a.indexOf(2) => 返回 １

a.indexOf(4) => 返回 -1

a.indexOf(3,1) => 返回２

检测不到NaN

lastIndexOf()　<返回一个数字>

反向查找值在数组中的索引值

同上，相当于把数组反过来查找，返回的还是value在数组中的索引值

join()　<返回一个字符串>

将数组中的所有元素连接起来成为一个字符串

一个可选参数，默认是 ","

a.join(); => 1,2,3

a.join("+"); => 1+2+3

map()　<返回一个新数组>

为数组的每个元素调用参数函数，得到每个元素调用后函数的返回值组成的数组

该参数函数带有三个参数（ｆ（array[i], i, array）），后两个不用的话可不写

a.map(function(x){

return x*x;

}) => 返回[1,4,9]

pop()　<返回一个元素，改变了原数组>

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

a.pop(); => 返回3 原数组ａ变为 [1,2]

shift()　<返回一个元素，改变了原数组>

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

a.pop(); => 返回1 原数组ａ变为 [2,3]

push()　<返回改变后数组的长度length，改变原数组>

向原数组的最后面追加元素，将参数当成整体添加

a.push(1,2) => a: [1,2,3,1,2]

a.push(1,[4,5]) => a: [1,2,3,1,[4,5]]

unshift()　<返回改变后数组的长度length，改变原数组>

向原数组的最前面追加元素，将参数当成整体添加

a.unshift(1,2) => a: [1,2,1,2,3]

a.unshift(1,[4,5]) => a: [1,[4,5],1,2,3]

reduce(f，inital)　<返回一个值，不改变原数组>

返回数组的简化值，改值是最后一次调用 f 时的返回值

[1,2,3,4].reduce(function(x,y){return x*y}); // => 24:((1*2)*3)*4

第一次调用 f 时传入的是array的前两个元素，接下来会调用之前的计算值和array的下一个元素(按照从大到小的序号顺序)，最后一次调用 f 的返回值会成为reduce()方法的返回值

第二个参数 inital 是可选的，如果指定了 inital ，则 f 先调用的是该参数和array的第一个元素，再依次向下调用

[1,2,3,4].reduce(function(x,y){return x*y}，5); // => 120:(((5*1)*2)*3)*4

reduceRight(f，inital)　<返回一个值，不改变原数组>

具体的方法同reduce()方法，但 f 调用方向从又向左，

第二个可选参数像是放在array的尾部

[1,2,3,4].reduceRight(function(x,y){return x*y}); // => 24:((4*3)*2)*1

[1,2,3,4].reduceRight(function(x,y){return x*y}，5); // => 120:(((5*4)*3)*2)*1

reverse()　<返回改变后的数组，改变原数组>

颠倒数组中的元素顺序

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

slice(start，end)　<返回一个数组，不改变原数组>

start：数组片段的开始位置，如果为负数，表示从尾部开始计算

end：数组片段结束的后一个位置。如果没有指定，从start到原数组结尾。如果为负数，同上

[1,2,3,4,5].slice(0.3); //返回 [1,2,3]

[1,2,3,4,5].slice(3); //返回 [4,5]

[1,2,3,4,5].slice(1,-1); //返回 [2,3,4]

[1,2,3,4,5].slice(-3,-1); //返回 [3,4]

sort()　<什么都不返回，改变原数组>

对数组进行排序

splice(start,deleteCount,value,...)　删除：<返回由删除元素组成的数组，改变原数组>

插入：<什么都不返回，改变原数组>

start:开始插入或删除处的序号

deleteCount：要删除的元素个数，从start开始，并包含start的那个元素，

若为0，表示是插入元素

value：要插入的值

[1,2,3,4,5,6].splice(1,2) //返回[2,3] a: [1,4,5,6]

[1,2,3,4,5,6].splice(1,0,0,0) //返回[2,3] a: [1,0,0,2,3,4,5,6]

[1,2,3,4,5,6].splice(1,0,[0,0]) //返回[2,3] a: [1,[0,0],2,3,4,5,6] 将value当成一个整体插入

toString()　<返回数组的字符串形式，不改变原数组>

先将数组的每一个元素转化为字符串，再将这些字符串以逗号分隔的输出，返回值与调用join()不带参数的返回值是一样的

[1,2,"a",3,"ert"].toString(); //返回 "1,2,a,3,ert"

toLocaleString()

every(predicate)　<返回 bool，测试数组，不改变原数组>

测试数组的所有元素是否都满足某些条件，参数predicate测试函数，

从小到大遍历，都满足返回 true

只要有一个不满足，停止遍历，返回 false。空数组直接返回 true

[1,2,3].every(function(x){ return x < 5}); // true

[1,2,3].every(function(x){ return x < 2}); // false

[ ].every(function(x){ return flase}); // true

filter(predicate)　<返回数组，不改变原数组>

注意：predicate函数里可能会修改原数组

测试数组，返回由通过测试函数组成的子数组

[1,2,3].filter(function(x){ return x > 1}); // 返回 [2,3]

some(predicate)　<返回 bool，测试数组，不改变原数组>

测试数组中是否有元素满足测试函数

从小到大遍历，只要有一个满足，停止遍历，返回 true

都不满足返回false，空数组直接返回false

[1,2,3].some(function(x){ return x > 5 }); // 返回 false

[1,2,3].some(function(x){ return x > 2 }); // 返回 true

[ ].some(function(x){ return true }); // 返回 false

Array.form(对象)　<返回一个数组>

将类数组对象转化为数组

{'0':'a','1':'b','2':'c',length:3} 这种对象

还有DOM操作返回的NodeList对象集合

只要是部署了lterator接口的，都可以转化

Array.of()　<返回一个数组>

将一组数值转化为数组,将参数集合为一个数组，没有参数返回空数组

Array.of(3,4,5) // [3,4,5]

Array.of(3) // [3]

Array.of(undefined) // [undefined]

copyWithin(target,start,end)　<返回修改后的数组，改变原数组>

将指定位置的成员复制到其他位置（会覆盖原有成员）

第一个参数必写，其他两个可选

target：从该位置开始替换数据

start：从该位置开始读取数据，默认为0，负数表示倒数

end：到该位置停止读取数据，默认为数组长度，负数表示倒数（不包括该位）

[1,2,3,4,5].copyWithin(1,3,4) // [1,4,3,4,5]

find( f )　<遍历数组，不改变原数组>

用于找出第一个符合条件的数组成员，没有返回undefined

[1,4,-5,-10].find((n) => n < 0) // 返回 -5

可以查找到NaN

findindex( f )　<遍历数组，不改变原数组>

返回第一个符合条件的数组成员的位置，没有返回 -1

[1,5,10,15].findIndex(function(n){return n > 9}) // 返回 2

可以查找到NaN

fill(value,start,end)　<改变原数组>

用参数填充数组

value：必选，填充的内容

start：可选，开始的位置

end：可选，结束的位置 （不包括该位）

["a","b","c"].fill(7) // [7,7,7]

[1,1,1,1].fill()(7,1,2) // [1,7,1,1]

keys() values() entries() <遍历数组，不改变原数组>

遍历数组，都返回一个遍历器对象。可以结合for...of循环进行遍历

遍历数组的key值（索引值）

for(let index of ['a','b'].keys()){ console.log(index) } // 依次打印出 0 1

遍历数组的value值（内容值）

for(let elem of ['a','b'].values()){ console.log(elem) } // 依次打印出 0 1

遍历数组的key值和value值

for(let [index,elem] of ['a','b'].keys()){ console.log(index,elem) } // 解构赋值了

for(let care of ['a','b'].keys()){ console.log(care) } // 没有解构赋值 是数组

[0,"a"] [1,"b"]

includes()

转载于:https://juejin.im/post/5baf3f2f6fb9a05d2469cdb9