# 高频手写题目

// func是用户传入需要防抖的函数// wait是等待时间constdebounce=(func, wait=50)=>{// 缓存一个定时器idlet timer=0// 这里返回的函数是每次用户实际调用的防抖函数// 如果已经设定过定时器了就清空上一次的定时器// 开始一个新的定时器，延迟执行用户传入的方法returnfunction(...args){if(timer)clearTimeout(timer)    timer=setTimeout(()=>{func.apply(this, args)}, wait)}}

// func是用户传入需要防抖的函数// wait是等待时间constthrottle=(func, wait=50)=>{// 上一次执行该函数的时间let lastTime=0returnfunction(...args){// 当前时间let now=+newDate()// 将当前时间和上一次执行函数时间对比// 如果差值大于设置的等待时间就执行函数if(now- lastTime> wait){      lastTime= nowfunc.apply(this, args)}}}setInterval(throttle(()=>{    console.log(1)},500),1)

functiondeepCopy(obj){//判断是否是简单数据类型，if(typeof obj=="object"){//复杂数据类型var result= obj.constructor== Array?[]:{};for(let iin obj){            result[i]=typeof obj[i]=="object"?deepCopy(obj[i]): obj[i];}}else{//简单数据类型 直接 == 赋值var result= obj;}return result;}

classEventEmeitter{constructor(){this._events=this._events||newMap();// 储存事件/回调键值对this._maxListeners=this._maxListeners||10;// 设立监听上限}}// 触发名为type的事件EventEmeitter.prototype.emit=function(type,...args){let handler;// 从储存事件键值对的this._events中获取对应事件回调函数  handler=this._events.get(type);if(args.length>0){handler.apply(this, args);}else{handler.call(this);}returntrue;};// 监听名为type的事件EventEmeitter.prototype.addListener=function(type, fn){// 将type事件以及对应的fn函数放入this._events中储存if(!this._events.get(type)){this._events.set(type, fn);}};

classEventEmeitter{constructor(){this._events=this._events||newMap();// 储存事件/回调键值对this._maxListeners=this._maxListeners||10;// 设立监听上限}}// 触发名为type的事件EventEmeitter.prototype.emit=function(type,...args){let handler;// 从储存事件键值对的this._events中获取对应事件回调函数  handler=this._events.get(type);if(args.length>0){handler.apply(this, args);}else{handler.call(this);}returntrue;};// 监听名为type的事件EventEmeitter.prototype.addListener=function(type, fn){// 将type事件以及对应的fn函数放入this._events中储存if(!this._events.get(type)){this._events.set(type, fn);}};// 触发名为type的事件EventEmeitter.prototype.emit=function(type,...args){let handler;  handler=this._events.get(type);if(Array.isArray(handler)){// 如果是一个数组说明有多个监听者,需要依次此触发里面的函数for(let i=0; i< handler.length; i++){if(args.length>0){        handler[i].apply(this, args);}else{        handler[i].call(this);}}}else{// 单个函数的情况我们直接触发即可if(args.length>0){handler.apply(this, args);}else{handler.call(this);}}returntrue;};// 监听名为type的事件EventEmeitter.prototype.addListener=function(type, fn){const handler=this._events.get(type);// 获取对应事件名称的函数清单if(!handler){this._events.set(type, fn);}elseif(handler&&typeof handler==="function"){// 如果handler是函数说明只有一个监听者this._events.set(type,[handler, fn]);// 多个监听者我们需要用数组储存}else{    handler.push(fn);// 已经有多个监听者,那么直接往数组里push函数即可}};EventEmeitter.prototype.removeListener=function(type, fn){const handler=this._events.get(type);// 获取对应事件名称的函数清单// 如果是函数,说明只被监听了一次if(handler&&typeof handler==="function"){this._events.delete(type, fn);}else{let postion;// 如果handler是数组,说明被监听多次要找到对应的函数for(let i=0; i< handler.length; i++){if(handler[i]=== fn){        postion= i;}else{        postion=-1;}}// 如果找到匹配的函数,从数组中清除if(postion!==-1){// 找到数组对应的位置,直接清除此回调      handler.splice(postion,1);// 如果清除后只有一个函数,那么取消数组,以函数形式保存if(handler.length===1){this._events.set(type, handler[0]);}}else{returnthis;}}};

functionmyInstanceof(left, right){let proto= Object.getPrototypeOf(left);while(true){if(proto==null)returnfalse;if(proto== right.prototype)returntrue;        proto= Object.getPrototypeof(proto);}}

functionmyNew(fn,...args){let instance= Object.create(fn.prototype);let res=fn.apply(instance, args);returntypeof res==='object'? res: instance;}

// 模拟 call bar.mycall(null);//实现一个call方法：Function.prototype.myCall=function(context){//此处没有考虑context非object情况  context.fn=this;let args=[];for(let i=1, len= arguments.length; i< len; i++){    args.push(arguments[i]);}  context.fn(...args);let result= context.fn(...args);delete context.fn;return result;};

//实现apply只要把下一行中的...args换成args即可Function.prototype.myCall=function(context= window,...args){let func=this;let fn=Symbol("fn");  context[fn]= func;let res= context[fn](...args);//重点代码，利用this指向，相当于context.caller(...args)delete context[fn];return res;}

Function.prototype.myBind=function(context){if(typeofthis!=='function'){thrownewTypeError('Error')}const _this=thisconst args=[...arguments].slice(1)// 返回一个函数returnfunctionF(){// 因为返回了一个函数，我们可以 new F()，所以需要判断if(thisinstanceofF){returnnew_this(...args,...arguments)}return_this.apply(context, args.concat(...arguments))}}

// 模拟 Object.createfunctioncreate(proto){functionF(){}F.prototype= proto;returnnewF();}

functionParent(name){this.parent= name}Parent.prototype.say=function(){    console.log(`${this.parent}: 你打篮球的样子像kunkun`)}functionChild(name, parent){// 将父类的构造函数绑定在子类上Parent.call(this, parent)this.child= name}Child.prototype= Object.create(Parent.prototype);Child.prototype.say=function(){    console.log(`${this.parent}好，我是练习时长两年半的${this.child}`);}// 注意记得把子类的构造指向子类本身Child.prototype.constructor= Child;var parent=newParent('father');parent.say()// father: 你打篮球的样子像kunkunvar child=newChild('cxk','father');child.say()// father好，我是练习时长两年半的cxk

functionParent1(){this.name='parent1';}functionChild1(){Parent1.call(this);this.type='child1'}console.log(newChild1);

functionParent2(){this.name='parent2';this.play=[1,2,3]}functionChild2(){this.type='child2';}Child2.prototype=newParent2();  console.log(newChild2());

var s1=newChild2();var s2=newChild2();  s1.play.push(4);  console.log(s1.play, s2.play);// [1,2,3,4] [1,2,3,4]

functionParent3(){this.name='parent3';this.play=[1,2,3];}functionChild3(){Parent3.call(this);this.type='child3';}Child3.prototype=newParent3();var s3=newChild3();var s4=newChild3();  s3.play.push(4);  console.log(s3.play, s4.play);// [1,2,3,4] [1,2,3]

functionParent4(){this.name='parent4';this.play=[1,2,3];}functionChild4(){Parent4.call(this);this.type='child4';}Child4.prototype=Parent4.prototype;

var s3=newChild4();var s4=newChild4();  console.log(s3)

functionParent5(){this.name='parent5';this.play=[1,2,3];}functionChild5(){Parent5.call(this);this.type='child5';}Child5.prototype= Object.create(Parent5.prototype);Child5.prototype.constructor= Child5;

JSON.stringify(value[, replacer[, space]])：

functionjsonStringify(obj){let type=typeof obj;if(type!=="object"){if(/string|undefined|function/.test(type)){            obj='"'+ obj+'"';}returnString(obj);}else{let json=[]let arr= Array.isArray(obj)for(let kin obj){let v= obj[k];let type=typeof v;if(/string|undefined|function/.test(type)){                v='"'+ v+'"';}elseif(type==="object"){                v=jsonStringify(v);}            json.push((arr?"":'"'+ k+'":')+String(v));}return(arr?"[":"{")+String(json)+(arr?"]":"}")}}jsonStringify({x:5})// "{"x":5}"jsonStringify([1,"false",false])// "[1,"false",false]"jsonStringify({b:undefined})// "{"b":"undefined"}"

functionjsonParse(opt){returneval('('+ opt+')');}jsonParse(jsonStringify({x:5}))// Object { x: 5}jsonParse(jsonStringify([1,"false",false]))// [1, "false", falsr]jsonParse(jsonStringify({b:undefined}))// Object { b: "undefined"}

var rx_one=/^[\],:{}\s]*$/;var rx_two=/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g;var rx_three=/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g;var rx_four=/(?:^|:|,)(?:\s*\[)+/g;if(    rx_one.test(        json.replace(rx_two,"@").replace(rx_three,"]").replace(rx_four,""))){var obj=eval("("+json+")");}

var jsonStr='{ "age": 20, "name": "jack" }'var json=(newFunction('return '+ jsonStr))();

// 使用var promise=newPromise((resolve,reject)=>{if(操作成功){resolve(value)}else{reject(error)}})promise.then(function(value){// success},function(value){// failure})

functionmyPromise(constructor){let self=this;    self.status="pending"// 定义状态改变前的初始状态    self.value=undefined;// 定义状态为resolved的时候的状态    self.reason=undefined;// 定义状态为rejected的时候的状态functionresolve(value){if(self.status==="pending"){          self.value= value;          self.status="resolved";}}functionreject(reason){if(self.status==="pending"){          self.reason= reason;          self.status="rejected";}}// 捕获构造异常try{constructor(resolve,reject);}catch(e){reject(e);}}

// 添加 then 方法myPromise.prototype.then=function(onFullfilled,onRejected){let self=this;switch(self.status){case"resolved":onFullfilled(self.value);break;case"rejected":onRejected(self.reason);break;default:}}var p=newmyPromise(function(resolve,reject){resolve(1)});p.then(function(x){    console.log(x)// 1})

let url='http://www.domain.com/?user=anonymous&id=123&id=456&city=%E5%8C%97%E4%BA%AC&enabled';parseParam(url)

functionparseParam(url){const paramsStr=/.+\?(.+)$/.exec(url)[1];// 将 ? 后面的字符串取出来const paramsArr= paramsStr.split('&');// 将字符串以 & 分割后存到数组中let paramsObj={};// 将 params 存到对象中  paramsArr.forEach(param=>{if(/=/.test(param)){// 处理有 value 的参数let[key, val]= param.split('=');// 分割 key 和 value      val=decodeURIComponent(val);// 解码      val=/^\d+$/.test(val)?parseFloat(val): val;// 判断是否转为数字if(paramsObj.hasOwnProperty(key)){// 如果对象有 key，则添加一个值        paramsObj[key]=[].concat(paramsObj[key], val);}else{// 如果对象没有这个 key，创建 key 并设置值        paramsObj[key]= val;}}else{// 处理没有 value 的参数      paramsObj[param]=true;}})return paramsObj;}

let template='我是{{name}}，年龄{{age}}，性别{{sex}}';let data={  name:'姓名',  age:18}render(template, data);// 我是姓名，年龄18，性别undefined

functionrender(template, data){const reg=/\{\{(\w+)\}\}/;// 模板字符串正则if(reg.test(template)){// 判断模板里是否有模板字符串const name= reg.exec(template)[1];// 查找当前模板里第一个模板字符串的字段    template= template.replace(reg, data[name]);// 将第一个模板字符串渲染returnrender(template, data);// 递归的渲染并返回渲染后的结构}return template;// 如果模板没有模板字符串直接返回}

var s1="get-element-by-id"// 转化为 getElementByIdvarf=function(s){return s.replace(/-\w/g,function(x){return x.slice(1).toUpperCase();})}

let str="abcabcabcbbccccc";let num=0;let char='';// 使其按照一定的次序排列str= str.split('').sort().join('');// "aaabbbbbcccccccc"// 定义正则表达式let re=/(\w)\1+/g;str.replace(re,($0,$1)=>{if(num< $0.length){        num= $0.length;        char= $1;}});console.log(`字符最多的是${char}，出现了${num}次`);

a='34';b='1234567';// 返回 2a='35';b='1234567';// 返回 -1a='355';b='12354355';// 返回 5isContain(a,b);

functionisContain(a, b){for(let iin b){if(a[0]=== b[i]){let tmp=true;for(let jin a){if(a[j]!== b[~~i+~~j]){          tmp=false;}}if(tmp){return i;}}}return-1;}

// 保留三位小数parseToMoney(1234.56);// return '1,234.56'parseToMoney(123456789);// return '123,456,789'parseToMoney(1087654.321);// return '1,087,654.321'

functionparseToMoney(num){  num=parseFloat(num.toFixed(3));let[integer, decimal]=String.prototype.split.call(num,'.');  integer= integer.replace(/\d(?=(\d{3})+$)/g,'$&,');return integer+'.'+(decimal? decimal:'');}

functionisPhone(tel){var regx=/^1[34578]\d{9}$/;return regx.test(tel);}

functionisEmail(email){var regx=/^([a-zA-Z0-9_\-])+@([a-zA-Z0-9_\-])+(\.[a-zA-Z0-9_\-])+$/;return regx.test(email);}

functionisCardNo(number){var regx=/(^\d{15}$)|(^\d{18}$)|(^\d{17}(\d|X|x)$)/;return regx.test(number);}

Array.prototype.MyMap=function(fn, context){var arr=Array.prototype.slice.call(this);//由于是ES5所以就不用...展开符了var mappedArr=[];for(var i=0; i< arr.length; i++){    mappedArr.push(fn.call(context, arr[i], i,this));}return mappedArr;}

Array.prototype.myReduce=function(fn, initialValue){var arr=Array.prototype.slice.call(this);var res, startIndex;  res= initialValue? initialValue: arr[0];  startIndex= initialValue?0:1;for(var i= startIndex; i< arr.length; i++){    res=fn.call(null, res, arr[i], i,this);}return res;}

Function.prototype.bind=function(context,...args){let self=this;//谨记this表示调用bind的函数letfBound=function(){//this instanceof fBound为true表示构造函数的情况。如new func.bind(obj)returnself.apply(thisinstanceoffBound?this: context|| window, args.concat(Array.prototype.slice.call(arguments)));}    fBound.prototype= Object.create(this.prototype);//保证原函数的原型对象上的属性不丢失return fBound;}

functionproxy(func){let instance;let handler={constructor(target, args){if(!instance){                instance=Reflect.constructor(fun, args);}return instance;}}returnnewProxy(func, handler);}

let ary=[1,[2,[3,[4,5]]],6];let str=JSON.stringify(ary);

//第0种处理:直接的调用arr_flat= arr.flat(Infinity);

//第一种处理ary= str.replace(/(\[|\])/g,'').split(',');

//第二种处理str= str.replace(/(\[\]))/g,'');str='['+ str+']';ary=JSON.parse(str);

//第三种处理：递归处理let result=[];letfn=function(ary){for(let i=0; i< ary.length; i++)}{let item= ary[i];if(Array.isArray(ary[i])){fn(item);}else{      result.push(item);}}}

//第四种处理：用 reduce 实现数组的 flat 方法functionflatten(ary){return ary.reduce((pre, cur)=>{return pre.concat(Array.isArray(cur)?flatten(cur): cur);},[]);}let ary=[1,2,[3,4],[5,[6,7]]]console.log(flatten(ary))

//第五种处理：扩展运算符while(ary.some(Array.isArray)){  ary=[].concat(...ary);}

add(1); 			// 1add(1)(2);  	// 3add(1)(2)(3)；// 6add(1)(2,3);// 6add(1,2)(3);// 6add(1,2,3);// 6

functionadd(){let args=[].slice.call(arguments);letfn=function(){let fn_args=[].slice.call(arguments)returnadd.apply(null,args.concat(fn_args))}  fn.toString=function(){return args.reduce((a,b)=>a+b)}return fn}

constsleep=(time)=>{returnnewPromise(resolve=>setTimeout(resolve, time))}sleep(1000).then(()=>{// 这里写你的骚操作})

Number.prototype.add=function(n){returnthis.valueOf()+ n;};Number.prototype.minus=function(n){returnthis.valueOf()- n;};

functionunion(arr1, arr2){return arr1.filter(item=>{  	return arr2.indexOf(item)>-1;})}const a=[1,2,2,1];const b=[2,3,2]; console.log(union(a, b));// [2, 2]

functioncurry(fn, args){var length= fn.length;var args= args||[];returnfunction(){        newArgs= args.concat(Array.prototype.slice.call(arguments));if(newArgs.length< length){returncurry.call(this,fn,newArgs);}else{returnfn.apply(this,newArgs);}}}functionmultiFn(a, b, c){return a* b* c;}var multi=curry(multiFn);multi(2)(3)(4);multi(2,3,4);multi(2)(3,4);multi(2,3)(4)

constcurry=(fn, arr=[])=>(...args)=>(arg=> arg.length=== fn.length?fn(...arg):curry(fn, arg))([...arr,...args])let curryTest=curry((a,b,c,d)=>a+b+c+d)curryTest(1,2,3)(4)//返回10curryTest(1,2)(4)(3)//返回10curryTest(1,2)(3,4)//返回10

// 数据const data={  text:'default'};const input= document.getElementById('input');const span= document.getElementById('span');// 数据劫持Object.defineProperty(data,'text',{// 数据变化 --> 修改视图set(newVal){    input.value= newVal;    span.innerHTML= newVal;}});// 视图更改 --> 数据变化input.addEventListener('keyup',function(e){  data.text= e.target.value;});

// 数据const data={  text:'default'};const input= document.getElementById('input');const span= document.getElementById('span');// 数据劫持const handler={set(target, key, value){    target[key]= value;// 数据变化 --> 修改视图    input.value= value;    span.innerHTML= value;return value;}};const proxy=newProxy(data, handler);// 视图更改 --> 数据变化input.addEventListener('keyup',function(e){  proxy.text= e.target.value;});

Array.myIsArray=function(o){returnObject.prototype.toString.call(Object(o))==='[object Array]';};console.log(Array.myIsArray([]));// true

const responseList=[{ id:1, a:1},{ id:2, a:2},{ id:3, a:3},{ id:1, a:4},];const result= responseList.reduce((acc, cur)=>{const ids= acc.map(item=> item.id);return ids.includes(cur.id)? acc:[...acc, cur];},[]);console.log(result);// -> [ { id: 1, a: 1}, {id: 2, a: 2}, {id: 3, a: 3} ]

functiongetType(obj){if(obj===null)returnString(obj);returntypeof obj==='object'?Object.prototype.toString.call(obj).replace('[object ','').replace(']','').toLowerCase():typeof obj;}// 调用getType(null);// -> nullgetType(undefined);// -> undefinedgetType({});// -> objectgetType([]);// -> arraygetType(123);// -> numbergetType(true);// -> booleangetType('123');// -> stringgetType(/123/);// -> regexpgetType(newDate());// -> date

// 例: abbcccddddd -> 字符最多的是d，出现了5次let str="abcabcabcbbccccc";let num=0;let char='';// 使其按照一定的次序排列str= str.split('').sort().join('');// "aaabbbbbcccccccc"// 定义正则表达式let re=/(\w)\1+/g;str.replace(re,($0,$1)=>{if(num< $0.length){        num= $0.length;        char= $1;}});console.log(`字符最多的是${char}，出现了${num}次`);

functiondistinct(arr){for(let i=0, len=arr.length; i<len; i++){for(let j=i+1; j<len; j++){if(arr[i]== arr[j]){                arr.splice(j,1);// splice 会改变数组长度，所以要将数组长度 len 和下标 j 减一                len--;                j--;}}}return arr;}

functiondistinct(a, b){let arr= a.concat(b);return arr.filter((item, index)=>{//return arr.indexOf(item) === indexreturn arr.includes(item)})}

functiondistinct(array){return Array.from(newSet(array));}

var resources=[{ name:"张三", age:"18"},{ name:"张三", age:"19"},{ name:"张三", age:"20"},{ name:"李四", age:"19"},{ name:"王五", age:"20"},{ name:"赵六", age:"21"}]var temp={};resources= resources.reduce((prev, curv)=>{// 如果临时对象中有这个名字，什么都不做if(temp[curv.name]){}else{// 如果临时对象没有就把这个名字加进去，同时把当前的这个对象加入到prev中    temp[curv.name]=true;    prev.push(curv);}return prev},[]);console.log("结果", resources);