How to implement concurrent GET requests for multiple links in Tampermonkey and determine the return results in sequence?

Concurrent GET requests and result judgments for multiple links in Tampermonkey

This article discusses how to efficiently handle GET requests for multiple links in Tampermonkey scripts and make conditional judgments based on the returned results. The goal is to initiate multiple GET requests concurrently, and once the conditions are met, the subsequent requests are immediately stopped and the result is returned.

Because GM_xmlhttpRequest lacks a native cancel request mechanism, it is impossible to directly interrupt the initiated request. Therefore, we will adopt concurrent requests and implement conditional judgment and request termination through Promise and Promise.race .

Solution: Concurrent requests and Promise.race

This scheme initiates all GET requests at the same time, and uses Promise.race to find the first request result that meets the condition.

Code example:

 function fetchUrl(url) {
  return new Promise((resolve, reject) => {
    GM_xmlhttpRequest({
      method: "GET",
      url: url,
      onload: (response) => {
        resolve({ url: url, data: response.responseText });
      },
      oneError: (error) => {
        reject(error);
      }
    });
  });
}

async function main() {
  const urls = [
    "https://example.com/1",
    "https://example.com/2",
    "https://example.com/3"
  ];

  const promises = urls.map(url => fetchUrl(url));

  try {
    const result = await Promise.race(promises);
    // Determine whether the result meets the conditions, for example:
    if (result.data.includes("success")) {
      console.log("The condition is satisfied, result:", result);
      return result;
    } else {
      console.log("The first request does not meet the condition");
      // You can process subsequent requests here, or directly return null; // or handle other results
    }
  } catch (error) {
    console.error("Request error:", error);
    return null;
  }
}


main();

This code first defines a fetchUrl function, initiates a GET request using GM_xmlhttpRequest and returns a Promise. main function creates a Promise array containing all URLs, and uses Promise.race to execute these Promise concurrently. Promise.race returns the result of the first completed Promise. The code contains an example conditional judgment ( result.data.includes("success") ), which you can modify according to actual needs. If the first request does not meet the conditions, the remaining requests can be processed further or returned directly as needed. Error handling is also included in try...catch block.

Important Note: Although this solution is implemented concurrently, it still depends on the network status. If all requests take longer, the efficiency improvement is limited. For large numbers of URLs, consider batch processing or more advanced concurrency control strategies. Please make sure to replace the sample URL for your actual link. This code requires Tampermonkey or similar user script manager.

The above is the detailed content of How to implement concurrent GET requests for multiple links in Tampermonkey and determine the return results in sequence?. For more information, please follow other related articles on the PHP Chinese website!