数组常用方法

push

• 语法: 数组名.push(数据)
• 作用: 向数组末尾添加数据
• 返回值: 追加数据后, 数组最新的长度

 var arr = [1, 2, 3]
 var len = arr.push(100)
 console.log(arr)
 console.log('返回值: ', len)

手动模拟 push

在 函数传参的过程中, 如果实参的值是一个引用数据类型,然后在函数内部对对应的形参做了一些修改，那么会影响到 函数外边的原数据。

var arr = [1, 2, 3]
function push(push_arr, data) {
    push_arr[push_arr.length] = data
    return push_arr.length
}
push(arr, true)
console.log(arr)

pop

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

var arr = [1, 2, 3, 4, 5, 6]
var a = arr.pop()
console.log(arr);
console.log(a);

手动模拟 pop

• 作用: 删除数组末尾最后一个数据
• 返回值: 被删除的数据

        function f1 (array) {
            // 删除后 位置还在, 也就是说, 数组最后一位的值没有了, 但是 length 不变
            delete array[array.length - 1]
            return array.length
        }
        var b = f1 (arr)
        console.log(arr);
        console.log(b);

        function f2 (array1) {
            // 删除后 位置也没了, 也就是说, 数组最后一位的值和位置都被删除了
            array1.length -= 1 
            return array1.length
        }
        var c = f2(arr)
        console.log(arr);
        console.log(c);

unshift

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

        var arr1 = [1, 2, 3]
        console.log('原数组: ', arr1)
        var len = arr1.unshift('新的数据')
        console.log('方法执行完毕后的原数组: ', arr1)

手动模拟 unshift

1. 创建一个新的数组, 然后将这个数组开头放上我们执行要添加的数据
2. 在将原本数组后续的内容, 放在新数组的后边

        function f2(array1, add1) {
            var arr = [1, 2, 3]
            // 1. 创建一个新的数组, 然后将这个数组开头放上我们执行要添加的数据
            var newarray1 = [add1]
            // 2. 在将原本数组后续的内容, 放在新数组的后边
            for(i = 0; i < array1.length; i++) {
                newarray1 [i + 1] = array1 [i]
            }  
            // 3. 遍历 我们想要得到的数组, 拿到每一项, 然后重新赋值给 unshift_arr
            for(j = 0; j < newarray1.length; j++){
                array1[j] = newarray1[j]
            }         
        }
        f2(arr, -2)
        console.log(arr);
        console.log(arr.length);

shift

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

        var arr = [1, 2, 3, 4, 5, 6]
        var a = arr.shift()
        console.log(arr);
        console.log(a);

手动模拟 shift

        function f1(array) {
            temp = array[0]
            for(var i = 0; i < array.length; i++) {
                array[i] = array[i + 1]
            }
            array.length -= 1
            return temp
        }
        var b = f1(arr)
        console.log(arr);
        console.log(b);

reverse

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

        var arr = [1, 2, 3, 4, 5, 6, 7]
        var a = arr.reverse()
        console.log(arr);
        console.log(a);

手动模拟 reverse

        function f1 (array) {
            for(i = 0; i < array.length / 2; i++) {
                temp = array[i]
                array[i] = array[array.length - 1 - i]
                array[array.length - 1 - i] = temp
            }
            return array
        }

sort

• 语法: 数组名.sort(); 数组名.sort((a, b) => a - b); 数组名.sort((a, b) => b - a)

1. 数组名.sort(); 不传参数: 会将数据转换为字符串后, 一位一位的对比
2. 数组名.sort(function (a, b) { return a - b }),回调函数内进行 a - b, 那么会按照数字大小升序排序,速度不如算法
3. 数组名.sort(function (a, b) { return b - a }),回调函数内进行 b - a, 那么会按照数字大小降序排序，速度不如算法

• 作用: 根据参数对数组数据实现排序
• 返回值: 排序后的数组

indexOf

• 语法:

1. 数组名.indexOf(要检查的数据);
2. 数组名.indexOf(要检查的数据, 开始索引(第二个参数不传, 默认为0))`

• 作用: 从前到后检查该数据第一次在该数组内出现的索引位置
• 返回值: 如果在数组内找到了该数据, 那么会返回该数据第一次出现的索引位置, 没找到返回 -1

        var arr = [1, 2, 3, 2, 4, 5]
        //查询是否包含，返回下标
        console.log(arr.indexOf(2));
        //从下标2开始查
        console.log(arr.indexOf(2, 2));
        //查不到返回-1
        console.log(arr.indexOf(2, 4));
        //不影响原数组
        console.log(arr);

手动模拟 indexOf

        function fn1(array, data, index = 0) {
            for (var i = index; i < array.length; i++) {
                if (array [i] === data) {
                    return i
                }
            }
            return -1
        }

splice(作用类似于剪切)

• 语法:

1. 数组名.splice(开始索引, 剪切多少个);
2. 数组名.splice(开始索引, 多少个, 插入数据1, 插入数据2, ...)`

• 作用: 截取数组部分内容, 并选择性插入内容
• 返回值: 截取出来的部分内容组成的新数组

        var arr = [1, 2, 3, 4, 5]
        var res = arr.splice(0, 2)
        //剪切剩余
        console.log(arr);
        //剪切的部分
        console.log(res);

        //从剪切部分开始添加数据
        var temp = arr.splice(0, 2, '11', true, 12)
        console.log(arr);
        console.log(temp);

数组塌陷

        //注意数组塌陷，arr.splice(i,1)
        var arr =[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
        for(var i = 0; i < arr.length + i; i++) {
            arr.splice(0, 1)
        }
        console.log(arr);

数组去重

        //依次找重
        function fn (array) {
            for (var i = 0; i < array.length ; i++){
                for(var j = i + 1; j < array.length ; j++){
                    if (array[j] === array[i]){
                        array.splice(j, 1)
                        j--
                    }                 
                }
            }
            return array
        }
        var arr = [1, 2, 3, 4, 2, 3, 4, 2, 5, 5, 4, 3, 2, 1]
        var res = fn(arr)
        console.log(res);
        
        //先分类再找重
        arr1 = [1, 2, 3, 4, 2, 3, 4, 2, 5, 5, 4, 3, 2, 1]
        arr1.sort()
        for(var m = 0; m < arr1.length; m++){
            var temp = 0
            for (var n = m + 1; n < arr1.length; n++) {
                if (arr1[m] === arr1[n]) {
                    temp++
                }
            }
            arr1.splice(m ,temp)
        }
        console.log(arr1);

        //不唯一就删
        arr2 = [1, 2, 3, 4, 2, 3, 4, 2, 5, 5, 4, 3, 2, 1]
        for(var l = 0; l < arr2.length; l++) {
            if (arr2.indexOf(arr2[l], l + 1) !== -1) {
                arr2.splice(l, 1)
                l--
            }
        }
        console.log(arr2);

        //唯一时填入新数组
        arr3 = [1, 2, 3, 4, 2, 3, 4, 2, 5, 5, 4, 3, 2, 1]
        var newarr = []
        for(var k = 0; k < arr3.length; k++) {
            if (arr3.indexOf(arr3[k], k + 1) === -1) {
                newarr.push(arr3[k])
            }
        }
        console.log(newarr);

        //新数组没有就填
        arr4 = [1, 2, 3, 4, 2, 3, 4, 2, 5, 5, 4, 3, 2, 1] 
        var newarr2 = []
        for(var x = 0; x < arr4.length; x++) {
            if (newarr2.indexOf(arr4[x] === -1)) {
                newarr2.push(arr4[x])
            }
        }