有什么区别:

新承诺(函数(res, rej) { res(“aaa”); }） 不要犹豫(函数(结果){ 返回" bbb ";//直接返回字符串 }） 不要犹豫(函数(结果){ console.log(结果); })；

这:

new Promise（function（res， rej） { res（“aaa”）; }) .then（function（result） { 返回 Promise.resolve（“bbb”）;返回承诺 }) .then（function（result） { 控制台.log（结果）; });

我问，因为我得到了不同的行为使用Angular和$http服务链接.then()。代码有点多，所以首先是上面的例子。

考虑下面以串行/顺序方式读取文件数组的代码。readFiles返回一个承诺，只有在顺序读取所有文件后才会解析这个承诺。

var readFile = function(file) {
  ... // Returns a promise.
};

var readFiles = function(files) {
  return new Promise((resolve, reject) => {
    var readSequential = function(index) {
      if (index >= files.length) {
        resolve();
      } else {
        readFile(files[index]).then(function() {
          readSequential(index + 1);
        }).catch(reject);
      }
    };

    readSequential(0); // Start with the first file!
  });
};

上面的代码可以工作，但是我不喜欢为了使事情按顺序发生而进行递归。是否有一种更简单的方法可以重写这段代码，这样我就不必使用奇怪的readSequential函数了?

最初我尝试使用Promise。但是这会导致所有的readFile调用并发发生，这不是我想要的:

var readFiles = function(files) {
  return Promise.all(files.map(function(file) {
    return readFile(file);
  }));
};

无论是ES6承诺还是蓝鸟承诺，Q承诺等等。

我如何测试，看看一个给定的对象是一个承诺?

我已经开发JavaScript好几年了，我完全不理解关于承诺的大惊小怪。

似乎我所做的就是改变:

api(function(result){
    api2(function(result2){
        api3(function(result3){
             // do work
        });
    });
});

无论如何，我可以使用像async这样的库，比如:

api().then(function(result){
     api2().then(function(result2){
          api3().then(function(result3){
               // do work
          });
     });
});

代码更多，可读性更差。我在这里没有获得任何东西，它也没有突然神奇地“变平”。更不用说把事情变成承诺了。

那么，承诺有什么好大惊小怪的呢?

我写的代码是这样的:

function getStuffDone(param) {           | function getStuffDone(param) {
    var d = Q.defer(); /* or $q.defer */ |     return new Promise(function(resolve, reject) {
    // or = new $.Deferred() etc.        |     // using a promise constructor
    myPromiseFn(param+1)                 |         myPromiseFn(param+1)
    .then(function(val) { /* or .done */ |         .then(function(val) {
        d.resolve(val);                  |             resolve(val);
    }).catch(function(err) { /* .fail */ |         }).catch(function(err) {
        d.reject(err);                   |             reject(err);
    });                                  |         });
    return d.promise; /* or promise() */ |     });
}                                        | }

有人告诉我这分别被称为“延迟反模式”或“承诺构造函数反模式”，这段代码有什么不好的地方，为什么它被称为反模式?