整理一下前端面试中常考的一些函数

/**
 *  promiseAll 
 *  author yh
 *  to make many promise and finished together ,return the result that the  promise
 * 
**/ 
function promiseAll(promiseArray){
  return new Promise((resolve, reject) => {
    if(!Array.isArray(promiseArray)) return reject(new Error('入参是数组'))
    const result = []; // to save the Promise value
    const len = promiseArray.length; 
    let couter = 0;
    for(let i=0; i<len; i++ ){
      Promise.resolve(promiseArray[i]).then(value => {
        couter++;
        result[i] = value;
        if(counter===len) resolve(res)
      }).catch(e => reject(e))
    }
  })
}
/**
 *  new 
 *  author yh
 * 
 **/
function  news(f){
  return function () {
    var obj = { "__proto__": f.prototype }
    f.apply(obj, arguments);
    return obj
  }
} 
function news(f){
  return function () {
    var obj = {'__proto__': f.prototype };
    f.apply(obj,arguments);
    return obj
  }
}
/**
 * deppClone
 * author yh
 * @param {*}  object,number,boolean,string,NULL ,undefined 
 */
function deepClone(target){
  if(typeof target !=='object') return target;
  let obj = Array.isArray(target)?[]:{};
  for(let j in target){
    if(target.hasOwnProperty(j)){
      if(typeof target ==='object'){
        obj[i] = deepClone(target[j])
      }else{
        obj[i] = target[i]
      }
    }
  }
  return obj
}
/**
 * 
 * @param {*} arr 
 * @returns 
 */

/**
 * quickSort
 * author yh
 * @param {*} arr 
**/ 
function quickSort(arr){
  if(!Array.isArray(arr)) return new Error('quickSort的入参必须是数组');
  let result = arr.sort((a,b)=> {return a-b })
  return result;
}

/**
 * solution
 * author yh
 * get the median of the array
*/
function solution(arr){
  if(!Array.isArray(arr)) return  new Error('solution的入参必须是数组');
  let result = arr.sort((a,b) => { return a-b });
  let len = result.length;
  let mid = 0;
  if(len%2===0){
    mid = (result[len/2] +result[len/2+1])/2
  }else{
    mid = result[(len+1)/2]
  }
  return mid 
}

/**
 *  订阅者和发布者实现
 * 
 * */ 
let event = {
  clientList:{},
  listen:function(key,fn){
    if(!this.clientList[key]){
      this.clientList[key] = []
    }
    this.clientList[key].push(fn)
  },
  trigger:function(){
    var key = Array.prototype.shift.call(arguments),
    fns = this.clientList[key]
    if(!fns||fns.length==0) return false
    for(let i =0;fn;fn=fns[1++]){
      fn.apply(this,arguments)
    }
  },
  remove:function(key,fn){
    let fns = this.clientList[key]
    if(!fns) return false
    if(!fn){
      fns&&(fns.length===0)
    }else{
      for(let i=0;i<fns.length;i++){
        var _fn = fns[i];
        if(_fn===fn) fns.splice(i,1)
      }
    }
  }
}

let installEvent =  function(obj){
  for(let i in event){
    obj[i] = event[i]
  }
}


/**
 *  防抖实现
 *  debounce
 *  @author yh
 *  @params fn, interval, immediate
*/
function debounce(fn,interval,immediate){
  let timer = null;
  return function(){
    let context = this;
    let callNow = !timer&&immediate;
    clearTimeout(timer);
    timer=setTimeout(function(){
      !timer&&fn.apply(context,args);
      timer = null
    },interval)
    callNow&&fn.apply(context,args)
  }
}
/**
 * 截流函数
 * throttle
 * @author yh
 * @params  fn：函数，delay：延迟时间
 */
function throttle(fn,delay){
  let timer = null;
  let startTime = Date.now();
  return function(){
    let curTime = Date.now();
    let remaining = delay - (curTime-startTime);
    let context = this;
    let args = arguments;
    clearTimeout(timer);
    if(remaining<=0){
      fn.apply(context,args);
      startTime = Date.now()
    }else{
      timer= setTimeout(function(){
        fn.apply(context,args);
        timer = null;
      },delay)
    } 
  }
}

/**
 * 函数柯里花
 * curry
*/
const curry = fn =>{
  if(fn.length <= 1) return fn;
  const generator = args => {
    args.length === fn.length?fn(...args): arg => generator([...args,arg]);
  }
  return generator([],fn.length);
}
/**
 * js无限累加函数
 *  add
 * 
*/
function add(a){
  function sum(b){
    a = a+b;
    return sum
  }
  sum.toString = function(){
    return a
  }
  return sum;
}
/**
 * getParams 
 * 
*/ 
function getParams(){
  let query = location.search.substr(1);
  if(!query) return {}
  let arr = query.split('&')
  let obj = {}
  for(let i=0;i<arr.length;i++){
    let keyword = arr[i].split('=');
    obj[keyword[0]]=keyword[1]
  }
  return obj
}