Мой код:

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

И когда я пытаюсь запустить что-то вроде этого:

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

Я собираюсь:

Promise { <pending> }

Но почему?

Моя основная цель - получить токен, из google.login(data.username, data.password)которого возвращается обещание, в переменную. И только после этого выполните некоторые действия.

Обещание всегда будет записываться в состояние ожидания, пока его результаты еще не разрешены. Вы должны вызвать .thenобещание для захвата результатов независимо от состояния обещания (разрешено или все еще ожидает выполнения):

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

Это почему?

Обещания - это только прямое направление; Вы можете решить их только один раз. Разрешенное значение a Promiseпередается его.then или .catchметодам.

подробности

Согласно спецификации Promises / A +:

Процедура разрешения обещания - это абстрактная операция, принимающая в качестве входных данных обещание и значение, которое мы обозначаем как [[Resolve]] (обещание, x). Если x является пригодным для использования, он пытается заставить обещание принять состояние x, при условии, что x ведет себя, по крайней мере, в некоторой степени как обещание. В противном случае он выполняет обещание со значением x.

Такая обработка таблиц позволяет взаимодействовать реализациям обещаний при условии, что они предоставляют метод then, соответствующий Promises / A +. Это также позволяет реализациям Promises / A + «ассимилировать» несовместимые реализации с разумными тогда методами.

Эту спецификацию немного сложно разобрать, поэтому давайте разберемся с ней. Правило такое:

Если функция в .thenобработчике возвращает значение, то Promiseразрешается с этим значением. Если обработчик возвращает другой Promise, то исходный Promiseразрешается с разрешенным значением связанного Promise. Следующий .thenобработчик всегда будет содержать разрешенное значение связанного обещания, возвращенного в предыдущем .then.

Как это работает на самом деле, более подробно описано ниже:

1. Возврат .thenфункции будет разрешенным значением обещания.

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. Если .thenфункция возвращает a Promise, то разрешенное значение этого связанного обещания передается следующему .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"
  });

Я знаю, что этот вопрос был задан 2 года назад, но я столкнулся с той же проблемой, и ответ на эту проблему с ES6, что вы можете просто awaitвозвращать значение функции, например:

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

thenМетод возвращает ожидающее обещание , которое может быть решено асинхронно возвращаемым значением результирующего обработчика , зарегистрированным в вызове then, или отвергнут метание ошибки внутри обработчика вызывается.

Таким образом, вызов AuthUserне будет внезапно регистрировать пользователя в синхронном режиме, но возвращает обещание, зарегистрированные обработчики которого будут вызываться после успешного (или неудачного) входа в систему. Я бы предложил запускать всю обработку входа в систему с помощью thenпункта обещания входа в систему. EG использует именованные функции для выделения последовательности потока:

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

См. Раздел MDN об обещаниях. В частности, посмотрите на возвращаемый тип then ().

Чтобы войти в систему, пользовательский агент должен отправить запрос на сервер и дождаться ответа. Поскольку полное прекращение выполнения вашего приложения во время передачи запроса туда и обратно обычно ухудшает взаимодействие с пользователем, практически каждая функция JS, которая выполняет вход в систему (или выполняет любую другую форму взаимодействия с сервером), будет использовать обещание или что-то очень похожее на него. , чтобы предоставлять результаты асинхронно.

Также обратите внимание, что returnоператоры всегда оцениваются в контексте функции, в которой они появляются. Итак, когда вы написали:

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

это утверждение return token;означало, что анонимная функция then()должна возвращать токен, а не AuthUserфункция. То, что AuthUserвозвращается, является результатом вызова google.login(username, password).then(callback);, который оказывается обещанием.

В конечном итоге ваш обратный вызов token => { return token; }ничего не делает; вместо этого ваш ввод then()должен быть функцией, которая действительно каким-то образом обрабатывает токен.

Ваше обещание ожидается, завершите его

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

после вашего оставшегося кода. Все, что делает этот код, это то, что .then()выполняет ваше обещание и фиксирует конечный результат в переменной результата и выводит результат в консоль. Имейте в виду, что вы не можете сохранить результат в глобальной переменной. Надеюсь, это объяснение поможет вам.