常用的方法(数组)

• 现有数组

const arr = [1,2,3];
const arr2 = [7,8,9]

  arr.push() 在数组末尾添加新元素，返回值：数组新长度

console.log(arr.push(5));//4

arr.push(5)
console.log(arr);//[1,2,3,5]

  arr.pop() 删除数组的最后一个元素，返回值：该元素

console.log(arr.pop());//3

arr.pop()
console.log(arr);//[1,2]

  arr.unshift() 在数组的首位添加一个新元素，返回值：数组的新长度

console.log(arr.unshift(0));//4

arr.unshift(0)
console.log(arr);//[0,1,2,3]

  arr.shift() 删除数组的首位元素，返回值：该元素

console.log(arr.shift());//1

arr.shift()
console.log(arr);//[2,3]

  arr.reverse() 颠倒数组，返回值：颠倒后的数组

console.log(arr.reverse());//[3,2,1]

  arr.slice() 选择数组的一部分，返回值：选择的数组部分,不改变原数组

//两个参数(开始索引，结束索引)，选择内容为从开始索引到结束索引(不包含结束索引)
console.log(arr.slice(0,2));[1,2]

arr.slice(0,2)
console.log(arr);//[1,2,3]，

  arr.splice() 从数组中添加，删除元素，返回值：被删除的元素，改变原数组

/*
  *arr.splice(index,howmany,item1,item2)
  *三个参数 index howmany item
  *index 必选 整数 指定在什么位置添加或者删除元素，负值则为数组末尾位置
  *howmany 可选 要删除的元素数量 0为不删除
  *item 可选 可以为多个 要添加到数组的元素
 */
console.log(arr.splice(0,1));//[1]
console.log(arr);[2,3]
console.log(arr.splice(0,0,22,33));//[]
console.log(arr);//[22,33,2,3]

  arr.toString() 将数组转化为字符串，返回值：改变后的字符串，不改变原数组

console.log(arr.toString());//1,2,3
console.log(arr);//[1,2,3]

  Array.isArray() 判断对象是否是数组，返回值：Boolean

console.log(Array.isArray(arr));//true
const obj={a:10}
console.log(Array.isArray(obj));//false
let str = 'hello'
console.log(Array.isArray(str));//false

  arr.join() 将数组的所有元素拼成一个字符串，返回值：拼接后的字符串，不改变原数组

console.log(arr.join());//1,2,3 默认是以 , 拼接
console.log(arr.join('-'));//1-2-3
console.log('拼接');//1拼接2拼接3

  arr.map() map循环，返回值：每个元素调用函数后的结果，不会改变原数组

//函数为必填项
console.log(arr.map(item=>item+2));[3,4,5]

  arr.forEach() forEach循环，元素按顺序执行调用函数，没有返回值

console.log(arr.forEach(item=>item+=2));//undefined
//一般用于对数组进行的处理
const temp = []
arr.forEach(item=>{
  temp.push(item+=5)
})
console.log(temp);//[6,7,8]

  arr.filter() 数组过滤，返回值：符合函数过滤条件的元素，不改变原数组

//参数为一个函数 必选
console.log(arr.filter(item=>item>0));//[1,2]

  arr.concat() 合并数组，合并后的新数组,不改变原数组

const arr2 = [4,5,6];
const arr3 = [7,8,9];
console.log(arr.concat(arr2,arr3));//[1,2,3,4,5,6,7,8,9]
console.log(arr);//[1,2,3]

  合并数组 ES6的...扩展运算符

const arr2 = [4,5,6];
const arr3 = [7,8,9];
console.log([...arr,...arr2,...arr3]);//[1,2,3,4,5,6,7,8,9]

  arr.fill() 静态值填充数组中的指定元素，返回值：改变后的数组，会改变原数组

 /*
  * array.fill(value, start, end)
  * 有三个参数
  * value 静态的值
  * start 可选 开始索引
  * end 可选 结束索引,不包含结束索引，默认为数组长度
  */
console.log(arr.fill('a',1,2));//[a,'a',3]

  arr.copyWithin() 将数组中的元素复制到数组的另一个位置，覆盖现有的，返回值：复制之后的，改变原数组

 /*
  * array.copyWithin(target, start, end)
  * 三个参数
  * target 必选 元素被复制到的索引位置
  * start 可选 开始复制的索引位置
  * end 可选 结束复制的索引位置,不选则为最后的索引
  */
console.log(arr.copyWithin(1,0));//[1,1,2]
console.log(arr);//[1,1,2]

  arr.indexOf() 从数组中搜索指定元素，有则返回第一次出现的索引，没有则返回-1

console.log(arr.indexOf(3));//2
console.log(4);//-1

  arr.lastIndexOf() 倒序从数组中搜寻某个元素，有则返回索引，没有返回-1

console.log(arr.lastIndexOf(4));//-1
console.log(arr.lastIndexOf(2));//1

  arr.find() 元素查找，返回值：第一个符合函数过滤条件的元素，没有则为undefined，不改变原数组

console.log(arr.find(item=>item>0));//1
console.log(arr.find(item=>item>3));//undefined

  arr.findIndex() 获取第一个符合条件的元素的索引，类似于arr.indexOF()，返回值：第一个符合条件的元素的索引，没有则返回undefined，不改变原数组

console.log(arr.finIndex(item=>item>2));//2
console.log(arr.findindex(item=>item<0));//undefined

  arr.every() 判断数组的元素是否全部符合条件，返回值：Boolean，不会改变原数组

//参数是一个函数 必填
console.log(arr.every(item=>item>3));//false
console.log(arr.every(item=>item>0));//true

  arr.includes() 判断数组是否包含指定元素，返回值：Boolean，区分大小写，不改变原数组

console.log(arr.includes(4));//false
console.log(2);//true

  arr.some() 检查数组中的元素是否符合条件，返回值：Boolean，不改变原数组

//参数为一个函数 必选
//和arr.includes()类似，区别：找到后则不再往下寻找
console.log(arr.some(item=>item>3));//false
console.log(item.some(1));//true

  arr.keys() 返回带有数组键的Array interator对象，不改变原数组

console.log(arr.keys());//Array interator

let temp = arr.keys()
let arr2 = []
for(let item of temp){
  arr2.push(item)
}
console.log(arr2);//[0,1,2]原数组的键的数组

  arr.entries() 返回带有键/值对形式的Array interator对象，带有interator接口的可以使用for...of...循环不改变原数组

console.log(arr.entries());//Array Interator {}
let temp = arr.entries()
let arr2 = []
for(let item of temp){
  arr2.push(item)
};
//变成了二维数组，数组的第一个值为索引，第二个值为元素本身
console.log(arr2);//[[0,1],[1,2],[2,3]]

  arr.sort() 排序，默认是按字母和升序将值作为字符串进行排序，有一些局限性，所以一般情况下传入一个比较函数使用，返回值：排序后的函数，会改变原数组

const arr2 = [10,5,32,65,235]
console.log(arr.sort((a,b)=>{return a-b}));//[5,10,32,65,235]升序
console.log(arr.sort((a,b)=>{return b-a}));//[235,65,32,10,5] 降序
console.log(arr2);//[235,65,32,10,5]

  arr.valueOf() 返回数组，是数组的默认方法，不会改变原数组

console.log(arr.valueOf());//[1,2,3]

​​​​​​​  数组去重(只列举一个代码最少的),不改变原数组

const arr2 = [NaN,NaN,'aa','aa',2,24,24,null.null]
console.log([...new Set(arr2)])