如何运行相同承诺一个接一个NodeJs [英] How to run same promises one after another NodeJs

问题描述

我正在尝试解决以下问题。
请考虑以下情况。我需要检查一组服务器是否存活。或者更具体地说，我需要从提供的列表中找到第一个工作服务器，我需要一个接一个。

例如，如果第一个服务器不' t工作，检查另一个和另一个...

只要NodeJS是异步的，我不能在for循环中执行此操作。所以我试图实现类似于递归的东西，看起来很丑陋，不行，但是我试过）

  static findWorkingServer（servers，payload）{
 return NetworkUtils.getMyPublicIP（）
 .then（（ip）=> {
 return new Promise（function（resolve，reject））{
 let currentIndex = -1; 
 if（servers.length> 0）{
 let currentServer; 
 let serverCheckCallback = function（result）{
 if（result）{
 resolve（{working：currentServer，payload：payload}）; 
} 
 else {
 if（currentIndex< servers.length-1）{
 currentIndex ++; 
 currentServer = servers [currentIndex]; 
 NetworkUtils.checkIfServerWorking（currentServer，ip）
 .then（serverCheckCallback）; 
} 
 else {
 reject（new Error（No working servers found））
} 
} 
}; 
 serverCheckCallback（false）; 
} 
 else {
 resolve（new Error（No servers provided））; 
} 
}）
}）; 
} 
 static checkIfServerWorking（credentials，publicIp）{
 return new Promise（function（resolve，reject）{
 if（credentials）{
 request（{
 url：credentials.url，
 
 agentClass：agentClass，
 agentOptions：{
 //代理凭据
} 
}）
 。（）= $ {
 //做一些resposne 
解决（someCondition）; 
}的东西
 .catch（err => {
 resolve（false）; 
}）; 
} else {
 resolve（false）; 
} 
}）; 
} 
  

请帮助获得所需的结果，也许可以同步运行请求

解决方案

可以通过等待/异步完成：

div class =snippetdata-lang =jsdata-hide =falsedata-console =truedata-babel =false>

I am trying to solve the following problem. Consider the following case. I need to check if an array of servers is alive. Or to be more specific I need to find the first working server from the provided list, I need to do this one by one.

For example if the first server doesn't work, check another and another ...

As far as NodeJS is asynchronous I cannot do this in a for loop. So I tried to implement something similar to recursion, it looks ugly and doesn't work, but I've tried)

 static findWorkingServer(servers, payload) {
        return NetworkUtils.getMyPublicIP()
            .then((ip) => {
                return new Promise(function (resolve, reject) {
                    let currentIndex = -1;
                    if (servers.length > 0) {
                        let currentServer;
                        let serverCheckCallback = function (result) {
                            if (result) {
                                resolve({working: currentServer, payload: payload});
                            }
                            else {
                                if (currentIndex < servers.length-1) {
                                    currentIndex++;
                                    currentServer = servers[currentIndex];
                                    NetworkUtils.checkIfServerWorking(currentServer, ip)
                                        .then(serverCheckCallback);
                                }
                                else {
                                    reject(new Error("No working servers found"))
                                }
                            }
                        };
                        serverCheckCallback(false);
                    }
                    else {
                        resolve(new Error("No servers provided"));
                    }
                })
            });
    }
static checkIfServerWorking(credentials, publicIp) {
    return new Promise(function (resolve, reject) {
        if(credentials) {
            request({
                url: credentials.url,

                agentClass: agentClass,
                agentOptions: {
                   // Agent credentials
                }
            })
                .then(res => {
                     // Do some stuff with resposne
                    resolve(someCondition);
                })
                .catch(err => {
                    resolve(false);
                });
        }else {
            resolve(false);
        }
    });
}

Please help to get the desired result, maybe it is possible to run requests synchronously.

解决方案

Could be done with await/async:

let servers = ["test0.com","test1.com","test2.com","test3.com","test4.com"]

class ServerTest {
    static async checkServer(name) {
        if (name === "test3.com") 
            return true //returns promise that resolves with true
        else
            return false //returns promise that resolves with false
    }
}

(async()=>{ //IIFE (await can only be used in async functions)
    let targetServer
    for (i in servers) {
        if (await ServerTest.checkServer(servers[i]) === true) {
            targetServer = servers[i]
            break
        }
    }
    console.log("Found a working server: " + targetServer)
})()
    

这篇关于如何运行相同承诺一个接一个NodeJs的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！