数组Array

concat()用于合并两个或多个数组，而返回一个新的数组。 

const arr1=[1,2,4,3]
const arr2=[3,2,1,3]
console.log(arr1.concat(arr2))  //[1,2,4,3,3,2,1,3]

join()将一个数组的所有元素连接成一个字符串并返回这个字符串，用逗号或指定的分隔符分隔

const arr=['a','sd','dfs']
console.log(arr.join())        //a,sd,dfs
console.log(arr.join(''))      //asddfs
console.log(arr.join('-'))     //a-sd-dfs

pop()删除数组中的最后一个元素，并返回该元素的值

const arr=['avsd','sdf','dfx','dfs']
console.log(arr.pop())    //dfs
console.log(arr)          //['avsd','sdf','dfx']
arr.pop()
console.log(arr)          //['avsd','sdf']

shift()删除数组中的第一个元素，并返回该元素的值

const arr=[1,2,3,4]
cosnt ar=arr.shift()
console.log(arr)       //[2,3,4]
console.log(ar)        //1

unshift()将一个或多个元素添加到数组的开头，并返回该数组的新长度

const arr=[1,2,3]
console.log(arr.unshift(4,2))    //5
console.log(arr)                 //[4,2,1,2,3]

push()将一个或多个元素添加到数组的末尾，并返回该数组的新长度

const arr=[1,2,4]
console.log(arr.push(4,2))    //5
console.log(arr)              //[1,2,4,4,2]

reverse()将数组中的第一个元素变成最后一个，最后一个元素变成第一个

const arr=['as','dfs','dfs']
console.log(arr)                //['as','dfs','dfs']
console.log(arr.reverse())      //['dfs','dfs','as']
console.log(arr)                //['dfs','dfs','as']

slice(起始处，结束处)从起始处到终止处拷贝原数组，并返回一个新的数组对象，原始数组不会被改变

const arr=['ant','sa','sx','a',1,]
console.log(arr.slice(3))        //['a',1]
console.log(arr)                 //['ant','sa','sx','a',1,]
console.log(arr.slice(2.4))      //['sx','a',1]
console.log(arr)                 //['ant','sa','sx','a',1,]
console.log(arr.slice(-3))       //['sx','a',1]
console.log(arr)                 //['ant','sa','sx','a',1,]
console.log(arr.slice(2,-1))     //['sx','a']
console.log(arr)                 //['ant','sa','sx','a',1,]
console.log(arr.slice())         //['ant','sa','sx','a',1,]
console.log(arr)                 //['ant','sa','sx','a',1,]

sort()对数组的元素进行排序，并返回数组

const arr1=['asd','vfd','csd']
console.log(arr1.sort())            //['asd','csd','vfd']
const arr2=[432,0,123345,34,87]
console.log(arr2.sort())            //[0,123345,34,432,87]

splice()删除或替换现有元素或原地添加新的元素来修改数组，并返回新的数组

