失败请求的递归承诺

我有一个main函数，可以并行生成一系列GET请求。使用Promise.all函数评估它们的状态。

var promises = [];

for ( var i = 0; i < list.length; i++ )
{
   promises.push( REQ( list[ i ], 0 ) );
}

var responses = await Promise.all( promises );

REQ函数返回一个promise。

async function REQ( url, attempts )
{
   await sleep( 5000 * attempts ); // Uses a promise with setTimeout

   return new Promise( ( resolve, reject ) => {
      request( url, function ( error, response, body )
      {
         if ( error )
         {
            if ( attempts > ATTEMPT_THRESHOLD )
               reject( error );
            else
               return REQ( url, ++attempts );
         }
         else
         {
            if ( typeof body === 'undefined' || body.length === 0 )
            {
               if ( attempts > ATTEMPT_THRESHOLD )
                  reject( error );
               else
                  return REQ( url, ++attempts );
            }
            else
               resolve( { response, body } );
         }
      });
   });
};

我制作REQ函数async的原因是，如果请求失败，它会重新尝试，但重新尝试会延迟一点，以防它查询的服务器拥塞。

问题似乎是在Node控制台中，程序会在重新尝试时挂起，这样如果REQ失败，重新尝试它就不会返回原来的REQ并返回promise。

重新尝试它不会返回到原始REQ并返回承诺。

当然不是。在new Promise构造函数中，你需要resolve承诺不是return它。

如果你在尽可能低的水平上进行宣传会更好，即只包装request和request，而不是任何重试业务逻辑：

function requestAsync(url) {
  return new Promise((resolve, reject) => {
    request(url, (error, response, body) => {
      if (error) reject(error);
      else resolve({response, body});
    });
  });
}

然后你可以像往常一样使用await和return。

async function REQ(url, attempts) {
  try {
    const res = await requestAsync(url);
    if (typeof res.body == "undefined" || res.body.length == 0)
      throw new Error("no response"); // or throw undefined to get the original behaviour
    return res;
  } catch(error) {
    if (attempts > ATTEMPT_THRESHOLD)
      throw error;
    ++attempts;
    await sleep(5000 * attempts);
    return REQ(url, attempts);
  }
}

失败请求的递归承诺

我有一个main函数，可以并行生成一系列GET请求。使用Promise.all函数评估它们的状态。

var promises = [];

for ( var i = 0; i < list.length; i++ )
{
   promises.push( REQ( list[ i ], 0 ) );
}

var responses = await Promise.all( promises );

REQ函数返回一个promise。

async function REQ( url, attempts )
{
   await sleep( 5000 * attempts ); // Uses a promise with setTimeout

   return new Promise( ( resolve, reject ) => {
      request( url, function ( error, response, body )
      {
         if ( error )
         {
            if ( attempts > ATTEMPT_THRESHOLD )
               reject( error );
            else
               return REQ( url, ++attempts );
         }
         else
         {
            if ( typeof body === 'undefined' || body.length === 0 )
            {
               if ( attempts > ATTEMPT_THRESHOLD )
                  reject( error );
               else
                  return REQ( url, ++attempts );
            }
            else
               resolve( { response, body } );
         }
      });
   });
};

我制作REQ函数async的原因是，如果请求失败，它会重新尝试，但重新尝试会延迟一点，以防它查询的服务器拥塞。

问题似乎是在Node控制台中，程序会在重新尝试时挂起，这样如果REQ失败，重新尝试它就不会返回原来的REQ并返回promise。

重新尝试它不会返回到原始REQ并返回承诺。

当然不是。在new Promise构造函数中，你需要resolve承诺不是return它。

如果你在尽可能低的水平上进行宣传会更好，即只包装request和request，而不是任何重试业务逻辑：

function requestAsync(url) {
  return new Promise((resolve, reject) => {
    request(url, (error, response, body) => {
      if (error) reject(error);
      else resolve({response, body});
    });
  });
}

然后你可以像往常一样使用await和return。

async function REQ(url, attempts) {
  try {
    const res = await requestAsync(url);
    if (typeof res.body == "undefined" || res.body.length == 0)
      throw new Error("no response"); // or throw undefined to get the original behaviour
    return res;
  } catch(error) {
    if (attempts > ATTEMPT_THRESHOLD)
      throw error;
    ++attempts;
    await sleep(5000 * attempts);
    return REQ(url, attempts);
  }
}