Question

我想执行一个函数，它将使用代理测试第一个请求，而不使用代理测试另一个请求。

我的测试有效，但如果函数重新启动，则无法解析我的Promise：

const downloadFile = (configuration, proxy = true) => {

  return new Promise((resolve) => {

    // Save variable to know progress
    let receivedBytes = 0;
    let totalBytes    = 0;
    let requestFile = {
      method: 'get',
      headers: {
        'Content-Type': 'application/ld+json',
        'Authorization': `Bearer ${configuration.token}`
      },
      url: configuration.remoteFile
    };

    if (proxy) {
      requestFile = { ...requestFile, proxy: `${process.env.PROXY}:${process.env.PROXY_PORT}` };
    }

    console.log(requestFile);

    const out = fs.createWriteStream(configuration.localFile);


    const req = request(requestFile);

    req.pipe(out);

    req
      .on('response', (data) => {
        console.log(data);
        if (data.statusCode === 200) {
          totalBytes = parseInt(data.headers['content-length']);
          configuration.onStart();
        } else {
          console.log(data.statusCode);
        }
      })
      .on('data', (chunk) => {
        // Get progress if callback exists
        if (configuration.hasOwnProperty('onProgress')) {
          receivedBytes += chunk.length;
          configuration.onProgress(receivedBytes, totalBytes);
        } else {
          return receivedBytes += chunk.length;
        }
      })
      .on('error', (error) => {
        console.log(error);

        if (proxy) {
          downloadFile(configuration, false);
        }
      })
      .on('end', () => {
        console.log('end');
        resolve(configuration.onEnd());
      });

  });
};

如果第一个请求返回错误，我会传递第二个请求，然后传入end。但承诺没有得到解决：（

有人有想法吗？

谢谢社区！

Answer 1

您可以显式编码以从错误事件中发出结束事件。这将解决诺言。

         req.on('response', (data) => {
            // some code
          })
          .on('data', (chunk) => {
           // some code
          })
          .on('error', (error) => {
             this.emit("end");
          })
          .on('end', () => {
            resolve();
          });

承诺递归函数未解决

1 个答案: