So verwenden Sie async await elegant in JS

$.ajax( "/xxx" )
  .done(Funktion() {
    // Erfolg!!! tu etwas ...
  })
  .fail(Funktion() {
    // Fehlschlag!!! Tu etwas …
  })
  .immer(Funktion() {
    // Laden abgeschlossen..
  });

$.ajax('/xxx1')
  .done(Funktion() {
    // Erfolg!!! tu etwas ...
    $.ajax('/xxx2')
      .done(Funktion() {
        // Erfolg!!! tu etwas ...
        $.ajax('/xxx3')
          .done(Funktion() {
            // Erfolg!!! tu etwas ...
            $.ajax('/xxx4')
              .done(Funktion() {
                // Erfolg!!! tu etwas ...
                $.ajax('/xxx5')
                  .done(Funktion() {
                    // Erfolg!!! tu etwas ...
                    // mehr...
                  })
                  .fail(Funktion() {
                    // Fehlschlag!!! Tu etwas …
                  })
                  .immer(Funktion() {
                    // Laden abgeschlossen..
                  });
              })
              .fail(Funktion() {
                // Fehlschlag!!! Tu etwas …
              })
              .immer(Funktion() {
                // Laden abgeschlossen..
              });
          })
          .fail(Funktion() {
            // Fehlschlag!!! Tu etwas …
            $.ajax('/xxx6')
              .done(Funktion() {
                // Erfolg!!! tu etwas ...
                $.ajax('/xxx7')
                  .done(Funktion() {
                    // Erfolg!!! tu etwas ...
                    // mehr....
                  })
                  .fail(Funktion() {
                    // Fehlschlag!!! Tu etwas …
                  })
                  .immer(Funktion() {
                    // Laden abgeschlossen..
                  });
              })
              .fail(Funktion() {
                // Fehlschlag!!! Tu etwas …
              })
              .immer(Funktion() {
                // Laden abgeschlossen..
              });
          })
          .immer(Funktion() {
            // Laden abgeschlossen..
          });
      })
      .fail(Funktion() {
        // Fehlschlag!!! Tu etwas …
      })
      .immer(Funktion() {
        // Laden abgeschlossen..
      });
  })
  .fail(Funktion() {
    // Fehlschlag!!! Tu etwas …
  })
  .immer(Funktion() {
    // Laden abgeschlossen..
  });

const r1 = warte auf „doEtwas1“();
wenn (r1.xxx === 1) {
  const r2 = warte auf tuEtwas2(r1);
  const r3 = warte auf „doEtwas3(r2);
  // mach was...
} anders {
  const r4 = warte auf tuEtwas4(r1);
  const r5 = warte auf machEtwas5(r4);
  // mach was...
}
// mach was...

sei r1;
versuchen {
  r1 = warte auf „doEtwas1“();
} fangen (e) {
  // tu etwas...
  zurückkehren;
}
wenn (r1) {
  wenn (r1.xxx === 1) {
    sei r2;
    versuchen {
      r2 = warte auf „doSomthing2(r1);“
    } fangen (e) {
      // tu etwas...
      zurückkehren;
    }
    wenn (r2) {
      sei r3;
      versuchen {
        r3 = warte auf „doSomthing3(r2);“
      } fangen (e) {
        // tu etwas...
        zurückkehren;
      }
      // tu etwas...
    }
  } anders {
    sei r4;
    versuchen {
      r4 = warte auf „doSomthing4(r1);“
    } fangen (e) {
      // tu etwas...
      zurückkehren;
    }
    wenn (r4) {
      sei r5;
      versuchen {
        r5 = warte auf „doSomthing5(r4);“
      } fangen (e) {
        // tu etwas...
        zurückkehren;
      }
    }
    // tu etwas...
  }
  // tu etwas...
}

/**
 * Stellt den Abschluss einer asynchronen Operation dar
 */
