bind的兼容处理 及实现

Function.prototype.myBind=function(){
  var context=arguments[0];
  var arg=[].slice.call(arguments,1);
  var that=this;
  if('bind' in Function){
    arg.unshift(context)
    return that.bind.apply(that,arg);
  }else{
    return function(){
      var argIn=[].slice.call(arguments,0)
        that.apply(context,arg.concat(argIn))
    }
  }
}

call的兼容处理 及实现原理

Function.prototype.myCall=function(){
        var arg=[].slice.call(arguments,1);
        if('call' in Function){
            this.call.apply(this,arg);
        }else{
            var context=[].slice.call(arguments,0)[0];
            context.fn = this;
            eval('context.fn(' + arg.toString() +')');
            delete context.fn;
        }
    }

apply的兼容处理 及实现

Function.prototype.myApply=function(){
        var context = [].slice.call(arguments,0)[0]||window;
        var arr=[].slice.call(arguments,1);
        context.fn = this;
        if (!arr.length) {
            context.fn();
        }else {
            eval('context.fn(' + arr.toString() + ')')
        }
        delete context.fn;
    }

forEach的兼容处理 及实现（没有返回值）

Array.prototype.myForEach=function(callback,context){
  if(typeof callback !== 'function'){
      return;
    }
    var context=context||window;
    if('forEach' in Array){
        this.forEach(callback,context);
    }else{
      for(var i=0;i<this.length;i++){
        callback.call(context,this[i],i,this);
      }
    }
}

map的兼容处理 及实现(不改变原数组)

Array.prototype.myMap=function(callback,context){
  if(typeof callback !== 'function'){
      return;
    }
    var context=context||window;
    if('map' in Array){
        this.map(callback,context);
    }else{
      var arr=this.slice(0);
      for(var i=0;i<arr.length;i++){
        callback.call(context,arr[i],i,arr);
      }
      return arr;
    }
}

replace实现原理

String.protoType.myRepace=function(reg,callback){
  var res=reg.exec(this);
  var _this=this;
  while(res){
    var returnV=callback(...res);
    var v=res[0];
    var i=_this.indexOf(res[0])
    _this=_this.substring(0,i)+returnV+_this.substring(v.length+i);
    res=reg.exec(this)
  }
  return _this;
}

every的实现(数组中有一个不满足条件就返回false，都满足条件返回true)

Array.prototype.myEvery = function (callBack.context) {
        // this ---> arr;
       for(let i=0;i<this.length;i++){
           // 把数组每一项传给callback
          if(!callBack.call(context,this[i],i,this)){
              return false;
          }
       }
       return true;
    };

filter的实现（过滤出符合条件的项返回一个新的数组）

Array.prototype.myFilter=function (callBack,context){
  let arr=[];
  for(let i=0;i<this.length;i++){
    let res=callBack.call(context,this[i],i,this);
    if(res){
      arr.push(this[i])
    }
  }
  return arr;
}

find的实现（找出 第一个 符合条件的数组成员）

Array.prototype.myFind=function (callBack,context){
  for(let i=0;i<this.length;i++){
    res=callBack.call(context,this[i],i,this);
    if(res){
      return this[i]
    }
  }
}

reduce的实现

Array.prototype.myReduce=function (callBack,fir){
  var prev=fir||0;
  if(this.length){
    for(var i=0;i<this.length;i++){
      prev=callBack(prev,this[i],i,this)
    }
  }
  return prev
}

split的实现

String.prototype.mySplit= function (key,len) {
    let arr=[];
    let reg=/(\w+)(`${key}`)?/g;
    this.replace(reg,function(){
        arr.push(arguments[1])
    })
    if(len)arr.length=len;
    return arr
}

match的实现

String.prototype.myMatch= function (reg) {
    let res=reg.exec(this);
    let arr=[];
    while(res){
        arr.push(res[0]);
        res=reg.exec(this);
    }
    return arr;
}

Object.assign的实现

function assign(newObj,oldObj){
    function getAttr(newObj,oldObj){
        for(let key in oldObj){
            if(oldObj.hasOwnProperty(key)){
               newObj[key]=oldObj[key];
                if(typeof oldObj[key]=='object'&&oldObj[key]!==null){
                    getAttr(newObj[key],oldObj[key])
                }
            }
        }
    }
    getAttr(newObj,oldObj)
    return newObj
}
let newObj=assign({e:222,a:123},{a:{c:{d:1}}})

模板字符串的实现

let a='hehe';
let b='kaka';
let tempStr=temp`哈哈${a}哈哈，我${b}`

function temp(arr,...arg){
    console.log(arr,arg)
    let str='';
    for(let i=0;i<arg.length;i++){
        str+=arr[i]+arg[i];
    }
    str+=arr[arr.length-1];
    return str;
}

function temp(temp){
    let reg=/\$\{([^}]+)\}/g;
    let str= temp.replace(reg, function () {
        return eval(arguments[1]);
    })
    return str;
}

Object.create的实现

function create(prop){
    function Class(){}
    Class.prototype=prop;
    return new Class;
}