node.js - Utilisez Node comme robot d'exploration pour simuler l'interface afin d'obtenir des données en boucle. Comment async/await peut-il réaliser des opérations synchrones et contrôler le processus ?

Question

Les idées actuelles sont les suivantes : 1. Obtenez toutes les URL des pages de balises sous la catégorie, 2. Parcourez la page d'exploration et récupérez la page de balises actuelle pour obtenir l'adresse API json, 3. Récupérez la liste de produits de la balise actuelle, 4. Saisissez la balise actuelle Produits en cours de chargement dans la pagination. Mais ce qui est fait maintenant, c'est que la deuxième étape démarre sans attendre 2-4...

天蓬老师 · Answer

générateur
async
promesse

仅有的幸福 · Answer

L'ensemble de votre processus est asynchrone et vous ne voyez aucune signification à la synchronisation. Je pense que vous ne comprenez peut-être pas ce qu'est l'asynchrone.

Async/await est basé sur Promise et Superagent lui-même prend en charge Promise. Vous pouvez utiliser async/await directement.

async function() {
  try {
    const result = await superagent.get(url);
    console.log(result.headers);
    console.log(result.body);
  } catch (error) {
    console.error(error);
  }
}

http://visionmedia.github.io/...

http://www.ruanyifeng.com/blo...

Ensuite, il ne vous reste plus qu'à mettre http.get() 换成 superagent.get().

習慣沉默 · Answer

En général, les gens n’ont pas la patience de lire la logique métier des autres.

Comme mentionné ci-dessus, Async/await est basé sur Promise. Si l'interface API de la bibliothèque tierce que vous appelez ne renvoie pas d'objet de promesse, si vous souhaitez utiliser Async/await, vous ne pouvez créer un nouvel objet de promesse que sur à chaque étape. C'est en fait très difficile à écrire. Bien sûr, ce serait très pratique s'il pouvait renvoyer un objet promis.

Ce qui suit est écrit en utilisant l'événement du module core du nœud sans promesses, pour votre référence :

const EventEmitter = require('events');
class MyEmitter extends EventEmitter {}
const myEmitter = new MyEmitter();

myEmitter.on('step1', (m) => {
    //第一步
    //业务逻辑处理得到结果result1
        
    //判断是否触发下一步，如有需要将这步的结果传给下一步
    myEmitter.emit('step2', result1);
   
});
myEmitter.on('step2', (result1) => {
    //第二步
    //业务逻辑处理得到结果result2
        
    //判断是否触发下一步，如有需要将这步的结果传给下一步
    myEmitter.emit('step3', result2);
});
myEmitter.on('step3', (result2) => {
    //以此类推
});
myEmitter.emit('step1', urls);

怪我咯 · Answer

Peut utiliser Node8 util.promisify , ou Bluebird, etc. changez la fonction de style de rappel Node en une fonction de style Promise, puis vous pouvez utiliser async/await pour écrire du code.

Le code lui-même est toujours un appel asynchrone, mais la méthode d'écriture semble synchrone. Par conséquent, vous devez toujours faire attention à la structure du processus lors de l’écriture, en particulier lors de l’écriture de boucles. Le code est trop long, j'ai donc écrit un petit exemple pour illustrer

async function remoteCall() {
    // do something
}

list = [];  // 假设是很多数据


async function process() {
    // 这种写法必须要一个 remoteCall 完成之后才进行另一个
    for (let i = 0; i < list.length; i++) {
        await remoteCall();
    }

    doAfter();
}

async function process2() {
    // 这种写法没法 await
    list.forEach(function(t) {
        remoteCall();
    });
}

async function process3() {
    // 这种写法 doAfter 一早就会执行
    list.forEach(async function(t) {
        await remoteCall();
    });

    // 它可能会在 remoteCall() 之前
    doAfter();
}

async function process4() {
    // 这种写法必须要全部 remoteCall 成功才能进行到 doAfter
    // remoteCall返回的 promise 如果 reject 会抛异常
    var promises = list.map(t => remoteCall());
    await Promise.all(promises);
    doAfter();
}