Mój kod:

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

A kiedy próbuję uruchomić coś takiego:

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

Otrzymuję:

Promise { <pending> }

Ale dlaczego?

Moim głównym celem jest uzyskanie tokena, z google.login(data.username, data.password)którego zwraca obietnicę, do zmiennej. I dopiero wtedy wykonaj pewne czynności.

Obietnica będzie zawsze rejestrowana jako oczekująca, o ile jej wyniki nie zostaną jeszcze rozwiązane. Musisz odwołać .thensię do obietnicy, aby uchwycić wyniki niezależnie od stanu obietnicy (rozwiązany lub wciąż oczekujący):

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

Dlaczego?

Obietnice dotyczą tylko kierunku naprzód; Możesz je rozwiązać tylko raz. Rozstrzygnięta wartość a Promisejest przekazywana do jej metod .thenlub .catch.

Detale

Zgodnie ze specyfikacją Promises / A +:

Procedura rozstrzygania obietnic jest abstrakcyjną operacją przyjmującą jako dane wejściowe obietnicę i wartość, którą oznaczamy jako [[Rozwiąż]] (obietnica, x). Jeśli x jest zdolny do działania, to stara się, aby obietnica przyjęła stan x, przy założeniu, że x zachowuje się przynajmniej trochę jak obietnica. W przeciwnym razie spełnia obietnicę o wartości x.

Takie traktowanie elementów umożliwia współpracę obiecujących implementacji, o ile ujawniają one następnie metodę Promises / A +. Pozwala również implementacjom Promises / A + na „asymilację” niezgodnych implementacji z rozsądnymi metodami.

Ta specyfikacja jest trochę trudna do przeanalizowania, więc podzielmy ją. Zasada jest taka:

Jeśli funkcja w programie .thenobsługi zwraca wartość, to jest Promiserozwiązywana z tą wartością. Jeśli przewodnik zwróci inny Promise, oryginał zostanie Promiserozstrzygnięty z rozstrzygniętą wartością łańcucha Promise. Następny .thenprogram obsługi zawsze będzie zawierał rozstrzygniętą wartość połączonej obietnicy zwróconej w poprzednim .then.

Sposób, w jaki to faktycznie działa, opisano bardziej szczegółowo poniżej:

1. Zwrot .thenfunkcji będzie ustaloną wartością promesy.

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. Jeśli .thenfunkcja zwraca a Promise, to rozwiązana wartość tej połączonej obietnicy jest przekazywana do następującego .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"
  });

Wiem, że to pytanie zostało zadane 2 lata temu, ale napotykam ten sam problem, a odpowiedź na problem jest taka, że ​​od ES6 można po prostu awaitfunkcje zwracać wartość, na przykład:

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

thenMetoda zwraca oczekujące obietnicę, które mogą być rozwiązane w sposób asynchroniczny o wartości zwracanej handlera wynik zarejestrowany w wywołaniu thenlub odrzucony przez rzucanie błąd wewnątrz przewodnika nazwie.

Tak więc wywołanie AuthUsernie spowoduje nagłego zalogowania użytkownika synchronicznie, ale zwróci obietnicę, której następnie zarejestrowane procedury obsługi zostaną wywołane po pomyślnym (lub niepowodzeniu) logowania. Sugerowałbym wyzwalanie całego przetwarzania logowania thenklauzulą ​​obietnicy logowania. EG używając nazwanych funkcji do wyróżnienia sekwencji przepływu:

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

Zobacz sekcję MDN dotyczącą obietnic. W szczególności spójrz na zwracany typ then ().

Aby się zalogować, agent użytkownika musi wysłać żądanie do serwera i czekać na odpowiedź. Ponieważ całkowite wstrzymanie wykonywania aplikacji podczas przesyłania żądania w obie strony zwykle powoduje złe wrażenia użytkownika, praktycznie każda funkcja JS, która loguje Cię (lub wykonuje jakąkolwiek inną formę interakcji z serwerem), będzie używać Obietnicy lub czegoś bardzo podobnego , aby dostarczać wyniki asynchronicznie.

Zauważ też, że returninstrukcje są zawsze oceniane w kontekście funkcji, w której się pojawiają. Kiedy więc napisałeś:

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

instrukcja return token;oznaczała, że ​​przekazywana funkcja anonimowa then()powinna zwracać token, a nie AuthUserfunkcja powinna. To, co AuthUserwraca, jest wynikiem wezwania google.login(username, password).then(callback);, które okazuje się być obietnicą.

Ostatecznie twój callback token => { return token; }nic nie robi; zamiast tego dane wejściowe then()muszą być funkcją, która w jakiś sposób obsługuje token.

Twoja obietnica oczekuje na realizację, wypełnij ją do

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

po pozostałym kodzie. Wszystko, co robi ten kod, to .then()wypełnienie obietnicy i uchwycenie wyniku końcowego w postaci zmiennej wyniku i wyniku drukowania w konsoli. Pamiętaj, że nie możesz przechowywać wyniku w zmiennej globalnej. Mam nadzieję, że to wyjaśnienie może ci pomóc.