一、改变原数组的数组方法

1.push()

• 语法：数组.push(数据)
• 作用：在数组的末尾新增数据
• 返回值：新的长度

        arr = [1, 2, 3, 4]
        function push(arr,data) {
            arr[arr.length] = data
            return arr
        }
        console.log(push(arr,7))  // 5
        console.log(arr);        // [1, 2, 3, 4, 7]

2.pop()

• 语法：数组.pop()
• 作用：删除数组末尾的数据
• 返回值：被删除的数据

        arr = [1, 2, 3, 4]
        function pop(arr) {
            // 要设置一个变量来存储要删除的值，方便后面返回
            var num = arr[arr.length - 1]
            arr.length -= 1
            return num
        }
        console.log(pop(arr));  // 3
        console.log(arr);       // [1, 2, 3]

3.unshift()

• 语法：数组.unshift(数据)
• 作用：在数组的开头新增数据
• 返回值：新数组的长度

        arr = [1, 2, 3, 4]
        function unshift(arr, data) {
            // 定义一个变量把data变成数组，来存储data的值
            var a = [data]
            for (var i = 0; i < arr.length; i++) {
                a[i + 1] = arr[i]
            }
            // 返回心得数组和数组的长度
            return {
                arr: a,
                len: a.length
            }
        }
        console.log(unshift(arr, 7))  // 5
        console.log(arr)              // [7, 1, 2, 3, 4]

4.shift()

• 语法：数组.shift()
• 作用：删除数组首位数据
• 返回值：被删除的数据

        arr = [1,2,3,4]
        console.log(arr);
        function shift(arr) {
            for (var i = 0; i < arr.length; i++) {
            // 在循环结束后的结果为[2,3,4,5,6,undefined],arr[6]未定义，所以出现未定义值，所以长度应该 -1
                arr[i] = arr[i + 1]
            }
            arr.length -= 1
            return arr
        }
        console.log(shift(arr));

5.sort()

• 语法：
  • 1.数组.sort() 按照数据的首位排序
  • 2.数组.sort(function (a,b) { return a - b }) 按照从小到大顺序排列
  • 3.数组.sort(function (a,b) { return b - a }) 按照从达到小顺序排列
• 作用：将数组排序
• 返回值：排列好的新数组

        arr = [1, 2, 5, 3, 11, 4]
        arr.sort()
        console.log(arr);  // [1, 11, 2, 3, 4, 5]
        arr.sort(function (a, b) { return a - b })
        console.log(arr);  // [1, 2, 3, 4, 5, 11]
        arr.sort(function (a, b) { return b - a })
        console.log(arr);  // [11, 5, 4, 3, 2, 1]

6.reverse()

• 语法：数组.reverse()
• 作用：将数组反转
• 返回值：反转后的数组

        arr = [1, 2, 3, 4]
        function reverse(arr) {
            for (var i = 0; i < arr.length / 2; i++) {
                var num = arr[i]
                // - i 是为了让后面的数据与前面的数据对应，否则给前面数据赋的值一直是最后一位
                arr[i] = arr[arr.length - 1 - i]
                arr[arr.length - 1 - i] = num
            }
            return arr
        }
        console.log(reverse(arr));

7.splice()

• 语法：数组.splice(要剪切的位置， 剪切几个, 增加的数据1，增加的数据2，……)
• 作用：剪切数据
• 返回值：被剪切的数据以新数组的方式返回

    // ！important:清空数组内容（出现数组塌陷）
        var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9]
        for (var i = 0; i < arr.length; i++) {
            arr.splice(i,1)
            i--
          /* 
           * 当i=0 时，删除的是1，数组变为[2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
           * 当i=1 时，删除的是3, 数组变为[2, 4, 5, 6, 7, 8, 9, 10, 11]
           * 当i=2 时，删除的是5，数组变为[2, 4, 6, 7, 8, 9, 10, 11]
           * 上述现象就是数组塌陷，通过 i-- 让 i 从头开始
           */
        }
        console.log(arr);

二、不改变原数组的数组方法

1.indexOf()

• 语法：数组.indexOf(要查询的数据，从哪里开始查询)
• 作用：查找数组中的数据
• 返回值：
  • 如果有该数据，则返回 从左到右第一次出现的该数据的索引
  • 如果没有，则返回 -1

        arr = [1, 2, 3, 4, 5, 6, 1, 4, 2]
        function indexOf(arr, data, index = 0) {
            for (var i = index; i < arr.length - 1; i++) {
                if (arr[i] === data) {
                    return i
                }
            }
            return -1
        }
        var s1 = indexOf(arr, 7)
        console.log(s1);
        console.log(arr);

2.lastIndexOf()

• 语法：数组.lastIndexOf(要查询的数据，从哪里开始查询)
• 作用：查找数组中的数据
• 返回值：
  • 如果有该数据，则返回 从左到右第一次出现的该数据的索引
  • 如果没有，则返回 -1

    var arr2 = [11, 55, 66, 77, 100]
    console.log('原数组：', arr2);
    var res = arr2.lastIndexOf(100)     //  4
    var res = arr2.lastIndexOf(110, 3)  // -1
    console.log('新的数组：', arr2);
    console.log('返回值：', res);

