「中高级前端面试」JavaScript手写代码无敌秘籍（推荐）

1. 实现一个new操作符

new操作符做了这些事：

1. 它创建了一个全新的对象。
2. 它会被执行[[prototype]]（也就是__proto__）链接。
3. 它使this指向新创建的对象。。
4. 通过new创建的每个对象将最终被[[prototype]]链接到这个函数的prototype对象上。
5. 如果函数没有返回对象类型object(包含functoin, array, date, regexg, error)，那么new表达式中的函数调用将返回该对象引用。

function new(func) {
 var res = {};
 if (func.prototype !== null) {
  res.__proto__ = func.prototype;
 }
 var ret = func.apply(res, array.prototype.slice.call(arguments, 1));
 if ((typeof ret === "object" || typeof ret === "function") && ret !== null) {
  return ret;
 }
 return res;
}
var obj = new(a, 1, 2);
// equals to
var obj = new a(1, 2);

2. 实现一个json.stringify

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

1. boolean | number| string 类型会自动转换成对应的原始值。
2. undefined、任意函数以及symbol，会被忽略（出现在非数组对象的属性值中时），或者被转换成 null（出现在数组中时）。
3. 不可枚举的属性会被忽略
4. 如果一个对象的属性值通过某种间接的方式指回该对象本身，即循环引用，属性也会被忽略。

