JS数组方法总览_js 倒序插入-优快云博客

本文详细介绍了数组的32种常用方法，包括添加、删除、连接、排序、遍历等操作，还说明了各方法是否改变原数组。最后指出数组调用后会改变原数组的方法共有9个，分别是push、pop、unshift、shift、reverse、sort、fill、copyWithin、splice。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1. push(value) 将一个或多个元素添加到数组的末尾，并返回该数组的新长度（改变原数组）

    // Base
    var arr = [1, 2, 3, 4, 5]
    var result = arr.push(7)
    console.log(arr) // [1,2,3,4,5,7] 原数组被改变
    console.log(result) // 6

    //More
    arr = [1, 2, 3, 4, 5]
    result = arr.push(1, 2) // 可一次添加多个值
    console.log(arr) // [1,2,3,4,5,1,2]
    console.log(result) // 7

2. unshift(value) 将一个或多个元素添加到数组的开头，并返回该数组的新长度（改变原数组）

    // Base
    var arr = [1, 2, 3, 4, 5]
    var result = arr.unshift(7)
    console.log(arr) // [7,1,2,3,4,5] 原数组被改变
    console.log(result) // 6

    //More
    arr = [1, 2, 3, 4, 5]
    result = arr.unshift(1, 2) // 可一次添加多个值
    console.log(arr) // [1,2,1,2,3,4,5]
    console.log(result) // 7

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

    // Base
    var arr = [3]
    var result = arr.pop()
    console.log(arr) // []
    console.log(result) // 3

    //More
    result = arr.pop() // 数组元素为空后悔返回undefined
    console.log(arr) // []
    console.log(result) // undefined

4. shift() 删除数组第一个元素，返回删除的元素（改变原数组）

    // Base
    var arr = [3]
    var result = arr.shift()
    console.log(arr) // []
    console.log(result) // 3

    //More
    result = arr.shift() // 数组元素为空后悔返回undefined
    console.log(arr) // []
    console.log(result) // undefined

5. join(value) 将一个数组（或一个类数组对象）的所有元素连接成一个字符串并返回这个字符串。如果数组只有一个项，那么僵返回该项而不适用分隔符（不改变原数组）

    // Base
    var arr = [1, 2, 3, 4, 5]
    var result = arr.join('-')
    console.log(arr) // [1,2,3,4,5]
    console.log(result) // 1-2-3-4-5

    //More
    arr = [1]
    result = arr.join('-')
    console.log(arr) // [1]
    console.log(result) // 1 数组只有一个项，那么将返回该项而不使用分隔符

    var obj = {
      toString() {
        console.log('调用toString方法！')
        return 'a'
      },
      toValue() {
        console.log('调用了toValue方法！')
        return 'b'
      }
    }
    result = arr.join(obj) // 使用对象时会调用对象自身的toString方法转化为字符串，我们这里重写了toString，从而覆盖了原型链上的toString
    // 调用了toString方法！
    console.log(arr) // [1,2,3,4,5]
    console.log(result) // 1a2a3a4a5

    //join的一个相对的方法是字符串的split方法
    console.log('1a2a3a4a5'.split('a')) // [1,2,3,4,5]

6. reverse() 反转数组（改变原数组）

    // Base
    var arr = [1, 2, 3, 4, 5]
    var result = arr.reverse()
    console.log(arr) // [5,4,3,2,1]
    console.log(result) // [5,4,3,2,1]

    //More
    arr = [1, [2, 3], [4, 5]]
    result = arr.reverse()
    console.log(arr) // [[4,5],[2,3],1]
    console.log(result) // [[4,5],[2,3],1]
    // 可以看到这里的反转只是基于数组的第一层，属于浅反转

    //一个简单的深反转，使用递归实现
    var deepReverse = (arr) => {
      var temp = arr.reverse()
      temp.forEach(item => {
        if (Array.isArray(item)) {
          deepReverse(item)
        }
      })
      return temp
    }
    arr = [1, [2, 3], [4, 5]]
    result = deepReverse(arr)
    console.log(arr) // [[5,4],[3,2],1]
    console.log(result) // [[5,4],[3,2],1]

