feat: 新增Promise写法

README.md

@@ -19,12 +19,16 @@
 - [实现 new](./src/new.js) ★
 - [实现 jsonp](./src/jsonp.js) ★★★
 - [实现 Promise](./src/promise.js) ★★★
+- [实现 Promise (外网摘下来的A+测试版, 可以直接背)](./src/PromiseAPlus.js) ★★★
 - [实现 Promise.all()](./src/promiseAll.js) ★★★
 - [实现 Promise.race()](./src/promiseRace.js) ★
+- [实现并发Promise](./src/PromisPool.js) ★★
+- [实现用Promise封装的ajax](./src/PromiseAjax.js) ★★
 - [实现 Proxy](./src/proxy.js) ★★
 - [实现 EventEmitter 订阅监听模式](./src/subscribe.js) ★★
 - [setTimout 实现 setInterval](./src/interval.js) ★
 - [深拷贝](./src/deepclone.js)  ★★★
+- [实现全排列](./src/permutation.js) ★★
 
 
 ### 函数
@@ -66,6 +70,7 @@
 - [最长公共子串](./src/longestCommonPrefix.js) ★★
 - [城市数据找父节点](./src/city.js) ★
 - [查找缺失的数](./src/missingNumber.js) ★
+- [**多个**数组取交集](./src/ArrayIntersections.ts) ★
 
 
 分享一下自己整理的 LeetCode 上必刷的题，比较具有代表性。

funcs/README.md

@@ -0,0 +1,3 @@
+# 算法部分
+
+* [获取树形结构最大深度](./algo/MaxDeep.js)

funcs/algo/MaxDeep.js

@@ -0,0 +1,56 @@
+/* 
+[
+    {
+        "id":"1",
+        "childrens":[{
+            "id":"12",
+            "childrens":[]
+        },{
+            "id":"13",
+            "childrens":[{
+               "id":"123",
+               "childrens":[]
+          }]
+        }]
+    },
+    {
+        "id":"2",
+        "childrens":[]
+    }
+]
+*/
+
+function maxDeep(list) {
+    // boundary case
+    if (!list.length) return 0;
+
+    let res = 1;
+
+    // 栈法获取
+    list.forEach(item => {
+        let tmp = 1;
+        const { childrens } = item;
+        if (childrens.length) {
+            // 开栈
+            const stack = [];
+
+            childrens.forEach(child => {
+                tmp = 1;
+                stack.push(child);
+                while (stack.length) {
+                    tmp++;
+                    const { childrens } = stack.pop();
+                    if (childrens.length) {
+                        stack.push(...childrens);
+                    }
+                }
+            });
+
+            if (tmp > res) {
+                res = tmp;
+            }
+        }
+    });
+
+    return res;
+}

src/ArrayIntersections.ts

@@ -0,0 +1,25 @@
+// 数组unique
+const uniqueArray = (list: number[]) => Array.from(new Set(list));
+
+/**
+ * 多个数组取交集
+ * @param args 数组
+ * @returns 交集数组
+ */
+const getIntecsectionOfArrays = (...args: number[][]): number[] => {
+    // 边界情况
+    if (args.length <= 1) {
+        return args.length ? [...args[0]] : [];
+    }
+
+    // 打平数组
+    const flatterNums = args.map(ls => uniqueArray(ls)).flat(Number.MAX_SAFE_INTEGER) as number[];
+
+    // 打表
+    const hashMap = flatterNums.reduce((prev, num) => {
+        prev.hasOwnProperty(num) ? prev[num]++ : prev[num] = 1;
+        return prev;
+    }, {} as Record<number, number>);
+
+    return Object.keys(hashMap).filter(k => hashMap[k] === args.length).map(k => +k);
+};

src/PromisPool.js

@@ -0,0 +1,69 @@
+/**
+ * @description: https://juejin.cn/post/7197246543208071205
+ */
+
+/**
+ * 并发控制Promise
+ * @param {number} concur 并发数
+ */
+export const pLimit = (concur) => {
+  // 用数组模拟队列, 作为请求池
+  const queue = [];
+
+  // 当前活跃数量
+  let active = 0;
+
+  const next = () => {
+    active--;
+
+    if (queue.length) {
+      queue.shift()();
+    }
+  };
+
+  const run = async (fn, resolve, ...args) => {
+    active++;
+
+    const res = (async () => fn(...args))();
+    resolve(res);
+
+    try {
+      await res;
+    } catch (err) {
+      console.log(err);
+    }
+
+    next();
+  };
+
+  const enqueue = (fn, resolve, ...args) => {
+    queue.push(run(fn, resolve, ...args));
+
+    if (queue.length && active < concur) {
+      queue.shift()();
+    }
+  };
+
+  const generator = (fn, ...args) =>
+    new Promise((reso) => {
+      enqueue(fn, reso, ...args);
+    });
+
+  Object.defineProperties(generator, {
+    active: {
+      get: () => active,
+    },
+    pendingCount: {
+      get: () => queue.length,
+    },
+    clear: {
+      value() {
+        while (queue.length) {
+          queue.pop();
+        }
+      },
+    },
+  });
+
+  return generator;
+};

src/PromiseAPlus.js

