/*push();     
          入栈,在数组的最后添加一个元素. 参数：要入栈的元素.返回值：数组长度*/

        //重构myPush(),插入一个元素
        Array.prototype.myPush = function(){
            //将需要插入数组的元素赋值给原数组最后一个索引，实现插入元素功能
            for(var i=0;i<arguments.length;i++){
                this[this.length] = arguments[arguments.length-1];
            }
            //返回数组长度
            return this.length;
        }
        var arr = [1,2,3,4];
        var result = arr.myPush(5);
        console.log('原数组',arr);    //[1,2,3,4,5]
        console.log('返回值',result);    //5

        // 重构myPush(),插入多个元素
        Array.prototype.myPush = function () {
            //定义num并将新数组长度赋值给num，新数组长度=原数组长度+插入元素长度
            var num = this.length+arguments.length;
            //将原数组长度赋值给len
            var len = this.length;
            //将需要插入数组的多个元素赋值给原数组最后一个索引，实现插入元素功能
            for(var i=0;i<arguments.length;i++){
                arr[len+i]=arguments[i];
            }
            //返回新数组长度
            return num;
        };
        var arr = [1,2,3,4];
        var result = arr.myPush(5,6,7);
       console.log('原数组',arr);    //[1,2,3,4,5]
        console.log('返回值',result);
        


        /*pop();
        从数组的最后取出一个元素.  返回值：出栈的元素.  原数组删除最后一个数*/

        //重构myPop();
        Array.prototype.myPop = function(){
            // 拿到数组的最后一个数
            var result = this.length;
            // 通过lenght属性删除数
            this.length = this.length-1;
            // 返回被删除的数
            return result;
        }
        var arr = [1,2,3,4,5,6,7];
        var result = arr.myPop();
        console.log('原数组',arr);    //[1,2,3,4,5,6]
        console.log('返回值',result);    //7


        /*shift();    
            出队，将数组中第一个元素取出来.  参数：none.  返回值：出队的元素.  原数组第一项被删除*/

        //重构myShift();
        Array.prototype.myShift = function(){
            // 拿到数组第一个数
            var result = this[0];
             // 将数组的第二项赋值给第一项，第三项赋值给第二项...
            for(var i=0;i<this.length-1;i++){
                this[i] = this[i+1];
            }
            // 通过length属性删除最后一项
            this.length--;
            //返回被删除的项
            return result;
            
        }
        var arr = [1,3,5,7,9];
        var result = arr.myShift();
        console.log('1  原数组',arr);    //[3,5,7,9]
        console.log('返回值',result);    //1


        /*unshift();
            插队，将元素插入在数组的最前面. 返回值：插队后队列的长; 原数组新增插入的元素*/

        //重构myUnshift();
        Array.prototype.myUnshift = function(){
            // 插入数之后的长度 = 原数组的长度 + 插入数的长度
            var num = this.length + arguments.length;
            // 将这个长度给了数组之后，数组会多出来相应的空槽
            this.length = num;
            // 将原数组中的数向后移动
            for(var i=this.length-1;i>=arguments.length;i--){
                this[i] = this[i-arguments.length];
            }
            // 将需要插入的值赋值给数组前面
            for(var j=0;j<arguments.length;j++){
                this[j] = arguments[arguments.length-j-1];
            }
            return num;
        }
        var arr = [5,4,3,2,1];
        var result = arr.myUnshift(22,44,66,88);
        console.log('原数组',arr);    //[88,66,44,22,5,4,3,2,1]
        console.log('返回值',result);    //9