javascript - Pourquoi Promise est-il exécuté immédiatement lorsqu'il est renvoyé par Promise? Merci d'expliquer le principe.

Question

Voici le code

    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. Pourquoi l'objet Promise est-il renvoyé puis résolu dans le prochain alors ?

2. La chaîne d'exécution de la seconde est-elle alors la seconde Promesse ?

Answer 1

L'idée de Promise est de traiter tous les codes synchrones et asynchrones comme du code asynchrone. La méthode then renverra une nouvelle Promise (appel en chaîne), et le premier paramètre de la méthode then . onfulfilled est appelé une fois l'appel asynchrone de l'objet Promise précédent terminéPromise（链式调用）,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

Cela implique encore quelques implémentations dans le constructeur Promise. Je viens d'implémenter une simple Promise il y a quelques jours. Voici le portail, j'espère qu'il vous sera utile🎜.

Answer 2

Je ne suis pas un grand gars-_-Je vais décrire mon point de vue.
Ensuite, l'appel en chaîne prendra la valeur de retour du précédent then comme paramètre.L'implémentation interne de la fonction then de Promise consiste à effectuer le traitement de l'objet Promise sur la valeur de retour, par exemple, les types de données de base renverront directement les objets Promise via Promise.resolve. (données). S'il s'agit d'un objet Promise, exécutez sa fonction de résolution pour déclencher la fonction then suivante.

Answer 3

Vous pouvez décomposer cette chaîne d'exécution en :

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);
})

Vous pouvez également utiliser setTimeout pour définir la fonction retPromise(str) sur un retour différé. Cela fonctionne mieux

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