Kann ich ein Promise in nodejs (ES7) auslösen und vergessen?

Ich möchte diesen Code mit babel ausführen:

redisClientAsync.delAsync('key');
return await someOtherAsyncFunction();

innerhalb einer asynchronen Funktion ohne erwarten die erste Zeile. ist das ok?

Wie sonst kann ich etwas ausführen, das mir egal ist?

Kann ich die nicht versprochene Funktion del(‘key’,null) einfach ohne Callback auslösen?

Ja, Sie können das tun, und es werden die beiden asynchronen Funktionen parallel ausgeführt. Sie haben gerade ein Versprechen erstellt und es weggeworfen.

Dies bedeutet jedoch, dass Sie es nicht bemerken, wenn das Versprechen abgelehnt wird. Du bekommst nur eine unhandledRejection Schließlich wird Ihr Prozess zum Absturz gebracht, wenn es nicht behandelt wird.

Ist das ok? Wie kann ich etwas betreiben, das mir egal ist?

Wahrscheinlich ist es nicht in Ordnung. Wenn es dir wirklich egal wäre, hättest du es gar nicht erst laufen lassen. Sie sollten also klar und deutlich sagen, was Ihnen wichtig ist (und was nicht):

• willst du warten? (für Nebenwirkungen)
• Brauchst du das Ergebnis?
• Möchten Sie Ausnahmen abfangen?

Wenn Sie nur warten möchten und sich nicht um den Ergebniswert kümmern, können Sie das Ergebnis einfach wegwerfen:

void (await someAsyncFunction()); // or omit the void keyword,
                                  // doesn't make a difference in an expression statement

Wenn Sie sich nicht um Ausnahmen kümmern, können Sie sie mit ignorieren

… someAsyncFunction().catch(function ignore() {}) …

Du kannst das wegwerfen, darauf warten, alles damit machen.

Wenn Sie das Ergebnis wollen, müssen Sie es abwarten. Wenn Sie sich für Ausnahmen interessieren, aber nicht wirklich warten möchten, können Sie sie parallel zu den folgenden Funktionen ausführen:

var [_, res] = await Promise.all([
    someAsyncFunction(), // result is ignored, exceptions aren't
    someOtherAsyncFunction()
]);
return res;

innerhalb einer asynchronen Funktion, ohne auf die erste Zeile zu warten. ist das ok?

Ja, es gibt Fälle, in denen Sie dies tun möchten, was durchaus vernünftig ist. Besonders dort, wo Ihnen das Ergebnis egal ist – ein Beispiel ist ein Analyse-Tracking-Vorgang, der geschäftskritischen Code nicht beeinträchtigen sollte.

Wie sonst kann ich etwas ausführen, das mir egal ist?

In vielerlei Hinsicht funktioniert jedoch das einfache Aufrufen der Promise-Funktion. Dein del ohne Rückruf würde in diesem Fall wahrscheinlich funktionieren, aber einige Funktionen schützen nicht davor, Rückrufe nicht zu übergeben, sodass Sie stattdessen eine leere Funktion übergeben können (.del('key', () => {})).

Sie möchten jedoch sicherstellen, dass Sie wissen darüber, dass es fehlschlägt, auch wenn Sie den Betrieb des Codes nicht stören möchten – erwägen Sie also bitte, eine hinzuzufügen process.on("unhandledRejection', Ereignishandler, um diese speziellen Ausnahmen explizit zu ignorieren oder zu unterdrücken über:

redisClient.delAsync('key').catch(()=>{});

Oder besser so etwas wie:

redisClient.delAsync('key').catch(logErr);

Nach all den Recherchen, die ich bisher gemacht habe, denke ich, dass es in Ordnung ist, es zu tun, solange Sie garantieren, dass die Funktion, die Sie nicht haben, gewährleistet ist awaitfür Garantien eine Möglichkeit, mit eigenen Fehlern umzugehen, falls dies passiert. Zum Beispiel ein try-catch Umhüllen des gesamten Funktionskörpers, wie Sie im folgenden Snippet für die sehen asyncFunction.

Es spielt keine Rolle, ob die Funktion synchron oder asynchron auslöst. Es garantiert die Ihre mainFunction werden vervollständigen egal was. Das ist hier der springende Punkt.

Wer das nicht garantiert, riskiert:

• Wenn es synchron wirft, wird Ihre Hauptfunktion nicht abgeschlossen.
• Wenn es asynchron ausgelöst wird, erhalten Sie eine unbehandelte Ausnahme

// THIS IS SOME API CALL YOU DON'T WANT TO WAIT FOR

const mockAPI = () => {
  console.log("From mockAPI");
  return new Promise((resolve,reject) => {
    setTimeout(() => reject("LATE THROW: API ERROR"), 500);
  });
};

// THIS IS THE SOME ASYNC FUNCTION YOU CALL BUT NOT AWAIT FOR

const asyncFunction = async (syncThrow) => {
  try {
    console.log("Async function START");
    if (syncThrow) throw new Error("EARLY THROW");
    await mockAPI();
    console.log("Async function DONE");
  }
  catch(err) {
    console.log("From async function catch");
    console.log(err.message || err);
    return;
  }
};

// THIS IS YOUR MAIN FUNCTION

const mainFunction = async (syncThrow) => {
  try {
    console.clear();
    console.log("Main function START");
    asyncFunction(syncThrow);
    console.log("Main function DONE <<< THAT'S THE IMPORTANT PART");
  }
  catch(err) {
    console.log("THIS WILL NEVER HAPPEN");
    console.log(err);
  }
};

<div>
  <button onClick="mainFunction(true)">Sync throw</button>
  <button onClick="mainFunction(false)">Async throw</button>
</div>