const arr=['as','sdf','dfs',23,'sd']
arr.splice(2,0,'dx')
console.log(arr)        //['as','sdf','dx','dfs',23','sd']
arr.splice(3,2,'as')
console.log(arr)        //['as','sdf','dx','as','sd']
console.log(arr.splice(2,1,'xd')       //['dx']被替换的值
console.log(arr)        //['as','sdf','xd','as','sd']

toString()返回一个字符串

const arr=[1,'a',2,'sx']
console.log(arr.toString())    //1,a,2,sx
console.log(arr)               //[1,'a',2,'sx']

valueOf()返回原始值

注意：不会改变原数组

const arr=['afs','sdg','afe']
console.log(arr.valueOf())    //['afs','sdg','afe']

indexOf(查找的元素)返回数组中找到给定元素的第一个索引，如果不存在，则返回-1

const arr=['as','sf',2,'sfd']
console.log(arr.indexOf('sf'))    //1
console.log(arr.indexOf('sf',2))  //-1
console.log(arr.indexOf(2))       //2

lastIndexOf()返回指定元素在数组仲的最后一个的索引，如果不存在则返回-1,

const arr=['sfg','xa',2,'sfg']
console.log(arr.lastIndexOf('sfg'))    //3
console.log(arr.lastIndexOf(2))        //2
console.log(arr.lastIndexOf(1))        //-1

forEach()对数组的每个元素执行一次给定的函数

const arr=['a','b','d']
arr.forEach(element => console.log(element)) 
//a
//b
//d

map()创建一个新的数组，在原数组中每个元素都调用一遍，返回的值组成新的数组

const arr=[1,4,2,5]
console.log(arr.map(x=>x*3))    //[3,12,6,15]
console.log(arr)                //[1,4,2,5]

filter()创建一个新的数组，并测试原来数组到达所给条件，返回的值组成新的数组

const arr1=['asd','sfgw','cxs','s','werg']
console.log(arr1.filter(arr=>arr.length>3))      //['sfgw','werg']
const arr2=[5,2,1,4,12]
console.log(arr2.filter(arr=>arr>=4))            //[5,4,12]

every()测试数组所有元素是否通过指定函数的测试，并返回布尔值

注意：不会对空数组进行检测；不会改变原有数组

const arr=[1,32,12,35,20,45]
console.log(arr.every(ar=>ar>12))    //false
console.log(arr.every(ar=>ar<50))    //true

some()测试数组中是不是至少有1个元素通过了被提供的函数测试，并返回布尔值

注意：如果用空数组进行测试，在任何情况下返回的都是false;不会改变原始数组

const arr=[1,3,2,4]
console.log(arr.some(ar=>ar%2===0))    //true

reduce()计算数组所用元素的总和，从左至右

注意：空数组是不会执行回调函数的

const arr=[2,23,12,123]
console.log(arr.reduce((total,num)=>total+num))    //160

redceRight()计算数组元素相加后的总和，从右至左

注意：空数组是不会执行回调函数的

const arr=[23,53,12]
console.log(arr.reduceRight((total,num)=>total+num))    //88

keys() 返回一个包含数组中每个索引建的对象

const arr=['a','b','d']
for(const key of arr.keys()){    //0
    console.log(key)             //1
}                                //2

isArray() 判断对象是否为数组

Array.isArray([1,3,2])    //true
Array.isArray('asd')      //false

includes()判断数组是否包含一个指定的值，如果包含，则返回true，否则返回false

const arr=[1,3,'as',4]
console.log(arr.includes('as'))    //true
console.log(arr.includes(2))       /false
console.log(arr.includes(4))       //true

from()通过给定的对象中创建一个数组

const arr=Array.from('asdf')
console.log(arr)    //['a','s','d','f']

findIndex()返回数组中满足测试第一个元素的索引，若没有则返回-1

const arr=[1,3,2,5]
console.log(arr.findIndex(element=>element>4))    //3

find()返回数组中满足测试第一个元素的值，否则返回undefined

const arr=[1,32,43,2,5]
console.log(arr.find(element=>element>30))    //32

fill(value,start,end)用一个固定值填充一个数组中从起始索引到终止索引内的全部元素。不包括终止索引。

value：用来填充数组元素的值；start：起始索引；end：终止索引

const arr=[1,3,2,4]
console.log(arr.fill(2,4,0))    //[1,3,2,4]
console.log(arr.fill(1,2,4))    //[1,3,1,1]

entires()返回一个数组迭代器对象

const arr=['a','b','c']
console.log(arr.entries().next().value)    //[0,'a']

copyWithin()复制数组的一部分到同一数组中的另一个位置，并返回它，不改变原数组长度

const arr=['a','c',1,3]
console.log(arr.copyWithin(0,2,1))    //['a','c',1,3]
console.log(arr.copyWithin(1,2))      //['a',1,3,3]