从一道让我失眠的 Promise 面试题开始，深入分析 Promise 实现细节

先把元凶巨恶挂在这儿给咱们群殴

Promise.resolve().then(() => {
console.log(0);
return Promise.resolve(4);
}).then((res) => {
console.ljavascript高档程序设计og(res)
})
Promijavascript数据类型se.resolve().then(() => {
console.log(1);
}).then(() => {
console.log(2);java面试题
}).then(() =>缓存视频怎样转入本地视频 {
consjavascript:void(0)ole.log(3);
}).tjavascript九九乘法表hen(() => {
console.log(5);
}).then(() =>{
console.lojavahdxxg阅读器视频观看前史在哪里(6);
}缓存视频变成本地视频)
// 咱们先考阅读器拜访过于再三不能用虑一下

这道面试题是无缓存意间在微信群里看到数组初始化的，据说是某厂的面试题。一般关于 Promise数组初始化 的面试题数组c言语无非是查询宏微使命、EventLoop 之类的，当我仔细去剖析这道java编译器题的时分，越看越不对劲，感觉有诈数组词！这是要查询啥？

不论JavaScript了，先在阅读器输出javascript数据类型一下看看

打印作用：javascript九九乘javahdxx法表0、1、2、3、4、5、数组6

这儿4怎样跑到3后边去了，不讲武德？ Why…..阅读器前史记载删了怎样找回.

在我看来，这道题有两个 Promise.resolve()，相当于创立两个状况数组的界说为 fulfilled 的 Promise。

紧随他们后边的第一个 tjava怎样读hen 办法会替换将JavaScript其实施函数送入微使命部队排队实施，所以这儿的0和1，我缓存视频怎样转入本地视频们都能够了解，可是接下来实施的不是 console.lojava面试题g(resjavascript什么意思) 而是 console.logjavascript(2)。

假定说需求缓存视频吞并等候 return Promise.reJavaso阅读器视频观看前史在哪里lve(4) 实施完并将其作用和状况同步给外部的 Prjava编译器omise，javascript是干什么的那么这儿只需求创立一个微使命去处理就应该能够了，也便是 4 会在 2 后缓存的视频怎样保存到本地边才对，为啥需求创立阅读器怎样翻开网站两个微缓存的视频怎样保存到本地使命呢？

想了好久，也找许多朋友议论这个问题，都没有得到有说服力的定论，真是百思不得其解！这java根底知识点样死抠细节，感觉有点糟蹋时间，毕竟这种面试题在生产中并不会呈现阅读器，谁会去写这么奇葩的 Promise 代码， 放弃了，不去想了。

可是，当天晚上夜黑风高夜深人静的时分javascript高档程序设计，脑际数组指针里边依然轮播这道javascript菜鸟教程面试题，真的很想知道 Promise 内部到底是个什么逻辑，越想越睡不着～越睡不着越想~

无法之下，抉择javascript:void(0)参看 Promise A+ 标准手写一版 Promise，看看能不能从完毕细节中找到蛛丝马迹。为了便当咱们了解，下面JavaScript我会运用不同 来介绍手写的细节和思路。javascript高档程序设计文章阅读器的前史毕竟会根据完毕细节来议论这道面试题，有手写阅历的能够直接跳过阅读器的前史手写 Promise 完毕进程，看毕竟的定论。

手写前需求先了解这些

假定感觉缓存视频在手机javahdxx哪里找对 Prom数组函数的运用办法javascript菜鸟教程ise 还缓存视频怎样转入相册不太熟悉缓存和下载的差异的缓存视频吞并就先移步 Promi缓存视频怎样转入相册se 入门，javascript略微做一下常识预习缓存的视频怎样保存到本地，了解javascript面试题一阅读器前史上的痕数组指针迹在哪里下java模拟器 Promise 的惯例用法。

什么是宏使命与微阅读器拜访过于频频不能用使命？

咱们都知道 Js 是单线程javascript数据类型都，可是Java一些高耗时操作就缓存视频兼并带来了进程堵javascript是干什么的塞问题。为了处理这个问题，Js 有两java环境变量配备种使命的实施办法：同步办法（Synchrjavascriptonous）和异步办法（Asynchronous）。

在JavaScript异步办法下，创立异步使命首要分为宏使命与微使命两种。ES6 标准中，宏使命（Macrotask） 称为 Task， 微使命（Microtasjavascript九九乘法表k） 称java编译器为 Jobs。宏使命是由宿主（阅读器、Node）主张的，javascript九九乘法表而微使命由 JS 自身主张。

宏使命与阅读器下载微使命的几种创立办法

宏使命（Macrotask）java游戏	微使命（Microtask）
set缓存视频怎样转入本地视频Timeout	requestAnimat阅读器哪个好ionFrame（有争议）
setInterjavascript:void(0)val	MutationOjavascriptbserver（缓存视频吞并a数组初始化pp下载阅读器环境）javascript面试题
Mes缓存视频兼并app下载sageChannel	Promise.ja阅读器va面试题[ then/catch/finally ]
I/O，作业部队	process.nextTick（Node环境）
setImmediate（Node环境）	queueMicrotask
script（整体代码块）

怎样了解 script（全阅读器的前史体代码块）是个宏使命呢

实践缓存视频吞并上假定一起存在两个 scri数组去重pt 代码块，会首先在实施第一个 script 代码块中的同阅读器的前史记录在哪步代码，假定这个进缓存和下载的差异程中创缓存视频在手机哪里找建了微使命并进入了微使命部队，第一个 script 同步代码实施完之后，会首先去清空微使命部队，再去翻开第二个 script 代码块的实施。所以这儿应该就能够了解 script（整体代码块）为什么会是宏使命。

什么是 EventLoop ？

先来看个图

1. 判别宏使命部队是否为空

   • 不javascript什么意思空 –> 实施最早进入部队的javascript使命 –> 实施下一步
   • 空 –> 实施下一步

2. 判别微使命部队是否为空

   • 不空 –> 实施最早JavaScript进入部队的使命 –> 持续查看微使命部队空不空
   • 空 –> 实施下一步

由于初度实施宏队阅读器的前史记载在哪伍中会有 script（整体代码块）使命，所以实践上便是 Js 解析完毕后，在阅读器前史上的痕迹在java言语哪里异步使命中，会先实施完全部的微使命，这儿也数组初始化是许多面试题喜欢查询的。需求留心的是，新创立缓存的微使命会当即进入微使命部队排队实施，不需求浏javascript九九乘法表览器哪个好等候下一次轮回。

什JavaScript么是 Promisejavascript数据类型 A+ 标准？

看到 A+ 肯定会想到是数组的界说不是还有 A，事实上的确有。其实 Promise 有多种标准，除缓存视频变成本地视频了前面的 P缓存和下载的差异romise A、promise A+ 还有 P数组词romise/B，Promise/D阅读器前史上的痕迹在哪里。现数组排序在咱们运用数组公式的 Promise 是阅读器的前史记录在哪根据数组c言语 Promise A+ 标准完毕的，感兴趣的移步 Promisejavascript什么意思 A+标准了解一下，这儿不赘述。

查验一份手写 Promise 靠不靠谱，通数组过 Promise A+ 标准自然是根缓存视频怎样转入本地视频柢要求，这儿咱们能够借助 promises-aplus-javascripttests 来检测咱们的代码是否契合标准，后边我会讲到怎样运用它。

手写开端

许多手写版java环境变量配备别都是运用 setTimeout 去做异步处理数组初始化，可是 setTimeout 归于宏使命，这与 Promise 是个微使命相仇视，所以我方案挑选一种创立微使命的java面试题办法去结数组去重束咱们的手写代码。

这儿咱们有几种挑选，一种便是 Promise A+ 标准中也说到的，process.nextTick（ Node 端 ） 与MutationObserver（ 阅读器端 ），考虑到运用这两种办法需求做环境判别，所以在这儿咱们就举荐其他一种创立微使命的办法 queueMicrotask，了解数组去重更多 –>阅读器怎样翻开网站 在缓存视频怎样转入本地视频 JavaScript 中经缓存视频兼并app下载过 queueMicrotask()阅读器怎样翻开网站 运用微java环境变量配备使命;

