instanceof的实现

  1. function myInstanceof(left, right) {
  2.     let rightProto = right.prototype;
  3.   let leftProto = left._proto_;
  4.   // 判断实例对象的类型是否等于类型的原型
  5.   while (true) {
  6.       if (rightProto === null) return false;
  7.     if (leftProto === rightProto) return true;
  8.     leftProto = leftProto.prototype;
  9.   }
  10. }

new的实现

  1. function New(Constructor, ...args){
  2.     let obj = {};   // 创建一个新对象
  3.     Object.setPrototypeOf(obj, Constructor.prototype);  // 连接新对象与函数的原型
  4.     return Constructor.apply(obj, args) || obj;   // 执行函数，改变 this 指向新的对象
  5. }
  7. function Foo(a){
  8.     this.a = a;
  9. }
  11. New(Foo, 1);  // Foo { a: 1 }
  13. // 第二种
  14. function _new() {
  15.     let target = {}; //创建的新对象
  16.     //第一个参数是构造函数
  17.     let [constructor, ...args] = [...arguments];
  18.     //执行[[原型]]连接;target 是 constructor 的实例
  19.     target.__proto__ = constructor.prototype;
  20.     //执行构造函数，将属性或方法添加到创建的空对象上
  21.     let result = constructor.apply(target, args);
  22.     if (result && (typeof (result) == "object" || typeof (result) == "function")) {
  23.         //如果构造函数执行的结构返回的是一个对象，那么返回这个对象
  24.         return result;
  25.     }
  26.     //如果构造函数返回的不是一个对象，返回创建的新对象
  27.     return target;
  28. }
  30. //第三种
  31. function _new2(constructor, ...args) {
  32.   if (typeof constructor !== 'function') {
  33.       throw new TypeError('Type Error')
  34.   }
  35.     let obj = Object.create(constructor.prototype);
  36.   const res = constructor.apply(obj, args);
  38.   const isObject = typeof res === 'object';
  39.   const isFunction = typeof res === 'function';
  41.   return isObject || isFunction ? res : obj;
  42. }

Ajax封装

  1. function ajax(type, url, data, success, fail) {
  2.     var xhr = null;
  3.     if (widnow.XMLHttpRequest) {
  4.         xhr = new XMLHttpRequest();
  5.     } else {
  6.         xhr = new ActiveXObject();
  7.     }
  9.     if (typeof data === 'object') {
  10.         var dataStr;
  11.         for (var key in data) {
  12.             dataStr += key + '=' + data[key] + '&';
  13.         }
  14.         data = dataStr.replace(/&$/, '');
  15.     }
  17.     type = type.toUpperCase();
  19.     //随机数，清缓存
  20.     var random = Math.random();
  22.     if (type === 'GET') {
  23.         if (data) {
  24.             xhr.open('GET', url + '?' + data, true);
  25.         } else {
  26.             xhr.open('GET', url + '?t='+ random, true);
  27.         }
  28.     } else {
  29.         xhr.open('POST', url, true);
  30.         xhr.setRequestHeader("Content-type", 'application/x-www-form-urlencoded');
  31.         xhr.send(dataStr);
  32.     }
  34.     xhr.onreadystatechange = function () {
  35.         if (xhr.readyState === 4) {
  36.             if(xhr.status === 200) {
  37.                 success && success(xhr.responseText);
  38.             } else {
  39.                 fail && fail(xhr.status);
  40.             }
  41.         }
  42.     }
  43. }
  45. // Promise版
  46. const getJSON = function(url) {
  47.   return new Promise((resolve, reject) => {
  48.     const xhr = XMLHttpRequest ? new XMLHttpRequest() : new ActiveXObject('Mscrosoft.XMLHttp');
  49.     xhr.open('GET', url, false);
  50.     xhr.setRequestHeader('Accept', 'application/json');
  51.     xhr.onreadystatechange = function() {
  52.       if (xhr.readyState !== 4) return;
  53.       if (xhr.status === 200 || xhr.status === 304) {
  54.         resolve(xhr.responseText);
  55.       } else {
  56.         reject(new Error(xhr.responseText));
  57.       }
  58.     }
  59.     xhr.send();
  60.   })
  61. }

浅拷贝与深拷贝

  • Object.assign 与 slice() 都是浅拷贝，JSON.parse(JSON.stringify(obj)) 是深拷贝
  • JSON.stringify的几个缺点

