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()