JavaScript承诺在幕后的工作原理

当承诺被生产和消费时，我对幕后发生的事情感到非常困惑。请澄清我的观点，并为我的英语不好道歉

使用新关键字Promise创建空对象构造函数为 已调用且新关键字设置此承诺构造函数指向的 空白对象这= BalkObjut.

承诺构造函数在参数中接收回调（执行器函数） 并调用执行器函数

executor函数接收两个回调（resolve、reject）作为参数

在executor函数中调用setTimeout，setTimeout为 异步代码

异步代码转到后台，然后承诺构造函数返回 承诺对象以前为空对象和承诺对象引用 为了我的承诺

将创建一个变量

接下来会发生什么？当

then

方法被称为

的代码时，那么
方法会进入后台吗？我想象它进入后台，一个变量是console.log//10

主代码执行完成后，异步代码启动
setTimeout
回调开始执行，执行完成后，承诺得到履行，解析函数返回值。这个值是如何存储在promise对象中的，以及在
then
方法中会发生什么

let myPromise = new Promise (
    (resolve, reject) => {

        setTimeout(() => {
            console.log(getIDs)
            resolve(10);

        }, 1500);

    }
)


let a = 10
        myPromise.then(val => {
            console.log(val);

        })
        console.log(a)

我将按执行顺序检查您的代码

无论何时，
此
的值都是它在开始时的值。这是因为您只使用了箭头函数。但这并不相关，因为您没有引用此

主代码
让我的承诺=新的承诺（执行人）创建挂起的承诺对象。创建承诺时，将执行
executor
功能

setTimeout（回调，1500）
将
回调
函数放在某个内部计时器队列上。javascript引擎承诺在（至少）1500毫秒后尽最大努力执行
回调

设a=10
将变量
a
设置为
10

myPromise.then（履行时）创建另一个挂起的承诺。它链接到
myPromise
，这样当
myPromise
得到满足时，
oncompleted
将被异步调度

console.log（a）
打印
a
的值，即
10

在接下来的1500毫秒内，什么都没有发生。然后执行
回调

setTimeout的回调
console.log（getid）打印
getid
。从名字你可以猜出它是一个函数。因此将打印类似于
[Function:getid]
的内容

resolve（10）实现了
myPromise
，并将其结果设置为
10
。由于
myPromised
现在已实现，
另一个承诺的
oncompleted
将异步调度

现在我们必须等待调用堆栈处理。在此之后，将调用
oncompleted

我履行了我的诺言
console.log（val）
打印
val
的内容。也就是说，
myPromise
的结果是，以下是内置的简化实现<代码>捕获
和
最终
尚未实现

提供给Promise构造函数的函数称为executor函数，并立即同步调用

每个承诺都有一个方法
。然后
，实现承诺的链接

提供给
。然后
的函数总是在微任务上异步调用（注意下面的用法）

每次调用
。然后
，都会创建并返回一个新的承诺

。然后可以对同一承诺多次调用
，创建承诺结果的多播和承诺链的分支

承诺可以处于三种状态之一：未决、履行或拒绝。状态转换是单向的：您不能从“已完成”或“已拒绝”移回“挂起”

如果一个承诺被另一个承诺解析，那么两个承诺链将连接起来，外部承诺将处于内部承诺的状态（可能是待定的），直到内部承诺解析为止


功能承诺（执行者）{
如果（！executor）抛出“未定义承诺执行者”
让status=“pending”，值，然后q=[]
const then=oncompleted=>{
let解析器
//这确保了控制不会转移到以后的承诺
//直到之前的承诺得到解决。
const nextPromise=新承诺（resolve=>（resolver=resolve））
//每个承诺可以注册多个“then”。
然后q.push（（…args）=>resolver（oncompleted（…args）））
返回下一步
}
//我们检查结果是否为“thenable”；如果是，我们处理
//它是一种内在的承诺，否则我们只需要用它来实现
//结果呢。
const resolve=result=>result？.then？result.then（履行）：履行（结果）
//当一个承诺实现后，它的“thens”就可以运行了。
const fulfill=result=>（status=“completed”，value=result，executeThens（value））
//“Thens”在微任务上异步运行。
const executeThens=value=>queueMicrotask（（）=>thenQ.forEach（el=>el（value）））
//执行器是同步运行的。
执行人（决议）
返回{
那么，
获取状态（）{return status}，
获取值（）{return value}
}
}
//锁链
新承诺（解决=>{
log（'正在等待步骤1…'）
setTimeout（（）=>解析（“一，二…”），1500）
})
.然后（结果=>新承诺（解决=>{
log（'正在等待步骤2…'）
setTimeout（（）=>resolve（`${result}三，四`），1500）
}))
.then（result=>console.log（`Chaining result:${result}.`））
//分支
const p=新承诺（解析=>{
console.log（'正在等待步骤a…）
setTimeout（（）=>resolve（“Alpha，B