重写数组方法 pop push shift… -- js随记

push

这个方法是向数组的末尾添加一个或多个元素，并且返回数组新的长度（改变数组长度）

思路：先把存进来的参数利用 arguments 存起来，遍历 arguments ，并将 arguments 里的元素依次放在数组的末尾。

// 重写push
var arr = [7, 21, 53, 99];
Array.prototype.myPush = function(){
    // 把传进来的参数先存起来
    // console.log(arguments);
    // 遍历arguments
    for(var i = 0; i < arguments.length; i++){
        // 依次放在数组的最后
        this[this.length] = arguments[i];
    }
    return this.length;
}
var res = arr.myPush(22,76);
console.log(res);
console.log(arr);

pop

这个方法不用添加参数，直接将数组最后一个参数弹出数组，并返回这个删除的元素。

思路：将最后一个元素定义为空，然后将数组长度减一（改变数组长度）

// 重写pop
Array.prototype.myPop = function(){
    var del = this[this.length-1];
    this[this.length-1] = null;
    this.length--;
    return del;
}
var res=arr.myPop();
console.log(res);
console.log(arr);

shift

这个方法是把数组第一个元素删除，并返回第一个元素的值（改变数组长度）

思路：从最后一个元素开始遍历数组，依次将后一个赋值给前一个元素（改变数组长度）

// 重写shift
Array.prototype.myShift = function () {
  var delfir = this[0];
  for (var j = 0; j < this.length-1; j++) {
    this[j] = this[j + 1];
  }
  this.length--;
  return delfir;
};
var res = arr.myShift();
console.log(res);
console.log(arr);

unshift

这个方法可以向数组的开头添加一个或多个元素，并返回新的数组长度（改变数组长度）

思路： 先把存进来的参数利用 arguments 存起来，然后将原数组向后移 arguments.length 个位置，arguments 里的元素依次传进新数组（改变数组长度）

// 重写unshift
Array.prototype.myUnShift = function(){
    console.log(arguments);
    this.length = this.length + arguments.length;
    for(let i=this.length; i>0; i--){
        if(i>arguments.length){
            this[i-1] = this[i-1-arguments.length]
        }else{
            this[i-1] = arguments[i-1]
        }
    }
    return this.length;
}
var res = arr.myUnShift(34, 59,66);
console.log(res);
console.log(arr);

every

这个方法用于检测数组中的所有元素是否都符合指定条件，有一个元素不符合就返回false，都符合条件就返回true，第一个参数是用来判断的函数，还要判断是否有第二个参数，有的话在函数回调时会返回第二个参数。（不改变原始数组）

思路：利用三目运算符,只要有一个不满足条件就跳出循环 不再判断

 // 重写every
var arr = [1, 2, 3, 4];
Array.prototype.myEvery=function(fun,obj){
    for(var i = 0;i < this.length; i ++){
        if(!(obj?fun.call(obj,this[i],i,this):fun(this[i],i,this))){
            return false;
        }
    }
    return true;
}
var res = arr.myEvery(function(item,index,arr){
    // 只要有一个不满足条件就跳出循环 不再判断
    console.log(this);
    return item > 2;
},{name:'zzy'});
console.log(res,arr);

some

这个方法用于检测数组中的所有元素是否有元素符合指定条件，如果有一个元素满足条件，则表达式返回*true* , 剩余的元素不会再执行检测。第一个参数是用来判断的函数，还要判断是否有第二个参数，有的话在函数回调时会返回第二个参数。（不改变原始数组）

var arr = [1,2,3,4];
Array.prototype.mySome = function(fun, obj){
    for(let i= 0; i<this.length; i++){
        // 只要有一个满足条件就返回true
        // 是否有第二个参数，有的话不仅要调用fun并且返回第二个参数obj，否则直接调用即可
        if((obj?fun.call(obj,this[i],i,this):fun(this[i],i,this))){
            return true;
        }
    }
}
var res = arr.mySome(function(item,index,arr){
    return item>1;
},'hello')
console.log(res);

map

这个方法会按照原始数组中的元素顺序依次调用函数处理元素，返回一个新数组（不改变原数组）

var arr = [1,2,3,4];
Array.prototype.myMap = function(fun, obj){
    let newArr = []
    for(let i= 0; i<this.length; i++){
        newArr.push(obj?fun.call(obj,this[i],i,this):fun(this[i],i,this))
    }
    return newArr;
}
var res = arr.myMap(function(item,index,arr){
    console.log(this);
    return item + 1;
},['hello', 123])
console.log(res);

 fileter

这个方法会创建一个新数组，新数组里的元素都是通过检查指定数组中符合条件的所有元素。（不改变原数组）

// filter
// 返回一个新数组，包含了符合条件的所有元素。如果没有符合条件的元素则返回空数组。
// 不改变原数组
arr = [1, 2, 3, 4]
Array.prototype.myFilter = function(fun,obj){
    let newArr = []
    for(let i = 0; i<this.length; i++){
        if(obj?fun.call(this[i],i,this):fun(this[i],i,this)){
            newArr.push(this[i]);
        }
    }
    return newArr;
}
var res = myFilter(function(item,index,arr){
    console.log(this);
    return item > 1;
},'yes')
console.log(res,arr);

forEach

这个方法用来调用数组中的每个元素，并将元素传递给回调函数，返回值是undefined

// forEach 遍历数组
// forEach() 方法用于调用数组的每个元素，并将元素传递给回调函数。
// 返回值是undefined
arr = [1, 2, 3, 4]
Array.prototype.myforEach = function(fun,obj){
    for(let i = 0; i<this.length; i++){
        obj?fun.call(obj,this[i],i,this):fun(this[i],i,this)
    }
}
var res = arr.myforEach(function(item,index,arr){
    console.log(this);
    console.log(item);
},1)
console.log(res);