7. slice(start,[end]) 返回新数组，包含原数组索引start的值到索引end的值，不包含end（不改变原数组）

     // Base
    var arr = [1, 2, 3, 4, 5]
    var result = arr.slice(2, 4)
    console.log(arr) // [1,2,3,4,5]
    console.log(result) // [3,4]

    //More
    console.log(arr.slice(1)) // [2,3,4,5] 只有一个参数且不小于0，则从此索引开始截取到数组的末位
    console.log(arr.slice(-1)) // [5] 只有一个参数且小于0，则从倒数|start|位截取到数组的末位
    console.log(arr.slice(-1, 1)) // [] 反向截取，不合法返回空数组
    console.log(arr.slice(1, -1)) // [2,3,4] 从第一位截取到倒数第一位，不包含倒数第一位
    console.log(arr.slice(-1, -2)) // [] 反向截取，不合法返回空数组

8. splice(index,count,value) 从索引为index处删除count个元素，插入value（改变原数组）

    // Base
    var arr = [1, 2, 3, 4, 5]
    var result = arr.splice(1, 2, 9)
    console.log(arr) // [1,9,4,5]
    console.log(result) // [2,3]

    //More
    arr = [1, 2, 3, 4, 5]
    result = arr.splice(-2)
    console.log(arr) // [1,2,3]
    console.log(result) // [4,5]

    arr = [1, 2, 3, 4, 5]
    result = arr.splice(-1)   // 当参数为单个且小于0时，将从数组的倒数|index|位截取到数组的末位
    console.log(arr) // [1,2,3,4]
    console.log(result) // [5]

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

    arr = [1, 2, 3, 4, 5]
    result = arr.splice(1) // 当参数为单个且不小于0时，将从当前数代表的索引位开始截取到数组的末位
    console.log(arr) // [1]
    console.log(result) // [2,3,4,5]


    arr = [1, 2, 3, 4, 5]
    result = arr.splice(-1, 2) // 从倒数第一位开始截取两个元素，元素不够，只返回存在的元素
    console.log(arr) // [1,2,3,4]
    console.log(result) // [5]

    arr = [1, 2, 3, 4, 5]
    result = arr.splice(0, 2, 'a', 'b', 'c')  // 截取后将value一次填充到数组被截取的位置，value的数量大于截取的数量时，数组中剩余的元素后移
    console.log(arr) // ['a','b','c',3,4,5]
    console.log(result) // [1,2]

9. sort() 对数组元素进行排序（改变原数组）

    // Base
    var arr = [31, 22, 27, 1, 9]
    var result = arr.sort()
    console.log(arr) // [1,22,27,31,9]
    console.log(result) // [1,22,27,31,9]

    //More
    arr = ['c', 'ac', 'ab', '1c', 13, 12, '13', '12', '3', '2', '1b', '1a', 1, 'aa', 'a', 3, 'b', 2]
    arr.sort()
    console.log(arr) // [1, 12, "12", 13, "13", "1a", "1b", "1c", "2", 2, "3", 3, "a", "aa", "ab", "ac", "b", "c"]
    // 可以看出sort排序是根据位来进行排序，而非值得大小，先比较第一位数字在前，字母在后，若相同则比较后面位（实际是比较各个值转化为字符串后的各个位点的unicode位点）

    arr = [31, 22, 27, 1, 9]
    arr.sort((a, b) => {
      return a - b
    })
    console.log(arr) // [1,9,22,27,31] 按数值大小正序排列

    arr = [31, 22, 27, 1, 9]
    arr.sort((a, b) => {
      return b - a
    })
    console.log(arr) // [31,27,22,9,1] 按数值大小倒序排列

10. toString() 将数组中的元素用逗号拼接成字符串（不改变原数组）

    // Base
    var arr = [1, 2, 3, 4, 5]
    var result = arr.toString()
    console.log(arr) // [1,2,3,4,5]
    console.log(result) // 1,2,3,4,5

