实现new

new Foo的过程
1、创建一个新对象，他的原型__proto__指向构造函数的prototype
2、执行构造函数，重新指定this为该新对象，并传入对应参数
3、返回一个对象，如果构造函数返回一个对象，则返回这个对象，否则返回创建的新对象

编码如下：

  1. // 模拟new的实现
  2. let newMock = function () {
  3.     let argus = Array.prototype.slice.apply(arguments);
  4.     let Foo = argus.shift();
  5.     let target = Object.create(Foo.prototype);
  6.     let foo = Foo.apply(target, argus);
  7.     if (typeof foo === 'object') {
  8.         // 比如构造函数返回了一个Object，工厂模式之类的
  9.         return foo;
  10.     } else {
  11.         return target;
  12.     }
  13. }
  15. // 构造函数
  16. let Person = function (name) {
  17.     this.name = `i am ${name}`;
  18.     this.say = function () {
  19.         console.log(this)
  20.     }
  21. }
  23. // 使用
  24. let p = newMock(Person, 'www')
  25. console.log(p instanceof Person) // === true 说明newMock使用成功

实现Promise

实现bind

实现节流和防抖

  1. /**
  2.  * 防抖函数
  3.  * 函数停止1s后执行
  4.  * @param func
  5.  * @param wait
  6.  * @returns {Function}
  7.  */
  8. const debounce = (func, wait) => {
  9.     let timeout;
  10.     return function () {
  11.         let context = this;
  12.         let argus = arguments;
  14.         if (timeout) clearTimeout(timeout);
  16.         timeout = setTimeout(() => {
  17.             func.apply(context, argus)
  18.         }, wait);
  19.     }
  20. };
  22. /**
  23.  * 节流函数
  24.  * 1s执行一次目标函数
  25.  * @param func
  26.  * @param wait
  27.  * @returns {Function}
  28.  */
  29. const throttle = (func, wait) => {
  30.     let previous = 0;
  31.     return function () {
  32.         let now = Date.now();
  33.         let context = this;
  34.         let argus = arguments;
  35.         if (now - previous > wait) {
  36.             func.apply(context, argus);
  37.             previous = now;
  38.         }
  39.     }
  40. };