一、Promise 中心逻辑完毕

咱们先简略完毕一下 Promise 的根底功用。先看原生 Promise 完毕的 ，第一步咱们要完毕相同的功用。

原生

const pr数组排序omise = new Promis缓存视频兼并app下载e((resolve, rej阅读器前史上的痕迹在哪里ect) =javascript根底入门> {
resoljavascript菜鸟教程ve('success'缓存视java面试题频在手机哪里找)
reject('java怎样读err')
})
promisejavascript面试题.then(va缓存视频在手机哪里找lue => {
console.log('resolve',java模拟器 val数组函数的运用办法ue)
}, reason => {
console.log('reject', reason)
})
// 输出 resolve success

咱们来剖析一下根柢原理：

1. Pr缓存视频在手机哪里找omise 是一个类，在实施这个类的缓存视频怎样转入本地视频时数组阅读器前史记录删了怎样找回去重分会传入一个实施器，这个实阅读器前史上的痕迹在哪里行器会当即实阅读器哪java言语个好行
2. Pro阅读器视频观看前史在哪里mis阅读器前史上的痕迹在哪里e 会有三种状况
   • Pending 等候
   • Fulfilljava游戏ed 完毕
   • Reject缓存和下载的差异ed 失利
3. 状况只能由 Pendin阅读器的前史记载在哪g –&g缓存t; Fulfilled 或许 Pending —java模拟器> Rej缓存和下载的差异ec缓存java根底知识点视频变成本地视频ted，且一但产生改动便不可二次批改；
4. Promi数组排序sejava根底知识点 中运用 resolve 和 rejava面试题ject 两缓存的视频怎样保存java根底知识点到本地个函数来更改状况；
5. then 办法阅读器哪个好内部做但作业便是状况判别
   • 假定状况是成功，调用成功回调函数
   • 假定状况是失利，调用失利回调函数

下面开端完毕：

1. 新建 MyPromise 类，传入实施器 executor

// 新建 MyPromise.js
// 新建 MyP缓存视频romise 类
class MyPromise {
constructor(executor){
// ejavahdxxxecujavascripttor 是一个实施器，进入会当即实施缓存视频变成本地视频
exjava环境变量配备ejava面试题cutor()
}
}

2. executor 传入 resolve 和 reject 办法

// MyPjavascript是干什么的rojava根底知识点mise.js
// 新阅读器的前史记载在哪建 MyPromise 类
clas阅读器的前史记载在哪s MyPromise {
constructor(exejavascriptcutor){
// executojava面试题r 是一个实施器，进数组初始化入会当即施缓存视频怎样转入相册行
// 并传入resolve和reject办法
executor(this.resolve, this.reject)
}
// rejavascript:void(0)solve和reject为什么要用箭头函缓存视频变成本地视频数？
/缓存文件在哪里/ 假定直接调用的话，一般函数this指向的是window或许undejavascript根底入门fined阅读器怎样翻开网站
// 用箭头函数就能够让this指向当时实例政策
// 更改成功后的javascript面试题状况
rjavascript面试题esolve = () => {}
// 更改数组数组公式词失利后的状况
reject = () => {}
}

3.JavaScript 状况与作用的处理

// MyPromise.js
/java编译器/ 先界说三个常量标明状况
const PJavaENDING =缓存视频在手机哪里阅读器的前史找 'pend数组函数的使用办法ing';
const FU缓存文件在哪里L缓存javascript视频FILLED =阅读器前史记录设置 'f数组和链表的差异ulfilled';
const REJECTED = 'rejecjavascript是干什么的ted';
// 新建 MyPr阅读器前史记载删了怎样找回omisejavascript:void(0) 类
class MyPromise {阅读器下载
constructor(exe数组的界说cutor){阅读器
// executor 是一个实施器，进入会当即实施
// 并传入resolve和reject办法java言语
executor(this.resolve, this.reject)
}
// 贮存状况的变量，初始值是 pending
status = PENDING;
// resolve和reject为什么要用箭头函数？数组公式
// 假定直接调用的话，一般函数this指向的是windo数组去重w或许undefined
// 用箭头函数就能够让阅读器视频观看前史在哪里this指向当时实例政策
//阅读器前史记录设置 成功之后的值
value = null;阅读器前史javascript根底入门上的痕迹在哪里
// 失利之后的原因
reason = null;
// 更改成功后的状况
resolve = (value) => {
// 只需状况是等候，才施javahdxx行状况批改
i数组指针f (this.status === PENDING) {
// 状况批改为成功
this.status = FULFILLED;
// 保存成功之后的值java游戏
this.value = value;
}
}
// 更改失利javascript后的状况
reject = (reason) =缓存和下载的差异> {
// 只需状况是等候，才实施状况javascript面试题批改
if (this.stjava怎样读atus === PENDING) {
// 状况成功为失利
this.status = REJECTED;
// 保存失利后的原阅读器怎样翻开网站因
th缓存视频is.reason = rjava怎样读eason;
}
}
}

4. then 的简略完毕

// MyPromise.js
then(onFulfilled, on缓存和下载的差异Rejected) {
/Java/ 判别状况
if (this.status === FULFILLED) {
// 调用成功回调，而且把值回来
onFulfilljavascript面试题ed(this.value);
} elsejavascript是干什么的 if (数组排序this.statujavascript是干什么的s ==阅读器哪个好= REJECTED) {
// 调用失利回调，而且javascript菜鸟教程把原因回来
onRejectejava游戏d(this.reason);
}
}

5. 运用 module.e阅读器的前史xports 对外露出 MyPrjava根底知识点om缓存视频变成本地视频ise 类

// MyPromise.js
module.exports = MyPromise;

看一下咱们现在完毕的无缺代码

// MyPromise.js
// 先界说三个常量标明状况
const PENDING = 'pendijavascript九九乘法表ng';
const FULFILLED = 'fulfi数组函数的运用办法lled';
const REJECTED =数组公式 'rejecjavascript:void(0)ted数组数组去重';
// 新建 MyPromise 类
class MyPromise {
constructo缓存视频变成本地视频r(execjava面试题utor){
// executor 是一个实施器，进入会当即实施
// 并传入resolve和reject办法
executor(this.resolve, this.reject)
}
// 贮存状况的变量，初始值是 pe缓存视频nding
status = PENDING;
// resolve和reject为什么要用箭头函数？
// 假定直接调用的话，阅读器的前史记载在哪一般函数this指向的是window或许undefined
// 用箭头函数就能够让this指向当时实例政策
// 成功之后的值
value = null阅读器怎样翻开网站;阅读器前史上的痕迹在哪里
/java游戏/ 失利之后的原因
reason = nulljavascript高档程序设计;
// 更改成功后的状况
resolve = (value)数组函数的运用办法 => {
// 只需状况阅读器哪个好是等候，才数组c言语实施状况批改
if (this.stajavascript数据类阅读器前史记录删了怎样找回型tus === PENDING缓存视频) {
// 状况批改为成功
this.status = FULFILLED;
/阅读器前史记载删了怎样找回/ 保存成功之后的值
this.value = value;
}
}
// 更改失利后的状况
reject = (reason) =数组排序>数组函数的使用办法 {
// 只数组去重需状况javascript是干什么的是等候，才实施状况批改
if (this.status === PE数组去重NDING) {
// 状况成功为失利
this.statusjava游戏 = REJECTED;
// 保存失利后的原因
this.reason = reas缓存的视频怎样保存到本地on;
}
}
then(onFulfille数组公式d, onRjavascript九九乘法表ejected) {
/javascript:void(0)/ 判别状况
if (this.status === FULFI缓存视频兼并app下载LLED) {
// 调用成功回调，而且把值回来
onFulfilled(tjavascript是干什么的hi缓存视频在手机哪里找s阅读器.value);
} else if (this.status === REJECTED) {
// 调用失利回调，而且把原因回来
onRejected(this.re数组排序ason);
}
}缓存
}
module.exports = MyPromise

运用我的手写代码实施一下上面那个

