数组常用的方法(详解版)

数组常用的方法

* 1.push
        语法:数组.push(数据)
        作用:在数组末尾添加数据
        返回值:追加数据后,数组的最新长度(length)

        var arr = [1, 2, 3]
        var len = arr.push(500)
        console.log('返回值',len)     // 4-----最新长度(length)
        console.log(arr)             // [1, 2, 3, 500]

* 2.pop
        语法:数组.pop()
        作用:删除数组最后一条数据
        返回值:被删除的数据

        var arr = [1, 2, 3]
        var po = arr.pop(3)
        console.log('返回值',po)      // 3-----被删除的最后一条数据
        console.log(arr)             // [1,2]

* 3.unshift
        语法:数组.unshift(数据)
        作用:向数组开头添加数据
        返回值:添加数据后,数组最新的长度(length)

        var arr = [1, 2, 3]
        var len = arr.unshift(666)
        console.log('返回值',len)        // 4-----最新长度(length)
        console.log(arr)                // [666, 1, 2, 3]

* 4. shift
        语法:数组.shift()
        作用:删除数组第一条数据
        返回值:被删除的数据

        var arr = [1, 2, 3]
        var sh = arr.shift()
        console.log('返回值',sh)         // 1-----被删除的第一条数据
        console.log(arr)                // [2, 3]

* 5. reverse
        语法:数组.reverse()
        作用:反转数组
        返回值:反转后的数组

        var arr = [1, 2, 3]
        var newArr = arr.reverse()
        console.log('返回值:',newArr)    // [3, 2, 1]-----反转后的数组
        console.log('arr:',arr)         // [3, 2, 1]

* 6. sort
        语法1: 数组.sort()
            作用:会将数据转换为字符串后,一位一位的对比
        语法2: 数组.sort(function (a,b) {return a - b})
            作用:会按照数字大小升序排列,也就是从小到大排列
        语法2: 数组.sort(function (a,b) {return b - a})
            作用:会按照数字大小降序排列,也就是从大到小排列
        返回值:排序后的数组

        6.1
        var arr = [3, 5, 10, 20, 100, 162]
        var newArr = arr.sort()
        console.log('返回值',newArr)         // [10, 100, 162, 20, 3, 5]---数字会一位一位的进行比较(此数组数字 1 开头的先比较)
        console.log('arr',arr)              // [10, 100, 162, 20, 3, 5]

        6.2
        var arr = [3, 5, 10, 20, 100, 162]
        var newArr = arr.sort(function (a,b) {return a - b})
        console.log('返回值',newArr)         // [3, 5, 10, 20, 100, 162]---数字会从小到大排列(升序)
        console.log('arr',arr)              // [3, 5, 10, 20, 100, 162]

        6.3
        var arr = [3, 5, 10, 20, 100, 162]
        var newArr = arr.sort(function (a,b) {return b - a})
        console.log('返回值',newArr)         // [162, 100, 20, 10, 5, 3]---数字会从大到小排列(降序)
        console.log('arr',arr)              // [162, 100, 20, 10, 5, 3]

*** 7. splice
        语法1:数组.splice(开始索引,多少个)
            作用:截取数组部分内容
        语法2:数组.splice(开始索引,多少个,插入的数据1,插入的数据2,插入的数据3....)
            作用:截取数组部分内容,并插入新的数据
        返回值:截取出来的部分内容,组成的数组

        7.1
        var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9]
        var newArr = arr.splice(3,4)        
        console.log('返回值',newArr)          // [4,5,6,7]-----从下标3开始截取,截取4个数据
        console.log(arr)                     // [1,2,3,8,9]

        7.2
        var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9]
        var newArr = arr.splice(3,4,'我是新插入进来的数据1','数据2')  // 不管插入多少个都是从下标3开始的
        console.log('返回值',newArr)          // [4,5,6,7]-----从下标3开始截取,截取4个数据     
        console.log(arr)                     // [1, 2, 3, '我是新插入进来的数据1', '数据2', 8, 9]


--------------------------数组的方法能够改变原数组的  只有上面的7个方法--------------------------->


