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(f) <什么都不返回,仅仅是操作数据>

为数组的每个元素调用参数函数,该函数带有三个参数(f(array[i], i, array)),后两个不用的话可不写

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

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

})


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

查找值在数组中的索引值

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

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

a.indexOf(2) => 返回 1

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

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

检测不到NaN


lastIndexOf() <返回一个数字>

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

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


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

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

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

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

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


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

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

该参数函数带有三个参数(f(array[i], i, array)),后两个不用的话可不写

a.map(function(x){

return x*x;

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


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

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

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


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

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

a.pop(); => 返回1 原数组a变为 [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

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值