В чем разница между возвращаемым значением или Promise.resolve от then ()

В чем разница между:

new Promise(function(res, rej) {
    res("aaa");
  })
  .then(function(result) {
    return "bbb";
  })
  .then(function(result) {
    console.log(result);
  });

и это:

new Promise(function(res, rej) {
    res("aaa");
  })
  .then(function(result) {
    return Promise.resolve("bbb");
  })
  .then(function(result) {
    console.log(result);
  });

Я спрашиваю, как я получаю другое поведение, используя Angular и $ http сервис с цепочкой .then (). Слишком много кода, поэтому сначала пример выше.

Правило состоит в том, что если функция, находящаяся в thenобработчике, возвращает значение, обещание разрешается / отклоняется с этим значением, и если функция возвращает обещание, что происходит, следующее thenпредложение будет thenпредложением, возвращаемым функцией. Таким образом, в этом случае первый пример проваливается в нормальной последовательности thensи выводит значения, как и следовало ожидать, во втором примере объект обещания, который возвращается, когда вы делаете Promise.resolve("bbb")'s', является тем, thenкоторый вызывается при сцеплении (для всех намерений и целей). Как это на самом деле работает, более подробно описано ниже.

Цитирование из Обещаний / A + spec:

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

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

Ключевой момент, на который следует обратить внимание, это строка:

если xобещание, прими его состояние [3.4]

ссылка: https://promisesaplus.com/#point-49

Проще говоря, внутри thenфункции обработчика:

А) Когда xэто значение (число, строка и т. Д.):

1. return x эквивалентно return Promise.resolve(x)
2. throw x эквивалентно return Promise.reject(x)

Б) Когда xобещание уже выполнено (больше не ожидается):

1. return xэквивалентно return Promise.resolve(x), если Обещание уже выполнено.
2. return xэквивалентно return Promise.reject(x), если обещание уже было отклонено.

C) Когда xожидается обещание:

1. return xвернет ожидающее обещание, и оно будет оценено в последующем then.

Подробнее об этом читайте в документации Promise.prototype.then () .

Оба ваших примера должны вести себя примерно одинаково.

Значение, возвращаемое в then()обработчике, становится значением разрешения обещания, возвращенного из этого then(). Если значение, возвращаемое внутри, .then является обещанием, возвращенное обещание then()«примет состояние» этого обещания и разрешит / отклонит так же, как и возвращенное обещание.

В первом примере вы возвращаете "bbb"первый then()обработчик, поэтому "bbb"он передается следующему then()обработчику.

Во втором примере вы возвращаете обещание, которое немедленно разрешается со значением "bbb", поэтому "bbb"оно передается следующему then()обработчику. ( Promise.resolve()Здесь посторонний).

Результат тот же.

Если вы можете показать нам пример, который на самом деле демонстрирует другое поведение, мы можем рассказать вам, почему это происходит.

Вы уже получили хороший официальный ответ. Я решил добавить короткий.

Следующие вещи идентичны обещаниям / обещаниям A + :

• Вызов Promise.resolve(в вашем угловом случае это $q.when)
• Вызов конструктора обещаний и разрешение в его преобразователе. В твоем случае это new $q.
• Возврат значения из thenобратного вызова.
• Вызов Promise.all для массива со значением и затем извлечение этого значения.

Таким образом, для обещания или простого значения X все они идентичны:

Promise.resolve(x);
new Promise(function(resolve, reject){ resolve(x); });
Promise.resolve().then(function(){ return x; });
Promise.all([x]).then(function(arr){ return arr[0]; });

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

Разница лишь в том, что вы создаете ненужное обещание, когда делаете return Promise.resolve("bbb"). Возвращение обещания от onFulfilled()обработчика запускает разрешение обещания . Вот как работает цепочка обещаний .