1.如果obj里面有时间对象，则JSON.stringify后再JSON.parse的结果，时间将只是字符串的形式，而不是对象的形式
2.如果obj里有RegExp(正则表达式的缩写)、Error对象，则序列化的结果将只得到空对象

3、如果obj里有函数，undefined，则序列化的结果会把函数或 undefined丢失

4、如果obj里有NaN、Infinity和-Infinity，则序列化的结果会变成null

5、JSON.stringify()只能序列化对象的可枚举的自有属性，例如 如果obj中的对象是有构造函数生成的， 则使用JSON.parse(JSON.stringify(obj))深拷贝后，会丢弃对象的constructor

6、如果对象中存在循环引用的情况也无法正确实现深拷贝

  • 浅拷贝 ```javascript // 简易例子 function cloneObject(source) { let target = {}; for(let prop in source) { if(source.hasOwnProperty(prop)){
    1. target[prop] = source[prop];
    } } return target; }

// 对象merge export default merge(target) { for( let i = 1; i < arguments; i++){ let source = arguments[i]; for( let prop in source){ if(source.hasOwnProperty(prop)) { let value = source[prop]; if(value != undefined) { target[prop] = value; } } } } }

// 实现Object.assign if (type of Object._assign != ‘function’) { Object.defineProperty(Object, ‘assign2’, { value: function (target) { if (target == null) { throw new TypeError(‘Cannot not undefined or null to object’); }

  1.         target = Object(object);
  3.         for (let i = 1; i < arguments.length; i++) {
  4.             let source = arguments[i];
  5.             if (source != null) {
  6.                 for (let prop in source) {
  7.                     if (source.hasOwnProperty(prop)) {
  8.                         let value = source[prop]
  9.                         if (value != undefined) {
  10.                             target[prop] = value
  11.                         }
  12.                     }
  13.                 }
  14.             }
  15.         }
  16.     }
  17. })

}

  2. - 深拷贝
  3. ```javascript
  4. // 简易
  5. function deepClone(source) {
  6.   let target = {};
  7.   for (let prop in source) {
  8.     if(typeof source[prop] === 'object') {
  9.       target[prop] = deepClone(source[prop]);
  10.     } else {
  11.       target[prop] = source[prop];
  12.     }
  13.   }
  14.   return target;
  15. }
  17. // 考虑数组与对象情况
  19. function clone(Obj) {
  20.   var buf;   
  21.   if (Obj instanceof Array) {
  22.     buf = [];  // 创建一个空的数组
  23.     let i = Obj.length;
  24.     while (i--) {
  25.       buf[i] = clone(Obj[i]);
  26.     }
  27.     return buf;
  28.   } else if (Obj instanceof Object){
  29.     buf = {};  // 创建一个空对象
  30.     for (let k in Obj) {  // 为这个对象添加新的属性
  31.       buf[k] = clone(Obj[k]);
  32.     }
  33.     return buf;
  34.   }else{
  35.     return Obj;
  36.   }
  37. }
  39. // 最完整示例，包括对象循环引用
  40. function deepClone(obj, hash = new WeakMap()) {
  41.   if (obj === null) return obj; // 如果是null或者undefined我就不进行拷贝操作
  42.   if (obj instanceof Date) return new Date(obj);
  43.   if (obj instanceof RegExp) return new RegExp(obj);
  44.   // 可能是对象或者普通的值  如果是函数的话是不需要深拷贝
  45.   if (typeof obj !== "object") return obj;
  46.   // 是对象的话就要进行深拷贝
  47.   if (hash.get(obj)) return hash.get(obj);
  48.   let cloneObj = new obj.constructor();
  49.   // 找到的是所属类原型上的constructor,而原型上的 constructor指向的是当前类本身
  50.   hash.set(obj, cloneObj);
  51.   for (let key in obj) {
  52.     if (obj.hasOwnProperty(key)) {
  53.       // 实现一个递归拷贝
  54.       cloneObj[key] = deepClone(obj[key], hash);
  55.     }
  56.   }
  57.   return cloneObj;
  58. }
  59. let obj = { name: 1, address: { x: 100 } };
  60. obj.o = obj; // 对象存在循环引用的情况
  61. let d = deepClone(obj);
  62. obj.address.x = 200;
  63. console.log(d);
  65. // 考虑symbol情况
  66. const cloneDeep1 = (target, hash = new WeakMap()) => {
  67.   // 对于传入参数处理
  68.   if (typeof target !== 'object' || target === null) {
  69.     return target;
  70.   }
  71.   // 哈希表中存在直接返回
  72.   if (hash.has(target)) return hash.get(target);
  74.   const cloneTarget = Array.isArray(target) ? [] : {};
  75.   hash.set(target, cloneTarget);
  77.   // 针对Symbol属性
  78.   const symKeys = Object.getOwnPropertySymbols(target);
  79.   if (symKeys.length) {
  80.     symKeys.forEach(symKey => {
  81.       if (typeof target[symKey] === 'object' && target[symKey] !== null) {
  82.         cloneTarget[symKey] = cloneDeep1(target[symKey]);
  83.       } else {
  84.         cloneTarget[symKey] = target[symKey];
  85.       }
  86.     })
  87.   }
  89.   for (const i in target) {
  90.     if (Object.prototype.hasOwnProperty.call(target, i)) {
  91.       cloneTarget[i] =
  92.         typeof target[i] === 'object' && target[i] !== null
  93.         ? cloneDeep1(target[i], hash)
  94.         : target[i];
  95.     }
  96.   }
  97.   return cloneTarget;
  98. }

