javascript - Mengapa Janji dilaksanakan serta-merta apabila dikembalikan dari Janji? Tolong jelaskan prinsipnya.

Question

Ini kodnya

    function retPromise(str) {
        return new Promise(resolve=>{
            resolve(str);
        })
    }
    
    console.log(retPromise("first")) // 返回一个Promise对象
    
    retPromise("x").then(str=>{
        return retPromise("first")
    }).then(str=>{
        console.log(str) // 返回"first"
    })

1. Mengapa objek Promise dikembalikan kemudian diselesaikan pada seterusnya?

2. Adakah rantai perlaksanaan yang kedua kemudian Janji yang kedua?

Answer 1

Idea Promise adalah untuk menganggap semua kod segerak dan tak segerak sebagai kod tak segerak Kaedah kemudian akan mengembalikan Promise baharu (panggilan berantai), dan parameter pertama kaedah itu . onfulfilled dipanggil selepas panggilan tak segerak objek Promise sebelum ini selesaiPromise（链式调用）,then方法的第一个参数onfulfilled是在前一个Promise对象的异步调用完成之后调用的

    then(onfulfilled, onrejected){
            // 每个then方法都返回一个新的promise对象，实现链式调用

            return new Promise((resolve, reject)=>{

                let success = (value)=>{
                    // 这里执行onFulfilled，判断是否是promise对象并将返回结果作为参数传递到当前promise的reslove中
                    // 如果没有返回值，则默认返回原本的value值，这一步的处理并不是必须的
                    let result = onfulfilled(value) || value;
                    if (isThenable(result)){
                        result.then((value)=>{
                            resolve(value);
                        }, (value)=>{
                            reject(value);
                        });
                    }else {
                        resolve(result);
                    }
                }

                let error = (value)=>{
                    let result = onrejected(value) || value;
                    resolve(result);
                }
                
                // 当调用then方法的那个promise对象onfulfilled时调用success，执行上面的操作
                switch(this.status){
                    case PENDING:
                        this.onfulfilled = success;
                        this.onrejected = error;
                        break;
                    case FULFILLED:
                        success(this.value);
                        break;
                    case REJECTED:
                        error(this.reason);
                        break;
                }
                
            })
        }

这里还是牵扯到Promise rrreee

Ini masih melibatkan beberapa pelaksanaan dalam pembina Promise Saya baru sahaja melaksanakan Promise beberapa hari yang lalu. Saya harap ia akan membantu anda

Answer 2

Saya bukan orang besar-_-Saya akan menerangkan pandangan saya.
Kemudian panggilan berantai akan mengambil nilai pulangan daripada sebelumnya sebagai parameter Pelaksanaan dalaman fungsi Promise adalah untuk melaksanakan pemprosesan objek Promise pada nilai pulangan Sebagai contoh, jenis data asas akan mengembalikan objek Promise melalui Promise.resolve (data). Jika ia adalah objek Janji, laksanakan fungsi penyelesaiannya untuk mencetuskan fungsi seterusnya.

Answer 3

Anda boleh menguraikan rantai pelaksanaan ini kepada:

var promise1 = retPromise('x');//函数retPromise('x')返回的一个promise
var promise2 = promise1.then(str=>{//当retPromise('x')返回的promise执行成功后返回一个新的promise，也就是promise2
 console.log(str);
 return retPromise("first");
})

promise2.then(str=>{
    console.log(str);
})

Anda juga boleh menggunakan setTimeout untuk menetapkan fungsi retPromise(str) kepada pemulangan tertunda. Ini berfungsi lebih baik

   function retPromise(str) {
    return new Promise(resolve=>{
      //var str1;
       setTimeout(function(){ console.log(str); str = str + " success!"; resolve(str);}, 3000);
    })
}