3.concat()

• 语法：数组.concat()
• 作用：将传入的数据, 合并到指定的数组中
• 返回值：合并后的新数组

    var arr2 = [11, 55, 66, 77, 100]
    console.log('原数组：', arr2);
    var res = arr2.concat(15, 16, 17, [10, 150])
    console.log('新的数组：', arr2);
    console.log('返回值：', res);  // [11, 55, 66, 77, 100, 15, 16, 17, 10, 150]

4.join()

• 语法：数组.join('连接符')
• 作用：将数据用连接符连接起来
• 返回值：以连接符链接的完整字符串

    var arr = [1, 2, 3, 4]
    var res = arr.join('&')
    console.log('新的数组：', arr);
    console.log('返回值：', res);  // 1&2&3&4

5.slice()

• 语法：数组.slice(开始下标，结束下标)
• 作用：复制数据
• 返回值：复制的数据
• 注意：包前不包后

    var arr1 = [3, 1, 5, 7, 2, 8, 4, 11, 55]
    var res = arr1.slice(3, 6)   // [7, 2, 8, 4, 11, 55]
    var res = arr1.slice()       // 复制整个数组
    var res = arr1.slice(3, -1)  // -1 => arr.length - 1
    console.log('新的数组：', arr1);
    console.log('返回值：', res);

6.forEach()

• 语法：数组.forEach(function (item, index, origin) {遍历数组后要执行的代码})
  • item：数组的每一项
  • index：元素对应的索引/下标
  • origin：原来的数组
• 作用：遍历数组，拿到数组的每一项
• 返回值：无
• 语义：遍历数组

    var arr = [11, 55, 66, 77, 100]
    arr.forEach(function (item, index, origin) {
        console.log(item, index)  // 11 0; 55 1; 66 2; 77 3; 100 4
    })

7.map()

• 语法：数组.map(function (item, index, origin) {遍历数组后要执行的代码})
• 作用：根据原数组映射一个新的数组
• 返回值：映射出来的新数组(需要在函数内部书写 return)
• 语义：映射数组

    var arr = [11, 55, 66, 77, 100]
    var res = arr2.map(function (item, index, origin) {
        return item + '1'
    })
    console.log(res);  // ['111', '551', '661', '771','1001']

8.filter()

• 语法：数组.filter(function (item, index, origin) { })
• 作用：过滤符合要求的数据
• 返回值：被过滤掉的符合要求的数据以数组形式返回

    var arr = [11, 55, 66, 77, 100, 111]
    var res = arr.filter(function (item) {
        return item % 11 === 0
    })
    console.log(arr);
    console.log(res);  // [11, 55, 66, 77]

9.find()

• 语法：数组.find(function (item, index, origin) { })
• 作用：查找数组中的数据
• 返回值：满足条件的第一个数据, 如果找不到则返回undefined

    var arr = [11, 55, 66, 77, 100, 111]
    var res = arr.find(function (item) {
        return item % 11 === 0
    })
    console.log(arr);
    console.log(res);  // 11

10.findIndex()

• 语法：数组.findIndex(function (item, index, origin) { })
• 作用：查找数组中数据对应的索引
• 返回值：满足条件的第一个数据对应的索引, 如果找不到则返回undefined

    var arr = [11, 55, 66, 77, 100, 111]
    var res = arr.findIndex(function (item) {
        return item % 11 === 0
    })
    console.log(arr);
    console.log(res);  // 0

11.every()

• 语法：数组.every(function (item, index, origin) { })
• 作用：判断数组中是否全部满足条件
• 返回值：是，返回true，不是，返回false

    var arr = [11, 55, 66, 77, 100, 111]
    var res = arr.every(function (item) {
        return item > 0          //  true
        return item % 11 === 0   //  false
    })
    console.log(arr);
    console.log(res);

12.some()

• 语法：数组.some(function (item, index, origin) { })
• 作用：判断数组中是否有满足条件
• 返回值：是，返回true，不是，返回false

    var arr = [11, 55, 66, 77, 100, 111]
    var res = arr.some(function (item) {
        return item < 0          //  false
        return item % 11 === 0   //  true
    })
    console.log(arr);
    console.log(res);

13.reduce()

• 语法：数组.reduce(function (prev, item, index, origin) { }， init)
  • 参数1：function (prev, item, index, origin) { }
    • 1.item, index, origin
    • 2.prev：
      • 如果是第一次执行那么可能是 数组[0] 的值, 也有可能是 init 的值
      • 如果是第一次后续的执行, 那么他的值就是上一次遍历返回的结果
  • 参数2：init 随意传递一个值即可, 只要符合需求
• 作用：累加器
• 返回值：累加后的结果

    var arr = [1, 2, 3, 4, 5]
    var res = arr.reduce(function (prev, item) {
        return prev + item  // 12345
    }, "")  // ""将数据转化为字符串
    console.log(res)