Schnittstelle Promise<T> {
    /**
     * Fügt Rückrufe für die Lösung und/oder Ablehnung des Versprechens an.
     * @param onfulfilled Der Rückruf, der ausgeführt werden soll, wenn das Versprechen eingelöst wird.
     * @param onrejected Der Rückruf, der ausgeführt werden soll, wenn das Versprechen abgelehnt wird.
     * @returns: Ein Promise für die Ausführung des jeweils ausgeführten Rückrufs.
     */
    dann <TResult1 = T, TResult2 = nie> (nicht erfüllt?: ((Wert: T) => TResult1 | PromiseLike<TResult1>) | undefiniert | null, nicht abgelehnt?: ((Grund: beliebig) => TResult2 | PromiseLike<TResult2>) | undefiniert | null): Promise<TResult1 | TResult2>;

    /**
     * Fügt einen Rückruf nur für die Ablehnung des Versprechens an.
     * @param onrejected Der Rückruf, der ausgeführt werden soll, wenn das Versprechen abgelehnt wird.
     * @returns Ein Promise für die Fertigstellung des Rückrufs.
     */
    catch<TResult = nie>(bei Ablehnung?: ((Grund: beliebig) => TResult | PromiseLike<TResult>) | nicht definiert | null): Promise<T | TResult>;
}

Funktion any(Versprechen) {
  gibt Versprechen zurück. Dann((v) => v).catch((_) => null);
}

Funktion any(Versprechen) {
  Rückgabeversprechen
    .then((v) => ({ ok: v, hasErr: false }))
    .catch((e) => ({ err: e, hasErr: true }));
}

const r = warte auf irgendetwas(tu etwas());
wenn (r.hasErr) {
  Konsole.log(r.err);
  zurückkehren;
}
Konsole.log(r.ok);

// Unten ist der neuste Code/**
 * @param { Versprechen } Versprechen
 * @param { Object= } errorExt – Zusätzliche Informationen, die Sie an das err-Objekt übergeben können
 * @return { Versprechen }
 */
Exportfunktion nach <T, U = Fehler> (
  Versprechen: Versprechen<T>,
  errorExt?: Objekt
): Versprechen<[U, undefiniert] | [null, T]> {
  Rückgabeversprechen
    .then<[null, T]>((Daten: T) => [null, Daten])
    .catch<[U, undefiniert]>((err: U) => {
      wenn (FehlerExt) {
        Objekt.assign(err, errorExt);
      }

      return [err, undefiniert];
    });
}

Standardmäßig exportieren nach;

importieren nach von „await-to-js“;
// Wenn Sie CommonJS verwenden (also eine NodeJS-Umgebung), sollte es lauten:
// const bis = erfordern ('await-to-js').default;

asynchrone Funktion asyncTaskWithCb(cb) {
     let err, Benutzer, gespeicherteAufgabe, Benachrichtigung;

     [ err, Benutzer ] = warte auf(UserModel.findById(1));
     if(!user) return cb('Kein Benutzer gefunden');

     [ err, gespeicherteAufgabe ] = warte auf(TaskModel({userId: user.id, name: 'Demo Task'}));
     if(err) return cb('Beim Speichern der Aufgabe ist ein Fehler aufgetreten');

    if(user.notificationsEnabled) {
       [ err ] = warte auf (NotificationService.sendNotification (user.id, 'Task erstellt'));
       if(err) return cb('Fehler beim Senden der Benachrichtigung');
    }

    wenn(savedTask.assignedUser.id !== user.id) {
       [ err, notification ] = warte auf (NotificationService.sendNotification(savedTask.assignedUser.id, 'Aufgabe wurde für Sie erstellt'));
       if(err) return cb('Fehler beim Senden der Benachrichtigung');
    }

    cb(null, gespeicherteAufgabe);
}

asynchrone Funktion asyncFunctionWithThrow() {
  const [err, Benutzer] = warte auf (UserModel.findById(1));
  if (!user) throw new Error('Benutzer nicht gefunden');
  
}

const [, Ergebnis] = warte auf(iWillSucceed());