数组方法重构

Array.prototype.push()

向数组的末尾添加一个或多个元素，并返回新的长度，改变数组长度

Array.prototype.myPush = function() {
  for(var i=0;i<arguments.length;i++){
    this[this.length] = arguments[i];
  }
  return this.length; //返回新的长度
}
var arr = [1,2,3,4,5];
console.log(arr); //[ 1, 2, 3, 4, 5 ]
var result  = arr.myPush('hello push');
console.log(result); //8
console.log(arr); // [ 1, 2, 3, 4, 5, 12, 13, 14 ]

Array.prototype.pop()

用于删除数组的最后一个元素并返回删除的元素，改变数组长度

Array.prototype.myPop = function () {
  if (this.length == '') {
    return undefined;//如果要执行的数组为空，则返回undefined
  } else {
    var temp = this[this.length - 1];
    this.length--;
    return temp;//返回删除的元素
  }
}
var arr = [1, 2, 3, 4, 5];
console.log(arr); //[ 1, 2, 3, 4, 5 ]
var result = arr.myPop();
console.log(result); //5
console.log(arr);//[ 1, 2, 3, 4 ]

Array.prototype.shift()

用于删除数组的的第一个元素，返回删除的元素，改变数组长度

Array.prototype.myShift = function() {
  var result = this[0];//把第一个元素赋值给一个变量
  for(var i=0;i<this.length;i++){
    this[i] = this[i+1] //for循环 数组元素依次往前移
  }
  this.length--;//删除一个元素，数组长度减一
  return result;//返回删除的元素
}
var arr = [1,2,3,4,5];
console.log(arr); //[ 1, 2, 3, 4, 5 ]
var result  = arr.myShift();
console.log(result); //1
console.log(arr); //[ 2, 3, 4, 5 ]

Array.prototype.unshift()

向数组的开头添加一个或多个元素，返回新的长度，改变数组长度

Array.prototype.myUnshift = function() {
  var result = this.length+arguments.length;//新的长度
  for(var i=result;i>0;i--){
    // 这里是 i-- 新数组减到一定程度后剩下插入的数组
    if(i>arguments.length){
      this[i-1] = this[i-1-arguments.length]//插入原数组中的值
    }else{
      this[i-1] = arguments[i-1]//插入要添加数组中的值
    }
  }
  return result;//返回新的长度
}
var arr = [1,2,3,4,5];
console.log(arr);  //[ 1, 2, 3, 4, 5 ]
var result  = arr.myUnshift('hello','a','b');
console.log(result);  //8
console.log(arr);  //[ 'hello', 'a', 'b', 1, 2, 3, 4, 5 ]

Array.prototype.concat()

用于连接两个或多个数组，不会改变原数组，返回新的数组

Array.prototype.myConcat = function () {
  var newArr = new Array()
  for(var k=0;k<this.length;k++){
    newArr[k] = this[k]
  }
  for (i=0;i<arguments.length;i++){
    if (Array.isArray(arguments[i])) {
      for(j=0;j<arguments[i].length;j++){
        newArr.push(arguments[i][j])
      }
    } else {
      newArr.push(arguments[i])
    }
  }
  return newArr
}
var arr = [1, 5, 2, 8, 10];
console.log(arr);  //[ 1, 5, 2, 8, 10 ]
var stale = ["Emil", "Tobias"];
var we = 'qweqrwqe'
var children = arr.myConcat(stale, we);
console.log(children);  //[ 1, 5, 2, 8, 10, 'Emil', 'Tobias', 'qweqrwqe' ]
console.log(arr);  //[ 1, 5, 2, 8, 10 ]

Array.prototype.forEach()

用于调用数组的每一个元素，并将元素返回给回调函数，对空数值不会执行回调函数

列出数组的每个元素：

Array.prototype.myForEach = function (fun) {
  for (var i = 0; i < this.length; i++) {
    fun(this[i], i, this)
  }
}
var arr = [1, 2, 3, 4, 5];
console.log(arr); //[ 1, 2, 3, 4, 5 ]
var result = arr.myForEach(function (item, index, arr) {
  console.log(item, index, arr);
});
//1 0 [ 1, 2, 3, 4, 5 ]
//2 1 [ 1, 2, 3, 4, 5 ]
//3 2 [ 1, 2, 3, 4, 5 ]
//4 3 [ 1, 2, 3, 4, 5 ]
//5 4 [ 1, 2, 3, 4, 5 ]

Array.prototype.every()

用于检测数组所有元素是否都符合指定条件（通过函数提供），不会对空数组进行检查，不改变原数组 ,有一个不符合 返回false 都符合 返回true

Array.prototype.myEvery = function (fun, obj) {
  for (i = 0; i < this.length; i++) {
    if (!(obj?fun.bind(obj)(this[i]):fun(this[i]))) {
      return false; //三目运算符判断是否有第二个参数，如果有第二个参数，则修改this指向,不等于  返回false 
    }
  }
  return true;
}
var arr = [1,2,3,4,5];
var result = arr.myEvery(function(item,index,arr) {
  // console.log(this);//this指向第二个参数
  return item>0 //有一项不满足 直接返回false
},{name : 'lisa'}) //一个参数是数组中的每一个元素都会执行的函数，是固定的  第二参数是前一个参  数的function内的额this指向，可以是任意数据类型
console.log(result); //true

Array.prototype.some()

用于检测数组中的元素是否满足指定条件（函数提供），不会对空数组进行检测，不改变原数组

有一个满足 返回true 没有满足条件的元素 返回false

Array.prototype.mySome = function (fun, obj) {
  for (i = 0; i < this.length; i++) {
    if(obj?fun.bind(obj)(this[i]):fun(this[i])) {
      return true;  //判断是否有第二参数 有则修改this指向
    }
  }
  return false;
}
var arr = [1,2,3,4,5];
var result = arr.mySome(function(item,index,arr) {
  //console.log(this); -> { name: 'lisa' }
  return item>1
},{name : 'lisa'})
console.log(result); //true

Array.prototype.filter()

创建一个新数组，新数组中的元素是通过检查指定数组中符合条件的所有元素，如果没有符合条件的元素则返回空数组，不会对空数组进行检测，不改变原数组

Array.prototype.myFilter = function (fun, obj) {
  var result = [];
  for (i = 0; i < this.length; i++) {
    if (obj ? fun.bind(obj)(this[i]) : fun(this[i])) {
      result.push(this[i])  //向result中添加元素
    }
  }
  return result;
}
var arr = [1, 2, 3, 4, 5];
var result = arr.myFilter(function (item, index, arr) {
  console.log(this);//打印5次：{ name: 'lisa' }
  return item > 2
}, { name: 'lisa' })
console.log(result); //[ 3, 4, 5 ]

Array.prototype.map()

返回一个新数组，数组中的元素为原始数组元素调用函数处理后的值，按原始数组元素顺序依次处理函数，不会对空数值进行检测，不改变原数组

Array.prototype.myMap = function (fun, obj) {
  var result = [];
  for (i = 0; i < this.length; i++) {
    result.push(obj ? fun.bind(obj)(this[i]) : fun(this[i])) //向result中添加元素
  }
  return result;
}
var arr = [1, 2, 3, 4, 5];
var result = arr.myMap(function (item, index, arr) {
  console.log(this);//打印5次：{ name: 'lisa' }
  return item + 1
}, { name: 'lisa' })
console.log(result); //[ 2, 3, 4, 5, 6 ]