我这里手写一下常见的面试题

深拷贝

function deepcopy(val){

  const getType = value => Object.prototype.toString.call(value).slice(8,-1);
  const constructor = getType(val);
  if( constructor !== 'Array' && constructor !== 'Object') return val;
  const newObj = constructor === 'Array' ? [] : {};
  for(let i in val){
    const newType = getType(val[i]);
    newObj[i] = newType === 'Array' || newType === 'Object' ? deepcopy(val[i]) : val[i];
  }
  return newVal;
}

promise

class Prom {
  constructor(fn){
    this.status = 'PENDING';
    this.value = undefined;
    this.reason = undefined;
    this.resolveFns = [];
    this.rejectFns = [];

    const resolve = value => {
      this.status = 'RESOLVED';
      this.value = value;
      this.resolveFns.forEach(({fn, resolve: res, reject: rej})=>res(fn(value)))
    }

    const reject = e => {
      this.status = 'REJECTED';
      this.reason = e;
      this.resolveFns.forEach(({fn, resolve: res, reject: rej})=>rej(fn(e)))
    }
    fn(resolve, reject);
  }

  static resolve(value){
    if(value && value.then){
      return value;
    }
    return new Prom(resolve=>resolve(value))
  }

  then(fn){
    if(this.status === 'RESOLVED'){
      return Prom.resolve(fn(this.value));
    }

    if(this.status === 'PENDING'){
      return new Prom((resolve, reject) => {
        this.resolveFns.push({fn, resolve, reject});
      })
    }
  }


  catch(fn){
    if(this.status === 'REJECTED'){
      return Prom.resolve(fn(this.reason));
    }
    if(this.status === 'PENDING'){
      return new Prom((resolve, reject) => {
        this.rejectFns.push({fn, resolve, reject});
      })
    }  
  }


  static all(iterators){
    const promises = Array.from(iterators);
    const len = promises.length;
    let count = 0;
    let results = [];
    return new Prom((resolve, reject)=>{
      promises.forEach((p,indnx)=>{
        Prom.resolve(p).then(result=>{
          count++;
          results[index] = result;
          if(index === count) resolve(results);
        }).catch(e=>reject(e))
      })
    })
  }
}

new

function _new() {
  const Constructor = [].shift.call(arguments);
  const obj = Object.create(Constructor.prototype);
  const res = Constructor.apply(obj, arguments);
  return typeof res === 'object' ? res : obj;
}

debounce

function debounce(fn, wait){
  let timer = null;
  return function(){
    const _this = this;
    const args = arguments;
    if(timer) clearTimeout(timer)
    timer = setTimeout(() => fn.apply(_this, args) , wait)
  }
}

throttle

function throttle(fn, wait){
  let timer = null
  return function(){
    const _this = this
    const args = arguments
    if(timer) return;
    timer = setTimeout(() => fn.apply(_this, args), wait)
  }
}

instanceof

function myInstanceof(left, right){
  // 获取类型的原型
  let prototype = right.prototype;
  // 获得对象原型
  left = left.__proto__;
  // 判断对象的类型是否等于类型的原型
  while(left){
    if(prototype === left)
    return true;
    left = left.__proto__;
  }
  return false
}

bind

Function.prototype._bind = function() {
 const target = [].shift.call(arguments),
  func = this,
  otherArgs = arguments;
 return function() {
  [].push.apply(otherArgs, arguments);
  func.apply(this instanceof func ? this : target, otherArgs);
 };
};

apply