11. indexOf(value,[start]) 从索引为0开始，检查数组是否包含value，start为开始查找的位置，有则返回匹配到的第一个索引，没有返回-1（不改变原数组）

    // Base
    var arr = [1, 2, 3, 4, 5]
    var result = arr.indexOf(2)
    console.log(arr) // [1,2,3,4,5]
    console.log(result) // 1

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

12. lastIndexOf(value) 从最后的索引开始，检查数组是否包含value，有则返回匹配到的第一个索引，没有返回-1（不改变原数组）

    // Base
    var arr = [1, 2, 3, 4, 5]
    var result = arr.lastIndexOf(4)
    console.log(arr) // [1,2,3,4,5]
    console.log(result) // 3

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

13. concat(value) 将数组和/或值连接成新数组（不改变原数组）

    // Base
    var arr = [1, 2], arr1 = [3, 4], arr2 = [5]
    var result = arr.concat(arr1, arr2)
    console.log(arr) // [1,2]
    console.log(result) // [1,2,3,4,5]

    //More
    arr1 = [3, [4]]
    result = arr.concat(arr1, arr2)
    console.log(arr) // [1,2]
    console.log(result) // [1,2,3,[4],5] concat对于嵌套数组无法拉平

14. fill(value,start,end) 使用给定value填充数组，从索引start开始end结束，不包含end（改变原数组）

    // Base
    var arr = [1, 2, 3, 4, 5]
    var result = arr.fill(8, 1, 3)
    console.log(arr) // [1,8,8,4,5]
    console.log(result) // [1,8,8,4,5]

    //More
    arr = [1, 2, 3, 4, 5]
    console.log(arr.fill(1)) // [1,1,1,1,1] 参数一个时，将该参数覆盖填充到数组每一项
    arr = [1, 2, 3, 4, 5]
    console.log(arr.fill(1, 2)) // [1,2,1,1,1] 只有start时，从索引start开始填充到数组末位
    arr = [1, 2, 3, 4, 5]
    console.log(arr.fill(1, -2)) // [1,2,3,1,1] 只有start且为负数时，从倒数|start|位开始填充到数组末位

15. flat(depth) 将二维数组变为一维数组（不改变原数组）

    // Base
    var arr = [1, 2, 3, [4, 5]]
    var result = arr.flat()
    console.log(arr) // [1, 2, 3, [4, 5]]
    console.log(result) // [1,2,3,4,5]

    //More
    arr = [1, 2, 3, [4, [5, [6, [7]]]]]
    result = arr.flat(Infinity) // 不传参数默认为将二维数组转换为一维数组，传参为将depth维数组转换为一维数组
    console.log(arr) // [1, 2, 3, [4, [5, [6, [7]]]]]
    console.log(result) // [1,2,3,4,5,6,7]

16. flatMap() 相当于map与flat的结合（不改变原数组）

    // Base
    var arr = [1, 2, 3, 4, [5]]
    var result = arr.flatMap(currentValue => {
      return currentValue
    })
    console.log(arr) // [1, 2, 3, 4, [5]]
    console.log(result) // [1,2,3,4,5]
    //More
    arr = [1, 2, 3, 4, [5]]
    result = arr.flatMap(currentValue => {
      return currentValue * 2
    })
    console.log(arr) // [1, 2, 3, 4, [5]]
    console.log(result) // [2,4,6,8,10]

17. copyWithin(target,start,end) 将数组从start到end索引的元素（不包含end）复制到target开始的索引位置（改变原数组）

    // Base
    var arr = [1, 2, 3, 4, 5, 6]
    var result = arr.copyWithin(1,2,5) // 索引2到5的元素为3、4、5，复制到1开始的位置，替换掉了2、3、4
    console.log(arr) // [1,3,4,5,5,6]
    console.log(result) // [1,3,4,5,5,6]

    //More
    arr = [1, 2, 3, 4, 5, 6]
    result = arr.copyWithin(3)
    console.log(arr) // [1,2,3,1,2,3] 参数只有一个时，start默认为0，end默认为数组长度-1

