Node.js 为什么'；我的异步函数是否返回任何结果？

我写了这个小程序来获取数据。然而，这是异步完成的。因为我仍然需要在另一个模块中使用函数holevertretter（kzl），所以我希望得到一个最终可以传递的返回值。 请原谅我的意大利面代码（我通常在完成任务后美化代码…）

凭据存储在文件中，因此在此文件中找不到凭据。 我希望以“vertreter”作为返回值结束

先谢谢你

const node = require("deasync");
const DSB = require('dsbapi');
const tabletojson = require('tabletojson');
const https = require('https');
const cred = require("./vertrCred");

const dsb = new DSB(cred["dsb"]["user"], cred["dsb"]["passw"]); //Sanitized - no Credentials here

//Stackoverflow 2332811
String.prototype.capitalize = function(lower) {
    return (lower ? this.toLowerCase() : this).replace(/(?:^|\s)\S/g, function(a) { return a.toUpperCase(); });
};

function holePlan(kuerzel) {

dsb.fetch()
    .then(data => {
        const timetables = DSB.findMethodInData('timetable', data);
        const tiles = DSB.findMethodInData('tiles', data);

        var tilesStr = JSON.stringify(tiles["data"][0]["url"]);
        var url = JSON.parse(tilesStr);
        https.get(url, (resp) => {
        let data = '';
            resp.on('data', (chunk) => {
            data += chunk;
                });
            resp.on('end',() => {

            var tableasjson = tabletojson.convert(data);
            var erstetab = tableasjson[0];
            var zweitetab = tableasjson[1];
            var drittetab = tableasjson[2];
            var viertetab = tableasjson[3];
            var fuenftetab = tableasjson[4];
            var sechstetab = tableasjson[5];
            var siebtetab = tableasjson[6];
            var achtetab = tableasjson[7];
            if (typeof kuerzel === "undefined")
            {
                var regenechse = '(Aaa|Aaa[A-Za-z?]|[A-Za-z?]Aaa)';

                }
            else {
                var name = kuerzel.capitalize(true);
                var regenechse = '('+name+'|'+name+'[A-Za-z?]|[A-Za-z?]'+name+')';
            }
            const regex = new RegExp(regenechse,'g');
            var sammel = Object.assign(drittetab,fuenftetab);
            var z= 0;
            var vertreter = {}
            var y = JSON.parse(JSON.stringify(sammel));
            for (i=0;i<y.length;i++)    {
            if (typeof y[i].Vertreter =='undefined') {
            }
            else {
                if(y[i].Vertreter.match(regex))
                {
                    z += 1;

                    vertreter[z] = y[i];
                }
         }
        }
            if (z == 0) {
//              console.log("Es gibt nichts zu vertreten");
                }
            else {
                //console.log("Es werden "+z+" Stunden vertreten");
                return (vertreter);
            }   ;
                });

        })
        })
    .catch(e => {
        // An error occurred :(
        console.log(e);
    });
}

//Stackoverflow
function warte(promise) {
    var done = 0;
    var result = null;
    promise.then(
    function (value) {
        done = 1;
        result = value;
        return (value);
    },
    function (reason) {
        done = 1;
        throw reason;
        }
    );

    while (!done)
        node.runLoopOnce();
    return (result);
    }

function holeVertretung(kzl) {
    var aufgabe = new Promise((resolve,reject) => {
        setTimeout(resolve,1000,holePlan(kzl));
        });
    var ergebnis = warte(aufgabe);
    if (typeof ergebnis === "undefined")    {
        console.log("Mist");
    }
    else {
    console.log(ergebnis);
    }
    return ergebnis;
    }

holeVertretung("Aaa");