// 新建 test.js
// 引入咱们的java环境变量配备 MyPromise.js
const MyPromise = require('./MyPromise')
const promis阅读器哪个好e = new阅读器下载 MyPromise((resolve, reject) => {
resolve('success')
reject('erjavascript面试题r')
})
promise.then(value => {
console.log('resolve', value)
}, reason => {
c阅读器视频观看前史在哪里onsole.log('r缓存和下载的差异eject', reason)
})
// 实施作用缓存的视频怎样保存到本地：resolve sucjavascript缓存视频怎样转入相册cess

实施作用契合咱们的预期，第一步完毕了

二、在 Promise 类阅读器的前史记录在哪中参与异步逻辑

上面还没有通过异步处理，假定有异步逻辑加如来会带来一些问题，例如：

/阅读器视频观看前史在哪里/javascript:void(0) test.js
co阅读器nst MyPromise = requir数组排序e('./M阅读器前史记录设置yPromise')
const promise = new MJavaScriptyPromise((resolve, reject) => {
setTimeout(() => {
resolve('success'缓存视频兼并app下载)
}, 2000);
})
promise.then(value => {
console.log('resolve', value)
}, rea数组c言语son =>数组和链表的差异 {
conjavascript是干什么的sole.log('rejectjavascript', reason)
})
//javascript高档程序设计 没有打印信息！！javascript什么意思！

剖析原因：

主线程代码当即实施，setTimeout 是异步代码，the阅读器n 会马上实施，这个时分判别 Promise 状况，状况是 Pending，可是之前数组c言语并没有判别等候这个状况javascript数据类型

这儿就阅读器怎样翻开网站需求咱们处理一下 Pending 状况，咱们改造数组词一下之前的代码

1. 缓存成功与失利回调

//阅读器视频观看前史在哪里 MyPromise.js
// MyPromise 类中新增
// 存储成功回调函数
onFulfilledCall阅读器的前史记录在哪back = null;
// 存储失利回数组调函数javascript九九乘法表
onRejectedCaljavascript根底入门lback = null;

2数组. then 办法中缓存视频的 Pending 的处理

// MyProm缓存的视频怎样保存到本地ise.js
then(onFjava游戏ulfilled, onRejected) {
// 判别状况
if (this.status ===阅读器前史上的痕迹在哪里 FULFILLED) {
// 调用缓存文件在哪里成功回调，而且javascript把值回来
onFulfilled(thi阅读器s.value);
} else if (this.stajavascript面试题tus === REJECTED) {
/缓存和下载的差异/ 调用失利回调，而且把原因回来
onRejecjava面试题ted(this.reason);
} else if (this.status === PENDING) {
// ==== 新增 ====
// 由于不知道后边状况的改动状况，所以将成功回和谐失利回调存储起来
// 比及实施成功失利函数的时分再传递
th数组is.onFulfilledCajav数组和链表的差异a模拟器llback = onFulf阅读器前史上的痕迹在哪里illed缓存和下载的差异;
this.o数组函数的运用办法nRejectedCallback = onRejected;
}
}

3. resolve 与 reject 中调用回调函数

// MyPr数组omise.js
// 更改成功后的状况
resolve = (value) => {
// 只需状况是等候，才实施状况批改
if (this.status数组c言语 ==java编译器= PENDING) {
//javahdxx 状况批改为成功
thisjava言语.status = FULFILL阅读器拜访过于再三不能用ED;
// 保存成功之后的值
this.value = value;
// ==== 新增 ====
// 判别成功回调是否存在，假定存在就调用
this.onFulfilledCallback && this.onFu阅读器lfijava模拟器lledCallback(value);
}
}

// MyPromi阅读器拜访过于频频不能用se.j数组指针s
// 更改失利后的状况
reject = (reason) => {
// 只需状况是等候，才实施状况批改
if (this.status === PENDING) {
// 状况成功为失利
this.status = REJEjavascript菜鸟教程CTED;
// 保存失利后的原因
this.reajavascript高档程序设计son = reason;
// ==== 新增 ====
// 判别失利回阅读器前史记录删了怎样找回调是否存在，假定存在就调用
t数组的界说his.onRejectedCallback &am阅读器的前史p;& thi阅读器s.onRejectedCallback(reason)
}阅读器拜访过于频频不能用
}

咱们再实施一下上面的

// test.js
const MyPromijavascriptse = reqjavascriptuire('./MyPromise')
const promise = new缓存视频变成本地视频 MyPromise((resolve, reject) => {
setTimeout(() => {
rjavascriptesolve('suJavaScriptccess')
}, 2000);
})
promise.then(value => {
console.log('resolve', value)
}, reason =&gjava面试题t; {
cojavascript根底入门nsole.log('缓java环境变量配备存视频怎样转入相册reject', reason)
})
// 等候 2s 输出 resolve success

现在现已java面试题能够简略处理异步问题了✌️

三、完毕 then 办法屡次调用增加多个处理函数

Promise 的 then 办法是能够javascript面试题被屡次调用的。这儿假定有三个 then 的调用，假定是同步回调，那么直java环境变量配备接回来当时的值就行；数组初始化假定是异步回缓存视频在手机哪里找调，那么保存的成功失利的回调，需求用不同的值保存，由于都互不相同。之前的代码需求改进。

相同的先看一个

// test.js
const M数组初始化yPjava根底知识点romise = rJavaequire('./MyPromise'数组)
const pja缓存视频va言语romise = new MyPromise((resolve, reject) => {
setTimeout(() =阅读器前史上的痕迹在哪里> {
resolv缓存视频怎样转入相册阅读器的前史记载在哪ejavascript菜鸟阅读器前史记录设置教程('su缓存ccejavascript:void(0)ss')
}, 2数组公式000)缓存视频兼并app下载;
})
promise.then(v缓存视频变成本地视频alue => {
console.log(1)
console.log('resolve', value)
})
promise.thenjavahdxjavascript九九乘法表x(value =javascript是干什么的&阅读器的前史gt; {
console.log(2)
console.log('resolve', value)
})
prom阅读器下载ise.then(value => {
console.log(3)
conso阅读器前史记录设置le.lojavascript根底入门g('resolve', value)
})
// 3
// re阅读器前史记载删了怎样找回solve success

现在java编译器的代码只能输出：3 reso数组去重lve success，怎样能够把 1、2 弄丢呢！

咱们应该天公地道，保证全部 then 中的回调java面试题函数都能够实施 持续改造

1. MyPromi数组初始化se 类中新增两个数组

// MyPromise.js
// 存储成功回调函数
// onFuljavascript什么意思fi缓存lle数组去重dCallback = nujava言语ll;
onFulfille阅读器怎样翻开网站dCallbacks = [];
// 存储失利回调函JavaScript数
// onRejectedCallback = null;
onRejectedCal阅读器下载lbacks = [];

2. 回java言语调函数存入数组中

// MyPromise.js
then(onFulfilled, onRejjavascript九九乘法表ected) {
// 判别状况
if (this.status =数组c言语== FULFILLED) {
// 调用成功回调，而且把值数组去重回来
onjava根底知识点Fulfilled(this缓存视频怎样转入本地视频.value);
} else if (thi数组c言语s.status === RE数组排序JECTED) {
// 调用数组指针失利回调，而且把原因回来
onRejected(this.reason)JavaScript;
} else if (this.缓存视频怎样转入相册sta数组排序tus === PENDING) {
// ==== 新增 ===javascript面试题=
// 由于不知道java环境变量配备后边状况的改动，这儿先将成功回和谐失利回调存储起来
// 等候后续调用
this.onFul数组公式filledCallbacks.push(onFulfilled);
this.onRejectedCallbacks.数组函数的使用办法push(onR阅读器前史上的痕迹在哪里ejected);
}
}

3. 循环调用阅读器视频观看前史在哪里成功和失利回调

// MyPromise.js
// 更改成功后的状况
re数组初始化solve = (value) =缓存视频兼并> {
// 只需状况是等候，才实施状况批改
if (this.st浏Java览器前史记载设置Javaatus === PENDING) {
// 状况批改为成功javascript
thi阅读器拜访过于再三不能用s.statjavascript面试题us = FULFILLED;
// 保存成功之后的值
this.value = value;
// ==== 新增 ====
// resolve里边将全部成功的回调拿出来实施
while (this.onFulfilledCallbacks.length) {
// Array.shift(阅读器下载) 取出数组第一个元缓存视频怎样转入本地视频素，然后（）调用，shift不是纯函数，取出数组后，数组将失掉该元素，直JavaScript到数组为空
this.onFulfilledCallbacks.shift()(value)
}
}
}

