前端基础方法的实现

new做了什么？以及如何实现一个new

• 创建一个空的简单js对象
• 给新创建的对象添加属性__proto__ ，将该属性关联至构造函数的原型对象prototype；
• 以指定构造函数的this为新创建的对象的方式调用构造函数
• 判断构造函数返回值类型返回对象，如果该函数没有返回对象，则返回this
  function myNew() {
  let obj ={}
  const fn = [].prototype;
  obj._proto = fn.prototype;
  let response = fn .apply(obj,arguments)
  return (typeof response === ‘object’ || typeof response ===‘function’)?response:obj
  }

js如何实现两个大数的相加

let  a = 2345678567890+''
let b = 234564345464654654+''
function handleAdd (a,b){
	// 取两个数字的最大长度	
	let maxLen = Math.max(a.length,b.length)
	// 使用0补齐长度
	 a = a.padStart(maxLen , 0);
	 b = b.padStart(maxLen,0);
	 let num1 = 0;
  	let num2 = 0;   //"进位"
   	let sum = "";
  	 for(let i=maxLen-1 ; i>=0 ; i--){
      num1 = parseInt(a[i]) + parseInt(b[i]) + num2;
      num2 = Math.floor(t/10);
      sum = num1%10 + sum;
   	}
   	if(num2== 1){
      sum = "1" + sum;
   	}
  	 return sum;
}

实现一个防抖

const Debounce = (fn,timer) => {
    let timerOut= null;
    return function() => {
        if(timerOut){
            clearTimeout(timerOut)
        }
        timerOut = setTimeout(() => {
            fn.apply(this,arguments)
        },timer)
    }
}

实现一个节流

const Throttle = (fn, timer) => {
  let timerOut = true
  return function() {
    if (!timerOut) return
    timerOut = false
    setTimeout(() => {
      fn.apply(this.arguments)
      timerOut = true
    }, timer)
  }
}

bind,call,apply的区别，以及函数的实现

call和apply都是围了解决改变this的指向，作用都是相同的，只是传参的方式不同。
出了一个参数外，call接收的是一个参数列表，apply只接收一个参数数组

bind的实现

Function.prototype.myBind= function(Arg,...argArray){
    let that = this
    Arg = (Arg !== null && Arg !== undefined)?Object(Arg):window
    function fns (...arg){
        Arg.fn = that
        let fin = [...argArray,...arg]
        let res= Arg.fn(...fin)
        delete Arg.fn
        return res
    }
    return fns
}

实现apply

Function.prototype.myApply = function(Arg,argArray){
    let that	 = this 
    Arg= Arg?Object(Arg):window
    Arg.fn= that
    argArray = argArray?arrArray:[]
    let res= Arg.fn(...argArray)
    return res
}

实现call

Function.prototype.myCall = function(Arg,...args){
    let that = this;
    Arg= Arg?Object(Arg):window
    thisArg.fn = that
    let res = Arg.fn(...arg)
    delete Arg.fn
    return res
}

实现一个filter

function myFilter(list, callback) {
    if (!Array.isArray(list) || !list.length || typeof callback != 'function') {
      return []
    }
    let result = []
    for(let i = 0; i < list.length; i ++) {
      let item = list[i];
      callback(item, i, list) && result.push(item)
    }
    return result
}

实现map

function map(list, callback) {
    if (!list.length || !Array.isArray(list) || typeof callback !== 'function') {
      return []
    } 
    const result = []
    for (let i = 0; i < list.length; i++) {
      const item = list[i]
      result.push(callback(item, i, list))
    }
    return result
}

实现reduce

function myReduce(list, callback) {
    if (!Array.isArray(list) || !list.length || typeof callback !== 'function') {
      return []
    } else {
      sum = arr[0]
      for (let i = 1; i < arr.length; i++) {
        sum = callback(sum, list[i], i, list)
      }
      return sum
    }
}

实现instanceof

function myInstanceof(a, b) {
  if (!a || typeof a != 'object' || !b) return false
  const A = a.__proto__
  const B = b.prototype
  if (A && B) {
    return A == B
  }
  return false
}