12.29---01数组常用方法1

数组的常用方法

     *      1. push
     *          * 语法: 数组.push(数据)
     *          * 作用: 向数组末尾添加数据
     *          * 返回值: 追加数据后, 数组最新的长度(length)
     *
     *      2. pop
     *          * 语法: 数组.pop()
     *          * 作用: 删除数组最后一条数据
     *          * 返回值: 被删除的数据
     *
     *      3. unshift
     *          * 语法: 数组.unshift(数据)
     *          * 作用: 向数组开头添加数据
     *          * 返回值: 添加数据后, 数组最新的长度(length)
     *
     *      4. shift
     *          * 语法: 数组.shift()
     *          * 作用: 删除数组第一条数据
     *          * 返回值: 被删除的数据
     *
     *      5. reverse
     *          * 语法: 数组.reverse()
     *          * 作用: 反转数组
     *          * 返回值: 反转后的数组
     *
     *      6. sort
     *          * 语法1: 数组.sort()
     *                  * 作用: 会将数据转换为 字符串后, 一位一位的对比
     *          * 语法2: 数组.sort(function (a, b) {return a - b})
     *                  * 作用: 会按照数字大小升序排列
     *          * 语法3: 数组.sort(function (a, b) {return b - a})
     *                  * 作用: 会按照数字大小降序排列
     *
     *          * 返回值: 排序后的数组
     * 
     *      7. splice
     *          * 语法1: 数组.splice(开始索引, 多少个)
     *                  * 作用: 截取数组部分内容
     *          * 语法2: 数组.splice(开始索引, 多少个, 插入的数据1, 插入的数据2, 插入的数据3...)
     *                  * 作用: 截取数组部分内容, 并插入新的数据
     * 
     *          * 返回值: 截取出来的部分内容   组成的 数组
     * 
     *      数组的方法 能够改变原数组的 就只有上边说的 7 个
     * 
     * 
     *      8. slice
     *          * 语法: 数组.slice(开始索引, 结束索引)
     *          * 参数:
     *              + 包前不包后: 包含开始索引位置的数据, 不包含结束索引位置的数据
     *              + 不写开始索引, 默认是0; 不写 结束索引, 默认是 数组的length
     *              + 参数支持写负数, 表示倒数第几个, 其实就是 length + 负数
     *          * 作用: 截取数组部分内容
     *          * 返回值: 截取出来的部分内容组成的新数组
     * 
     *      面试题: 数组中有两个方法, splice 与 slice, 你能描述一下他们两个的区别吗?
     *                  1. 参数含义不同, 然后介绍一下 参数哪里不同
     *                  2. splice 会改变原数组, 而 slice 不会
    */
    

实例

     var arr = [1, 2, 3]
    console.log('原始数组: ', arr)
    

1. push

    var len = arr.push(500)
    console.log(len)    // 4
    console.log(arr)    // [1, 2, 3, 500]
   

2. pop

   var po = arr.pop()
   console.log(po)     // 3
   console.log(arr)    // [1, 2]
   

3. unshift

   var len = arr.unshift(666)
   console.log(len)    // 4
   console.log(arr)    // [666, 1, 2, 3]
   

4. shift

    var st = arr.shift()
    console.log(st)     // 1
    console.log(arr)    // [2, 3]
   

5. reverse

    var newArr = arr.reverse()
    console.log('newArr: ', newArr)
    console.log('arr: ', arr)
   

6. sort

    var arr = [100, 101, 200, 10, '999', 'qwe', '123abc']
    console.log('原始数组: ', arr)
    
    var newArr = arr.sort()
    console.log('newArr', newArr)
    console.log('arr', arr)
    
     var newArr = arr.sort(function (a, b) {return a - b})
    console.log('newArr', newArr)
    console.log('arr', arr)
    
    
    var newArr = arr.sort(function (a, b) { return b - a })
    console.log('newArr', newArr)
    console.log('arr', arr)
    
   

7. splice

    var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9]
    //         0  1  2  3  4  5  6  7  8
    console.log('原始数组: ', arr)
    
   

7.1

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

7.2

    var newArr = arr.splice(2, 3, '数据1', '数据2', '数据3', '数据4', '数据5')  // 不管插入多少个数据, 都是从下标2开始的
    console.log('newArr', newArr)
    console.log('arr', arr)
    

8. slice

    var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9]
    //         0  1  2  3  4  5  6  7  8
    console.log('原始数组: ', arr)
    
    var newArr = arr.slice(3, 4)    // 从 下标3 开始截取, 截取到 下标4
    console.log('newArr', newArr)   // [4]
    console.log('arr', arr)
    
    var newArr = arr.slice(5)   // 不写 结束索引, 相当于 写了数组.length, 所以这里相当于写了 slice(5, arr.length)
    console.log(newArr) // [6, 7, 8, 9]
    
   

此时 开始索引与结束索引都没有填写, 那么 开始索引相当于是写了一个 0, 结束索引相当于写了 数组.length arr.slice() 相当于写了 arr.slice(0, arr.length)

     var newArr = arr.slice()
     console.log(newArr)
     
     var newArr = arr.slice(3, -2)
    console.log(newArr) // [4, 5, 6, 7]
    

arr.slice(3, -2) slice 这个方法 允许写 负数

写负数的时候 就相当于写了 length + 负数

arr.slice(3, -2) -> arr.slice(3, arr.length + (-2)) -> arr.slice(3, arr.length - 2) -> arr.slice(3, 9 - 2) -> arr.slice(3, 7)