18. entries() 方法返回一个新的Array Iterator对象，该对象包含数组中每个索引的键/值对，可用for...of遍历（不改变原数组）

    // Base
    var arr = [1, 2, 3, 4, 5, 6]
    var result = arr.entries()
    console.log(arr)
    console.log(result) // Array Iterator {}
    console.log(result.next()) // {value:[0,1],done:false} value数组中第一个元素为索引，第二个元素为索引对应的值
    console.log(result.next()) // {value:[1,2],done:false}
    // ...
    console.log(result.next()) // {value:[5,6],done:true}

    result = arr.entries()
    for (let value of result) {
      console.log(value)
    }
    // [0,1]
    // [1,2]
    // [2,3]
    // [3,4]
    // [4,5]
    // [5,6]

    //Time
    arr = []
    for (let i = 0; i < 1000000; i++) {
      arr.push(i)
    }
    let dateStart = Date.now()
    result = arr.entries()
    for (let v of result) { }
    let dateEnd = Date.now()
    console.log(dateEnd - dateStart) // 运行三次，三次的耗时数 37ms 33ms 36ms

19. keys() 返回一个新的Array 迭代器对象，可用for...of遍历（不改变原数组）

    // Base
    var arr = [1, 2, 3, 4, 5, 6]
    var result = arr.keys()
    console.log(arr)
    console.log(result) // Array Iterator {}
    console.log(result.next()) // {value:0,done:false} value为索引
    console.log(result.next()) // {value:1,done:false}
    // ...
    console.log(result.next()) // {value:5,done:true}

    result = arr.keys()
    for (let value of result) {
      console.log(value)
    }
    // 0
    // 1
    // 2
    // 3
    // 4
    // 5

    //Time
    arr = []
    for (let i = 0; i < 1000000; i++) {
      arr.push(i)
    }
    let dateStart = Date.now()
    result = arr.entries()
    for (let v of result) { }
    let dateEnd = Date.now()
    console.log(dateEnd - dateStart) // 运行三次，三次的耗时数 36ms 36ms 35ms

20. values() 返回一个新的迭代器对象，可用for...of遍历（不改变原数组）

    // Base
    var arr = [1, 2, 3, 4, 5, 6]
    var result = arr.values()
    console.log(arr)
    console.log(result) // Array Iterator {}
    console.log(result.next()) // {value:1,done:false} value为索引
    console.log(result.next()) // {value:2,done:false}
    // ...
    console.log(result.next()) // {value:6,done:true}

    result = arr.values()
    for (let value of result) {
      console.log(value)
    }
    // 1
    // 2
    // 3
    // 4
    // 5
    // 6

    //Time
    arr = []
    for (let i = 0; i < 1000000; i++) {
      arr.push(i)
    }
    let dateStart = Date.now()
    result = arr.entries()
    for (let v of result) { }
    let dateEnd = Date.now()
    console.log(dateEnd - dateStart) // 运行三次，三次的耗时数 36ms 37ms 34ms

21. forEach() 遍历数组（不改变原数组），forEach的callback函数接受三个参数currentValue(数组中正在处理的当前元素)，index(数组中正在处理的当前元素的索引)，array（forEach()方法正在操作的数组）。（不改变原数组）

    // Base
    var arr = [1, 2, 3, 4, 5, 6]
    let result = arr.forEach((v, i, a) => {
      console.log(v, i, a)
      // 1 0 [1, 2, 3, 4, 5, 6]
      // 2 1 [1, 2, 3, 4, 5, 6]
      // 3 2 [1, 2, 3, 4, 5, 6]
      // 4 3 [1, 2, 3, 4, 5, 6]
      // 5 4 [1, 2, 3, 4, 5, 6]
      // 6 5 [1, 2, 3, 4, 5, 6]
    })
    console.log(result) // undefined
    console.log(arr) // [1,2,3,4,5,6]

    //Time
    arr = []
    for (let i = 0; i < 1000000; i++) {
      arr.push(i)
    }
    let dateStart = Date.now()
    arr.forEach(v => { })
    let dateEnd = Date.now()
    console.log(dateEnd - dateStart) // 运行三次，三次的耗时数 16ms 17ms 20ms