*** 8. slice
        语法: 数组.slice(开始索引,结束索引)
        参数:
                + 包前不包后:包含开始索引位置的数据,不包含结束索引位置的数据
                + 不写开始索引默认是0;不写结束索引,默认是数组length
                +  参数支持写负数,表示倒数第几个,其实就是length + 负数
        作用:截取数组部分内容
        返回值: 截取出来的部分内容组成的新数组

        8.1包前不包后
        var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9]
        var newArr = arr.slice(1,4)             //从下标 1 开始,截取到下标 4
        console.log('返回值',newArr)            //[4]  包前不包后
        console.log(arr)                       //和原数组一样,不变

        8.2不写结束索引
        var newArr = arr.slice(5)       // 不写结束索引,相当于写了 数组.length, 所以这里相当于写了slice(5,arr.Length)

        8.3不写开始和结束索引
        var newArr = arr.slice()        // 不写开始和结束索引,相当于写了开始索引是 0 ,结束索引是 数组.length 

        8.4索引为负数
        var newArr = arr.slice(3,-2)    // 负数表示 数组.length + 负数,其实就是 9+(-2)=7,那么开始索引就是 3 ,结束索引就是7

* 9.concat
        语法: 原始数组.concat(数组1, 数组2, ...,数据1, 数据2....)
        作用: 进行数据拼接，把数组1...数据1之类的小括号里的内容，拼接在原始数组中
        返回值: 拼接好的数组

        var arr = [1, 2, 3, 4]
        var newArr = arr.concat([4, 5, 6], [10, 20], ['a', 'b', 'c', 'qwe'])
        console.log('返回值:',newArr)   // [1, 2, 3, 4, 4, 5, 6, 10, 20, 'a', 'b', 'c', 'qwe']-----拼接完成的数组
        console.log(arr)

* 10. join
        语法: 数组.join('连接符')
        作用: 使用'连接符',把数组内的每一个数据连成一个字符串(不写连接符默认使用的是 逗号)
        返回值: 连接好的字符串

        var arr = [1, 2, 3, 4]
        var newArr = arr.join()             
        console.log('返回值:',newArr)        // 1,2,3,4-----不传递连接符,默认使用的是 逗号 链接

         var arr = [1, 2, 3, 4]
        var newArr = arr.join('!')          
        console.log('返回值:',newArr)       // 1!2!3!4-----使用 ! 将数组内的所有数据拼接成一个字符串

* 11. indexOf
        语法1: 数组.indexOf(要检查的数据)
            作用:从前到后(从左到右),检查该数据第一次在该数据内出现的 索引
        语法2: 数组.indexOf(要检查的数据,开始索引)
            作用:再开始索引的位置,按照从左到右的顺序，检查该数据第一次在该数组内出现的索引
        返回值: 找到数据的情况下,会将该数据第一次出现的下标(索引)返回
                没找到的情况下,会直接返回一个 -1

        11.1
        var arr = [1, 1, 2, 2, 3, 3, 0, 4, 0]
        var num = arr.indexOf(100)      // 此时要检查的数据是数字100，但是数组中并没有出现过数字100,所以返回值应该是 -1       
        console.log('返回值:',num)      // -1 -----

        var arr = [1, 1, 2, 2, 3, 3, 0, 4, 0]
        var num = arr.indexOf(1)        // 此时要检查的数据是数字1，数字1按照从左到右的顺序，第一次出现的下标为0,所以返回值应该是 0
        console.log('返回值:',num)      // 0

        11.2
        var arr = [1, 1, 2, 2, 3, 3, 0, 4, 0]
        var num = arr.indexOf(1,3)      // 从下标3的位置开始按照从左往右的顺序查找,因为后续并没有数字1，所以此处应该返回-1
        console.log('返回值:',num)       // -1

* 12. lastIndexOf
        语法1: 数组.lastIndexOf(要检查的数据)
            作用:从后向前(从右到左),检查该数据第一次在该数据内出现的 索引
        语法2: 数组.lastIndexOf(要检查的数据,开始索引)
            作用:再开始索引的位置,按照从右到左的顺序，检查该数据第一次在该数组内出现的索引

        返回值: 找到数据的情况下,会将该数据第一次出现的下标(索引)返回
                没找到的情况下,会直接返回一个 -1

        12.1
        var arr = [1, 1, 2, 2, 3, 3, 0, 4, 0]
        var num = arr.lastIndexOf(3)       // 此时按照从右向左的顺序查找，发现第一次出现的位置是下标5的位置
        console.log('返回值:',num)          // 5

        12.2
        var arr = [1, 1, 2, 2, 3, 3, 0, 4, 0]
        var num = arr.lastIndexOf(3,2)     // 此时在下标2的位置按照从右向左的顺序查找，但是此时在数组中后续的位置并没有出现数字3,所以返回值为- 1
        console.log('返回值:',num)          // -1