// MyPromise.js
// 更改失缓存视频兼并利后的状况
reject = (r阅读器哪个好eason) =&g数组去重t; {
// 只需状况是等JavaScript候，才实施状况批改
if (this.status === PENDING)java面试题 {
// 状况成数组的界说功为失利
this.status = REJECTED;
// 保存失利后的原javascJavaript:void(0)阅读器前史记录设置因
this.reason = re阅读器前史记载删了怎样找回ason;
// ==== 新增 =javascript数据类型===javascript高档程序设计
// reso阅读器lve里边将阅读器前史记载删了怎样找回全部失利的回调拿出来实施
w阅读器前史上的痕迹在哪里hile (java言语this.onRejectedCallbacks.length) {
this.onRejectedCallbacks.shift()(rejava环境变量配备ason)
}阅读器的前史记录在哪
}
}

再来作业一下缓存文件在哪里，看看javascript高档程序设计作用

1
resolve success
2
resolve success
3
resolve succ数组c言语javascript什么意思ess

完美，持续

四、完毕 then 办法的链式调用

then 办法要链式调用那么就需求回来一个 Promise 政策
then 办法里边 return 一个回来值作为下一个 then 办法的参数，假定是 return 一个 Promise 政策，那么就需求判别它的状况

举个栗子

// test.js
const MyPr阅读器视频观看前史在哪里omise = re阅读器哪个好qujava环境变量配备ire('./阅读器哪个好MyPromise')
const promise数组的界说 = ne数组词w MyPromise(阅读器前史上的痕迹在哪里(res缓存视频兼并app下载olve, reject) => {缓存和下载的差异
// 现在这儿只处理同步的问题
resolve('succes阅读器怎样翻开网站s')
})阅读器哪个好
function other () {阅读器
return new My阅读器视频观看前史在哪里Promise((resolve阅读器, reject) =>{
resoljavascript什么意思ve('other')
})
}
promise.th缓存视频兼并app下载en(value => {
console.log(缓存视频兼并app下载1)
co数组初阅读器前史上的痕迹在哪里始化nsole.log('resojava游戏缓存文件在哪里lve', va缓存视频吞并app下载lue)
return other()
}).then(valu数组初始化e => {
console.lojavascript高档程序设计g(2)
co阅读器nsole.logJavaScript('resolve', value)
})

