数组常用方法

Array.isArray( )用于确定传递的值是否是一个数组

Array.isArray('footer')//false
Array.isArray([1,2,3])//true
Array.isArray({a:1})//false
Array.isArray(undefined)//false

Array.from( )对一个类似数组或可迭代对象创建一个新的，浅拷贝的数组实例

从String生成数组
Array.from('foo') //['f','o','o']
从set生成数组
Array.from(new Set(['foo','bar','baz','foo']))//['foo','bar','baz','foo']
从类数组对象(arguments)生成数组
function f(){
    return Array.from(arguments)
}
f(1,2,3) //[1,2,3]

改变原数组

pop( )删除数组最后一个元素(改变原数组)，返回被删除的元素

[1,2,3].pop() //返回被删除的元素：3  改变原数组,原数组：[1,2]

shift( )删除数组的第一个元素(改变原数组)，返回被删除的元素

[1,2,3].shift()//返回被删除的元素：1；改变原数组，原数组:[2,3]

push( )向数组末尾添加元素(改变原数组)，返回添加后数组的length

[1,2,3].push('four')//返回添加后数组的length：4，改变原数组[1,2,3,'four']

unshift( )向数组开头添加元素( 改变原数组)，返回添加后数组的length

[1,2,3].unshift('first')//返回添加后数组的length：4，改变原数组['first',1,2,3]

reverse( )反转数组，改变原数组

['a','b','c'].reverse()//['c','b'.'a']

splice( )通过删除或替换现有元素或添加新的元素来修改数组，改变原数组

array.splice(index,howmany,item1,...,itemX)
index:必选，整数，指定在什么位置添加、删除项目，使用负值指定从数组末尾开始的位置
howmany：可选，要删除的项目数，如果设置为0，则不会删除任何项目
item1,...,itemX 可选，要添加到数组中的新项目

['banner','orange','apple'].splice(1,1,'lemon','kiwi')//删除元素，并添加2个元素

['banner','orange','apple'].splice(1,2) 
//返回被删除的元素['orange','apple'];改变原数组['banner']

sort ( )对数组的元素进行排序，改变原数组

[1, 30, 4, 21, 100000].sort() //改变原数组[1, 100000, 21, 30, 4]

fill( )用一个固定值填充一个数组中从起始索引到终止索引内的全部元素,改变原数组

array.fill(value, start, end)
value：必须，填充的值；start：开始填充的位置；end:停止填充的位置
['a','b','c','d'].fill('two',2) //返回['a','b','two','two']，改变原数组

不改变原数组

slice( )返回值：一个含有被提取元素的新数组。

array.slice(start,end)
start如果该参数为负数，则表示从原数组中的倒数第几个元素开始提取
end如果该参数为负数， 则它表示在原数组中的倒数第几个元素结束抽取。
[1,2,3,4,5].slice(-3,-1) //返回[3,4] 不包括-3处

join( )返回值：一个所有数组元素连接的字符串。如果 arr.length 为0，则返回空字符串。

toString( )返回值：一个表示指定的数组及其元素的字符串。

[1,2,3,4].join( )//1234
[1,2,3,4].join('')//1,2,3,4
[1,2,3,4].join('-')//1-2-3-4

const array1 = [1, 2, 'a', '1a'];
log(array1.toString())//"1,2,a,1a"

concat( )连接合并多个数组，返回新的数组，不改变原数组

let a1=[1,2]
let a2=[3,4]
let a3=[6,7]
let a4=a1.concat(a2,a3) //[1,2,3,4,6,7]

//concat浅拷贝
const a1 =[1,2]
cosnt a2=a1.concat()
a2[0]=2
log(a1)// [1,2]
log(a2)// [2,2]

indexOf( ) 返回值：首个被找到的元素在数组中的索引位置; 若没找到则返回 -1.

lastIndexOf( )返回值：数组中该元素最后一次出现的索引，如未找到返回-1。

array.indexOf(item,start)
item:规定需检索的字符串
start:规定在数组中开始检索的位置
[a,b,c,d].indexOf(a) 0
[a,b,c,d].indexOf(e)-1

includes( )返回布尔值, 查找数组是否包含某个元素，不改变原数组

[1,2,3,4].includes(1) //true
[1,2,3,4].includes(1,6)//false

遍历方法

▲ forEach( )按顺序为数组中的每个元素调用一次函数,返回值：undefined

var arr=[1,2,3,4]
var arr2=[]
arr.forEach(function(el,index,arr){
    arr2.push(el+1)
}) //[2,3,4,5]

▲ map( ) 返回值：一个由原数组每个元素执行回调函数的结果组成的新数组。方法创建一个新数组，其结果是该数组中的每个元素是调用一次提供的函数后的返回值。

let arr=[1,2,3,4]
let newArr=arr.map((el)=>{
    return el+3
})
log(arr)//[1,2,3,4]
log(newArr)//[4,5,6,7]

▲ some( ) 返回值：数组中有至少一个元素通过回调函数的测试就会返回**true**；所有元素都没有通过回调函数的测试返回值才会为false。

let arr=[1,2,3,4]
let flag=arr.some((el)=>{
    return el > 10
}) 
log(flag)//false

▲ every( )返回值：如果回调函数的每一次返回都为true，返回 true ，否则返回 false。

let arr=[1,2,3,4]
let flag=arr.every((el)=>{
    return el<5
})
log(flag)//true

▲ filter( )返回值：返回一个新的、由通过测试的元素组成的数组，如果没有任何数组元素通过测试，则返回空数组。

let arr=[1,2,3,4]
let item=arr.filter((el)=>{
    return el<2
})
log(item) //[1]

▲ find() 返回值：返回数组中满足提供的测试函数的第一个元素的值。否则返回 undefined

let arr=[5, 12, 8, 130, 44]
let item = arr.find((el)=>{
    return el>100
})
log(item) //130

▲findIndex() 返回值：返回数组中通过提供测试函数的第一个元素的索引。否则，返回-1

let arr=[5, 12, 8, 130, 44]
let index = arr.find((el)=>{
    return el>100
})
log(index) //3

▲reduce( )返回值：函数累计处理的结果值

var arr = [3,9,4,3,6,0,9];

//求数组项之和
var num =arr.reduce((prev,next)=>{
    return prev+next
},0)

//求数组项最大值
var max = arr.reduce( (prev, cur) =>{
    return Math.max(prev,cur);
});
log(max)//9

//数组去重
var newArr = arr.reduce( (prev, cur)=> {
    var num=prev.findIndex((el)=>{
        return el===cur
    }) 
    if(num===-1){
        prev.push(cur);
    }
    return prev;
},[]);
//实现基本原理
1.初始化一个空数组
2.将需要去重处理的数组的第1项在初始化数组中查找，如果找不到（空数组中肯定找不到），就将该项添加到初始化数组中
3.将需要去重处理的数组中的第2项在初始化数组中查找，如果找不到，就将该项继续添加到初始化数组中
4将需要去重处理的数组的第n项在初始化数组中查找，如果找不到，就将该项继续添加到初始化数组中
5将这个初始化数组返回

▲keys( )遍历健名，一个新的Array 迭代器对象。

const arr = ['a', 'b', 'c'];
const iterator = arr.keys();
for(let i of iterator){
    log(i)
}//0,1,2