javascript - La promesse dans le nœud est également imbriquée

Question

1.

S'il y a deux collections mongodb, l'une est celle des utilisateurs et l'autre des publications, et les informations des utilisateurs correspondantes sont affichées dans la liste des publications, le traitement asynchrone conventionnel est trop imbriqué pour le résoudre, et a constaté qu'il existe également un. problème lors de la résolution des promesses

2. Le code de la solution est le suivant

//封装查询一条函数
findOneData = function(db, colName, data) {
    return new Promise(function(reslove, reject) {
        db.collection(colName).find(data).toArray(function(err, data) {
            if (err) {
                console.log("数据查询错误" + err);
                reject(err);
                return;
            }
            reslove({ db: db, data: data });
        });
    });
};

db_conn()
    .then(function(db) {
        return findOneData(db, "test", {});
    })
    .then(function(data) {
        console.log(data);
    });

Cette méthode est-elle correcte ? Elle semble avoir été résolue, mais j'ai toujours l'impression que quelque chose ne va pas

Answer 1

La promesse n'est pas la solution finale et elle n'est pas nécessairement plus élégante que les rappels asynchrones/attendre

.

Answer 2

Il y a trois points. Écrivez le code ci-dessus directement dans le then de db_conn, puis renvoyez-le
Utilisez catch dans la couche la plus externe pour capturer les exceptions.
Supprimez le console.log, ça a l'air bizarre,

Answer 3

db_conn()
.then(db=>{
        return {
               db:db,
               test:'test',
               data:{}
         }
})
.then(findOneData)
.then(r=>{
   console.log(r);
});

Enfin, changez la façon dont votre findOneDatareçoit les paramètres. Est-ce mieux ?

.

Answer 4

db_conn()
    .then(db => findOneData(db, "test", {}))
    .then(data => console.log(data));

Cela n’a-t-il pas l’air plus agréable à regarder ?

(async function() {
    const db = await db_conn();
    const data = await findOneData(db, "test", {});
    console.log(data);
})();

Est-ce plus agréable à regarder ?

Answer 5

La solution Promise résout le problème des rappels asynchrones sans ajouter d'éléments de langage, il doit donc y avoir certaines limitations.

En plus des rappels d'origine, Promise ajoutera au moins une couche de rappels, donc lorsque la chaîne de rappel d'origine est très courte, comme dans le cas du sujet, il n'y a qu'une seule couche, il semble qu'il n'y ait aucun avantage à utiliser Promise , ce qui est normal.

Si vous rencontrez des situations plus complexes et plus de niveaux d'imbrication, vous pouvez voir l'intérêt d'utiliser Promise.

Tout le monde à l'étage a fourni de bonnes méthodes d'écriture, donc je n'en dirai pas plus.