javaScript：9个数组方法的重构

1、toString重写

重写将分隔符作为参数

//toString重写
Array.prototype.toString= function (a) {
  var str = '';
  for(var i =0 ; i < this.length; i++){
    if(i == this.length-1){
      str =str + this[i]
    }
    else{
      str =str + this[i] + a;
    }
  }
  return str;
}

var arr = [1,2,3,4,5,6]
// toString 将分隔符作为参数
console.log(arr2.toString('-'));

2、indexOf

// indexOf
Array.prototype.indexOf = function (item) {
  if(arguments[1] !=null){
    for(var i =arguments[1];i<=this.length;i++){
      if(item == this[i]){
        return i;
      }
    }
  }
  else{
    for(var i =0;i<=this.length;i++){
      if(item == this[i]){
        return i;
      }
    }
  }
}

3、pop 移除数组末尾元素

重写返回当前移除元素

// pop  移除最后一个元素重写
Array.prototype.pop=function () {
  this.length--;
  return this[this.length-1]
}

// pop测试 返回删除数据
var arr = [1,2,3,4,5,6]
arr.pop() 
console.log(arr.pop());
console.log(arr)

4、push 数组末尾添加元素

重写返回当前数组

// push
Array.prototype.push = function () {
  for(var i = 0; i< arguments.length ; i++){
    this[this.length]=arguments[i]
  }
  return this;
}
var arr2 = [1,2,3,4,5,6]

// push测试  返回当前数组
arr2.push(8888,22222);
console.log(arr2.push('hhh'));

5、shift

移除数组第一个元素
依次向前覆盖 最后减少数组长度

// shift
Array.prototype.shift = function () {

  for(var i =0 ; i < this.length-1; i++){
    this[i] = this[i+1];
  }
  this.length--;
  return this;
}

var arr2 = [1,2,3,4,5,6]
// shift测试  返回当前数组
arr2.shift();
console.log(arr2);

6、unshift 数组头部添加一个或多个元素

重写返回当前数组

// unshift
Array.prototype.unshift = function () {
   //len保存当前数组长度
  var len = this.length;
  // 重新设置数组长度  ---增加长度
  this.length = this.length + arguments.length
  // 将原有数据向后移动  从原数组最后一个元素 依次移动到最后
  for(var i =this.length-1 ; i >= arguments.length ; i--){
  // this[len-1]是数组原有数据  将它移动到最后空出来的数组位置中
    this[i] = this[len-1]
    len--;
  }
  // 将移动后空出来的数组 放入参数数据
  for(var i =0 ; i < arguments.length; i++){
    this[i] = arguments[i];
  }
  return this;
}

var arr2 = [1,2,3,4,5,6]
// unshift测试 返回当前数组
arr2.unshift('hhh','hhh2','hhh3')
console.log(arr2)

7、reverse 数组倒序

// reverse
Array.prototype.reverse = function () {
  len=this.length-1;
  for(var i = 0; i <len ;i++){
    var temp = this[i];
    this[i] = this[len];
    this[len] = temp;
    len--;
  }
  return this;
}

var arr2 = [1,2,3,4,5,6]
arr2.reverse()
console.log(arr2)

8、slice 获取某一区间的数组元素

// slice
Array.prototype.splice = function(start,end) {
  var arr=new Array();
  var j = 0;
  for(var i = start;i < end; i++){
    arr[j] = this[i];
    j++;
  }
  return arr;
}

var arr2 = [1,2,3,4,5,6]
// slice测试
var arr = arr2.splice(1,3)
console.log(arr)

9、splice 删除某下标开始的几个数据，并插入新数据

换句话说：删除index开始的num个数据，并从index开始插入数据

// splice
Array.prototype.splice = function (index,num) {
  var a = 2;
    if(num == arguments.length-2){
      // 设置一个变量
      var j = 2;
      // 如果当前删除元素和插入元素相同，则将插入元素直接覆盖删除的元素
      for(var i= index;i<index+num;i++){
        this[i]=arguments[j]
        j++;
      }
    }
    if(num > arguments.length-2){
        // 保存当前元素长度
      var len = this.length;
      // 设置当前把参数添加后下一个应该被删除元素下标的开始
      var delFlag = index+arguments.length-2;
      // 仍然应该存在的元素下标
      var exitFlag = index+num;
      // 设置一个变量
      var j=2;
      console.log('当前argument长度',arguments.length)
      console.log('当前数组',this)

      // 遍历从下标到插入元素  将插入元素覆盖到应该被删除的元素里
      for(var i = index; i < index+arguments.length-2; i++){
        this[i] = arguments[j];
        j++;
      }
      // 因为删除的元素比插入元素多   所以需要把数组右边剩下的元素 移动到新插入的元素后面
      // 找到存在的元素下标  依次向前移动 
      for(var i = exitFlag; i<len ;i++){
        this[delFlag] = this[i];
        delFlag++;
      }
      // 将数组移动后，新数组长度会大于变换后的数组  应该重新设置数组长度
      this.length = this.length-num+arguments.length-2;
    }


    if(num < arguments.length-2){
      // 如果删除元素长度小于参数长度  则先对元素进行向后移动
      // 设置初始i为新数组的随后一个元素下标  
      // s为当前最后一个删除元素的下一个元素的下标

      // 设置一个变量
      var flag = 2;
        // 保存当前元素长度
      var len = this.length;
      // 设置新数组长度
      this.length = this.length-num+arguments.length-2;
  
      // 保存当前最后未被删除的元素下标
       var s = index+num;//最后删除元素的下一个的下标（未删除）
      for(var i = this.length-1; i >= s; i--){
        // len为初始数组的长度 this[len-1]则为原有的最后一个元素
        this[i] = this[len-1]
        len--;
      }
      // 将参数放到删除并移动后的位置
      for(var i = index;i<index+arguments.length-2;i++){
        this[i] = arguments[flag];
        flag++;
      }
    }

  return this;
}

var arr2 = [1,2,3,4,5,6]

// splice测试
console.log(arr2.splice(2,2))
console.log(arr2.splice(2,2,'h'))
console.log(arr2.splice(2,2,'h','h2','h3'))