Il mio codice:

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

E quando provo a eseguire qualcosa del genere:

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

Sto ottenendo:

Promise { <pending> }

Ma perché?

Il mio obiettivo principale è ottenere un token da google.login(data.username, data.password)cui restituisce una promessa, in una variabile. E solo allora preforma alcune azioni.

La promessa sarà sempre registrata in sospeso fino a quando i suoi risultati non saranno ancora risolti. È necessario chiamare .thenla promessa per acquisire i risultati indipendentemente dallo stato della promessa (risolta o ancora in sospeso):

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

Perché?

Le promesse sono solo una direzione in avanti; Puoi risolverli solo una volta. Il valore risolto di a Promiseviene passato ai suoi metodi .theno .catch.

Dettagli

Secondo le specifiche Promises / A +:

La procedura di risoluzione della promessa è un'operazione astratta che prende come input una promessa e un valore, che indichiamo come [[Risolvi]] (promessa, x). Se x è una variabile, tenta di fare in modo che la promessa adotti lo stato di x, assumendo che x si comporti almeno in qualche modo come una promessa. Altrimenti, soddisfa la promessa con il valore x.

Questo trattamento degli oggetti di valore consente alle implementazioni delle promesse di interagire, purché espongano un metodo conforme alle promesse / A +. Consente inoltre alle implementazioni Promises / A + di "assimilare" implementazioni non conformi con metodi ragionevoli.

Questa specifica è un po 'difficile da analizzare, quindi analizziamola. La regola è:

Se la funzione nel .thengestore restituisce un valore, allora si Promiserisolve con quel valore. Se il gestore ne restituisce un altro Promise, l'originale si Promiserisolve con il valore risolto del concatenato Promise. Il .thengestore successivo conterrà sempre il valore risolto della promessa concatenata restituita nel precedente .then.

Il modo in cui funziona effettivamente è descritto di seguito in modo più dettagliato:

1. Il ritorno della .thenfunzione sarà il valore risolto della promessa.

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. Se la .thenfunzione restituisce a Promise, il valore risolto di quella promessa concatenata viene passato al seguente .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"
  });

So che questa domanda è stata posta 2 anni fa, ma mi imbatto nello stesso problema e la risposta al problema è da ES6, che puoi semplicemente awaitle funzioni restituire un valore, come:

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

Il thenmetodo restituisce una promessa in sospeso che può essere risolta in modo asincrono dal valore di ritorno di un gestore dei risultati registrato nella chiamata athen , o rifiutata lanciando un errore all'interno del gestore chiamato.

Quindi la chiamata AuthUsernon registrerà improvvisamente l'utente in modo sincrono, ma restituirà una promessa i cui gestori registrati in quel momento verranno chiamati dopo che l'accesso riesce (o fallisce). Suggerirei di attivare tutta l'elaborazione dell'accesso tramite una thenclausola della promessa di accesso. Ad esempio utilizzando funzioni denominate per evidenziare la sequenza del flusso:

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

Vedere la sezione MDN sulle promesse. In particolare, guarda il tipo restituito di then ().

Per accedere, lo user-agent deve inviare una richiesta al server e attendere di ricevere una risposta. Dal momento che interrompere completamente l'esecuzione della tua applicazione durante un round-trip della richiesta di solito crea un'esperienza utente negativa, praticamente ogni funzione JS che ti accede (o esegue qualsiasi altra forma di interazione con il server) utilizzerà una promessa, o qualcosa di molto simile , per fornire risultati in modo asincrono.

Ora, nota anche che le returnistruzioni sono sempre valutate nel contesto della funzione in cui compaiono. Quindi, quando hai scritto:

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

l'istruzione return token;significava che la funzione anonima a cui si stava passando then()dovrebbe restituire il token, non che la AuthUserfunzione dovrebbe. Ciò che AuthUserritorna è il risultato della chiamata google.login(username, password).then(callback);, che sembra essere una promessa.

Alla fine la tua richiamata token => { return token; }non fa nulla; invece, il tuo input then()deve essere una funzione che effettivamente gestisce il token in qualche modo.

La tua promessa è in sospeso, completala entro

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

dopo il codice rimanente. Tutto ciò che fa questo codice è che .then()completa la tua promessa e cattura il risultato finale nella variabile del risultato e stampa il risultato nella console. Tieni presente che non puoi memorizzare il risultato nella variabile globale. Spero che questa spiegazione possa aiutarti.