function jsonstringify(obj) {
 let type = typeof obj;
 if (type !== "object") {
  if (/string|undefined|function/.test(type)) {
   obj = '"' + obj + '"';
  }
  return string(obj);
 } else {
  let json = []
  let arr = array.isarray(obj)
  for (let k in obj) {
   let v = obj[k];
   let type = typeof v;
   if (/string|undefined|function/.test(type)) {
    v = '"' + v + '"';
   } else if (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"}"

3. 实现一个json.parse

json.parse(text[, reviver])

用来解析json字符串，构造由字符串描述的javascript值或对象。提供可选的reviver函数用以在返回之前对所得到的对象执行变换(操作)。

3.1 第一种：直接调用 eval

function jsonparse(opt) {
 return eval('(' + opt + ')');
}
jsonparse(jsonstringify({x : 5}))
// object { x: 5}
jsonparse(jsonstringify([1, "false", false]))
// [1, "false", falsr]
jsonparse(jsonstringify({b: undefined}))
// object { b: "undefined"}

避免在不必要的情况下使用 eval，eval() 是一个危险的函数， 他执行的代码拥有着执行者的权利。如果你用 eval()运行的字符串代码被恶意方（不怀好意的人）操控修改，您最终可能会在您的网页/扩展程序的权限下，在用户计算机上运行恶意代码。

它会执行js代码，有xss漏洞。

如果你只想记这个方法，就得对参数json做校验。

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 + ")");
}

3.2 第二种：function

来源神奇的eval()与new function()

核心：function与eval有相同的字符串参数特性。

var func = new function(arg1, arg2, ..., functionbody);

在转换json的实际应用中，只需要这么做。

var jsonstr = '{ "age": 20, "name": "jack" }'
var json = (new function('return ' + jsonstr))();

eval 与 function 都有着动态编译js代码的作用，但是在实际的编程中并不推荐使用。

这里是面向面试编程，写这两种就够了。至于第三，第四种，涉及到繁琐的递归和状态机相关原理，具体可以看：

《json.parse 三种实现方式》

 4. 实现一个call或 apply

实现改编来源：javascript深入之call和apply的模拟实现 #11

call语法：

fun.call(thisarg, arg1, arg2, ...)，调用一个函数, 其具有一个指定的this值和分别地提供的参数(参数的列表)。

apply语法：

func.apply(thisarg, [argsarray])，调用一个函数，以及作为一个数组（或类似数组对象）提供的参数。

 4.1 function.call按套路实现

call核心：

1. 将函数设为对象的属性
2. 执行&删除这个函数
3. 指定this到函数并传入给定参数执行函数
4. 如果不传入参数，默认指向为 window

为啥说是套路实现呢？因为真实面试中，面试官很喜欢让你逐步地往深考虑，这时候你可以反套路他，先写个简单版的：

4.1.1 简单版

var foo = {
 value: 1,
 bar: function() {
  console.log(this.value)
 }
}
foo.bar() // 1

4.1.2 完善版

当面试官有进一步的发问，或者此时你可以假装思考一下。然后写出以下版本：

function.prototype.call2 = function(content = window) {
 content.fn = this;
 let args = [...arguments].slice(1);
 let result = content.fn(...args);
 delete content.fn;
 return result;
}
let foo = {
 value: 1
}
function bar(name, age) {
 console.log(name)
 console.log(age)
 console.log(this.value);
}
bar.call2(foo, 'black', '18') // black 18 1

4.2 function.apply的模拟实现

apply()的实现和call()类似，只是参数形式不同。直接贴代码吧：

function.prototype.apply2 = function(context = window) {
 context.fn = this
 let result;
 // 判断是否有第二个参数
 if(arguments[1]) {
  result = context.fn(...arguments[1])
 } else {
  result = context.fn()
 }
 delete context.fn
 return result
}

5. 实现一个function.bind()

bind()方法:

会创建一个新函数。当这个新函数被调用时，bind() 的第一个参数将作为它运行时的 this，之后的一序列参数将会在传递的实参前传入作为它的参数。(来自于 mdn )

此外，bind实现需要考虑实例化后对原型链的影响。

function.prototype.bind2 = function(content) {
 if(typeof this != "function") {
  throw error("not a function")
 }
 // 若没问参数类型则从这开始写
 let fn = this;
 let args = [...arguments].slice(1);
 
 let resfn = function() {
  return fn.apply(this instanceof resfn ? this : content,args.concat(...arguments) )
 }
 function tmp() {}
 tmp.prototype = this.prototype;
 resfn.prototype = new tmp();
 
 return resfn;
}

6. 实现一个继承

寄生组合式继承

一般只建议写这种，因为其它方式的继承会在一次实例中调用两次父类的构造函数或有其它缺点。

核心实现是：用一个 f 空的构造函数去取代执行了 parent 这个构造函数。

function parent(name) {
 this.name = name;
}
parent.prototype.sayname = function() {
 console.log('parent name:', this.name);
}
function child(name, parentname) {
 parent.call(this, parentname); 
 this.name = name; 
}
function create(proto) {
 function f(){}
 f.prototype = proto;
 return new f();
}
child.prototype = create(parent.prototype);
child.prototype.sayname = function() {
 console.log('child name:', this.name);
}
child.prototype.constructor = child;

var parent = new parent('father');
parent.sayname(); // parent name: father

var child = new child('son', 'father');

7. 实现一个js函数柯里化

什么是柯里化？

在计算机科学中，柯里化（currying）是把接受多个参数的函数变换成接受一个单一参数（最初函数的第一个参数）的函数，并且返回接受余下的参数且返回结果的新函数的技术。

函数柯里化的主要作用和特点就是参数复用、提前返回和延迟执行。

7.1  通用版

function curry(fn, args) {
 var length = fn.length;
 var args = args || [];
 return function(){
  newargs = args.concat(array.prototype.slice.call(arguments));
  if (newargs.length < length) {
   return curry.call(this,fn,newargs);
  }else{
   return fn.apply(this,newargs);
  }
 }
}

function multifn(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);

7.2 es6骚写法

const curry = (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) //返回10
currytest(1,2)(4)(3) //返回10
currytest(1,2)(3,4) //返回10

8. 手写一个promise(中高级必考)

我们来过一遍promise/a+规范：

1. 三种状态pending| fulfilled(resolved) | rejected
2. 当处于pending状态的时候，可以转移到fulfilled(resolved)或者rejected状态
3. 当处于fulfilled(resolved)状态或者rejected状态的时候，就不可变。

必须有一个then异步执行方法，then接受两个参数且必须返回一个promise：

// onfulfilled 用来接收promise成功的值
// onrejected 用来接收promise失败的原因
promise1=promise.then(onfulfilled, onrejected);

8.1 promise的流程图分析

来回顾下promise用法：

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

8.2 面试够用版

来源：实现一个完美符合promise/a+规范的promise

function mypromise(constructor){
 let self=this;
 self.status="pending" //定义状态改变前的初始状态
 self.value=undefined;//定义状态为resolved的时候的状态
 self.reason=undefined;//定义状态为rejected的时候的状态
 function resolve(value){
  //两个==="pending"，保证了状态的改变是不可逆的
  if(self.status==="pending"){
   self.value=value;
   self.status="resolved";
  }
 }
 function reject(reason){
  //两个==="pending"，保证了状态的改变是不可逆的
  if(self.status==="pending"){
   self.reason=reason;
   self.status="rejected";
  }
 }
 //捕获构造异常
 try{
  constructor(resolve,reject);
 }catch(e){
  reject(e);
 }
}

 

同时，需要在mypromise的原型上定义链式调用的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=new mypromise(function(resolve,reject){resolve(1)});
p.then(function(x){console.log(x)})
//输出1

8.3 大厂专供版

直接贴出来吧，这个版本还算好理解

const pending = "pending";
const fulfilled = "fulfilled";
const rejected = "rejected";

function promise(excutor) {
 let that = this; // 缓存当前promise实例对象
 that.status = pending; // 初始状态
 that.value = undefined; // fulfilled状态时 返回的信息
 that.reason = undefined; // rejected状态时 拒绝的原因
 that.onfulfilledcallbacks = []; // 存储fulfilled状态对应的onfulfilled函数
 that.onrejectedcallbacks = []; // 存储rejected状态对应的onrejected函数

 function resolve(value) { // value成功态时接收的终值
  if(value instanceof promise) {
   return value.then(resolve, reject);
  }
  // 实践中要确保 onfulfilled 和 onrejected 方法异步执行，且应该在 then 方法被调用的那一轮事件循环之后的新执行栈中执行。
  settimeout(() => {
   // 调用resolve 回调对应onfulfilled函数
   if (that.status === pending) {
    // 只能由pending状态 => fulfilled状态 (避免调用多次resolve reject)
    that.status = fulfilled;
    that.value = value;
    that.onfulfilledcallbacks.foreach(cb => cb(that.value));
   }
  });
 }
 function reject(reason) { // reason失败态时接收的拒因
  settimeout(() => {
   // 调用reject 回调对应onrejected函数
   if (that.status === pending) {
    // 只能由pending状态 => rejected状态 (避免调用多次resolve reject)
    that.status = rejected;
    that.reason = reason;
    that.onrejectedcallbacks.foreach(cb => cb(that.reason));
   }
  });
 }

 // 捕获在excutor执行器中抛出的异常
 // new promise((resolve, reject) => {
 //  throw new error('error in excutor')
 // })
 try {
  excutor(resolve, reject);
 } catch (e) {
  reject(e);
 }
}

promise.prototype.then = function(onfulfilled, onrejected) {
 const that = this;
 let newpromise;
 // 处理参数默认值 保证参数后续能够继续执行
 onfulfilled =
  typeof onfulfilled === "function" ? onfulfilled : value => value;
 onrejected =
  typeof onrejected === "function" ? onrejected : reason => {
   throw reason;
  };
 if (that.status === fulfilled) { // 成功态
  return newpromise = new promise((resolve, reject) => {
   settimeout(() => {
    try{
     let x = onfulfilled(that.value);
     resolvepromise(newpromise, x, resolve, reject); // 新的promise resolve 上一个onfulfilled的返回值
    } catch(e) {
     reject(e); // 捕获前面onfulfilled中抛出的异常 then(onfulfilled, onrejected);
    }
   });
  })
 }

 if (that.status === rejected) { // 失败态
  return newpromise = new promise((resolve, reject) => {
   settimeout(() => {
    try {
     let x = onrejected(that.reason);
     resolvepromise(newpromise, x, resolve, reject);
    } catch(e) {
     reject(e);
    }
   });
  });
 }

 if (that.status === pending) { // 等待态
  // 当异步调用resolve/rejected时 将onfulfilled/onrejected收集暂存到集合中
  return newpromise = new promise((resolve, reject) => {
   that.onfulfilledcallbacks.push((value) => {
    try {
     let x = onfulfilled(value);
     resolvepromise(newpromise, x, resolve, reject);
    } catch(e) {
     reject(e);
    }
   });
   that.onrejectedcallbacks.push((reason) => {
    try {
     let x = onrejected(reason);
     resolvepromise(newpromise, x, resolve, reject);
    } catch(e) {
     reject(e);
    }
   });
  });
 }
};

emmm，我还是乖乖地写回进阶版吧。

9. 手写防抖(debouncing)和节流(throttling)

scroll 事件本身会触发页面的重新渲染，同时 scroll 事件的 handler 又会被高频度的触发, 因此事件的 handler 内部不应该有复杂操作，例如 dom 操作就不应该放在事件处理中。
针对此类高频度触发事件问题（例如页面 scroll ，屏幕 resize，监听用户输入等），有两种常用的解决方法，防抖和节流。

9.1 防抖(debouncing)实现

典型例子：限制 鼠标连击 触发。
一个比较好的解释是：

当一次事件发生后，事件处理器要等一定阈值的时间，如果这段时间过去后 再也没有 事件发生，就处理最后一次发生的事件。假设还差 0.01 秒就到达指定时间，这时又来了一个事件，那么之前的等待作废，需要重新再等待指定时间。

// 防抖动函数
function debounce(fn,wait=50,immediate) {
 let timer;
 return function() {
  if(immediate) {
   fn.apply(this,arguments)
  }
  if(timer) cleartimeout(timer)
  timer = settimeout(()=> {
   fn.apply(this,arguments)
  },wait)
 }
}

结合实例：滚动防抖

// 简单的防抖动函数
// 实际想绑定在 scroll 事件上的 handler
function realfunc(){
 console.log("success");
}

// 采用了防抖动
window.addeventlistener('scroll',debounce(realfunc,500));
// 没采用防抖动
window.addeventlistener('scroll',realfunc);

9.2 节流(throttling)实现

可以理解为事件在一个管道中传输，加上这个节流阀以后，事件的流速就会减慢。实际上这个函数的作用就是如此，它可以将一个函数的调用频率限制在一定阈值内，例如 1s，那么 1s 内这个函数一定不会被调用两次

简单的节流函数:

function throttle(fn, wait) {
	let prev = new date();
	return function() { 
	 const args = arguments;
		const now = new date();
		if (now - prev > wait) {
			fn.apply(this, args);
			prev = new date();
		}
	}

9.3 结合实践

通过第三个参数来切换模式。

const throttle = function(fn, delay, isdebounce) {
 let timer
 let lastcall = 0
 return function (...args) {
 if (isdebounce) {
  if (timer) cleartimeout(timer)
  timer = settimeout(() => {
  fn(...args)
  }, delay)
 } else {
  const now = new date().gettime()
  if (now - lastcall < delay) return
  lastcall = now
  fn(...args)
 }
 }
}

10. 手写一个js深拷贝

有个最著名的乞丐版实现，在《你不知道的javascript（上）》里也有提及：

10.1 乞丐版

 var newobj = json.parse( json.stringify( someobj ) );

10.2 面试够用版

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

关于深拷贝的讨论天天有，这里就贴两种吧，毕竟我...

11.实现一个instanceof

function instanceof(left,right) {

 let proto = left.__proto__;
 let prototype = right.prototype
 while(true) {
  if(proto === null) return false
  if(proto === prototype) return true
  proto = proto.__proto__;
 }
}

以上所述是小编给大家介绍的javascript手写代码详解整合，希望对大家有所帮助