const node=require（“deasync”）；
const DSB=require（'dsbapi'）；
const tabletojson=require（'tabletojson'）；
常量https=require（'https'）；
const cred=需要（“/vertrCred”）；
const dsb=新的dsb（cred[“dsb”][“user”]、cred[“dsb”][“passw”]）//已消毒-此处没有凭据
//堆栈溢出2332811
String.prototype.capitalize=函数（下）{
return（lower？this.toLowerCase（）：this）.replace（/（？：^ |\s）\s/g，函数（a）{return a.toUpperCase（）；}）；
};
功能holePlan（kuerzel）{
dsb.fetch（）
。然后（数据=>{
const timetables=DSB.findMethodInData（“时间表”，数据）；
const tiles=DSB.findMethodInData（“tiles”，数据）；
var tilesStr=JSON.stringify（tiles[“数据”][0][“url”]）；
var url=JSON.parse（tilesStr）；
https.get（url，（resp）=>{
让数据=“”；
在（'数据'，（块）=>{
数据+=块；
});
分别在（'结束'，（）=>{
var tableasjson=tabletojson.convert（数据）；
var erstetab=tableasjson[0]；
var zweitetab=tableasjson[1]；
var drittetab=tableasjson[2]；
var viertetab=tableasjson[3]；
var fuenftetab=tableasjson[4]；
var sechstetab=tableasjson[5]；
var siebtetab=tableasjson[6]；
var-achtetab=tableasjson[7]；
if（kuerzel的类型==“未定义”）
{
var regenechse='（Aaa | Aaa[A-Za-z？]|[A-Za-z？]Aaa）；
}
否则{
var name=kuerzel.capitalize（真）；
var REGENCHE='（'+name+'|'+name+'[A-Za-z？].[A-Za-z？]'+name+'）；
}
const regex=new RegExp（regenechse，'g'）；
var sammel=Object.assign（drittetab、fuenftetab）；
var z=0；
var vertreter={}
var y=JSON.parse（JSON.stringify（sammel））；
对于（i=0；i{
//发生错误：(
控制台日志（e）；
});
}
//堆栈溢出
功能（承诺）{
var done=0；
var结果=null；
我保证，那么(
函数（值）{
完成=1；
结果=值；
回报（价值）；
},
功能（原因）{
完成=1；
抛出理由；
}
);
而（！完成）
node.runLoopOnce（）；
返回（结果）；
}
函数Holevertrethung（kzl）{
var aufgabe=新承诺（（解决、拒绝）=>{
setTimeout（解析，1000，holePlan（kzl））；
});
var ergebnis=warte（aufgabe）；
if（ergebnis的类型==“未定义”）{
控制台日志（“Mist”）；
}
否则{
控制台日志（ergebnis）；
}
返回ergebnis；
}
Holevertrethung（“Aaa”）；

这不是处理承诺的正确方法。如果您执行这种无限循环，它将超出使用承诺的全部目的。相反，从承诺返回值，并使用异步等待，如下所示：

function warte(promise) {
  var done = 0;
  var result = null;
  return promise.then(
    ...
}

async function holeVertretung(kzl) {
  var aufgabe = new Promise((resolve, reject) => {
    setTimeout(resolve, 1000, holePlan(kzl));
  });
  var ergebnis = await warte(aufgabe);
  ...

如果由于某种原因，

async await

不起作用，请使用then子句：

warte(aufgabe).then(value => {
  var ergebnis = value;
});

---

谢谢我实现了等待场景，但是，我知道只需获得承诺谢谢！异步函数holeVertretung（kzl）{var aufgabe=newpromise（（resolve，reject）=>{setTimeout（resolve，1000，holePlan（kzl））；}；//var ergebnis={}var ergebnis=wait warte（aufgabe）；return ergebnis；}是的，我确实在promise之前添加了return。然后（如果相关的话，我使用节点12.14.1=>Promises和async/wait）嗯……那么它应该可以工作。如果控制台日志

ergebnis

，你会得到什么？我基本上得到两个（因为我还调用了函数

holevertreturn（）

从外部调用，从外部调用的是

Promise{}

在等待之后立即调用的是

未定义的