Warum ist mein asynchrone Funktion Rückkehr Versprechen { <pending> } anstatt den Wert?

Das Versprechen wird immer Protokoll ausstehend, solange Ihre Ergebnisse sind noch nicht behoben. Unabhängig von der promise-Zustand (gelöst oder noch ausstehende) rufen Sie .then auf das Versprechen, die Erfassung der Ergebnisse:

let AuthUser = function(data) {
  return google.login(data.username, data.password).then(token => { return token } )
}

let userToken = AuthUser(data)
console.log(userToken) //Promise { <pending> }

userToken.then(function(result) {
   console.log(result) //"Some User token"
})

Warum ist das so?

Versprechen in vorwärts-Richtung nur; Sie können nur lösen Sie Sie einmal. Der aufgelöste Wert einer Promise übergeben wird, um seine .then oder .catch Methoden.

Details

Entsprechend der Promises/A+ - Spezifikation:

Dem Versprechen, Auflösung Verfahren wird eine abstrakte operation unter
input, Versprechen und Wert, die wir bezeichnen als [[Auflösen]](Versprechen,
x). Wenn x eine thenable, versucht es zu machen, Versprechen verabschieden, die den Staat
x, unter der Annahme, dass x verhält sich zumindest so etwas wie ein
Versprechen. Ansonsten erfüllt es das Versprechen mit dem Wert x.

Dieser Behandlung der thenables können Versprechen Implementierungen
zusammenarbeiten, so lange Sie Belichten ein Promises/A+-kompatibel dann
Methode. Es ermöglicht auch Promises/A+ - Implementierungen zu "assimilieren"
nonconformant Implementierungen mit angemessenem dann Methoden.

Diese Skillung ist ein wenig schwer zu analysieren, so lassen Sie uns es brechen. Die Regel ist:

Wenn die Funktion in der .then - handler einen Wert zurückgibt, der Promise löst sich mit diesem Wert. Wenn der hf ein weiterer Promise original Promise löst sich mit der aufgelösten Wert der verketteten Promise. Die nächste .then handler enthält immer den aufgelösten Wert der verketteten Versprechen wieder in den vorhergehenden .then.

Dem, wie es tatsächlich funktioniert, ist im folgenden ausführlich beschrieben:

1. Die Rückkehr der .then Funktion wird der gelöste Wert der Versprechen.

function initPromise() {
  return new Promise(function(res, rej) {
    res("initResolve");
  })
}

initPromise()
  .then(function(result) {
    console.log(result); //"initResolve"
    return "normalReturn";
  })
  .then(function(result) {
    console.log(result); //"normalReturn"
  });

2. Wenn die .then - Funktion gibt eine Promise, dann mit der aufgelösten Wert das Versprechen gekettet ist an die folgenden .then.

function initPromise() {
  return new Promise(function(res, rej) {
    res("initResolve");
  })
}

initPromise()
  .then(function(result) {
    console.log(result); //"initResolve"
    return new Promise(function(resolve, reject) {
       setTimeout(function() {
          resolve("secondPromise");
       }, 1000)
    })
  })
  .then(function(result) {
    console.log(result); //"secondPromise"
  });

InformationsquelleAutor Bamieh

Den then Methode gibt ein ausstehendes Versprechen, die gelöst werden können, die asynchron durch den return-Wert einer Ergebnis-handler registriert, die im Aufruf then oder abgelehnt durch auslösen eines Fehlers innerhalb der handler aufgerufen.

So aufrufen AuthUser wird nicht plötzlich melden sich die Benutzer in synchron, sondern gibt ein Versprechen, dessen dann registrierte Handler werden aufgerufen, nachdem die Anmeldung erfolgreich ist ( oder ausfällt). Ich würde vorschlagen, Auslösung alle login-Verarbeitung durch eine then - Klausel der login-Versprechen. E. G. mit benannten Funktionen zu markieren, die Reihenfolge der flow:

let AuthUser = data => {   //just the login promise
  return google.login(data.username, data.password);
};

AuthUser(data).then( processLogin).catch(loginFail);

function processLogin( token) {
      //do logged in stuff:
      //enable, initiate, or do things after login
}
function loginFail( err) {
      console.log("login failed: " + err);
}

InformationsquelleAutor traktor53