22. every(fn) 判断数组中是否所有元素都满足fn函数中的条件（不改变原数组）

    // Base
    var arr = [1, 2, 3, 4, 5]
    var result = arr.every(currentValue => {
      return currentValue > 0
    })
    console.log(result) // true 所有元素都大于0
    console.log(arr) // [1, 2, 3, 4, 5]

    result = arr.every(currentValue => {
      return currentValue > 2
    })
    console.log(result) // false 1和2并不大于2

    //Time
    arr = []
    for (let i = 0; i < 1000000; i++) {
      arr.push(i)
    }
    let dateStart = Date.now()
    arr.every(v => v > -1)
    let dateEnd = Date.now()
    console.log(dateEnd - dateStart) // 运行三次，三次的耗时数 15ms 17ms 16ms

    dateStart = Date.now()
    arr.every(v => v > 8)
    dateEnd = Date.now()
    console.log(dateEnd - dateStart) // 运行三次，三次的耗时数 0ms 0ms 0ms 不超过1ms，可见every的判断实在识别到不满足条件时。立刻停止

23. filter(fn) 返回数组中满足fn函数中添加的集合（不改变原数组）

    // Base
    var arr = [1, 2, 3, 4, 5]
    var result = arr.filter(currentValue => {
      return currentValue > 3
    })
    console.log(result) // [4,5]
    console.log(arr) // [1, 2, 3, 4, 5]

    //Time
    arr = []
    for (let i = 0; i < 100000; i++) {
      arr.push(i)
    }
    let dateStart = Date.now()
    arr.filter(v => v > -1)
    let dateEnd = Date.now()
    console.log(dateEnd - dateStart) // 运行三次，三次的耗时数 5ms 6ms 6ms 全部值都满足条件的情况

    arr = []
    for (let i = 0; i < 100000; i++) {
      arr.push(i)
    }
     dateStart = Date.now()
    arr.filter(v => v < 0)
     dateEnd = Date.now()
    console.log(dateEnd - dateStart) // 运行三次，三次的耗时数 2ms 3ms 3ms

24. find(fn) 返回数组中第一个匹配fn函数中条件的值，没有则返回undefined（不改变原数组）

    // Base
    var arr = [1, 2, 3, 4, 5]
    var result = arr.find(currentValue => {
      return currentValue > 3
    })
    console.log(result) // 4
    console.log(arr) // [1, 2, 3, 4, 5]

    result = arr.find(currentValue => {
      return currentValue > 5
    })
    console.log(result) // undefined

    //Time
    arr = []
    for (let i = 0; i < 100000; i++) {
      arr.push(i)
    }
    let dateStart = Date.now()
    arr.find(v => v < 0)
    let dateEnd = Date.now()
    console.log(dateEnd - dateStart) // 运行三次，三次的耗时数 2ms 3ms 4ms 全部不满足的情况下

    arr = []
    for (let i = 0; i < 100000; i++) {
      arr.push(i)
    }
    dateStart = Date.now()
    arr.find(v => v > 10)
    dateEnd = Date.now()
    console.log(dateEnd - dateStart) // 运行三次，三次的耗时数 0ms 0ms 0ms，可以判断当匹配到满足条件的第一个值后，立刻停止循环，与every相当

25. findIndex(fn) 返回数组中第一个匹配fn函数中条件的索引，没有则返回-1（不改变原数组）

    // Base
    var arr = [1, 2, 3, 4, 5]
    var result = arr.findIndex(currentValue => {
      return currentValue > 3
    })
    console.log(result) // 3
    console.log(arr) // [1, 2, 3, 4, 5]

    result = arr.findIndex(currentValue => {
      return currentValue > 5
    })
    console.log(result) // -1

    //Time
    arr = []
    for (let i = 0; i < 100000; i++) {
      arr.push(i)
    }
    let dateStart = Date.now()
    arr.findIndex(v => v < 0)
    let dateEnd = Date.now()
    console.log(dateEnd - dateStart) // 运行三次，三次的耗时数 3ms 4ms 3ms 全部不满足的情况下

    arr = []
    for (let i = 0; i < 100000; i++) {
      arr.push(i)
    }
    dateStart = Date.now()
    arr.findIndex(v => v > 10)
    dateEnd = Date.now()
    console.log(dateEnd - dateStart) // 运行三次，三次的耗时数 0ms 0ms 0ms，可以判断当匹配到满足条件的第一个值后，立刻停止循环，与every相当

