数组API和部分API的重构——1（push、pop、unshift、shift、join、concat、splice、slice、reverse）

数组的API和部分API的重构

1、push: //可以在数组的尾部添加若干个元素，返回值为新数组的长度

        var arr=[1];
        var len=arr.push(5,6,7,8);
        console.log(len);
    //循环给尾部添加若干个元素 
        while(arr.push({})<10);
        arr[0].a=10;
        console.log(arr); 

    //重构！
        function push(arr){
            for(var i=1;i<arguments.length;i++){
                arr[arr.length]=arguments[i];
            }
            return arr.length;
        }
        var arr=[];
        var len=push(arr,1,2,3);
        console.log(len,arr);

2、pop: //删除数组尾部的最后一个元素，并且将删除的元素返回

        var element=arr.pop();
        console.log(element,arr);

        while(arr.pop()!==3);//删除到某元素为止
        console.log(arr);
    //如果数组中存储的是对象，我们必须将所有的对象引用全部设为null(引用关系)
        while(arr.length>0){
            arr[arr.length-1]=null;
            arr.pop();
        }
        有种效率更高的方法
        for(var i=0;i<arr.length;i++){
            arr[i]=null;
        }
        arr.length=0;
    //重构！
        function pop(arr){
            var elem=arr[arr.length-1];
            if(arr.length>0)arr.length--;
            return elem;
        }

3、unshift //在数组的头部添加若干个元素，并且返回这个数组的新长度

        var len=arr.unshift(5,6)
    //重构！方案1
        function unshift(arr){
            var len=arguments.length-1;
            for(var i=arr.length-1;i>=0;i--){
                arr[i+len]=arr[i];
                arr[i]=null;
            }
            for(var j=1;j<arguments.length;j++){
                arr[j-1]=arguments[j];
            }
            return arr.length;
        }
    //方案2
        function unshift(arr){
            var arr1=[];
            for(var i=0;i<arr.length;i++){
                arr1[i]=arr[i];
            }
            arr.length=0;
            for(var j=1;j<arguments.length;j++){
                arr[j-1]=arguments[j];
            }
            for(var k=0;k<arr1.length;k++){
                arr[arr.length]=arr1[k];
            }
            return arr.length;
        }

4、shift //将数组的头部一个元素删除，并且返回这个元素

        var elem=arr.shift();
    //重构！
        function shift(arr){
            var elem=arr[0];
            for(var i=1;i<arr.length;i++){
                arr[i-1]=arr[i];
            }
            if(arr.length>0)arr.length--;
            return elem;
        }

//unshift和shift两个方法很少使用，因为从头增加删除元素会导致整个数组向前或向后，时间复杂度较高
//这四种方法，操作后原数组的引用关系不变

5、join //使用某个字符作为连接符，将所有数组的元素链接成为一个字符串并且返回这个字符串，如果没有连接符，则默认逗号链接

        var str=arr.join("*");
        console.log(str);
    //重构！
        function join(arr.separator){
            if(separator==undefined) separator=",";
            separator=String(separator);
            var str="";
            for(var i=0;i<arr.length;i++){
                if(i!==arr.length-1) str+=arr[i]+separator;
                else str+=arr[i];
            }
            return str;
        }

6、concat //连接数组
//数组连接若干个数组或者元素，返回一个新的连接完成的数组，与原数组无引用关系

        var arr=[1,2,3,4];
        arr.concat([5,6,7],[8,9]);
    //重构！
        function concat(arr){
            var arr1=[];
            for(var i=0;i<arr.length;i++){
                arr1[i]=arr[i];
            }
            if(arguments.length===1) return arr1;
            for(var j=1;j<arguments.length;j++){
                if(arguments[j]!==null && arguments[j].constructor===Array){
                    for(var k=0;k<arguments[j].length;k++){
                        arr1[arr1.length]=arguments[j][k];
                    }
                }else{
                    arr1[arr1.length]=arguments[j];
                }
            }
            return arr1;
        }
        var arr=[3,4,5];
        var arr1=concat(arr,"");
        console.log(arr1);

