• 手写promis(1)

    目录

    前言

    核心功能--构造函数 

    核心功能--状态及原因

    then方法

    成功和失败回调

    异步及多次调用

    异步任务--核心api

    Promise.then:

    queueMicrotask:

    MutationObserver:

    setImmediate:

    setTimeout:

    异步任务---函数封装

    前言

    Promise（承诺）是一种用于处理异步操作的JavaScript编程技术。它是一种代表一个尚未完成的操作的对象，该操作可能会在将来的某个时刻完成或失败。Promise提供了一种更结构化和可维护的方式来处理异步代码，特别是在处理网络请求、文件I/O、定时器等操作时非常有用。

    Promise对象有三种状态：

    1. Pending（进行中）：初始状态，表示操作尚未完成或失败。
    2. Fulfilled（已完成）：表示操作成功完成。
    3. Rejected（已失败）：表示操作失败。

    Promise对象具有两个重要的方法：

    1. then(): 用于注册回调函数，当Promise状态变为Fulfilled时执行。
    2. catch(): 用于注册回调函数，当Promise状态变为Rejected时执行。

    使用Promise，可以更清晰地定义异步操作的工作流程，避免了回调地狱（Callback Hell）的问题，使代码更易于理解和维护。以下是一个简单的Promise示例：

    1. const myPromise = new Promise((resolve, reject) => {
    2.   // 异步操作
    3.   setTimeout(() => {
    4.     const randomValue = Math.random();
    5.     if (randomValue > 0.5) {
    6.       resolve("操作成功");
    7.     } else {
    8.       reject("操作失败");
    9.     }
    10.   }, 1000);
    11. });
    12.  
    13. myPromise
    14.   .then(result => {
    15.     console.log(result); // 在操作成功时执行
    16.   })
    17.   .catch(error => {
    18.     console.error(error); // 在操作失败时执行
    19.   });

    这个示例创建了一个Promise对象，模拟了一个异步操作，并根据随机值决定是成功还是失败。通过.then()和.catch()方法，我们可以分别处理成功和失败的情况。这使得异步代码的处理更加结构化和可控。

    手写原来步骤

    核心功能--构造函数 

    1. 定义类（Define the class）: 这里定义了一个名为MyPromise的类，用于创建自定义Promise对象。

    2. 添加构造函数（Add a constructor）: 在构造函数中，通过constructor方法定义了一个新的MyPromise对象。当创建MyPromise对象时，会执行构造函数。构造函数接受一个函数func作为参数，这个函数在创建MyPromise对象时传入。

    3. 定义resolve/reject（Define resolve and reject functions）: 在构造函数中，定义了resolve和reject函数，它们分别用于处理Promise的成功和失败情况。resolve函数用于处理成功情况，它接受一个参数result，表示成功的原因。reject函数用于处理失败情况，它也接受一个参数result，表示失败的原因。

    4. 执行回调函数（Execute the callback function）: 最后，构造函数中调用了传入的func函数，这个函数接受resolve和reject作为参数。这意味着在创建MyPromise对象时，会执行传入的回调函数，并在适当的时候调用resolve或reject函数来处理异步操作的结果

    1. /**
    2.  * 构造函数
    3.  * 1. 定义类
    4.  * 2. 添加构造函数
    5.  * 3. 定义reslove/reject
    6.  * 4. 执行回调函数
    7.  */
    9. //1.定义类
    10. class MyPromise {
    11.     // 2.添加构造函数 new时会执行 constructor 传入回调函数
    12.     constructor(func) {
    13.         // 3.func 接受两个行参 成功回调（成功原因），失败回调（失败原因）
    14.         // resolve：<Function>(result:<any>)  reject：<Function>(result:<any>) 
    15.         const resolve = (result) => {
    16.             console.log('resolve执行了--', result);
    17.         }
    18.         const reject = (result) => {
    19.             console.log('reject执行了--', result);
    20.         }
    21.  
    22.         // 4. 执行回调函数
    23.         func(resolve, reject)
    24.     }
    25. }
    26.  
    27.  
    28. // 测试代码
    29. const p = new MyPromise((resolve, reject) => {
    30.     console.log('执行回调函数');
    31.     // resolve('success')
    32.     reject('error')
    33. })

    核心功能--状态及原因

    1. 添加实例属性状态（pending / fulfilled / rejected）(默认为等待）

    2. 添加实例属性原因（默认为undefined）

    3. 调整resolve函数和reject函数 resolve和reject函数改变状态和保存原因，这是Promise的核心功能之一。

    4. 添加状态检查：在resolve和reject函数中，添加状态检查来确保状态只能从pending改变一次。这可以防止状态被多次改变。
    1. /**
    2.  * 状态及原因
    3.  * 1. 添加状态 pending / fulfilled / rejected
    4.  * 2. 添加原因
    5.  * 3. 调整reslove/reject
    6.  * 4. 状态不可逆
    7.  */
    9. //通过变量保存状态，方便使用
    10. const PENDING = 'pending'
    11. const FULFILLED = 'fulfilled'
    12. const REJECTED = 'rejected'
    13.  
    14. class MyPromise {
    15.     // 1. 添加实例属性 状态（pending / fulfilled / rejected）(默认为等待)
    16.     state = PENDING
    17.     // 2. 添加实例属性 原因（默认为undefined）
    18.     result = undefined
    19.     constructor(func) {
    20.         // this 箭头函数this-->上级作用域（构造函数）-->  实例 
    21.         // 3. 调整reslove pending-- > fulfilled 添加原因
    22.         const resolve = (result) => {
    23.             // 4. 状态不可逆
    24.             if (this.state == PENDING) {
    25.                 this.state = FULFILLED
    26.                 this.result = result
    27.             }
    28.         }
    29.  
    30.         // 3. reject pending-- > rejected 添加原因
    31.         const reject = (result) => {
    32.             if (this.state == PENDING) {
    33.                 this.state = REJECTED
    34.                 this.result = result
    35.             }
    36.         }
    37.  
    38.         func(resolve, reject)
    39.     }
    40. }
    41.  
    42.  
    43. // 测试代码
    44. const p = new MyPromise((resolve, reject) => {
    45.  
    46.     resolve('success')
    47.     // reject('error')
    48. })

    then方法

    成功和失败回调

    1. 添加实例方法(then)

    2. 参数判断（参考文档）

    如果是个函数 执行回调函数 

    如果 onFulfilled 不是一个函数，则内部会被替换为一个恒等函数（(x) => x），它只是简单地将兑现值向前传递。

    如果 onRejected 不是一个函数，则内部会被替换为一个抛出器函数（(x) => { throw x; }），它会抛出它收到的拒绝原因。

    3.判断状态执行成功回调函数or失败回调函数（实例化完成后状态已经确定）

    1. /**
    2.  * 成功和失败回调
    3.  * 1. 添加实例方法
    4.  * 2. 参数判断（参考文档）
    5.  *  2.1. 执行成功回调
    6.  *  2.2. 执行失败回调
    7.  */
    9. //通过变量保存状态，方便使用
    10. const PENDING = 'pending'
    11. const FULFILLED = 'fulfilled'
    12. const REJECTED = 'rejected'
    13.  
    14. class MyPromise {
    15.     state = PENDING
    16.     result = undefined
    17.     constructor(func) {
    18.         const resolve = (result) => {
    19.             if (this.state == PENDING) {
    20.                 this.state = FULFILLED
    21.                 this.result = result
    22.             }
    23.         }
    24.  
    25.         const reject = (result) => {
    26.             if (this.state == PENDING) {
    27.                 this.state = REJECTED
    28.                 this.result = result
    29.             }
    30.         }
    31.  
    32.         func(resolve, reject)
    33.     }
    34.     // 添加实例方法
    35.     then(onFulfilled, onRejected) {
    36.         // 参数判断  如果 onFulfilled 不是一个函数，则内部会被替换为一个恒等函数（(x) => x），它只是简单地将兑现值向前传递。
    37.         onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : x => x
    38.         // 参数判断  如果 onRejected 不是一个函数，则内部会被替换为一个抛出器函数（(x) => { throw x; }），它会抛出它收到的拒绝原因。
    39.         onRejected = typeof onRejected === 'function' ? onRejected : (x) => { throw x }
    40.  
    41.         // 执行成功回调or执行失败回调(状态实例化完成就立即调用了，所以可以执行返回结果--》异步暂时不考虑)
    42.         if (this.state === FULFILLED) {
    43.             onFulfilled(this.result)
    44.         } else if (this.state === REJECTED) {
    45.             onRejected(this.result)
    46.         }
    47.  
    48.     }
    49. }
    50.  
    51.  
    52. // 测试代码
    53. const p = new MyPromise((resolve, reject) => {
    54.  
    55.     // resolve('success')
    56.     reject('error')
    57. })
    58. // p.then((result) => {
    59. //     console.log('成功回调', result)
    60. // }, err => {
    61. //     console.log('失败回调', err);
    62. // })
    63. p.then((result) => {
    64.     console.log('成功回调', result)
    65. })

    异步及多次调用

    1. 定义实例属性，添加#为类内部使用标识
    2. 如果then执行后状态为pending存储异步时成功回调与失败回调

    3. 定时器两秒后 resolve执行 取出成功回调函数放入成功原因

    4. 定时器两秒后 reject执行 取出失败回调函数放入失败原因

    1. /**
    2.  * then-异步及多次调用
    3.  * 1. 定义实例属性
    4.  * 2. 保存回调函数
    5.  * 3. 调用成功回调
    6.  * 4. 调用失败回调
    7.  */
    9. //通过变量保存状态，方便使用
    10. const PENDING = 'pending'
    11. const FULFILLED = 'fulfilled'
    12. const REJECTED = 'rejected'
    13.  
    14. class MyPromise {
    15.     state = PENDING
    16.     result = undefined
    17.     // 定义实例属性 #外部不能访问 保存回调
    18.     #handlers = []//[{onFulfilled,onRejected}...]
    19.     constructor(func) {
    20.         const resolve = (result) => {
    21.             if (this.state == PENDING) {
    22.                 this.state = FULFILLED
    23.                 this.result = result
    24.                 // 3.定时器两秒后 resolve执行 取出成功回调函数放入成功原因
    25.                 this.#handlers.forEach(({ onFulfilled }) => {
    26.                     onFulfilled(this.result)
    27.                 })
    28.             }
    29.         }
    30.  
    31.         const reject = (result) => {
    32.             if (this.state == PENDING) {
    33.                 this.state = REJECTED
    34.                 this.result = result
    35.                 // 4.定时器两秒后 reject执行 取出失败回调函数放入失败原因
    36.                 this.#handlers.forEach(({ onRejected }) => {
    37.                     onRejected(this.result)
    38.                 })
    39.             }
    40.         }
    41.  
    42.         func(resolve, reject)
    43.     }
    44.  
    45.     then(onFulfilled, onRejected) {
    46.  
    47.         onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : x => x
    48.  
    49.         onRejected = typeof onRejected === 'function' ? onRejected : (x) => { throw x }
    50.  
    51.         if (this.state === FULFILLED) {
    52.             onFulfilled(this.result)
    53.         } else if (this.state === REJECTED) {
    54.             onRejected(this.result)
    55.         } else if (this.state === PENDING) {
    56.             // 2. 代表状态还没有发生过改变，保存回调函数
    57.             this.#handlers.push({
    58.                 onFulfilled, onRejected
    59.             })
    60.         }
    61.  
    62.     }
    63. }
    64.  
    65.  
    66. // 测试代码
    67. const p = new MyPromise((resolve, reject) => {
    68.  
    69.     setTimeout(() => {
    70.         // resolve('success')
    71.         reject('error')
    72.     }, 2000);
    73. })
    74. p.then((result) => {
    75.     console.log('成功回调', result)
    76. }, err => {
    77.     console.log('失败回调', err);
    78. })
    79. p.then((result) => {
    80.     console.log('成功回调', result)
    81. })

    异步任务--核心api

     * Vue Promise.then, MutationObserver,setImmediate,setTimeout

     * 我们选用 queueMicrotask MutationObserver setTimeout

    • Promise.then,手写promise 不考虑这个
    • queueMicrotask：node11,新式浏览器(不包括ie11)
    • MutationObserver node不支持 ie11支持
    • setImmediate：ie10，11支持 edge:(12-18)支持（不考虑）
    • setTimeout：node，浏览器全支持

    Promise.then:

    • 兼容性: 几乎所有现代浏览器和Node.js都支持Promise。
    • 用法: Promise是一种用于处理异步操作的机制，通过.then()方法可以注册回调函数来处理异步任务的完成或失败。例如：
    1. const myPromise = new Promise((resolve, reject) => {
    2.   // 异步操作
    3.   if (/* 操作成功 */) {
    4.     resolve(result);
    5.   } else {
    6.     reject(error);
    7.   }
    8. });
    9.  
    10. myPromise.then(
    11.   (result) => {
    12.     // 处理成功的情况
    13.   },
    14.   (error) => {
    15.     // 处理失败的情况
    16.   }
    17. );

    queueMicrotask:

    Window 或 Worker 接口的 queueMicrotask() 方法，将微任务加入队列以在控制返回浏览器的事件循环之前的安全时间执行。

    微任务是一个简短的函数，它将在当前任务完成其工作后运行，并且在执行上下文的控制权返回到浏览器的事件循环之前没有其他代码等待运行时运行。

    它让你的代码在运行时不会干扰任何可能具有更高优先级的代码的运行，但在浏览器重新获得对执行上下文的控制之前，这可能取决于你需要完成的工作。你可以在我们的微任务指南中了解更多关于如何使用微任务以及选择这样做的原因。

    微任务的重要性在于它能够以特定顺序异步执行任务。查看在 JavaScript 中通过 queueMicrotask() 使用微任务的详情。

    微任务对于需要执行最后阶段的任务或其他在渲染之前的任务的库和框架特别有用。

    参数

    当浏览器引擎确定可以安全调用你的代码时执行的 function。微任务（microtask）的执行顺序在所有进行中的任务（pending task）完成之后，在对浏览器的事件循环产生控制（yielding control to the browser's event loop）之前。

    返回值

    无 undefined

    • 兼容性: 支持新式浏览器，但不包括IE11。
    • 用法: queueMicrotask用于将微任务排入微任务队列中，通常在Promise处理中使用，以确保微任务在宏任务之后执行。示例：
    1. queueMicrotask(() => {
    2.   // 这里执行微任务
    3. });

    MutationObserver:

    MutationObserver 接口提供了监视对 DOM 树所做更改的能力。它被设计为旧的 Mutation Events 功能的替代品，该功能是 DOM3 Events 规范的一部分。

    构造函数

    MutationObserver()

    创建并返回一个新的 MutationObserver 它会在指定的 DOM 发生变化时被调用。

    方法

    disconnect()

    阻止 MutationObserver 实例继续接收的通知，直到再次调用其 observe() 方法，该观察者对象包含的回调函数都不会再被调用。

    observe()

    配置 MutationObserver 在 DOM 更改匹配给定选项时，通过其回调函数开始接收通知。

    takeRecords()

    从 MutationObserver 的通知队列中删除所有待处理的通知，并将它们返回到 MutationRecord 对象的新 Array 中。

    • 兼容性: 在大多数现代浏览器中支持，但Node.js不支持，而IE11也支持。
    • 用法: MutationObserver用于监视DOM树的变化，并在发生变化时触发回调函数。这通常用于监听DOM元素的变化。示例：
    1. // 选择需要观察变动的节点
    2. const targetNode = document.getElementById("some-id");
    3.  
    4. // 观察器的配置（需要观察什么变动）
    5. const config = { attributes: true, childList: true, subtree: true };
    6.  
    7. // 当观察到变动时执行的回调函数
    8. const callback = function (mutationsList, observer) {
    9.   // Use traditional 'for loops' for IE 11
    10.   for (let mutation of mutationsList) {
    11.     if (mutation.type === "childList") {
    12.       console.log("A child node has been added or removed.");
    13.     } else if (mutation.type === "attributes") {
    14.       console.log("The " + mutation.attributeName + " attribute was modified.");
    15.     }
    16.   }
    17. };
    18.  
    19. // 创建一个观察器实例并传入回调函数
    20. const observer = new MutationObserver(callback);
    21.  
    22. // 以上述配置开始观察目标节点
    23. observer.observe(targetNode, config);
    24.  
    25. // 之后，可停止观察
    26. observer.disconnect();

    setImmediate:

    setImmediate参数设置：第一个参数是需要执行的方法，第二个参数到第n个参数是传入方法中的参数。

    setImmediate表示立即执行，它是宏任务，回调函数会被放置到事件循环的check阶段。
    在应用中如果大量的计算型任务，它是不适合放在主线程中执行的，因为计算任务会阻塞主线程，主线程一旦被阻塞，其他任务就需要等待，
    可以通过setImmediate方法将任务放入事件循环中的check阶段，因为代码在这一个阶段执行不会阻塞主线程，也不会阻塞事件循环
     

    • 兼容性: 主要支持IE10和IE11，以及一些较旧版本的Edge浏览器。
    • 用法: setImmediate用于将函数排入宏任务队列，以便在当前任务完成后立即执行。示例：
    1. function sleep(delay) {
    2.   var start = new Date().getTime()
    3.   while (new Date().getTime() - start < delay) {
    4.     continue
    5.   }
    6.   console.log('ok')
    7. }
    8.  
    9. console.log('start')
    10. setImmediate(sleep, 2000)
    11. console.log('end')

    先打印出start，然后再打印end,最后等待2000ms后打印ok。 

    setTimeout:

    • 兼容性: 在Node.js和几乎所有现代浏览器中都支持。
    • 用法: setTimeout用于在一定时间后将函数排入宏任务队列。它是处理异步操作的常用方法。示例：
    1. setTimeout(() => {
    2.   // 这里执行宏任务
    3. }, 1000);

    异步任务---函数封装

    •  1.定义函数
    •  2.调用核心api（queueMicrotask，MutationObserver，setTimeout）
    •  3.使用封装的函数

     在then方法中使用无论promse是啥状态都需要直接或者间接的执行回调函数

    1. /**
    2.  * 异步任务--函数封装
    3.  * 1.定义函数
    4.  * 2.调用核心api（queueMicrotask，MutationObserver，setTimeout）
    5.  * 3.使用封装的函数
    6.  */
    8. //1.定义函数
    9. function runAsyncTask(callback) {
    10.   //  2.调用核心api（queueMicrotask，MutationObserver，setTimeout）
    11.   if (typeof queueMicrotask === "function") {
    12.     queueMicrotask(callback);
    13.   } else if (typeof MutationObserver == "function") {
    14.     const obs = new MutationObserver(callback);
    15.     const divNode = document.createElement("div");
    16.     obs.observe(divNode, { childList: true });
    17.     divNode.innerHTML = "贾公子";
    18.   } else {
    19.     setTimeout(callback, 0);
    20.   }
    21. }
    22.  
    23. const PENDING = "pending";
    24. const FULFILLED = "fulfilled";
    25. const REJECTED = "rejected";
    26.  
    27. class MyPromise {
    28.   state = PENDING;
    29.   result = undefined;
    30.   #handlers = [];
    31.   constructor(func) {
    32.     const resolve = (result) => {
    33.       if (this.state == PENDING) {
    34.         this.state = FULFILLED;
    35.         this.result = result;
    36.         this.#handlers.forEach(({ onFulfilled }) => {
    37.           onFulfilled(this.result);
    38.         });
    39.       }
    40.     };
    41.  
    42.     const reject = (result) => {
    43.       if (this.state == PENDING) {
    44.         this.state = REJECTED;
    45.         this.result = result;
    46.         this.#handlers.forEach(({ onRejected }) => {
    47.           onRejected(this.result);
    48.         });
    49.       }
    50.     };
    51.  
    52.     func(resolve, reject);
    53.   }
    54.  
    55.   then(onFulfilled, onRejected) {
    56.     onFulfilled = typeof onFulfilled === "function" ? onFulfilled : (x) => x;
    57.  
    58.     onRejected =
    59.       typeof onRejected === "function"
    60.         ? onRejected
    61.         : (x) => {
    62.             throw x;
    63.           };
    64.     // 3.使用封装的函数
    65.     if (this.state === FULFILLED) {
    66.       runAsyncTask(() => {
    67.         onFulfilled(this.result);
    68.       });
    69.     } else if (this.state === REJECTED) {
    70.       runAsyncTask(() => {
    71.         onRejected(this.result);
    72.       });
    73.     } else if (this.state === PENDING) {
    74.       this.#handlers.push({
    75.         // 成功或者失败后调用 onFulfilled
    76.         // onFulfilled 执行之后调用runAsyncTask（传入:promise传入的回调）
    77.         //runAsyncTask内部执行了回调 onFulfilled
    78.         onFulfilled: () => {
    79.           runAsyncTask(() => {
    80.             onFulfilled(this.result);
    81.           });
    82.         },
    83.         onRejected: () => {
    84.           runAsyncTask(() => {
    85.             onRejected(this.result);
    86.           });
    87.         },
    88.       });
    89.     }
    90.   }
    91. }
    92.  
    93. // 测试代码
    94. console.log("TOP");
    95. const p = new MyPromise((resolve, reject) => {
    96.   // resolve("success");
    97.   reject("error");
    98. });
    99. p.then(
    100.   (result) => {
    101.     console.log("成功回调", result);
    102.   },
    103.   (err) => {
    104.     console.log("失败回调", err);
    105.   }
    106. );
    107. console.log("BOTTOM");

  • 相关阅读:
    JSON.stringify()与Qs.stringify()区别 应用场景
    深度学习（PyTorch）——反向传播
    【设计模式】创建者模式_工厂、抽象工厂、建造者
    LLM在text2sql上的应用
    快手实时数仓保障体系研发实践
    from PIL import Image,文字成图，ImageFont import jieba分词，input优雅python绘制图片
    黄石市知识产权示范企业申报条件及奖励政策，2022年申报时间
    .NET Core中一些优秀的项目和框架
    学会这招，轻松实现英语文本转语音，巩固学习内容
    想找一个英文的二元分类数据集，类似sst2这种
  • 原文地址：https://blog.csdn.net/qq_63358859/article/details/134103048