26. includes() 返回一个布尔值，表示某个数组是否包含给定的值（不改变原数组）

    // Base
    var arr = [1, 2, 3, 4, 5]
    var result = arr.includes(2)
    console.log(result) // true
    console.log(arr) // [1, 2, 3, 4, 5]

    result = arr.includes(6)
    console.log(result) // false

    //Time
    arr = []
    for (let i = 0; i < 100000; i++) {
      arr.push(i)
    }
    let dateStart = Date.now()
    arr.includes(10)
    let dateEnd = Date.now()
    console.log(dateEnd - dateStart) // 运行三次，三次的耗时数 0ms 0ms 0ms

    arr = []
    for (let i = 0; i < 100000; i++) {
      arr.push(i)
    }
    dateStart = Date.now()
    arr.includes(100000 - 1)
    dateEnd = Date.now()
    console.log(dateEnd - dateStart) // 运行三次，三次的耗时数 0ms 0ms 0ms

27. map(fn) 创建一个新数组，其结果是该数组中的每个元素都调用fn函数后返回的结果（不改变原数组）

    // Base
    var arr = [1, 2, 3, 4, 5]
    var result = arr.map((v, i) => {
      return v + 1
    })
    console.log(result) // [2, 3, 4, 5, 6]
    console.log(arr) // [1, 2, 3, 4, 5]

    //Time
    arr = []
    for (let i = 0; i < 100000; i++) {
      arr.push(i)
    }
    let dateStart = Date.now()
    arr.map(v => 1)
    let dateEnd = Date.now()
    console.log(dateEnd - dateStart) // 运行三次，三次的耗时数 3ms 4ms 6ms

28. reduce(callback[,initialValue]) 为数组中的每个元素依次执行callback函数，不包括数组中被删除或从未被赋值的元素，接受四个参数：accumulator 累计器，currentValue 当前值，currentIndex 当前索引，array 数组。（不改变原数组）

回调函数第一次执行时，accumulator和currentValue的取值有两种情况：如果调用reduce()时提供了initialValue,accumulator取值为initialValue，currentValue取数组中的第一个值；如果没有提供initialValue，那么accumulator取数组中的第一个值，currentValue取数组中的第二个值

注意：如果没有提供initialValue，reduce会从索引1的地方开始执行callback方法，跳过第一个索引。如果提供initialValue，从索引0开始

    // Base
    var arr = [1, 2, 3, 4, 5]
    var result = arr.reduce((accumulator, currentValue, currentIndex, array) => {
      console.log(accumulator, currentValue, currentIndex, array)
      return accumulator + currentValue
      // 1 2 1 [1, 2, 3, 4, 5]
      // 3 3 2 [1, 2, 3, 4, 5]
      // 6 4 3 [1, 2, 3, 4, 5]
      // 16 10 5 4 [1, 2, 3, 4, 5]
      // 无初始值时，accumulator的初始值为数组的第一个元素，currentValue为数组的第二个元素
    })
    console.log(result) // 15
    console.log(arr) // [1, 2, 3, 4, 5]

    result = arr.reduce((accumulator, currentValue, currentIndex, array) => {
      console.log(accumulator, currentValue, currentIndex, array)
      return accumulator + currentValue
      // 10 1 0 [1, 2, 3, 4, 5] 第一次accumulator的值为第二个参数10，currentValue为数组第一个元素
      // 11 2 1 [1, 2, 3, 4, 5] 第二次accumulator的值为第一次循环时return的值
      // 13 3 2 [1, 2, 3, 4, 5]
      // 16 4 3 [1, 2, 3, 4, 5]
      // 20 5 4 [1, 2, 3, 4, 5]
    }, 10)
    console.log(result) // 25

    //Time
    arr = []
    for (let i = 0; i < 100000; i++) {
      arr.push(i)
    }
    let dateStart = Date.now()
    arr.reduce((accumulator, currentValue) => {
      return accumulator + currentValue
    })
    let dateEnd = Date.now()
    console.log(dateEnd - dateStart) // 运行三次，三次的耗时数 4ms 5ms 6ms