7、splice //将数组中从第几位(下标)开始删除的多少元素，并且返回被删除的元素组成的新数组
//将数组中从第几个位开始删除多少个元素后，并在该位置插入新的若干元素，返回删除元素组成的新数组
//在数组的第几位开始插入若干个元素，并且返回控的新数组

        var arr=[1,2,3,4]
        var arr1=arr.splice(1,2);//arr为[1,4],arr1为[2,3];
        var arr1=arr.splice(1);//删除到尾部
        var arr1=arr.splice(-1);//如果第一个参数是负数，则从后向前开始删除;(删除了一个)
        var arr1=arr.splice(0);//将一个数组的所有元素转移到另一个数组
        var arr1=arr.splice();//没有删除返回新数组
        var arr1=arr.splice(-3,2);//从倒数第3个元素向后删除2个元素

        var arr1=arr.splice(1,2,-2,-3);//从第1位开始向后删除两个元素，并且在该位置添加-2,-3,返回被删除两个元素组成的数组。
        var arr1=arr.splice(1,arr.length,0,-1,-2);//从第1个元素开始删除到数组尾部，并且添加0，-1，-2
        var arr1=arr.splice(1,0,0);//在第1位插入一个元素0，不删除，返回空数组
    //splice这个方法实现需要耗费大量时间
        var arr=[1,3,3,6,8,2,3,5,6,3,7,9,8,3,6,7,3,8,9];
        var len=arr.length;
        for(var i=0;i<len;){
            if(arr[i]===3) arr.splice(i,1);
            else i++;
        }
    //去重
        var arr=[1,3,3,6,8,2,3,5,6,3,7,9,8,3,6,7,3,8,9];
        var arr1=[];
        for(var i=0;i<arr.length;i++){
            var bool=false;
            for(var j=0;j<arr1.length;j++){
                if(arr[i]===arr1[j]){
                    bool=true;
                    break;
                }
            }
            if(!bool) arr1.push(arr[i]);
        }
        arr.length=0;
        for(var k=0;k<arr1.length;k++){
            arr[k]=arr1[k];
        }
        arr1.length=0;
        arr1=null;
        console.log(arr);

8、slice //从第几项开始到第几项结束复制这些元素到新数组中，原数组不变

        var arr=[1,2,3,4];
        var arr1=arr.slice();//复制原数组到新数组，没有引用关系
    //将列表转换为数组的3个方法，要记住！！
        var divs=document.getElementsByTagName("div");//获取body里所有的div
        第一种：    var arr=Array.prototype.slice.call(divs);
                    var arr=[].slice.call(divs);
        第二种:     var arr=Array.from(divs);//ES6
        第三种：    var arr=Array.prototype.concat.apply([],divs);
                    var arr=[].concat.apply([],divs);

        var arr1=arr.slice(2);//从第2（下标）开始复制
        var arr1=arr.slice(0);//复制数组
        var arr1=arr.slice();//复制数组
        var arr1=arr.slice(-2);//从后向前数第2个元素到尾部的所有元素复制
        var arr1=arr.slice(1,2);//从第一项复制到第二项，不包括结束这一项
    //重构！(有BUG)
        function slice(arr,start,end){
            if(start===undefined) start=0;
            if(end===undefined) end=arr.length;
            start=Number(start);
            end=Number(end);
            if(!isNaN(end) && isNaN(start)) start=0;
            if(isNaN(start)) return [];
            if(start<0) start=arr.length+start;
            if(end<0) end=arr.length+end;
            var arr1=[];
            for(var i=start;i<end;i++){
                arr1[i-start]=arr[i];
            }
            return arr1;
        }

9、reverse //当前数组按照倒装顺序将原数组颠倒，并且返回原数组

        var arr=[2,3,4,5];
        var arr1=arr.reverse();
    //重构！方案1
        function reverse(arr){
            var len=parseInt(arr.length/2);
            for(var i=0;i<len;i++){
                var temp=arr[i];
                arr[i]=arr[arr.length-i-1];
                arr[arr.length-i-1]=temp;
            }
            return arr;
        }
    //方案2
        function reverse(arr){
            var arr1=[];
            for(var i=0;i<arr.length;i++){
                if(i in arr){
                    arr1[i]=arr[i];
                }
            }
            arr.length=0;
            for(var j=arr1.length-1;j>=0;j--){
                if(j in arr1){
                    arr[arr1.length-j-1]=arr1[j];
                }
            }
            return arr;
        }