参考资料
浅拷贝与深拷贝
如何写出一个惊艳面试官的深拷贝?

防抖与节流

  1. // 防抖
  2. function debounce(fn) {
  3.   // 创建一个标记用来存放定时器的返回值
  4.   let timeout = null;
  5.   return function() {
  6.     //每次当用户点击/输入的时候，把前一个定时器清除
  7.     clearTimeout(timeout);
  9.     // 然后创建一个新的 setTimeout，
  10.     // 这样就能保证点击按钮后的 interval 间隔内
  11.     // 如果用户还点击了的话，就不会执行 fn 函数
  12.     timeout = setTimeout(() => {
  13.       fn.apply(this, arguments);
  14.     }, 1000);
  15.   };
  16. }
  18. // 节流
  19. function throttle(fn) {
  20.   // 通过闭包保存一个标记
  21.   let canRun = true;
  22.   return function() {
  23.     // 在函数开头判断标志是否为 true，不为 true 则中断函数
  24.     if(!canRun) {
  25.       return;
  26.     }
  27.     // 将 canRun 设置为 false，防止执行之前再被执行
  28.     canRun = false;
  29.     // 定时器
  30.     setTimeout( () => {
  31.       fn.call(this, arguments);
  32.       // 执行完事件（比如调用完接口）之后，重新将这个标志设置为 true
  33.       canRun = true;
  34.     }, 1000);
  35.   };
  36. }

数组方法

扁平化

  1. const arr = [1, [2, [3, [4, 5]]], 6];
  3. // 1.使用flat
  4. const res1 = arr.flat(Infinity);
  6. // 2.使用正则匹配
  7. const res3 = JSON.parse('[' + JSON.stringify(arr).replace(/\[|\]/g, '') + ']');
  9. // 3.使用reduce
  10. const flatten = arr => {
  11.   return arr.reduce((pre, cur) => {
  12.     return pre.concat(Array.isArray(cur) ? flatten(cur) : cur);
  13.   }, [])
  14. }
  15. const res4 = flatten(arr);
  17. // 4. 递归
  18. const res5 = [];
  19. const fn = arr => {
  20.   for (let i = 0; i < arr.length; i++) {
  21.     if (Array.isArray(arr[i])) {
  22.       fn(arr[i]);
  23.     } else {
  24.       res5.push(arr[i]);
  25.     }
  26.   }
  27. }
  28. fn(arr);