29. reduceRight(callback[,initialValue]) 与reduce功能一样，只是从数组末尾开始进行累计（不改变原数组）

    // Base
    var arr = [1, 2, 3, 4, 5]
    var result = arr.reduceRight((accumulator, currentValue, currentIndex, array) => {
      console.log(accumulator, currentValue, currentIndex, array)
      return accumulator + currentValue
        // 5 4 3 (5) [1, 2, 3, 4, 5]
        // 9 3 2 (5) [1, 2, 3, 4, 5]
        // 12 2 1 (5) [1, 2, 3, 4, 5]
        // 14 1 0 (5) [1, 2, 3, 4, 5]
        // 无初始值时，accumulator的初始值为数组的最后一个元素，currentValue为数组的倒数第二个元素
    })
    console.log(result) // 15
    console.log(arr) // [1, 2, 3, 4, 5]

    result = arr.reduceRight((accumulator, currentValue, currentIndex, array) => {
      console.log(accumulator, currentValue, currentIndex, array)
      return accumulator + currentValue
      // 10 5 4 [1, 2, 3, 4, 5] 第一次accumulator的值为第二个参数10，currentValue为数组第一个元素
      // 15 4 3 [1, 2, 3, 4, 5] 第二次accumulator的值为第一次循环时return的值
      // 19 3 2 [1, 2, 3, 4, 5]
      // 22 2 1 [1, 2, 3, 4, 5]
      // 24 1 0 [1, 2, 3, 4, 5]
    }, 10)
    console.log(result) // 25

    //Time
    arr = []
    for (let i = 0; i < 100000; i++) {
      arr.push(i)
    }
    let dateStart = Date.now()
    arr.reduceRight((accumulator, currentValue) => {
      return accumulator + currentValue
    })
    let dateEnd = Date.now()
    console.log(dateEnd - dateStart) // 运行三次，三次的耗时数 14ms 15ms 16ms

30. some(fn) 检查数组中是否含有满足fn函数条件的值（不改变原数组）

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

    result = arr.some(v => {
      return v > 6
    })
    console.log(result) // false

    //Time
    arr = []
    for (let i = 0; i < 100000; i++) {
      arr.push(i)
    }
    let dateStart = Date.now()
    arr.some(v => {
      return v < 0
    })
    let dateEnd = Date.now()
    console.log(dateEnd - dateStart) // 运行三次，全部不满足的情况下，三次的耗时数 2ms 5ms 4ms

31. toLocaleString() 返回一个字符串表示数组中的元素。数组中的元素将使用各自的toLocaleString方法转成字符串，这些字符串将使用一个特定语言环境的字符串（例如一个逗号“，”）隔开（不改变原数组）

    // Base
    var arr = [1, new Date(), 'a', { m: 1 }]
    var result = arr.toLocaleString()
    console.log(result) // 1,2019/5/7 上午10:45:45,a,[object Object]
    console.log(arr) // [1, Tue May 07 2019 10:45:45 GMT+0800 (中国标准时间), "a", {m: 1}]

32. [@@iterator]() 数组自带的迭代器方法（不改变原数组）

    // Base
    var arr = ['w', 'y', 'k', 'o', 'p']
    var eArr = arr[Symbol.iterator]()
    for(let letter of eArr){
      console.log(letter)
    }
    // w
    // y
    // k
    // o
    // p

最后，数组调用后会改变原数组的方法共有9个，分别是push、pop、unshift、shift、reverse、sort、fill、copyWidth、splice