数组常用的方法

1.find()

用于查找符合条件的某个元素，返回元素对象。遍历次数不确定，一旦找到符合条件的，立即返回元素对象，终止遍历。

 let arr = [
        {
          name: '张三',
          age: 20
        },
        {
          name: '李四',
          age: 30
        },
        {
          name: '王五',
          age: 18
        }
      ]
      // 数组的find方法，查找符合条件的元素，返回元素对象，找到立即停止
      let result = arr.find(item => {
        return item.age < 20
      })
      console.log(result) // {name:'王五',age:18}

2.findIndex()

查找符合条件的某个元素，返回该元素的索引。一旦找到符合条件的元素，则立即返回该元素的索引。如果找不到，则返回-1.

 let arr = [
        {
          name: '张三',
          age: 20
        },
        {
          name: '李四',
          age: 30
        },
        {
          name: '王五',
          age: 18
        }
      ]
      let result = arr.findIndex(item => {
        return item.name == '王五'
      })
      console.log(result) // 2

3.indexOf()

查询某个元素的索引位置。如果有多个相同元素，则返回该元素第一次出现的索引。如果找不到元素，则返回-1。

 let arr = [1, 2, 3, 4, 2, 6, 6]
      console.log(arr.indexOf(3)) // 2
      console.log(arr.indexOf(2)) // 1
      console.log(arr.indexOf(7)) // -1

4.lastIndexOf()

查询最后一个出现的元素的索引。

 let arr = [1, 2, 3, 4, 2, 6, 6]
      console.log(arr.lastIndexOf(2)) // 4
      console.log(arr.lastIndexOf(6)) // 6

5.forEach()

遍历数组的每一个元素

 let arr = [1, 2, 3, 4]
      arr.forEach(item => {
        console.log(item) // 1 2 3 4
      })

6.some()

查询是否有符合条件的某个元素，有则返回true，无则返回false。找到满足条件的元素，则立即终止遍历。

let arr = [1, 2, 3, 4, 5]
      let result = arr.some(item => {
        return item > 3
      })
      console.log(result) // true

7.every()

查询是否每一个都符合条件。如果都符合条件，则返回true，如果有不满足条件的，则返回false。

let arr = [1, 2, 3, 4, 5]
      let result = arr.every(item => {
        return item > 1
      })
      console.log(result) // false

8.includes()

判断某个元素是否存在，返回一个布尔值。

let arr = [1, 2, 3, 4]
      console.log(arr.includes(3)) // true
      console.log(arr.includes(6)) //false

9.reduce()

可以做数组的累加操作。reduce((累加结果,循环项)=>{},初始值)

 let arr = [1, 2, 3, 4, 5]
      let result = arr.reduce((sum, item) => {
        return sum + item
      }, 0)
      console.log(result) // 15

 10.sort()

数组的排序操作。

let arr = [12, 2, 20, 1, 3, 25]
      let result = arr.sort((a, b) => {
        // return a - b // 升序
        return b - a // 降序
      })
      console.log(result) // [25,20,12,3,2,1]
    </script>

11.join()

用字符串将数组进行拼接，返回拼接后的字符串。

let arr = [1, 2, 3]
      let result = arr.join('-')
      console.log(result) // '1-2-3'

 12.toString()

将数组转换成字符串。

let arr = [1, 2, 3]
      let result = arr.toString()
      console.log(result) // '1,2,3'

13.concat()

实现数组的拼接，返回一个新的数组，不影响原数组。

 let arr = [1, 2, 3]
      let result = arr.concat(4, 5, 6)
      console.log(result) // [1,2,3,4,5,6]
      console.log(arr) // [1,2,3]

14.reverse()

实现数组反转。

      let arr = [1, 2, 3]
      let result = arr.reverse()
      console.log(result) // [3,2,1]

15.push()、unshift()

push:在末尾追加

unshift:在开头追加

 let arr = [1, 2, 3]
      arr.push(4)
      arr.unshift(0)
      console.log(arr) // [0,1,2,3,4]

16.pop()、shift()

pop:删除最后一个元素，返回被删除元素。

shift:删除第0个元素，返回被删除元素。

let arr = [0, 1, 2, 3, 4]
      arr.pop()
      arr.shift()
      console.log(arr) // [1,2,3]

17.splice()

splice(a)：删除从索引为a开始的所有元素，包括索引为a的元素。

splice(a,b)：从索引为a的位置开始，删除b个元素，包括索引为a的元素。

splice(a,b,c)：从索引为a的位置开始，删除b个元素，包括索引为a的元素,被删除元素的位置被c替代。

 let arr = [0, 1, 2, 3, 4]
      // arr.splice(2) // [0,1]
      // arr.splice(0, 2) // [2,3,4]
      arr.splice(0, 2, 33) // [33,2,3,4]
      console.log(arr)

18.slice()

切割数组，返回新数组。不影响原数组。

slice(a):从索引为a的位置开始截取到最后一个元素，包括索引为a的元素。

slice(a,b):从索引为a的位置开始截取到索引为b的元素。包括索引为a的元素，不包索引为b的元素。

 let arr = [1, 2, 3, 4, 5]
      console.log(arr.slice(1)) // [2,3,4,5]
      console.log(arr.slice(0, 2)) // [1,2]

未完待续……

慢一点没关系，只要自己没放弃！