数组去重

  1. const arr = [1, 1, '1', 17, true, true, false, false, 'true', 'a', {}, {}];
  3. // 1.利用Set
  4. const res1 = Array.from(new Set(arr));
  6. // 2.利用Map
  7. const unique5 = arr => {
  8.   const map = new Map();
  9.   const res = [];
  10.   for (let i = 0; i < arr.length; i++) {
  11.     if (!map.has(arr[i])) {
  12.       map.set(arr[i], true)
  13.       res.push(arr[i]);
  14.     }
  15.   }
  16.   return res;
  17. }
  19. // 3.两次for循环
  20. const unique1 = arr => {
  21.   let len = arr.length;
  22.   for (let i = 0; i < len; i++) {
  23.     for (let j = i + 1; j < len; j++) {
  24.       if (arr[i] === arr[j]) {
  25.         arr.splice(j, 1);
  26.         // 每删除一个树，j--保证j的值经过自加后不变。同时，len--，减少循环次数提升性能
  27.         len--;
  28.         j--;
  29.       }
  30.     }
  31.   }
  32.   return arr;
  33. }
  35. // 4.使用indexOf
  36. const unique2 = arr => {
  37.   const res = [];
  38.   for (let i = 0; i < arr.length; i++) {
  39.     if (res.indexOf(arr[i]) === -1) res.push(arr[i]);
  40.   }
  41.   return res;
  42. }
  44. // 5.使用includes
  45. const unique3 = arr => {
  46.   const res = [];
  47.   for (let i = 0; i < arr.length; i++) {
  48.     if (!res.includes(arr[i])) res.push(arr[i]);
  49.   }
  50.   return res;
  51. }

filter实现

  1. Array.prototype.filter = function(callback, thisArg) {
  2.   if (this == undefined) {
  3.     throw new TypeError('this is null or not undefined');
  4.   }
  5.   if (typeof callback !== 'function') {
  6.     throw new TypeError(callback + 'is not a function');
  7.   }
  8.   const res = [];
  9.   // 让obj成为回调函数的对象传递（强制转换对象）
  10.   const obj = Object(this);
  11.   // >>>0 无符号移位0位，保证len为number，且为正整数
  12.   const len = obj.length >>> 0;
  13.   for (let i = 0; i < len; i++) {
  14.     // 检查i是否在O的属性（会检查原型链）
  15.     if (i in obj) {
  16.       // 回调函数调用传参
  17.       if (callback.call(thisArg, obj[i], i, obj)) {
  18.         res.push(obj[i]);
  19.       }
  20.     }
  21.   }
  22.   return res;
  23. }

map实现

  1. Array.prototype.map = function(callback, thisArg) {
  2.     if (this == undefined) {
  3.       throw new TypeError('this is null or undefined');
  4.   }
  5.   if (typeof callback !== 'function') {
  6.       throw new TypeError(callback + ' is not a function');
  7.   }
  9.   const res = [];
  10.   const obj = Object(this);
  11.   const len = obj.length >>> 0;
  13.   for(let i = 0; i < len; i++) {
  14.     if (i in obj) {
  15.         res[i] = callback.call(thisArg, obj[i], i, this);
  16.     }
  17.   }
  18.   return res;
  19. }

forEach实现

  1. Array.prototype.forEach = function(callback, thisArg) {
  2.   if (this == null) {
  3.     throw new TypeError('this is null or not defined');
  4.   }
  5.   if (typeof callback !== "function") {
  6.     throw new TypeError(callback + ' is not a function');
  7.   }
  8.   const obj = Object(this);
  9.   const len = obj.length >>> 0;
  10.   let k = 0;
  11.   while (k < len) {
  12.     if (k in obj) {
  13.       callback.call(thisArg, obj[k], k, obj);
  14.     }
  15.     k++;
  16.   }
  17. }

reduce实现

  1. Array.prototype.reduce = function(callback, initialValue) {
  2.   if (this === undefined) {
  3.     throw new TypeError('this is null or not undefined');
  4.   }
  5.   if (typeof callback !== 'function') {
  6.     throw new TypeError(callback + 'is not a function');
  7.   }
  9.   const obj = Object(this);
  10.   const len = this.length;
  11.   let accumulator = initialValue;
  12.   let k = 0;
  14.   // 如果无初始值则取第一个值
  15.   if (accumulator === undefined) {
  16.     while(k < len && !(k in obj)) {
  17.       k++;
  18.     }
  20.     if(k >= len) {
  21.       throw new TypeError('Reduce of empty array with no initial value');
  22.     }
  24.     accumulator = obj[k++];
  25.   }
  27.   while (k < len) {
  28.     accumulator = callback.call(this, accumulator, obj[k], k, obj);
  29.     k++;
  30.   }
  31.   return accumulator;
  32. }

