数组的常用方法有哪些？

• 您可以在数组保存对象，函数，甚至可以在数组中保存数组，数组元素可以是对象；
• 数组是一种特殊类型的对象，数组使用typeof运算符会返回“object"

创建方法：

• 字面量创建（推荐使用）
  • let arr1 = ['a','b','c']
• 利用new Array()
  • let arr2 = new Array('a','b','c')

访问数组：

• 查找：引用索引号来引用某个数组元素；
  • let a = arr[0]  //访问数组第0个元素
• 访问：引用数组名来访问完整数组
  • console.log(arr)
• 修改：修改或追加数组元素
  • arr[0] = 'cc'
• 删除：使用delete会在数组留下未定义的空洞，请使用pop()或shift()取而代之
  • delete arr[0]

---

常用数组方法：

arr.at(index)

• 不会改变原数组，返回对应位置的元素，可查找数组任意位置的值；
• 当获取数组最后一个元素时，使用arr.at(-1)比arr[arr.length-1]更简洁。

arr.indexOf()

• 不会改变原数组，返回查找元素的索引（找到第一个即返回，就不找了）
• 语法：

• arr.indexOf('searchElement',formeindex)
  

• 第一个参数是要查找的元素，第二个表示从哪个位置开始查找；
• 在数组中查找元素时，找到即返回对应元素的索引，如找不到则返回-1；

• let arr = ['a','b','c','e','a']
  arr.indexOf('a') //返回0
  

lastIndexOf

• 和indexOf()用法一样，只不过他是从后面开始查找；

• let arr = ['a','b','c','e','a']
  arr.lastIndex('a') //返回4
  

concat()

• 合并两个或多个数组，不会改变原数组，返回合并后的新数组；
• arr.concat(),无参数时，直接调用用数组的浅拷贝，也就是复制原数组；

unshift()

• 数组开头添加一个或多个元素，会改变原数组，返回数组长度；
• 语法：let arr =[1,2,3] arr.unshift('apple','lucy')  // 返回5

push()

• 数组末尾添加一个或多个元素，会改变原数组，返回数组长度
• 语法：arr.push('aa')

pop()

• 删除数组第一个元素，会改变原数组，返回被删除元素；
• 语法：arr.pop()

shift()

• 删除数组第一个元素，会改变原数组，返回被删除元素
• 语法：arr.shift()

reserve()

• 返转（颠倒）数组，会改变原数组，并返回该数组；
• 语法： arr.reverse()
• eg：let arr =['1','a','c'];  arr.reverse(); //返回['c', 'a', '1']

sort()

• 数组排序，会改变原数组，并返回该数组；
• 语法：arr.sort(compareFunction)
• arr.sort((a,b)=>{return a -b}) //从小到大排序
• arr.sort((a,b)=>{return b-a)} //从大到小排序
• eg:

  let list =[
      {id:'001',name:'张三',age:18},
      {id:'005',name:'lisi',age:12},
      {id:'004',name:'lucy',age:25} 
  ]
  list.sort((a,b)=>{
      return a.id - b.id
  })
   
  console.log(list)
  /*[{"id": "001","name": "张三","age": 18},
     {"id": "004","name": "lucy","age": 25},
     {"id": "005","name": "lisi","age": 12}
    ]
  */
  

 slice()

• 不会改变原数组，返回从原数组剪切出来的新数组；
• arr.slice():无参数时，浅拷贝原数组；
• arr.slice(0,4)：从数组指定位置切出新数组，如省略结束参数，将切出

splice(0,1)

• 删除、添加数组元素，会改变原数组，返回被删除的元素；
• arr.splice(0,1)：从第0个位置开始，删除1个元素；
• splice(0,2,'apple,'lucy')：从第0个位置开始，删除两个元素，添加apple、lusy;
• splice（0，0，‘aa')：不删除元素，从0开始，添加aa;
• *可以理解为，具有同时对数组进行，删除，添加，替换的操作

join()

• 将数组变为字符串，不会改变原数组，返回这个数组的字符串；
• arr.join()：返回以逗号分隔的字符串，如：a,b,c,d,s,f
• arr.jpin('-')：返回以制定符号‘-’分隔的字符串，如a-s-d-f-g

fill()

• 用固定值填充数组中指定位置的元素，会改变原数组，并返回该数组；
• 语法：fill(value,end)
• arr.fill('asd',0,3)，用asd填充数组索引0-2的值

如果start是负数，则开始索引会被自动计算成为length+start。如end是负数，则结束索引会被自动计算成为length+end。

flat()

• 扁平化嵌套数组，语法：flat(depth),depth默认为1；
• 按照指定深度递归遍历数组，适用于当数组里面嵌套数组时；
• 会移除数组中的空项：不会改变原数组，返回被展开后的数组；
• [1,2,,4,5,,[6,7]].flat(); //返回[1, 2, 4, 5, 6, 7]，空值被移除，数组也被展开合并；
• [1,2,,4,5,[6,7,[8,9]]].flat()；//返回[1, 2, 4, 5, 6, 7, 8, 9]

copyWithin()

• 语法：copyWithin(target,start,end)，会改变原数组并返回该数组，不会改变原数组长度；
• target:复制序列到该位置。start：开始复制元素的起始位置。end:开始复制元素的结束位置；
• [1,2,3,4,5].copyWithin(3,0,2) //[1, 2, 3, 1, 2]
• 以数组索引3开始的位置（数组4），将从索引0到索引2的值（1,2）浅复制到该位置

entries()

• 不会改变原数组，返回新的Array Iterator对象，该对象包含数组中每个索引的键值对

• let arr = [1,2,3,4,5,6,7]
  console.log(arr.entries().next()); //{"value": [0,1], "done": false}
  console.log(arr.entries().next().value);  //[0,1]
  

keys()

• 不会改变原数组，返回一个新的Array iterator对象，该对象包含数组每个索引的键(key)

• let arr = [1,2,3,4,5,6,7]
  console.log(arr.keys.next()) //{value:0,done:false}
  

values() 

• 不会改变原数组，返回一个新的Array iterator对象，该对象包含数组每个索引的值(value)

• let arr = [1,2,3,4,5,6,7]
  console.log(arr.values.next()) //{value: 1,done:false}
  

includes()

• 判断一个数组是否包含特定的值，如有则返回true,否则返回false;
• 有意设计为通用方法。它不要求this值是数组对象，所以它可以被用于其他类型的对象。

• ['a','b','c','d'].includes('a'); //true
   
  function fn(){
      let x = [].includes.call(arguments,3)
         console.log(x)
  }
  fn(1,2,3,4,6)  //true