如何使用对多个链接同时进行GET请求，依次获取返回结果的值进行条件判断？

Question

Tampermonkey中使用GM_xmlhttpRequest对多个链接同时进行请求，将最先返回结果的值进行条件判断，要是符合条件不再获取后面的请求结果的值，要是不符合，依次获取第二个、第三个的返回结果的值进行条件判断，同样符合条件不再获取后面的，要是不符合条件，同样获取后面的值

使用AI写了一段代码，看注释和实际结果，貌似是先获取一个请求结果，进行判断，然后再等所有剩下的结果请求完成，再进行条件判断，并非依次等获取到请求结果就进行条件判断

    const promises = [];
    // 要请求的链接列表
    var urlavl = 'https://www.aaa.com'; 
    var urlero = 'https://www.bbb.com';
    var urlkuti = 'https://www.ccc.com';

    var urls = [urlwiki,urlero,urlkuti]; 
    // 遍历链接列表，发起请求并存储 Promise 和对应条件
    urls.forEach((url) => {
        promises.push(new Promise((resolve, reject) => {
            GM_xmlhttpRequest({
                method: "GET",
                url: url,
                onload: function(response) {
                    let domNew = new DOMParser().parseFromString(response.responseText, 'text/html');
                    resolve(domNew);
                },
                onerror: function(error) {
                    resolve('请求错误' + url); 
                }
            });
        }));
    });
    Promise.race(promises)
        .then((data) => { // 获取 response 和 condition
        // 判断第一个完成的请求是否满足对应条件
        if(data.indexOf('#') > -1) {
            console.log(data);
            
            // 取消其他未完成的请求 (可选)
            promises.forEach(promise => {
                if (promise.cancel) {
                    promise.cancel();
                }
            });
        } else {
            // console.log(`链接不满足条件，等待其他结果...`);

            // 使用 Promise.all() 等待所有请求完成
            Promise.all(promises)
                .then(results => {
                // 遍历所有结果，查找满足对应条件的结果
                console.log('重新查找')
                results.forEach((data) => {
                    if(data.indexOf('#') > -1) {
                        console.log(data);
                    // console.log(`链接满足条件:`, response);
                    }
                });
            })
                .catch(error => {
                console.error("请求出错:", error);
            });
        }
    })
        .catch(error => {
        console.error("请求出错:", error);
    });

Answer 1

1.这个是依次请求 请求一个判断符合与否再下一个

function Promise1() {
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve({
        data: '123'
      })
    },2000);
  })
}

function Promise2() {
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve({
        data: '#234'
      })
    }, 2000);
  })
}

function Promise3() {
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve({
        data: '1'
      })
    }, 2000);
  })
}

function mainRequest(promises) {
  return new Promise((resolve) => {
    let i = 0;

    function nextRequest() {
      if (i === promises.length) {
        resolve('全部不符合条件')
        return;
      }
      const request = promises[i]()
      i++;
      request
        .then((result) => {
          if (result.data.indexOf('#') > -1) {
            resolve(result.data);
          } else {
            nextRequest();
          }
        })
        .catch(() => {
          nextRequest();
        })
    }
    nextRequest();
  })
}

mainRequest([Promise3, Promise2, Promise1]).then((result) => {
  console.log('result', result);

})

2.这个版本是并发所有请求 但是在 Greasemonkey 和 Tampermonkey 中，GM_xmlhttpRequest 的确没有内建的取消请求功能。与标准的 XMLHttpRequest 不同，GM_xmlhttpRequest 不提供取消请求的方法。因此，无法直接取消已经发出的请求。只能让它去请求 你只需要拿到一个匹配的请求结果就行了

function Promise1() {
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve({
        data: '#123'
      })
    }, Math.random()*1000);
  })
}

function Promise2() {
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve({
        data: '#234'
      })
    }, Math.random()*1000);
  })
}

function Promise3() {
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve({
        data: '#1'
      })
    }, Math.random()*1000);
  })
}

function mainRequest(promises) {
  return new Promise((resolve) => {
    let resultCount = 0;

    function nextRequest(i) {
      if (i >= promises.length) {
        return;
      }
      const request = promises[i]()
      const now = performance.now();
      request
        .then((result) => {
          if (result.data.indexOf('#') > -1) {
            resolve({ successIndex : i, data:result.data });
          }
        })
        .finally(() => {
          const end = performance.now();
          console.log('time', end - now, i);
          resultCount++;
          if (resultCount === promises.length) {
            resolve('未找到符合条件请求');
          }
        })
    }

    for (let index = 0; index < promises.length; index++) {
      nextRequest(index);
    }
  })
}

mainRequest([Promise1,Promise2,Promise3]).then((result) => {
  console.log('result', result);

})