javascript数组(Array)常用方法

//Array数组
        //回忆：创建数组的第一种方式
        var obj = [1,2,3];     //通过字面量创建一个数组

        //创建数组的第二种方法
        var string1 = new Array();  //若Array()中不带参数则创建了一个空的数组
        var string2 = new Array(2); //若Array(2)中带了一个参数2 则说明创建了一个长度length为2的数组
        var string3 = new Array(1,2,3); //若Array()中参数超过一个，则相当于第一种字面量创建，等同于给数组添加数组元素了

        //检测是否为数组
        //第一种：数组名 instanceof Array
        console.log(obj instanceof Array);  //如若obj是数组则返回true 否则返回false

        //第二种：Array.isArray(参数名)
        console.log(Array.isArray(obj));    //若obj是数组返回true 否则返回false

        //添加数组元素的方法
        //1.push()我数组的末尾处添加一个或多个数组元素
        //obj.push(4,'wangziyu');     //添加多个数组元素用逗号隔开
        console.log(obj.push(4,'wangziyu'));    //这里输出的为5，可知push()是有返回值的，返回的是添加后数组的长度
        console.log(obj);

        //2.unshift()在数组的开头添加一个或多个数组元素
        //obj.unshift(4,'wangziyu');     //添加多个数组元素用逗号隔开
        console.log(obj.unshift('action',0));   这里输出的为7，可知unshift()是有返回值的，返回的是添加后数组的长度
        console.log(obj);

        //删除数组元素的方法
        //1.pop()我数组的末尾处删除一个数组元素只能删除一个
        console.log(obj.pop());    //这里输出的为'wangziyu'，可知pop()是有返回值的，返回的是删除的那个数组元素
        console.log(obj);

        //2.shift()在数组的开头删除一个数组元素只能删除一个
        console.log(obj.shift());   这里输出的为'action'，可知shift()是有返回值的，返回的是删除的那个数组元素
        console.log(obj);

        //颠倒数组的方法
        //reverse();
        var arr = [1,2,3,4];
        arr.reverse();
        console.log(arr);

        //数组排序（冒泡排序）的方法
        //sort();
        var arr1 = [1,2,3,4,5]; 
        arr1.sort();    //只能对于小于10的数有效，若数组为var arr2 = [1,22,31,4,5];就会出问题
        //用以下解决办法
        var arr2 = [1,22,31,4,5];
        arr1.sort(function(a,b){        //这种方法则不会出错    //按照升序排列
            return a - b;
        });
        console.log(arr2);

        //查找数组元素索引的方法
        //indexOf();
        var arr3 = [1,2,3,4,5,6,7,8,1];
        console.log(arr3.indexOf(1));   //返回0 ，我们发现末尾也有一个1，但indexOf只返回第一个，如果找不到则返回-1

        //做一个查重的案例（indexOf()的重要案例）
        function unique(arr){
            var newarr = [];
            for(var i =0;i < arr.length;i++){
                    if(newarr.indexOf(arr[i]) == -1){       //核心是这里 判断新的数组中是否有这个数，如果没有则将这个数传进新的数组
                        newarr.push(arr[i]);
                    }
            }
            return newarr;
        }
        var arr = unique([1,2,3,4,5,6,7,8,1]);
        console.log(arr);
        //数组转换为字符串
        //1.toString();将数组转换为字符串
        var arr = [1,2,3];
        console.log(arr.toString());    //返回1,2,3  转换成字符串后 默认用逗号将里面的数字分割
        //2.join(分隔符)(常用)
        var arr = [1,2,3];
        console.log(arr.join());    //join()中不带参数 默认是逗号分隔
        console.log(arr.join('-')); //参数是'-' 则用-分隔  所以返回为1-2-3

        //将两个数组连接起来的方法
        //concat(); 格式 被连接数组名.concat(要连接数组名)  返回的是一个新的数组
        //两个数组相连
        var alpha = ['a', 'b', 'c'];    
        var numeric = [1, 2, 3];

        alpha.concat(numeric);
        console.log(alpha);
        // result in ['a', 'b', 'c', 1, 2, 3]   numeric连接到alpha后面

        //三个数组相连
        var num1 = [1, 2, 3],
            num2 = [4, 5, 6],
            num3 = [7, 8, 9];
        var nums = num1.concat(num2, num3);

        console.log(nums);
        // results in [1, 2, 3, 4, 5, 6, 7, 8, 9]

        //将值连接到数组中
        var alpha = ['a', 'b', 'c'];
        var alphaNumeric = alpha.concat(1, [2, 3]);

        console.log(alphaNumeric);
        // results in ['a', 'b', 'c', 1, 2, 3]  

        //数组截取方法slice(begin,end)
        //slice() 方法返回一个新的数组对象，这一对象是一个由 begin 和 end 决定的原数组的浅拷贝（包括 begin，不包括end）。原始数组不会被改变。
        //注意如果begin省略则从索引0开始截取，如果end省略则截取到数组末尾
        const animals = ['ant', 'bison', 'camel', 'duck', 'elephant'];

        console.log(animals.slice(2));
        //end 省略则从索引2开始一直截取到末尾
        // 返回的新数组 ["camel", "duck", "elephant"]

        console.log(animals.slice(2, 4));
        //begin和end都未省略，所以从索引2开始一直到3 因为不包括end索引的数组元素
        // 返回的新数组 ["camel", "duck"]

        console.log(animals.slice(1, 5));
        // 返回的新数组 ["bison", "camel", "duck", "elephant"]

        console.log(animals.slice(-2,-1));
        //表示从倒数第二个到倒数第一个 但又不包括end 所以新数组为["duck"];
        // 返回的新数组["duck"];

        //splice() 方法通过删除或替换现有元素或者原地添加新的元素来修改数组,并以数组形式返回被修改的内容。此方法会改变原数组。
        //语法格式：array.splice(start[, deleteCount[, item1[, item2[, ...]]]])
        /* 参数1.start​
        指定修改的开始位置（从0计数）。如果超出了数组的长度，则从数组末尾开始添加内容；如果是负值，则表示从数组末位开始的第几位（从-1计数，这意味着-n是倒数第n个元素并且等价于array.length-n）；如果负数的绝对值大于数组的长度，则表示开始位置为第0位。
        
        参数2.deleteCount 可选
        整数，表示要移除的数组元素的个数。
        如果 deleteCount 大于 start 之后的元素的总数，则从 start 后面的元素都将被删除（含第 start 位）。
        如果 deleteCount 被省略了，或者它的值大于等于array.length - start(也就是说，如果它大于或者等于start之后的所有元素的数量)，那么start之后数组的所有元素都会被删除。
        如果 deleteCount 是 0 或者负数，则不移除元素。这种情况下，至少应添加一个新元素。
        
        参数3.item1, item2, ... 可选
        要添加进数组的元素,从start 位置开始。如果不指定，则 splice() 将只删除数组元素。 */
        
        // 从第 2 位开始删除 0 个元素，插入“drum”
        var myFish = ["angel", "clown", "mandarin", "sturgeon"];
        var removed = myFish.splice(2, 0, "drum");
        // 运算后的 myFish: ["angel", "clown", "drum", "mandarin", "sturgeon"]
        // 被删除的元素: [], 没有元素被删除

        // 从第 2 位开始删除 0 个元素，插入“drum” 和 "guitar"
        var myFish = ['angel', 'clown', 'mandarin', 'sturgeon'];
        var removed = myFish.splice(2, 0, 'drum', 'guitar');
        // 运算后的 myFish: ["angel", "clown", "drum", "guitar", "mandarin", "sturgeon"]
        // 被删除的元素: [], 没有元素被删除

        // 从第 3 位开始删除 1 个元素
        var myFish = ['angel', 'clown', 'drum', 'mandarin', 'sturgeon'];
        var removed = myFish.splice(3, 1);
        // 运算后的 myFish: ["angel", "clown", "drum", "sturgeon"]
        // 被删除的元素: ["mandarin"]

        // 从第 2 位开始删除 1 个元素，插入“trumpet”
        var myFish = ['angel', 'clown', 'drum', 'sturgeon'];
        var removed = myFish.splice(2, 1, "trumpet");
        // 运算后的 myFish: ["angel", "clown", "trumpet", "sturgeon"]
        // 被删除的元素: ["drum"]

        // 从第 2 位开始删除所有元素
        var myFish = ['angel', 'clown', 'mandarin', 'sturgeon'];
        var removed = myFish.splice(2);
        // 运算后的 myFish: ["angel", "clown"]
        // 被删除的元素: ["mandarin", "sturgeon"]

        // 从倒数第 2 位开始删除 1 个元素
        var myFish = ['angel', 'clown', 'mandarin', 'sturgeon'];
        var removed = myFish.splice(-2, 1);
        // 运算后的 myFish: ["angel", "clown", "sturgeon"]
        // 被删除的元素: ["mandarin"]
    </script>