Обещания Нолана / головоломки JavaScript a+

doSomething().then(function () {
  return doSomethingElse();
});

почему функция doSomethingElse () в 1-й головоломке имеет неопределенное значение? На мой взгляд, это должно привести к чему-то вроде 4-й головоломки.

обещанный результат doSomething передается анонимной функции (которая даже не принимает аргумент). Поэтому все, что там проходит, теряется. И doSomethingElse вызывается без каких-либо аргументов, поэтому первый аргумент функции undefined.

doSomething().then(doSomethingElse());

doSomething().then(doSomethingElse);

что разница между 3-й и 4-й уровень? В 3-й головоломке сначала пишем doSomethingElse (), а в 4-й головоломке пишем здесь только название функции - doSomethingElse. Как это возможно? Что на самом деле делает doSomethingElse в то 4-й головоломки?

функции в JavaScript-это объекты, которые вы можете передавать по своему усмотрению. Вот как на самом деле работает вся передача обратного вызова: есть функция (здесь это then), которая принимает функцию в качестве параметра, который затем позже вызывается.

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

почему функция doSomethingElse () в 3-й головоломки начать в тот же момент, как doSomething?

как я уже сказал, функция немедленно вызывается, в то же время вы вызываете doSomething. Только возвращаемое значение передается в then который затем будет называться, как только обещание разрешится.

вы должны обратить внимание: doSomethingElse является ссылкой на функцию while doSomethingElse() означает, что вы сразу" вызываете " функцию. Здесь вы можете получить результат функции, если таковые имеются...

насчет обещаний я понял, что:

A) метод "then" принимает результат предыдущего вызова и передает его как параметр своему собственному параметру, если это функция.

B) выполнение задерживается только в том случае, если функция внутри метода " then что-то.

в этих ситуациях мы имеем:

головоломка 1) resultOfDoSomething используется в качестве параметра для анонимной функции

function (){ return doSomethingElse ();} 

Это doSomethingElse() без параметров.

головоломка 2) анонимная функция не возвращает данные, поэтому следующий "затем" немедленно выполняется

Головоломка 3) выражение doSomethingElse() является результатом вызова doSomethingElse. Это значение используется в качестве параметра для метода then, и поскольку он не является функцией (в данном примере!), мы можем перейти к другому "тогда"...

finalHandler получает последние допустимые результаты в качестве параметров, в этом случае resultOfDoSomething.

головоломка 4) Каждый метод "тогда" получает в качестве параметра ссылку на функцию. Каждая из этих функций будет вызываться с предыдущими результатами в качестве параметров. Таким образом, каждая функция должна ждать результата предыдущего выполнения... и вот у вас очередь из обещаний...

Long story short-простые 2 правила, чтобы сделать ваши примеры понятными:

1. возврат значения изнутри .then Это то же самое, что вернуть обещание, которое разрешается с этим значением.

2. когда вы ничего не возвращаете, это то же самое, что и возвращение undefined, который в свою очередь вводит правило #1.

Если вы держите эти 2 в виду, ваши обещания головоломки становятся ясными, как день.

почему doSomethingElse() функция в 1-й головоломки есть undefined значение? По-моему, должно быть ... --6--> как в 4-й головоломки.

Неа. The resultOfDoSomething передается обратному вызову, что then был вызван, да, но мы просто игнорируем его в первом коде:

doSomething().then(function(resultOfDoSomething) {
//               it's here: ^^^^^^^^^^^^^^^^^^^
    return doSomethingElse(  );
//          but not there: ^^ - Ooops!
});

в чем разница между 3-й и 4-й головоломки? В 3-й головоломке в первой тогда напишем doSomethingElse() и в 4-й головоломке мы пишем здесь только имя функции, doSomethingElse. Как это возможно? Что действительно doSomethingElse сделать внутри то 4-й головоломки?

как вы, вероятно, знаете, это разница между вызываемой функцией и самой функцией.

кроме того, мы всегда хотим - no: must - передать функцию обратного вызова в then(…). Следующие два эквивалентны:

promise.then(function callback(res) {
    …
});

function callback(res) {
    …
}
promise.then(callback);

это ожидается-вы передаете функцию вызову, поэтому она прикована к обещанию как обычный. Но!--13--> (с вызовом) больше не является функцией:

почему doSomethingElse() функция в 3-й головоломки начать в тот же момент, как doSomething?

потому что он вызывается сразу в выражении then(doSomethingElse()) - это на самом деле называется до then, к которому это аргумент. Так это на самом деле называется через мгновение после doSomething(), но на том же повороте цикла событий; и два асинхронных somethings будут работать в параллельный.

и then принимает только аргументы функции, все остальное -игнорировать. Таким образом, здесь нет цепей, это то же самое, что делать

var promise = doSomething();
doSomethingElse();
promise.then(finalHandler);

не то, что мы хотим!

кстати, они также объясняются как"Расширенная Ошибка #3: обещания против обещаний фабрики" и "Расширенная Ошибка #5: обещания проваливаются", которые я бы оба рассматривал как ошибки новичка : -)

Я думаю, что порядок выполнения всегда сначала doSomethingElse затем doSomethingElse и finalHandler. Это просто синтаксис JavaScript.

разница в том, что args передают функции разные.

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

/**
 * Created by tshungle on 17-2-24.
 */
'use strict'
function doSomething() {
  console.log("doSomething start");
  sleep(1000)
  console.log("doSomething end");
  return new Promise(function (resolve, reject) {
    setTimeout(function() {
      console.log("Promise of doSomething is about to resolve");
      resolve("doSomething resolvation")
    }, 2500);
  });

}

function doSomethingElse() {
  console.log("doSomethingElse start");
  sleep(1000);
  console.log("doSomethingElse end");
  return new Promise(function (resolve, reject) {
    setTimeout(function() {
      console.log("Promise of doSomethingElse is about to resolve");
      resolve("doSomethingElse resolvation")
    }, 2500);
  });
}

function finalHandler(result) {
  console.log("finalHandler result is:", result);
}

function sleep(ms) {
  var stop = new Date().getTime();
  while(new Date().getTime() < stop + ms) {
    ;
  }
}


//1
 doSomething().then(function () {
   return doSomethingElse();
 }).then(finalHandler);

//2
// doSomething().then(function () {
//   doSomethingElse();
// }).then(finalHandler);
//
//3
// doSomething().then(doSomethingElse())
//   .then(finalHandler);

//4
// doSomething().then(doSomethingElse)
//   .then(finalHandler);