termine - que es un loop en javascript

Bucle a través de solicitud asincrónica

Question

entonces tengo el siguiente código para recorrer un objeto:

for(var x in block){
    sendTextMessage(block[x].text, sender, function(callback){
        //increment for?
    })
}

Para cada iteración, quiero hacer una solicitud (enviar un mensaje de Facebook), solo después de que esa solicitud haya finalizado, quiero pasar por la siguiente iteración, esto se debe a que sin ninguna devolución de llamada, los mensajes no se enviarán en la sucesión correcta .

function sendTextMessage(text, sender, callback) {
    let messageData = { text:text}
    request({
        url: ''https://graph.facebook.com/v2.6/me/messages'',
        qs: {access_token:token},
        method: ''POST'',
        json: {
            recipient: {id:sender},
            message: messageData,
        }
    }, function(error, response, body) {
        if (response.statusCode >= 200 &&  response.statusCode < 300){
            if(callback) callback(''success'')
        }
    })
}

He tenido este problema antes y no he podido resolverlo, ¿cómo puedo hacerlo de alguna manera?

Si tiene alguna pregunta, por favor pregunte. Gracias.

Answer 1

Puede utilizar el módulo async , que será de gran ayuda para realizar solicitudes una por una. A continuación se muestra un código de muestra de documentos oficiales asíncronos que es bastante intuitivo de entender.

  function asyncForEach (arr, iterator, callback) {
    queue = arr.slice(0)
        // create a recursive iterator
    function next (err) {
      if (err) return callback(err)

            // if the queue is empty, call the callback with no error
      if (queue.length === 0) return callback(null)

            // call the callback with our task
            // we pass `next` here so the task can let us know when to move on to the next task
      iterator(queue.shift(), next)
    }

        // start the loop;
    next()
  }

function sampleAsync (param, done) {
// put a callback when function is done its work 
}

  asyncForEach(result, function (param, done) { // result is the array you pass as iterator
    sampleAsync(param, function (message) {
      console.log(message)
      done()
    })
  }, function () {
    console.log(''callback'')
    callback(SOME_RESULT)
  })

}

Answer 2

Terminé siguiendo los consejos de @Matt Diamond y hago una función recursiva que se ve así:

function buildFlow(block, sender){
    var i = 0;
    recursive()
    /*  for(var x in block){
        sendTextMessage(block[x], block[x].type, sender)
        console.log(x)
    }*/
    function recursive(){
        if (i<Object.keys(block).length){
            sendTextMessage(block[Object.keys(block)[i]], block[Object.keys(block)[i]].type, sender, function(){
                i++
                recursive()
            })

        }else{
            i = 0
        }
    }
}

Gracias a todos los que dieron ayuda, muy apreciados.

Answer 3

Una de las formas en que he resuelto esto en el pasado es usar un temporizador de intervalo, algo así:

var isSending = false;
var sendMessages = setInterval(function() {
  if(!isSending) {
    isSending = true;
    sendTextMessage(block.pop().text, sender, function(){
      if(block.length) {
       isSending = false;
      } else {
        clearInterval(sendMessages);
        //Done
      }
    })
  }
})

function sendTextMessage(text, sender, callback) {
    let messageData = { text:text}
    request({
        url: ''https://graph.facebook.com/v2.6/me/messages'',
        qs: {access_token:token},
        method: ''POST'',
        json: {
            recipient: {id:sender},
            message: messageData,
        }
    }, function(error, response, body) {
        if (response.statusCode >= 200 &&  response.statusCode < 300){
            if(callback) callback(''success'')
        }
    })
}