apply与call的实现

  1. Function.prototype.apply = function(context = window, args) {
  2.   if (typeof this !== 'function') {
  3.     throw TypeError('this is not a function');
  4.   }
  6.   context.fn = this;
  8.   const res = context.fn(...args);
  9.   delete context.fn;
  11.   return res;
  12. }
  14. Function.prototype.call = function(context = window, ...args) {
  15.   if (typeof this !== 'function') {
  16.     throw TypeError('this is not a function');
  17.   }
  19.   context.fn = this;
  21.   const res = context.fn(args);
  22.   delete context.fn;
  24.   return res;
  25. }

bind的实现

  1. Function.prototype.bind = function(context, ...args) {
  2.   if (typeof this !== 'function') {
  3.     throw new Error('');
  4.   }
  6.   // 保存this
  7.   const selfFn = this;
  9.   return function() {
  10.     // 考虑new情况
  11.     if (this instanceof F) {
  12.       return new self(...args, ...arguments)
  13.     }
  15.     return selfFn.apply(context, [...args, ...arguments]);
  16.   }
  17. }

柯理化

  1. // 利用==判断会调用toString方法
  2. const arr = [1,2,3];
  4. function add() {
  5.   const _args = [...arguments];
  7.   function fn() {
  8.     _args.push(...arguments);
  9.     return fn;
  10.   }
  12.   fn.toString = function() {
  13.     console.log(_args);
  14.     return _args.reduce((sum, item) => sum + item);
  15.   }
  16.   return fn;
  17. }
  19. fn1 = add(1);
  20. console.log(fn1(2));
  23. // 固定参数个数的柯理化
  24. function sum(a, b, c) {
  25.   return a + b + c;
  27. function curry(fn) {
  28.   return function curried(...args) {
  29.     // function的length属性指函数所需形参的个数，如果参数有默认值则为第一个有默认值之前的参数个数
  30.     if (args.length >= fn.length) {
  31.       return fn.apply(this, args);
  32.     } else {
  33.       return function(...args2) {
  34.         return curried.apply(this, args.concat(args2));
  35.       }
  36.     }
  37.   }
  38. }
  40. const sum2 = curry(sum);
  41. console.log(sum2(1, 2)(3));   // 6
  43. // 非固定参数个数的珂理化
  44. // 非固定个数入参
  45. function curry2(fn) {
  46.   return function curried(...args) {
  47.     //args,累计保存的参数
  48.     return function(...args2) {
  49.       // args2,每次执行传入的参数
  50.       if (args2.length) {
  51.           return curried.apply(this, args.concat(args2))
  52.       } else {
  53.         return fn.apply(this, args);
  54.       }
  55.     }
  56.   }
  57. }

instanceof实现

  1. function _instanceof() {
  2.   if (typeof left !== 'object' || left === null) return false;
  3.   let proto = Object.getPrototypeOf(left);
  4.   while(true) {
  5.       if (proto === null) return false;
  6.     if (proto === right.prototype) return true;
  7.     proto = Object.getPrototypeOf(proto);
  8.   }
  9. }

继承实现

  1. function Parent() {
  2.   this.name = 'parent';
  3. }
  4. function Child() {
  5.   Parent.call(this);
  6.   this.type = 'children';
  7. }
  8. Child.prototype = Object.create(Parent.prototype);
  9. Child.prototype.constructor = Child;

Object.assign实现

  1. Object.defineProperty(Object, 'assign', {
  2.   value: function(target, ...args) {
  3.       if (target == null) {
  4.         return new TypeError('Cannot convert undefined or null to object');
  5.     }
  6.     let obj = Object(target);
  8.     for(let i = 0; i < args.length; i++) {
  9.       if (args[i] !== null) {
  10.         for(const key in args[i]) {
  11.           if (Object.hasOwnProperty.call(obj, key)) {
  12.             obj[key] = args[i][key];
  13.           }
  14.         }
  15.       }
  16.     }
  17.     return obj;
  18.   },
  19.   enumerable: false,        // 不可枚举
  20.   writable: false,            // 不可修改
  21.   configurable: false,    // 是否可使用delete，是否可重新定义属性特性
  22. })

Promise实现

  1. /**
  2.  * Promise 实现
  3.  */
  5. const PENDING = 'PENDING';
  6. const FULFILLED = 'FULFILLED';
  7. const REJECTED = 'REJECTED';
  9. class Promise {
  10.     constructor(exector) {
  11.         this.status = 'PENDING';            // 状态,初始等待状态
  12.         this.value = undefined;             // 值,便于后续then,catch访问
  13.         this.reason = undefined;            // 失败原因保存
  14.         this.onFulfilledCallbacks = [];     // 成功回调队列
  15.         this.onRejectedCallbacks = [];      // 失败回调队列
  17.         const resolve = (value) => {
  18.             // 等待中状态才能进行更改
  19.             if (this.status === PENDING) {
  20.                 this.status = FULFILLED;
  21.                 this.value = value;
  22.                 this.onFulfilledCallbacks.forEach(fn => fn(this.value));
  23.             }
  24.         }
  26.         const reject = (reason) => {
  27.             // 等待中状态才能进行更改
  28.             if (this.status === PENDING) {
  29.                 this.status = REJECTED;
  30.                 this.reason = reason;
  31.                 this.onFulfilledCallbacks.forEach(fn => fn(this.reason));
  32.             }
  33.         } 
  35.         try {
  36.             // 立即执行并传入修改状态的两个方法
  37.             exector(resolve, reject);
  38.         } catch(e) {
  39.             // 出现错误直接reject回去
  40.             reject(e);
  41.         }
  42.     }
  44.     then(onFulfilled, onRejected) {
  45.         // 初始化两个回调
  46.         onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : value => value;
  47.         onRejected = typeof onRejected === 'function' ? onRejected : 
  48.             reason => {throw new TypeError(reason instanceof Error ? reason.message : reason)}
  50.         // 保存this, 即当前Promise实例
  51.         const self = this;
  53.         // 返回一个新Promise
  54.         return new Promise((resolve, reject) => {
  55.             // 等待状态
  56.             if (self.status === PENDING) {
  57.                 // 加入成功回调队列
  58.                 self.onFulfilledCallbacks.push(() => {
  59.                     try {
  60.                         setTimeout(() => {
  61.                             const result = onFulfilled(self.value);
  62.                             // 处理链式传递
  63.                             resolvePromise(result, resolve, reject);
  64.                         })
  65.                     } catch(e) {
  66.                         reject(e)
  67.                     }
  68.                 })
  70.                 // 加入失败回调队列
  71.                 self.onRejectedCallbacks.push(() => {
  72.                     try {
  73.                         setTimeout(() => {
  74.                             const result = onRejected(self.reason);
  75.                             // 处理链式传递
  76.                             resolvePromise(result, resolve, reject);
  77.                         })
  78.                     } catch(e) {
  79.                         reject(e)
  80.                     }
  81.                 })
  82.             }
  83.         })
  84.     }
  86.     catch(onRejected) {
  87.         this.then(null, onRejected);
  88.     }
  90.     static resolve(value) {
  91.         if (value instanceof Promise) {
  92.             return value;
  93.         } else {
  94.             return new Promise((resolve, reject) => resolve(value));
  95.         }
  96.     }
  98.     static reject(reason) {
  99.         return new Promise((resolve, reject) => {
  100.             reject(reason);
  101.         })
  102.     }
  104.     static all(promiseArr) {
  105.         const len = promiseArr.length;
  106.         let values = new Array(len);
  107.         let count = 0;
  109.         return new Promise((resolve, reject) => {
  110.             for(let i  = 0; i < len; i++) {
  111.                 // 使用Promise.resolve处理，保证每个都是Promise实例
  112.                 Promise.resolve(promise[i]).then(value => {
  113.                     count++;
  114.                     values[i] = value;
  116.                     if (count === len) {
  117.                         resolve(values);
  118.                     }
  119.                 }, err => reject(err))
  120.             }
  121.         })
  122.     }
  124.     static race(promiseArr) {
  125.         return new Promise((resolve, reject) => {
  126.             promiseArr.forEach(promiseItem => {
  127.                 Promise.resolve(promiseItem).then(value => resolve(value), err => reject(err));
  128.             })
  129.         })
  130.     }
  131. }
  133. // 处理链式调用then, 传递返回值result
  134. function resolvePromise(result, resolve, reject) {
  135.     // 1. 返回是Promise类型,执行它的then
  136.     // 2. 返回不是Promise, 执行当前新Promise的resolve, 将值传递下去
  137.     if (result instanceof Promise) {
  138.         result.then(resolve, reject);
  139.     } else {
  140.         resolve(result);
  141.     }
  142. }

参考资料
promise实现—前端进阶之道
从零开始实现一个promise

参考

32个手写JS，巩固你的JS基础（面试高频）