Почему .then () работает без обещаний в JavaScript?

Question

Почему вызов второй функции .then (notPromise) все еще передает аргумент третьей функции .then (обещание C), хотя notPromise () является просто обычной функцией?

Я думал, что только обещания могут бытьиспользуется с .then (), но каким-то образом он все еще выполняется (и передает аргументы) правильно.

promiseA()
    .then(notPromise)
    .then(promiseC);


function promiseA() {
    return new Promise(function (resolve, reject) {
        const string = "a";
        resolve(string);
    });
}


function notPromise(string) {
    const nextString = "b"
    const finalString = string + nextString;

    return finalString;
}


function promiseC(string) {
    return new Promise(function (resolve, reject) {
        const nextString = "c";

        const finalString = string + nextString;

        alert(finalString);
        resolve(finalString);
    });
}

Answer 1

Это имеет отношение к цепочке обещаний, не имеет значения, если последующие вызовы then() не являются обещаниями, они все являются частью цепочки обещаний, хорошо, что вы можете продолжать связывать обещания, что позволяет вамЧтобы выполнить несколько асинхронных / обещающих операций подряд (как описано в вашем примере), вот пример из реальной жизни:

  // This is the generic http call
  private callServer(url: string, method: string, body?: any) {
    const uri = env.apiUrl + url;
    const session = this.sessionToken;

    const headers = {
      'Content-Type': 'application/json',
      'credentials': 'same-origin',
      'x-auth-token': session,
    };

    return fetch(uri, {
      method,
      headers,
      body: JSON.stringify(body),
    })
      .then(this.wait) // this is a timer, returns a promise
      .then(this.checkStatus) // this is a sync call
      .then((r) => r.text()) // r.text() is async
      .then((tx) => tx ? JSON.parse(tx) : {}); // this is sync
  }

Подробнее о цепочке обещаний можно прочитать здесь

Answer 2

Метод then () возвращает Promise. См. Документы .

У обещания есть метод-обработчик.Как только Обещание выполнено или отклонено, соответствующая функция-обработчик будет вызываться асинхронно.Поведение функции-обработчика следует определенному набору правил , как указано здесь .

Давайте рассмотрим их одно за другим.Вот код, который мы будем проверять рядом.Ничего особенного, просто цепочка обещаний, возвращающих значения.

let sequence = new Promise(function (resolve) {
  console.log('Say 1')
  resolve(1)
})

sequence
  .then(() => {
    console.log('Say 2')
    return 2
  })
  .then(() => {
    console.log('Say 3')
  })
  .then(() => {
    console.log('Say 4')
    return Promise.resolve(4)
  })
  .then(() => {
    return new Promise(function (resolve) {
      console.log('Say 5')
      setTimeout(() => { resolve(5) }, 1000)
    })
  })

1. возвращает значение, обещание, возвращаемое затем, разрешается с возвращенным значением в качестве значения;

В коде это Say 2, и ваш оригинальный вопрос.Когда возвращается значение, then() возвращает Обещание, которое разрешается значением, которое вы вернули.

ничего не возвращает, обещание, возвращаемое к тому времени, разрешается с неопределенным значением;

как указано выше.

выдает ошибку, обещание, возвращаемое потом, отклоняется с брошенной ошибкой в ​​качестве значения;

, как указано выше, за исключением того, что теперь then() возвращает обещание, которое было отклонено сваша ошибка.

возвращает уже выполненное обещание, а возвращенное обещание разрешается со значением этого обещания в качестве его значения;

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

возвращает уже отклоненное обещание, а возвращенное обещание отклоняется со значением этого обещания в качестве его значения;

, как указано выше, за исключением того, что теперь оно отклоняется.

возвращает другой объект ожидания обещания, разрешение / отклонение обещания, возвращенного к тому времени, будет следовать за разрешением / отклонением обещания, возвращенного обработчиком.Кроме того, значение обещания, возвращенного к тому времени, будет таким же, как и значение обещания, возвращенного обработчиком.

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

Одна вещь, на которую следует обратить внимание, что я также недавно узнал (предложено @Bergiв комментариях) метод then() всегда создает и возвращает новое Promise до того, как обратные вызовы цепочки даже начали выполняться.Обратные вызовы, которые вы передаете then(), просто сообщают обещанию значение / ошибку, с которой обещание должно быть разрешено / отклонено.

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