Wie kann verhindert werden, dass Node.js beendet wird, während auf einen Rückruf gewartet wird?

Ich habe folgenden Code:

var client = new mysql.Client(options);
console.log('Icanhasclient');

client.connect(function (err) {
  console.log('jannn');
  active_db = client;
  console.log(err);
  console.log('hest');

  if (callback) {
    if (err) {
      callback(err, null);
    }

    callback(null, active_db);
  }
});

Mein Problem ist, dass der Knoten sofort beendet wird, wenn ich ihn ausführe. Es wird 'Icanhasclient' gedruckt, aber keines der console.logs im Rückruf wird aufgerufen.

(MySQL in diesem Beispiel ist Node-MySQL .

Gibt es etwas, das getan werden kann, damit node.js vor dem Beenden auf den Abschluss des Rückrufs wartet?

Rückruf wird nicht in die Warteschlange gestellt

Knoten läuft , bis alle Ereigniswarteschlangen leer sind. Ein Rückruf wird zu einem Ereignis hinzugefügt Warteschlange , wenn ein Anruf , wie beispielsweise

  emmiter1.on('this_event',callback).

ausgeführt hat. Dieser Aufruf ist Teil des vom Modulentwickler geschriebenen Codes.

Wenn es sich bei einem Modul um einen Schnellport aus einer synchronen / blockierenden Version handelt, geschieht dies möglicherweise erst, wenn ein Teil des Vorgangs abgeschlossen ist und alle Warteschlangen zuvor leer sind, sodass der Knoten stillschweigend beendet werden kann.

Dies ist ein hinterhältiger Fehler, auf den der Modulentwickler während der Entwicklung möglicherweise nicht stößt, da er in ausgelasteten Systemen mit vielen Warteschlangen seltener auftritt, da es selten vorkommt, dass alle zum kritischen Zeitpunkt leer sind.

Ein möglicher Fix / Bug-Detektor für den Benutzer besteht darin, vor dem Funktionsaufruf des Verdächtigen ein spezielles Timer-Ereignis einzufügen.

Sie können mit setInterval einfach ein setTimeout oder ein wiederkehrendes Timeout ausgeben.

Wenn Sie nach Ausgangsbedingungen suchen möchten, können Sie auch eine bedingte Zeitüberschreitung durchführen:

(function wait () {
   if (!SOME_EXIT_CONDITION) setTimeout(wait, 1000);
})();

Fügen Sie dies am Ende Ihres Codes ein und die Konsole wartet nur ... und wartet ... bis Sie möchten, dass sie geschlossen wird.

Meine Lösung bestand darin, einen EventEmitter zu instanziieren und auf mein benutzerdefiniertes Ereignis zu warten.

var eventEmitter = new process.EventEmitter();

dann rief ich eventEmitter.emitvom asynchronen Rückruf an:

client.connect(function (err) {
    eventEmitter.emit('myevent', {something: "Bla"})
});

Das Letzte in meinem Skript war eventEmitter.on:

eventEmitter.on('myevent', function(myResult){
  // I needed the result to be written to stdout so that the calling process could get it
  process.stdout.write(JSON.stringify(myResult));
});

Der Knoten wartet dann, bis der Ereignishandler die Ausführung beendet hat.

Basierend auf der Antwort von @ Todd habe ich einen Einzeiler erstellt. Fügen Sie es am Anfang Ihres Skripts ein und legen done = trueSie fest, wann Sie fertig sind:

var done = (function wait () { if (!done) setTimeout(wait, 1000) })();

Beispiel:

var done = (function wait () { if (!done) setTimeout(wait, 1000) })();

someAsyncOperation().then(() => {
  console.log('Good to go!');
  done = true;
});

Wie funktioniert es? Wenn wir es ein bisschen erweitern:

// Initialize the variable `done` to `undefined`
// Create the function wait, which is available inside itself
// Note: `var` is hoisted but `let` is not so we need to use `var`
var done = (function wait () {

  // As long as it's nor marked as done, create a new event+queue
  if (!done) setTimeout(wait, 1000);

  // No return value; done will resolve to false (undefined)
})();

Hier sind meine zwei Cent:

async function main()
{
    await new Promise(function () {});
    console.log('This text will never be printed');
}

function panic(error)
{
    console.error(error);
    process.exit(1);
}

// https://stackoverflow.com/a/46916601/1478566
main().catch(panic).finally(clearInterval.bind(null, setInterval(a=>a, 1E9)));

So mache ich es. Ich lasse meinen Haupteinstiegspunkt ein Versprechen zurückgeben und verwende dann diesen kleinen Wrapper, um sicherzustellen, dass der Knoten nicht beendet wird, solange dieses Versprechen nicht erfüllt ist:

function wrapPromiseMain(entryPoint) {
    const pollTime = 1000000;
    let interval = setInterval(() => {}, pollTime);
    
    return entryPoint().finally(() => {clearInterval(interval)});
}

Um es zu verwenden, versprechen Sie einfach Ihren Haupteinstiegspunkt und übergeben Sie es als Argument an den Wrapper:

function main() {

    // ... main stuff ...

    return doSomethingAsync();
}

wrapPromiseMain(main);

Ich finde es etwas aufgeräumter als die grundlegenden Abfrageschleifen, da es den Timer automatisch abbricht, wenn das Versprechen erfüllt ist, sodass keine zusätzliche Latenz entsteht. Die Abrufzeit kann daher grundsätzlich für immer sein, wenn Sie dies wünschen.

Ich habe mir felixge / node-mysql angesehen Bibliothek angesehen und keinen Verweis auf den Befehl client.connect in der API gefunden. Ist dies der eigentliche Anruf, den Sie tätigen möchten (ohne hier pingelig zu sein)? Unabhängig davon müssen Sie meiner Meinung nach mehr darüber nachdenken, wie Javascript aufgebaut ist, da es ein anderes Programmierparadigma verwendet als die meisten anderen gängigen Sprachen.

Das erste Problem, das ich in Ihrem Code sehe, ist, dass Sie den Rückruf nicht definiert haben, sodass er tatsächlich nicht vorhanden ist. Ich würde annehmen, dass console.log (Rückruf) undefiniert ist. Nach Ihrem Code ist die anonyme Funktion der Rückruf für die Funktion client.connect. Sie müssen definieren, was Sie "Rückruf" in einem höheren Bereich nennen. Zum Beispiel werde ich eine Funktion myCallback so definieren, dass sie in einem höheren Bereich als der anonymen Funktion von client.connect vorhanden ist. Es kann nützlich sein, den Bereich der Javacscript- Variablen nachzuschlagen .

    var myCallback(err, response) {
      if (err) {
        console.log('err:%s',err);
      } else {
        console.log('response:%s',response);
      }
    }

    client.connect(err, function(response) {
      // this anonymous function is the callback to client.connect, the var
      // 'callback' would be undefined.
      if (err) {
        myCallback(err);
        return; // Explicit call to return, else the lines below would run.
      } 
      myCallback(null, response);
    });

Zweitens wird die Funktion weiter verarbeitet, wenn Sie return nicht explizit in Javascript aufrufen. Ich war von diesem gebissen mir . Schließlich führt Javascript eine ereignisgesteuerte Schleife aus, was bedeutet, dass es niemals darauf warten wird, dass Funktionen einen Wert zurückgeben, weshalb wir überhaupt alle diese Rückrufe haben. Sie können Javascript zwingen, sich anders zu verhalten, indem Sie beispielsweise eine while-Schleife verwenden, bis eine Bedingung erfüllt ist. In der 'async'-Bibliothek von caolan finden Sie verschiedene Strategien zur Manipulation der Ereignisschleife. Der Hauptnachteil einer übermäßigen Verwendung dieser Methoden besteht darin, dass Sie tatsächlich CPU-Zyklen / Blockierungen verschwenden, wenn Sie wahrscheinlich mehr Rückrufe verwenden und einfach überdenken sollten, wie Ihre Programme funktionieren.

Bitte versuchen Sie dies. Überprüfen Sie, ob diese Hilfe.

var client = new mysql.Client(options);
console.log('Icanhasclient');
var verbose;

if (!verbose) {
    return new Promise(function (resolve, reject) {
        client.connect(function (err) {
            if (err) {
                console.log(Error in connecting
                SQL ${err}
            )
                ;
                return reject(err);
            }
            verbose = client;
            return resolve(verbose);
        })
    })
} else {
    return new Promise(function (resolve) {
        resolve(verbose);
    })
}