Mon code:

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

Et quand j'essaye d'exécuter quelque chose comme ça:

let userToken = AuthUser(data)
console.log(userToken)

Je suis en train:

Promise { <pending> }

Mais pourquoi?

Mon objectif principal est d'obtenir un jeton à partir google.login(data.username, data.password)duquel retourne une promesse, dans une variable. Et alors seulement, effectuez certaines actions.

La promesse sera toujours enregistrée en attente tant que ses résultats ne sont pas encore résolus. Vous devez faire appel .thenà la promesse pour capturer les résultats quel que soit l'état de la promesse (résolu ou toujours en attente):

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"
})

Pourquoi donc?

Les promesses sont uniquement orientées vers l'avant; Vous ne pouvez les résoudre qu'une seule fois. La valeur résolue de a Promiseest transmise à ses méthodes .thenou .catch.

Détails

Selon les promesses / spécifications A +:

La procédure de résolution de promesse est une opération abstraite prenant comme entrée une promesse et une valeur, que nous notons [[Resolve]] (promise, x). Si x est un alorsable, il tente de faire adopter par promesse l'état de x, sous l'hypothèse que x se comporte au moins un peu comme une promesse. Sinon, il tient la promesse avec la valeur x.

Ce traitement des thenables permet aux implémentations de promesse d'interopérer, tant qu'elles exposent une méthode alors conforme à Promises / A +. Il permet également aux implémentations Promises / A + «d'assimiler» les implémentations non conformes avec des méthodes alors raisonnables.

Cette spécification est un peu difficile à analyser, alors décomposons-la. La règle est:

Si la fonction dans le .thengestionnaire renvoie une valeur, alors la Promiserésolution avec cette valeur. Si le gestionnaire en renvoie un autre Promise, l'original est Promiserésolu avec la valeur résolue de la chaîne Promise. Le .thengestionnaire suivant contiendra toujours la valeur résolue de la promesse chaînée retournée dans le précédent .then.

La façon dont cela fonctionne réellement est décrite ci-dessous plus en détail:

1. Le retour de la .thenfonction sera la valeur résolue de la promesse.

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. Si la .thenfonction renvoie a Promise, la valeur résolue de cette promesse chaînée est transmise au suivant .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"
  });

Je sais que cette question a été posée il y a 2 ans, mais je rencontre le même problème et la réponse au problème est depuis ES6, que vous pouvez simplement awaitrenvoyer la valeur des fonctions, comme:

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

let userToken = await AuthUser(data)
console.log(userToken) // your data

La thenméthode retourne une promesse en attente qui peut être résolue de manière asynchrone par la valeur de retour d'un gestionnaire de résultats enregistré dans l'appel à then, ou rejetée en lançant une erreur dans le gestionnaire appelé.

Ainsi, l'appel AuthUserne connectera pas soudainement l'utilisateur de manière synchrone, mais retournera une promesse dont les gestionnaires alors enregistrés seront appelés après la réussite (ou l'échec) de la connexion. Je suggérerais de déclencher tout traitement de connexion par une thenclause de la promesse de connexion. EG en utilisant des fonctions nommées pour mettre en évidence la séquence de flux:

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);
}

Voir la section MDN sur les promesses. En particulier, regardez le type de retour de then ().

Pour se connecter, l'agent utilisateur doit soumettre une requête au serveur et attendre de recevoir une réponse. Étant donné que faire en sorte que votre application arrête totalement l'exécution pendant un aller-retour de demande entraîne généralement une mauvaise expérience utilisateur, pratiquement toutes les fonctions JS qui vous connectent (ou exécutent toute autre forme d'interaction avec le serveur) utiliseront une promesse, ou quelque chose de très similaire. , pour fournir des résultats de manière asynchrone.

Maintenant, notez également que les returninstructions sont toujours évaluées dans le contexte de la fonction dans laquelle elles apparaissent. Ainsi, lorsque vous avez écrit:

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

l'instruction return token;signifiait que la fonction anonyme transmise then()devait renvoyer le jeton, pas que la AuthUserfonction le devrait. Ce qui AuthUserrevient est le résultat de l'appel google.login(username, password).then(callback);, qui se trouve être une promesse.

En fin de compte, votre rappel token => { return token; }ne fait rien; au lieu de cela, votre entrée then()doit être une fonction qui gère réellement le jeton d'une manière ou d'une autre.

Votre promesse est en attente, complétez-la en

userToken.then(function(result){
console.log(result)
})

après votre code restant. Tout ce que fait ce code, c'est qu'il .then()complète votre promesse et capture le résultat final dans la variable de résultat et le résultat d'impression dans la console. Gardez à l'esprit que vous ne pouvez pas stocker le résultat dans une variable globale. J'espère que cette explication pourrait vous aider.