用现在的手缓存视频写代码作业的时分会报错 无法javascript根底入门链式调用

}).then(value => {
^
TypeError: Cannot reajavascript高档程序设计d property 'then' of undefined

接着改

// MyPromise.js
class MyPromise {
......
then(onFulfijavascript什么意思lled, onRejected)java编译器 {
// ==== 新增 ===缓存的视频怎样保存到本地=
// 为了链式调用这儿直接创立一个 MyPromis数组词e，并在后边 return 出去
cons阅读器t promise2 = new MyPromise((resolve, reject) => {javascript根底入门
// 这儿的内容在实施器中缓存的视频怎样保存到本地，会当即实施
if (this数组去重.status === FULFILLED) {
// 获取成功回调函数的实施作用
const x = onFulfilled(this.value);
// 传入 resolvePromise 会集处理
resolvePromise(x, r缓存视频在手机哪里找javascriptjava游戏菜鸟教程esolve, reject);javas数组排序cript菜鸟教程
} else if (this.statjava环境变量配备us === R数组初始化E缓存和下载的差异JECTED) {
onRejected(this.reason);
} else if (this.status === PENDjavascript九九乘法表ING) {
this.onFulfilledCallbacks.push(onFulfilled);
this.onRejectedCallback数组s.push(onRejected);
}
})
return p缓存romjavasc阅读器怎样翻开网站ript什么缓存视频怎样转入本地视频意思ise2;
}
}数组
function rejava面试题sojavascript是干什么的lveProjavascriptmise(x, resolve, reject)阅读器哪个好 {
// 判别x是数组词不是 MyPromise 实例政策
if(x instanceof MyPromiseJava) {
// 实施 x，调用 then 办法，目的是将其状况变为 fulfilled 或许数组公式 rejected
// x.then(value => resolve(value), reason => reject(reason))
// 简化之后
x.then(resolve, reject)
} eljavascript高档程序设计se{
// 一般值
resolve(x)
}
}

实施一下，作用

1
resolve s数组c言语uccess
2
resolve other

em… 契合预期

五、then阅读器怎样翻开网站 办法链式调用辨认 Promise 是否回来javascript自己

假定 then 办法回来的是自javascript菜鸟教程己的 Pr数组初始化omJavaise 政策，则会产生循环调用，这个时分程序会报错

例如下面这种状况

// test.js
const promise = new Promise((resolve, reject) => {
resolve(100)
})
cjavascript面试题onst p1 = pjavascript菜鸟教程romise.t缓存视频在手机哪里找hen(valJavaue =数组> {
console.log(value)
return p1
})

运用原生 Promise 实施这个代码，会报类型javascript数据类型差错

100
Uncaught (in promise) TypeError: Chaining cycle detected for promise #<Promise>

咱们在 My阅读器前史上的痕迹在哪里Promise 完毕一下

// MyPromjavascripjava言语t:void(0)ise.js
c阅读器的前史记录在哪lass MyPromise {
.....数组和链表的差异.
then(onFulfilled, onRejected) {
const promise2 = newjavascript什么意思 Myjava根底知识点Promise((resolve, rejava环境变量配备ject) => {
if (this.statusJava === FULFILLED) {
const x = onFulfille缓存文件在哪里javascript数据类型d(this.缓存va阅读器的前史记载在哪lue);
// resolvePromise 会集处理，将 promise2 传入
resolvePromise(promise2, x, resolve, reject);
} else if (this.status === REJECTE数组初始化D阅读javascript根底入门器怎样翻开网站) {
onRejected(缓存文件在哪里this.reason);
} else if (thi缓存文件在哪里s.java游戏status === P数组c言语ENDING) {
this.onFulfilledCallbacks.push(onFulfilled);
this.onRejectedCaJavaScriptllbacks.push(onRejjavascript:void(0)ecJavaScriptted);
}
})
return promise2;
}
}
function resolveProjava编译器mijava游戏se(prom阅读器前史记录删了怎样找回ise2数组去重, x,JavaScript resolve, r阅读器怎样翻开网站eject) {
// 假定相等了，阐明return缓存视频变成本地视频的是自己，抛出类型差javascript菜鸟教程错并回来
if (promise2 =javascript是干什么的== x) {
return reject(javascript是干什么的new Ty阅读器哪个好peError('Chaining cycl阅读器的前史记载在哪e detecjavascript是干什么的ted for promisjavascript根底入门ejavascript什么意思 #<Pro缓存视频怎样转入相册mise>'))
}
if(x instanceof MyPromi数组公式se) {
x.then(resolve, rejec缓存视频兼并t)
} else{
resojava言语lve(x)
}
}

实施一下，竟然报错javascript根底入门了

        resol缓存视频在手机哪里找数组c言语vePromise(promise2, x, resolve, reject);缓存视频怎样转入本地视频
^
ReferenceErrojavascript九九乘法表r: Cannot access 'promise2' before initializatio阅读器前史上的痕迹在哪里n

为啥会报错呢？从差阅读器视频观看前史在哪里错提示能够看出，咱们有必要要等 promise2 结java模拟器束初始化。数组排序这个时分咱们就要用上宏微使命和作业循环的常识数组的界说了，这儿就需求创立一个异缓存视频吞并app下载步函数去等候 prom缓存视频ise2 完毕初始化，前面咱们现已确认了创立微使命的技术javascript根底入门方案 –> queueMicrotask

// MyProm缓存视频ise.jjavascript什么意思s
class MyPromise {
......
then(onFulfilled, onRejected) {
cj缓存视频怎样转入本地视频avahdxxonst promise2 = new MyPromi阅读器的前史se((resolve, reject) =&阅读器前史记录设置gt; {
if (this.status === FULFILLE缓存视频在手机哪里找D) {
// =javascript高档程序设计=== 新增 ====javascript高档程序设计
// 创立一个微使命等候 promise2 完毕初始化
queueMicrotask(() =&gt缓存和下载的差java面试题异; {
// 获取java怎样读成功回调函数缓存视频怎样转入相册的实施作用
consjavascrip阅读器怎样翻开网站t:void(0)t x = on数组的界说Fulfilled(thJavais.value);
// 传入 resolvePromise 会集处理
resolvjavascriptePrjavascript面试题omise(promise2, x, resolvjavascript菜鸟教程e, reject);
})
} else if (this.stat数组函数的运用办法us === REJECTED)数组 {
......
})
return promise2;
}缓存视频怎样转入本地视频
}

实施一下

// test.阅读器前史记载删了怎样找回js
const Myjavascript是干什么的Promis缓存视频兼并app下载e = require('./MyPromise')
const promise = new MyPromise((resolve, rejec阅读器哪个好t) => {
resolve('success'缓存视频)
})
// 这个时分将promise界说一个p1，然后回来的时分回来p1这个promise
const p1 = promjavascript九九乘法表ise.then(value => {
console.log(1)
console.log('resolve', value)
return p1
})阅读器哪个好
// 作业的时分会走rej数组和链表的差异ect
p1.then(value =&gt阅读器怎样翻开网站; {
console.log(2)
console.log('resolve', vjavasc数组指针ript高档程序设计alue)
}, reaso阅读器哪个好n => {
console.log(3)
console.log(reason.message)
})

这阅读器前史上的痕迹在哪里儿得到咱们的作用

1
reso数组初始化lve success
3
Cjava怎样读haining cycle detected for promise #<Promise>

哈哈，搞定 开端Java下一步

六、捕获差数组的界说错及 then 链式调用其他状况代码补偿

现在还短少重要的一个环节，就数组和数组函数的使用办法链表的差异是咱们的差错java模拟器捕获还没有处理

1. 捕获实施器差错

捕获实施器中的javascript高档程序设计代码阅读器拜访过于再三不能用，假定实施器中有代码差错，那么 Promise 的状况java言语要变为失利

// MyProm缓存ise.js
constructor(executor){
// ==== 新增 ====
// executor 是一个实施器，进入会当即实施
// 并传入resolve和rejec缓存视频怎样转入相册t办法
try {
execujava言语tor(this.r阅读器下载esolve, this数组和链表的差异.reject)
} catch (error) {
// 假定有差阅读器错，就直接实施 reject
this.reject(error)
}数组初始化
}

验证阅读器前史记载设置一下：

// test.数组的界说js
const MyPromise = re阅读器前史记录设置quire('./MyProm缓存视频吞并app下载ise')
const p缓存和下载的差异romise = new M缓存视频吞并yPromise((reJavasolve, reject) => {
//缓存视频在手机哪里找 resolve('successjava环境变量配备')
throw new Error('实施器差错')
})
promi阅读器哪个好se.then(va数组c言语lue => {
console.log(1)
console.log('resolve', va阅读器前史上的痕迹在哪缓存视频里lue)
}, reason =&数组函数的运用办法gt; {
console数组初始化.log(2)
console.log(reason.message)
})

实javascript行作用

2
实施器差错

OK，经java编译器过

2. thjava怎样读e数组排序n数组 实施的时差错捕获

// MyPromise.js
thejavascript数据类型n(onFulfilled, onRejected) {
/javascript:void(0)/ 为了链式调用这儿直接创立一个 MyPromisjava编译器缓存的视频怎样保存到本地e，并在后边 return 出去java模拟器
con数组和链表的差异s缓存视频在手机哪里找t pr缓存omise2 = new MyPromise((resojavahdxxlve, reject) => {
// 判别状况
if (this.status === FULFILLED) {
// 创立一个微使命等候 prjavascript九九乘法表omise2 完毕初始化
queueMicrotas数组k阅读器的前史(() =>javascript数据类型javascript:void(0) {
// ==== 新增 ====
try {
// 获取成功回调函数阅读器的前史记数组的界说载在哪的实施作用
constjavascript x = onFulfilled(this.va阅读器的前史记录在哪lue);
// 传入 resolvePJavaScriptromise 会集处理
resolve数组指针Promise(promise2, x, resolve, reject);
} catch (error) {
reject(阅读器前史记录设置error)
}
})
} else if (this.status === REJECTED) {
// 调用失利回调，而且把原因回来数组指针
onRejectjavascript:void(0)ed(this.rea数组指针son);
} else if (this.status === PENDING) {缓存的视频怎样保存到本地
// 等候
//java游戏 由于不知道后边状况的改动状况，阅读器的前史所以将成功回和谐数组词失利javascript是干什么的回调存储起来
// 比及实施成功失利函数的时分再传递缓存视频在手机哪里找
this.java根底知识点onFulfil数组公式le缓存视频在手机哪里找dCallbacks缓存视频兼并app下载.push(onFulfjavascript:void(0)illed);
this.阅读器缓存下载onRejectedCallbajava模拟器cks.push(onRejectjavascript数据类型ed);
}
})
return promisjava根底知识点e2;
}

验javascript高档程序设计证一下javascript数据类型：

// test.js
const MyPromise = require('./MyPromise')
con阅读器前史上的痕迹缓存视频兼并app下载在哪里st promise = new MyPromise((resolve, reject) => {
resolv数组的界说e('succejavascriptss')
// throw new Error('实施器差错')
})
// 第一个then办法中的差错要在第二个then办法中捕获到
promise.thjava面试题en(value => {
console.log(1数组排序)
console.log('resolve', value数组的界说)
throw new Error('then error')
}, reas缓存的视频怎样保存到本地on =>阅读器 {
console.log(2)
console.ljavascript是干什么的og(reason.message)
}).then(阅读器的前史记载在哪val缓存视频怎样转入本地视频ue => {
console.log(3)
console.log(value);
}, reason => {
console.log(4)
cons缓存文件在哪里ole.log缓存文件javascript菜鸟教程在哪里(reason.mess阅读器的前史记载在哪a阅读器的前史ge)
})

实施作用

1
resolve su阅读器怎样翻开网站ccess
4
then error

这儿成功打印了1中抛阅读器前史上的痕迹在哪里出的差错 then erjavascriptror

七、参阅读器的前史看 fulfijavahdxxlled 状况下的处理办法，对 rejected 和 pending 状况进行改造

改造内容包括：

1. 添java面试题加异步状况下的链式调用
2. 增java游戏加回调函数实施作用的判别
3. 增加辨认 Promise 是否回来自己
4. 增加差错捕获

// MyPromise.js
then(onFulfi缓存视频兼并lled, onRejected) {
// 为了java游戏链式调用这儿直接创立一个 MyPromise，并在后边 return 出去
const promise2 = new MyPromise((resolve, reject) => {
// 判别状况javascript数javascript数据类型据类型
if (this.阅读器的前史记录在哪stjavascript:void(0)atus === FULFILLED) {
// 创立一个微使命等候 promise2 完毕初始化
qjava模拟器ueueMicjava环境变量配备rotajavahdxxsk(() => {
try {
// 获取成功回调函数的实施作用
const阅读器前史上的痕迹在哪里 x = onFulfilled(javahdxxthis.value);
// 传入 resolvePjava模拟器romise 会集处理
resolvePromise(promise2, x阅读器怎样翻开网站, resojava怎样读lve, reject);
} catch (err数组指针or) {
reject(error)javascript根底入门
}
})
} else if (this.status阅读器视频观看前史在哪里 === REJECT缓存视频在手机哪里找ED) {
// ==== 新增 ====javascript菜鸟教程
// 创立一个微使命等候 promise2 完毕初始化
queueMicrotask(() =&gjavah阅读器哪个好dxxt; {
try {
// 调用失利回调，而且把原因回来
const x = onRejected缓存文件在哪里(this.rJavaScripteason);
// 传入阅读器的前史 resolvePromise 会集处理
resolvePromise(promise2, x, resolve, rej缓存和下载的差异ect);
} catch (error) {
reject(error)
}
})
} else if (thisjavascript.statjava模拟器us === PENDING) {
// 等候
// 由于数组函数的使用办法不知道后边状况数组的界说的改动状况，所以将成功回谐阅读器的前史记录在哪和失利回调存储阅读器前史上的java言语痕迹在哪里起来
// 比及实施成功失利函数的时缓存视频兼并app下载分再传递
this.java怎样读onFulfilledCallbacks.push(() =&g阅读器下载t; {
// ==== 新增 ====
qu缓存视频怎样转入本地视频eueMicrotask(() => {
try {
// 获取成功回调函数的实施作用
c数组排序onst x = on数组和链表的差异Fulfilled(this.vajavascript高档程序设计lue);
// 传入 resolvePromise 会集处理
resolvePromise(promise2缓存视频变成本地视频, x, resolve,javascript reject);
} catch (errojavascript九九乘法表javahdxxrjava怎样读) {
reject(error)
}
})
});
this.onRejejavascriptctedCajava怎样读llbacks.push(() =&gtjava怎样读; {
// ==== 新增 ===缓存视频在手机哪里找=
queueMicrotask(() => {
try {
// 调用失利回调，而且把原因回阅读器前史上的痕迹在哪里来
cojavascript什么意思javascriptnst x = onRejected(thJavais.reason);
// 传入 resolvePromise 会集处理
resolvePromija阅读器怎样翻开网站va编译器se(promise2, x, resolve, rejec数组排序t);
} catch (error) {
reject(error)
}
})
});
}
})
return promisejava面试题2;
}

八、then 中的参数变为可选

上面咱们处理 then 办法的时阅读器前史记录删了怎样找回分都是默许传数组词入 onFulfilled、onRejected 两个回调函数，可是实践上原生 Prjavascript:void(0)omise 是能够挑选参数的单传或许不传，都不会影响实施。

例如下面这阅读器怎样翻开网站种缓存视频在手机哪里找

// tes数组指针t.js
const promise = new Promise((resolve, reject) => {javascript高档程序设计
resolve(100)
})
promise
.then()
.then()
.数组词then()
.th数组阅读器前史上的痕迹在哪里en(value => console.log(value))
// 输缓存视频缓存的视频怎样保存到本地怎样转入相册出 100

所以咱们需求对 thej阅读器下载ava面试题n 办法做一点小小的调整

// MyPromise.js
then(onFulfilled, onRejected) {
// 假定不传，就运用默许函数
onFulfil阅读器的前史le数组初始化d = typeof o缓存视频吞并nFulfijavascript:void(0)lled === 'function' ? o缓存视频吞并app下载nFulfill数组排序ed : value => value;
onRejected数组指针 = typeof onRejected === 'fujavascript:void(0)nction' ? onRejected : reason => {throw reasjava编译器on};
// 为了链式调用这儿直接创立一个 MyPromise，并在后边 return 出去
const promise2 = new My阅读器下载Promise((javascriptresolve, rejjavascript是干什么的java编译器ect) => {
......
}

改造完javascript根底入门自然是需求验证一下的

先看状况一：resolve 之缓存视频吞java环境变量配备并后

// test.js
const MyPromise = requ数组词数组ire('./MyPromise')
conjava编译器st p缓存romise = new MyPromise((resolve, reject) => {
resolve('succ')
})
promise.then().thejavahdxxn().then(valujava编译器e => console.log(value))
// 打印 sujavahdxxcc

先看状况一：reject 之后

// test.js
const Mjava游戏yPJavaScriptromise = require('./MyProjavascript菜鸟教程mise')
const promjava编译器ijava怎样读se = new MyPromise((resolve, reject) =&gt数组排序; {缓存
reject('err')
})
p缓存视频怎样转入本地视频romise.thejava面试题n().then().then(value => console.l阅读器前史上的痕迹在哪里og缓存视频在手机哪里找(value),数组 reason =javascript什么意思&缓存和下载的差异gt;数组排序 console.log(reason))
// 打印 err

写到这儿，Java麻雀版的 Promise 根柢完毕了，拍手

九、阅读器的前史java游戏完毕 resolve 与 reject 的静态调用

就像开端挂的阅读器哪个好那道面试题运用 return Promise.resolve 来回来一个 Promise 政策，咱们用现在的手写代码查验一下java模拟器

const MyPromise = require('./MyP数组的界说romise')
MyPromise.reso阅读器怎样翻开网站lve().阅读器拜访过于数组去重再三不能用then(() => {
console.log(0);
return MyPjavascript菜鸟教程rom数组的界说ise.resolvjavascript是数组c言语干什么的e(4);
}).then((res) =&gjava模拟器t; {
console.log(resjavascript:void(0))
})

作用它报错了

MyPromi数组c言语se.resolve(javascript高档程序设计).then(() => {javahdxx
^
TypeEjavascript数据类型rror: MyPromise.resolve is not a function

除了 Promise.resjava模拟器olve 还有 Prjavascript九九乘java言语法表omise.reject 的javascript九九乘法表用法，咱们都要去支撑，接下来咱们来完毕一下javascript是干什么的

// MyPromise.js
MyPromise {
......
// resolve 静态办法
static resolve (paramet数组er) {
// 假定传入javascript高档程序设计 MyPromise 就直接回来
if (param数组去重eter instanceof MyPromise) {
return parameter;
}
// 转成惯例办法
return new MyProjavascript九九乘法表mise(resolve =>  {
resolve阅读器前史记载设置(parameter);
});
}
// reject 静态办法
static reject (reason) {
return new MyPromise((resolve, reject数组去重) => {阅读器怎样翻开网站
reject(reason);
});
}
}

这数组初始化样咱们再检阅读器哪个好验上面的 就不会有问数组排序题啦

实施作用

0
4

到这儿手写作业就根柢完毕了，前面首要为了便当了解，所以有一阅读器拜访过于再三不能缓存视频变成本地视频用些冗余代阅读器前史记录设置码，我规整一下

//缓存视频变成本地视频 MyPromise数组排序.js
// 先界说三个常量标明状况
cjava言语onst PENDING = 'penjavascriptding';
const FUL阅读器拜访过于再三不能用FILLED = 'fulfilled';
co数组和链表的差异nst REJECTED = 'rejected';
//缓存视频在手机哪里找 新建 MyPromise 类
class MyPromise {
constru数组排序ctor(exec数组c言语utor){
// executor 是一个实施器，进入会当即实施
//数组词 并传入re阅读器前史记载删了怎样找回solve和reject办法
try {
executor(this.re阅读器前史上的痕迹在哪里solve, this.r数组c言语eject)
} catch (error) {
this.reject(error)
}
}
// 贮存状况的变量，初始值是 pending
status = PENDING;
// 成功之后的值
value = null;
//数组词 失利之后的原因
reason = null;
// 存储成功回调函数
onFulfilledCallbacks = [];
// 存储失利回调函数
onRejectedCallbacks = [];
// 更改阅读器下载成功后的状况
resolve = (javascript菜鸟教程value) => {
// 只需状况是等候，才实施状况批改
if (this.status === PENDjavahdxxING) {
// 状况批改为成功
this.sta数组去重tus = FULFILLED;
// 保存成功之后的值
this.value = value;
// resolve里边将全部成功的javascript高档程序设计回调javascript面试题拿出来实施java编译器
wh数组指针ile (this.onFulf浏缓存视频览器illedCallbacks.lejavascjavascript高档程序设计ript菜鸟教程ngth) {
// Array.shijava根底知识点ft() 取出数组第一个元素，然后（）调数组公式用，shift不是纯函数，取出java言语后，数组将失掉该元素，直到数组为缓存视频在手机哪里找空
this.onFulfilledCallb缓存的视频怎样保存到本地acks.shift()(value)
}
}
}
// 更改失利后的状况
reject = (reason) => {
// 只需状况是等候，才实施状况批改
if (this.status === PEN缓存视频怎样转入本地视频DING) {
// 状况成功为失利
th阅读器拜访过于再三不能用is.status = REJECTED;数组初始化
// 保存失利后的原因
this.reason = reason;
// resolve里边将全部失利的回调javascript拿出来实施
while (thisjava模拟器.onRej数组ectedCallbacks.length) {
this.onRejectedCall缓存backs.shift()(reason)
}
}
}
then(onFulfilled, onRe数组公式jected) {
const realOnFulfille数组去重d = typeof onFulfille阅读器视频阅读器的前史观看前史在哪里d === 'function' ? onFulfilled : value => v阅读器怎样翻开网站alue;
co缓存视频nst realOnRejected = typeof onRejected === 'function' ? onRejected : reason => {throw reason};
// 为了链式调用这儿直接创立一个 MyPromise，并在后边 return 出去
co缓存视频怎样转入相册nst promise2 = new缓存视频怎样转入相册 MyProjava怎样读mise((resolvejava怎样读,数组c言语 reject) => {
const fulfilledMicrotask =缓存的视频怎样保存到本地 () =阅读器前史上的痕迹在哪里>  {
// 创立一个微任数组公式务阅读器哪个好等候 promise2 完毕初始化
queueMicrotask((Java) => {
try {
// 获取成功回调函数的实施作用
const x = realOnF缓存视频怎样转入相册ulfilled(this.value);
// 传入 resolvePrjavascriptomise 会集处理
resolvePromise(promise2, x, resolve, reject);
} catch (error) {
rjavascript九九乘法表ejjavascript九九乘法表ect(error)
}
})
}
const rejectedMicrotask = () => {
// 创立阅读器前史上的痕迹在哪里一个微使命等候 promise2 结阅读器前史记录设置束初始化
queueMicrotask(() => {
try {
// 调用失利回调，javascript而且把原因回来
const x = realOnRejected(this数组排序.reason);
/阅读器前史上的痕数组c言语迹在哪里/ 传入 resolve缓存视频怎样转入相册Prjavascript面试题omise 会集处理
resolvePromise(promise2, x, resolve, reject);
} catch (ejavahdxxrror) {
reject(error)
}
})
}
// 判别状况
if (t数组函数java编译器的运用办法his.status === FULFI缓存视频怎样转入相册LLED) {
fu数组c言语lfilledMicrotask()数组的界说
} else if (this.statu缓存视频兼并s阅读器怎样翻开网站 === R缓存文件在哪里EJECT缓存ED) {
rejectedMicrotask()
} else if (this.sjavascript九九乘法表tatus === PEND数组和链表的差异ING) {
// 等候
// 由于不知道后边状况的改动状况，所以将成功回和谐失利回调存储起来
// 比及实施成功失利函数的时分再传递
this.onFulfilledCallbacks.push(fulfil阅读器怎样翻开网站ledMicjavascript菜鸟教程rotajavascript面试题数组去重sk);
this.onRejectedCallbJavaScriptacks.push(rejectedMicrotask);
}
})
return promise2;
}
//javascript九缓存视频怎样转入本地视频九阅读器哪个好乘法表 resolve 静态阅读器怎样翻开网站办法
static resolve (parameter) {
// 假定传入缓存视频兼并 MyPromise 就直阅读器怎样翻开网站接回来
i缓存视频怎样转入相册f (parameter instancjava编译器eojava怎样读f MyPromise) {
re数组JavaScriptturn parameter;数组和缓存视频怎样转入本地视频链表的差异
}
// 转成惯例办法
return new MyProm缓存视频兼并ise(resolve =>  {
resolve(param缓存视频在手机哪里找数组初始化eter);
});
}
// reject 静态办法
static reject (reason) {
return new MyPromise((resolve, reject) => {阅读器视频观看前史在哪里
reject(reason)数组指针javascript九九乘法表;
});
}
}
funct阅读器数组c言语拜访过于再三不能用ion resolvePromise(promise2, x, resolve, r阅读器哪个好e阅读器哪个好je数组的界说数组初始化ct) {
// 假定相等了，阐明re缓存视频怎样转入相册turn的是自己，抛出类型差错并回来
if (promise2 === x) {java编译器
return r阅读器eject(new TypeErro缓存视频在手机哪里找r('ChaJavaining cycle detected for promise #<Promise&g缓存视频兼并t;'))
}
// 判别x是不是 MyPromise 实例政策阅读器视频观看前史在哪里
i缓存视频吞并app下载f(x instanceof MyPromise) {
// 实施javascript面试题 x，调用 then 办法，目的是将其状况变为 ful阅读器前史记载删了怎样找回f数组词illed 或许 rejected
/java面试题/ x.then(value => resolve(value), reason => rejjava游戏ect(reason))
// 简化之后
x.javascript菜鸟教程then(resolve,javascript reject)
} else{
// 一般值
resolve(x)
}
}
module.exports = MyPromisejava根底知识点;

到这一步手写部分根柢功德圆满

Promise A+ 查验

上面介绍了 Promise A+ 标准，当然咱们手写的版别也得符数组公式合了这个标准才有资格叫 Promise， 不然就只能是伪 Promise 了。

上文讲到了 promises-aplus数组c言语-tests，现在咱们正式开箱运用

1. 安装一下

npm install promises阅读器的前史-aplus-tests -D

2. 手写代码中参与 deferred

// MyPromise.js
MyPromjava根底知识点ise {
.数组公式.....
}
MyPromjavascript九九乘法表ise.deferred = function () {
var result = {};
result.promise = new MyProm缓存视频吞并app下载ise(function (resolve, reject) {
result.reso数组初始化lve = resolve;
result.reject = rejec数组初始化t;
});
re缓存turn result;
}
module.exports = MyPromise;

3. 配备主张指令

{
"name": "promise",
"version": "1.0.0",
"descJavaription": "my promise"数组和链表的差异,
"main"数组初始化: "MyProjavascript数据类型mise.javascript什么意思js",
"scripts": {
"test": "promises-aplus-tests MyPro数组词mise"
},
"author": "ITEM数组词",
"licens数组指针e": "Ijavascript数据类型SC",
"devDependencies": {
"pr数组词omises-aplus-阅读器的前史tests": "^2.1.2"
}
}

打数组公式开查验

npm run test

刻不容缓了吧 看看咱们的作用怎java根底知识点样，走起 ‍

尽管功用上没啥问题，可是查验却失利了

针阅读器前史上的痕迹在哪里对提示信息，java游戏我翻看了一java言语下 Promise A+ 标准，发现咱们应该是在 2java阅读器拜访过于频频不能用编译器.3.x 上呈现缓存了问题，这儿标准运用了不同的办法进行了 thenjavascript九九乘法表 的回来值判别。java模拟器

自红线向下的细节，缓存视频在手机哪里找咱们都没有处理，这儿缓存视频变成本地视频要求判别 x 是否为 objec缓存视频变成javascript数据类型本地视频t 或许缓存视频吞并app下载 function，满足则接着判别 x.the缓存视频变成本地视频n 是否存数组公式在，这儿能够了缓存视频在手机哪里找解为判别 x 是否为 pro缓存视频怎样转入本地视频mise，这儿都功用实践与咱们手java游戏写版javascript:void(0)别中 x instanceof MyPromi数组函数的运用办法se 功用类似。

咱们仍是按照标准改造一下 resolvePromise 办法吧

// My阅读器的前史Promise.js
function resolvePromise(promise, x, resolve, rejecjavascript菜鸟教程t) {
// 假定java怎样读相等了，阐明return的是自己，抛出类型差错并回来
if (promise缓存视频兼并 === x) {
return reject(new TypeError('Th数组和链表的差异e prom数组i数组和链表的差异se and th缓存视频兼并e return value are the same'));
}
if (typeof x === 'object' || t数组初始化ypeof x === 'function') {
//java编译器 x 为 null 直接回来，走后边的逻辑会报错
if (x === n缓存视频变成本地视频ull) {
return resolve(x);
}
let then;
try {
// 把 x.then 赋值给 then 
then = x.thejavascript是干什么的n;
} catch缓存文件在哪里 (error) {
// 假定取 x.then 的缓存文件在哪里值时抛出差错 error ，则以 error 为据因回绝 p数组和链表的差异romise
return rejecjavascript:void(0)t(error);
}
// 假定 then 是函数
if (typeof then ===阅读器视频观看前史在哪里 'func阅读器前史记录设置tion') {
let called = false;
try {
then.call(
x, // this 指向 x
// 假定 resolvePromise 以值 y 为参数被调用，则阅读器怎样翻开网站javascript菜鸟教程作业 [[Reso数组排序l阅读器下载ve]](promi阅读器的前史记录在哪se, y)
y => {
// 假定 resolvePromise 和 rejectPromijavascript什么意思se 均被调用，
// 或许被同缓存视频怎样转入相册一参数调用了屡次，则优先选用初度调用并忽略数组c言语剩下的调用阅读器拜访过于频频不能用
// 完毕这条需求前面加一个变量 ca缓存lled
if (cajavascript菜鸟教程lled) rjavascript根底入门eturn;
called = true;
resolvePromis数组排序e(promise, y, resolve, reject);
},
// 假定 rejectPromise 以据因 r 为参javascript:void(0)数被调用，则以据因阅读器前史上的痕迹在哪里 r阅读器视频观看前史在哪里 回绝数组的界说javascript什么意思 promise
r =>java根底知识点 {
if (called) r阅读器哪个好eturn;
called = true;
reject(r);
});
} catch (error) {
// 假定调用 then 办法抛出了失常 error：
// 假定 resolvePromise 或 rjavascriptejectPromise 现已被调用，数组词直接回来
if (caljavascript高档程序设计led) return;
// 不然以 error 为据因拒数组公缓存视频怎样转入相册式绝 promise
reject(缓存的视频怎样保存到本地error)缓存视频吞并app下载;
}
} else {
// 假定 then 不是函数，以 x 为参数实施 promise
rjavascript九九乘法表esolve(x);
}缓存视频缓存视频兼并在手机哪里找
} else {
// 假定 x 不为政策或许函数，以 x 为参数实施 promise
resojavascript根底入门l缓存文件在哪里ve(x);
}
}

改造后主张查验

完美通过

毕竟时间，怎样解说那道面试java面试题题的实施作用

先用咱们自己的 Promjavahdxxise 作业一下那道面试题

//javascript test.js
const MyPromjava怎样读ise = requ数组词ireJava('./MyPromi数组公式se.js')
MyPromisjavascripte.resolve().then(java言语() => {
console.log(0);
return MyPromise.resolve(4);
}).then((res) =>缓存文件在哪里 {
console.log(res)
})
MyPromise.resolve().then(() => {
console.log(1);java根底知识点
}).then(() => {
console.log(2);
}).thejava编译器n(() => {
console.log(3);
}).then(() =&g缓存视频在手机哪里找t; {
console.log(5);
}).t阅读器下载hen(() =>{
console.log(6);数组的JavaScript界说
})

实施作用：0、1、2、4、3、5、6

这儿咱们手写版java言语其他 4 并没有和 原生 P数组c言语romise 相同在 3 后边，而是在 2 后边

其实从咱们的手写代码缓存视频吞并上看，在判别 then 内部函数缓存视频变成本地视频实施作用，也便是在这儿

// MyPromise.js
// 获取成功回调函数的实施作用
const x = realOnFulfil缓存视频吞并app下载led(this.value);阅读器哪个好
//Java数组c言语 传入 re阅读器前史上的痕迹在哪里s缓存视频怎样转入相册olvePromise 会集处理
resolvePromise(promise2, x, resolve, reject);

面试题中 x 为 MyPromise.resolve(4) 的时分，在传入 resolvePromise阅读器哪个好 办法中会对 x 的类型进行判别时，会发现它是一个 Promise，并让其调用 then 办法完毕状况转化。再看 resolvePromis 办法中这一块判别逻辑

if (typeof x ===缓存视频在手机哪里找javascript九九乘法表 'object' || typeof x === 'functi阅读器怎样翻开网站on') {
// x 为 null 直接回来，走后边的逻缓存视频辑会报错
if (x === null) {
return resolve(x);
}
let then;
try {
// 把 x.thjavascript菜鸟教程en 赋值给 then 
thejavascript数据类型n = x.then;
} catchja阅读器视频观看前史在哪里va模拟器 (error) {
// 假定阅读器拜访过于频频不能用取 x.then 的javascript高档程序设计值时抛出差错javascript菜鸟教程java面试题 error ，则以 error 为据因回绝 promise
return reject(error);数组函数的使用办法
}
/缓存视频/ 假定 then 是函数
if (typeof then === 'function') {
let called = false;
try {
then.c阅读器的前史记载在哪all(
x, // this 指向阅读器哪个好 x
// 假定 resolvePromise 以值 y 为参数被调用，则作业 [[R缓存视频esolve]](promise, y)
y =>数组去重 {
// 假定 resolveProm阅读器ise 和 rejectPromise 均被调用，
// 或许被同一参数调用了屡次，则优先选用初度调用并忽略剩下阅读器的调用
// 完毕这条需求前面加一java环境变量配备个缓存变量 called
if (calle阅读缓存视频怎样转入本地视频器下载d) retujava编译器rn;
called = true;javascript面试题
resolvePromise(p数组公式romise, y,java面试题 res缓存视频兼并olve, reject);
},
// 假定 rejectPrJavaomise 以据因 r缓存视频怎样转入本地视频 为参数被调用，则以据因 r 回绝 pr阅读器前史上的痕迹在哪里omijava面试题se
r阅读器前史记录删了怎样找回 => {
if (called) return;
called = true;
rej缓存视频怎样转入本地视频ect(r);
});
}
......

那么问题来了

• 为阅读器前史上的痕迹在哪里什么咱们缓存视频兼并app下载 Promise A+ 查验全部通过的手缓存视频吞并写代码数组和链表的差异，实施作用却与原生 Promise 不数组词同？
• 在咱们手写代码运用创立一次微使命的办法，会带来什么问题吗？

ES6 中的 Promise 尽管是遵从 Promise A+ 标准java面试题完毕的，但实践上javascript什么意思也 Promise A+ 上做了一些功用扩展，例如：Promise.all、Promise.race 等，缓存视频在手机哪里找所以即javascript菜鸟教程使都契合 Pro缓存视频吞并app下载mise A+ ，实施作用也是或许存在差异的。咱们这儿更需求考虑的是第二个问题，不这么做会带来什么问题，也便是加一次微使命的必要性。

我查验过许多比方，都没有找到相javascript九九乘法表关比方，咱们Java手写完毕的 Promijavascriptse 都很好的完毕作业，拿到了javahdxx作用数组函数的使用办法。我不得不去翻看更多的相关文章，我数组函数的运用办法发现有些人缓存会为了jav数组词ascript根底数组和链表的差异入门让实施作用与原生相同，强行去再多加一javascript缓存视频变成本地视频高档程序设计次微使命，这阅读器的前史种做法是很牵强的缓存视频。

毕竟完毕 Promise 的目的是为了处理异步编程java怎样读的问题，能够拿到正确的作用才javascript根底入门是最重要的，强行数组词为了契合面试题的输出次第去多加一次微使命缓存视频吞并app下载，只能让手写代码变的更加凌乱，欠好了解。

在 stackoverflow 上，有一java根底知识点个类似的数组排序问javascript题 What i数组词s the difference between returned Promise?
答复中阅读器前史记载删了怎样找回有一个信息便是

It only r阅读器视频观看前史在哪里equired the execution context stack浏缓存视频兼并览器前史上的痕迹在哪里 contains only plat数组函数的运用办法form code. 也就相当于等候 execution contex缓存视频怎样转入本地视频t stack 清空。

这个在中缓存的一数组c言语篇文章 我认为我很懂Promise，直到我开端完毕Promise/A+标准 也有一段关于这道面试题的缓存的视频怎样保存到本地议论

return Promise.resolve(4)，JS引擎会组织一个jjava游戏ob缓存视频在手机哪里找（job是 ECMA 中的概念，等同于缓存视频怎样转入相册微使命的概念)，其回调目的是让其状况变为fulfilled。

实践上咱们现已在 static resolve 创立了一个新的 MyPromsie，并调用其 then 办法，创立了一个微使命。

所以，就现在的信息来说，两次微使命依旧不能证明其javascript菜鸟教程必要性，现在的 Promise 日常操作，一次微使命都是能够满足。

咱们关于这个道面试题有什么主意或许定见，赶忙在留言区告诉我吧，一起议论一下到底是必然仍是偶然

长文收拾不易，记住 点赞 支撑一下哦