@@ -0,0 +1,80 @@
+/**
+ * @author Yueb
+ * @description Promise A+实现。源码详见: https://www.talkinghightech.com/en/implementing-a-javascript-promise/
+ * 
+ * 这个版本可直接背
+ */
+
+const PEND = Symbol.for("pending");
+const RES = Symbol.for("resolved");
+const REJ = Symbol.for("rejected");
+
+class Prom {
+  status = PEND;
+  value = null;
+  reason = null;
+  onResolvedFns = [];
+  onRejectedFns = [];
+
+  constructor(executor) {
+    executor(this.__resolve.bind(this), this.__reject.bind(this));
+  }
+
+  __helperFunc(stateSymbol, tmpValue) {
+    if (this.status !== PEND) {
+      return this.value;
+    }
+
+    if ([REJ, RES].includes(stateSymbol)) {
+      // 核心
+      queueMicrotask(() => {
+        this.status = stateSymbol;
+        if (stateSymbol === REJ) {
+          this.reason = tmpValue;
+          this.onRejectedFns.forEach((cb) => cb(tmpValue));
+          this.onResolvedFns = [];
+        } else {
+          this.value = tmpValue;
+          this.onResolvedFns.forEach((cb) => cb(tmpValue));
+          this.onResolvedFns = [];
+        }
+      });
+    }
+  }
+
+  __resolve(value) {
+    this.__helperFunc(RES, value);
+  }
+
+  __reject(reason) {
+    this.__helperFunc(REJ, reason);
+  }
+
+  then(onFulfil, onRej) {
+    return new Prom((resolve, reject) => {
+      if (this.status === PEND) {
+        this.onResolvedFns.push((value) => { resolve(onFulfil(value)); });
+        if (reject) {
+          this.onRejectedFns.push(onRej);
+        }
+      } 
+      if (this.status === RES) {
+        resolve(onFulfil(this.value));
+      } 
+
+      if (this.status === REJ) {
+        reject(this.reason);
+      }
+    });
+  }
+
+  catch(onRej) {
+    if (this.status === REJ) {
+      onRej(this.reason);
+    }
+
+    if (this.status === PEND) {
+      this.onRejectedFns.push(onRej);
+    }
+  }
+}

src/PromiseAPlus.ts

@@ -0,0 +1,77 @@
+// https://www.talkinghightech.com/en/implementing-a-javascript-promise/
+
+/* eslint-disable prettier/prettier */
+export enum MyPromiseState {
+  pending,
+  resolved,
+  rejected,
+}
+export type MyPromiseInitiator<T> = (
+  resolve: (val: T) => any,
+  reject: (error: any) => any
+) => any;
+
+export class MyPromise<T> {
+  private state: MyPromiseState = MyPromiseState.pending;
+  private value: T | undefined;
+  private reason: any;
+  private onResolvedCallbacks: ((value: T) => void)[] = [];
+  private onRejectedCallbacks: ((reason: any) => void)[] = [];
+
+  constructor(executor: MyPromiseInitiator<T>) {
+    executor(
+      this.onCallbackResolved.bind(this),
+      this.onCallbackFailed.bind(this)
+    );
+  }
+
+  then(
+    onFulfilled: (value: T) => T | void,
+    onRejected?: (reason: any) => any
+  ): MyPromise<T> {
+    return new MyPromise<T>((resolve, reject) => {
+      if (this.state === MyPromiseState.resolved) {
+        resolve(onFulfilled(this.value as T) as T);
+      }
+      if (this.state === MyPromiseState.rejected) {
+        reject(this.reason);
+      }
+      if (this.state === MyPromiseState.pending) {
+        this.onResolvedCallbacks.push((value) => {
+          resolve(onFulfilled(value) as T);
+        });
+        onRejected && this.onRejectedCallbacks.push(onRejected);
+      }
+    });
+  }
+
+  catch(onRejected: (reason: any) => void) {
+    if (this.state === MyPromiseState.rejected) {
+      onRejected(this.reason);
+    }
+    if (this.state === MyPromiseState.pending) {
+      this.onRejectedCallbacks.push(onRejected);
+    }
+  }
+
+  private onCallbackResolved(value: T) {
+    queueMicrotask(() => {
+      if (this.state !== MyPromiseState.pending) return this.value;
+      this.value = value;
+      this.state = MyPromiseState.resolved;
+      // Now update all the other registered callbacks that are waiting for this promise to resolve
+      this.onResolvedCallbacks.forEach((callback) => callback(value));
+      this.onResolvedCallbacks = [];
+    });
+  }
+
+  private onCallbackFailed(reason: any) {
+    queueMicrotask(() => {
+      if (this.state !== MyPromiseState.pending) return this.reason;
+      this.reason = reason;
+      this.state = MyPromiseState.rejected;
+      this.onRejectedCallbacks.forEach((callback) => callback(reason));
+      this.onRejectedCallbacks = [];
+    });
+  }
+}

src/PromiseAjax.js

@@ -0,0 +1,20 @@
+'use strict';
+
+// ajax函数将返回Promise对象:
+function ajax(method, url, data) {
+    const request = new XMLHttpRequest();
+    return new Promise((resolve, reject) => {
+        request.onreadystatechange = () => {
+            const { readyState, status, responseText } = request;
+            if (readyState === 4) {
+                if (status === 200) {
+                    resolve(responseText);
+                } else {
+                    reject(status);
+                }
+            }
+        };
+        request.open(method, url);
+        request.send(data);
+    });
+}