转载

Promise 反模式

Promises are about making asynchronous code retain most of the lost properties of synchronous code such as flat indentation and one exception channel. – Bluebird Wiki: Promise Anti Patterns

Promises 是为了让异步代码也能保持这些同步代码的属性：扁平缩进和单异常管道。

Deferred 反模式

这种反模式中， deferred 对象的创建是没有意义的，反而会增加代码的复杂度。

例如：

//Code copyright by Twisternha http://stackoverflow.com/a/19486699/995876 CC BY-SA 2.5
myApp.factory('Configurations', function (Restangular, MotorRestangular, $q) {
    var getConfigurations = function () {
        var deferred = $q.defer();

        MotorRestangular.all('Motors').getList().then(function (Motors) {
            //Group by Config
            var g = _.groupBy(Motors, 'configuration');
            //Map values
            var mapped = _.map(g, function (m) {
                return {
                    id: m[0].configuration,
                    configuration: m[0].configuration,
                    sizes: _.map(m, function (a) {
                        return a.sizeMm
                    })
                }
            });
            deferred.resolve(mapped);
        });
        return deferred.promise;
    };

    return {
        config: getConfigurations()
    }

});

这里的 deferred 对象并没有什么意义，而且可能在出错的情况下无法捕获。

正确的写法应该为：

myApp.factory('Configurations', function (Restangular, MotorRestangular, $q) {
    var getConfigurations = function () {
        //Just return the promise we already have!
        return MotorRestangular.all('Motors').getList().then(function (Motors) {
            //Group by Cofig
            var g = _.groupBy(Motors, 'configuration');
            //Return the mapped array as the value of this promise
            return _.map(g, function (m) {
                return {
                    id: m[0].configuration,
                    configuration: m[0].configuration,
                    sizes: _.map(m, function (a) {
                        return a.sizeMm
                    })
                }
            });
        });
    };

    return {
        config: getConfigurations()
    }

});

再举一个例子：

function applicationFunction(arg1) {
  var deferred = Promise.pending(); // 获取 Q.defer()
  libraryFunction(arg1, function(err, value) {
    if (err) {
      deferred.reject(err);
    } else {
      deferred.resolve(value);
    }
  });
  return deferred.promise;
}

这就像重复造轮子，因为回调 API 的封装应该使用 promise 库的 promisification（promise 化）方法实现：

var applicationFunction = Promise.promisify(libraryFunction);

通用 promise 化可能更快，因为可以借助 Promise 的内部操作，还能处理一些极端情况：例如 libraryFunction 同步抛异常或者用到了多个成功值。

什么时候使用 deferred？

必须用的时候。

当要封装的回调 API 和规范不一致时，例如 setTimeout ：

// 通过 setTimeout 返回 promise
function delay(ms) {
  var deferred = Promise.pending();
  setTimeout(function() {
    deferred.resolve();
  }, ms);
  return deferred.promise;
}

`.then(success, fail)` 反模式

这样使用 .then 就像下面这段代码：

var t0;
try {
  t0 = doThat();
} catch(e) {
}

// 这样报错发生时会 catch 不到
var staff = JSON.parse(t0);

正常的同步写法是：

try {
  var stuff = JSON.parse(doThat());
} catch(e) {
}

所以正确的 .then 用法应该是：

doThat()
.then(function(v) {
  return JSON.parse(v);
})
.catch(function(e) {
});

嵌套 Promise

例如：

loadSomething().then(function(something) {
  loadAnothering().then(function(another) {
    DoSomethingOnThem(something, another);
  });
});

如果只是想对两个 promise 的结果做处理，可以使用 Promise.all 方法：

Promise.all([loadSomething, loadAnothering]).then(function(something, another) {
  DoSomethingOnThem(something, another);
});

断链

例如：

function anAsyncCall() {
  var promise = doSomethingAsync();
  promise.then(function() {
    somethingComplicated();
  });
  return promise;
}

这里的问题在于加入 somethingComplicated() 出错的话不会被捕获。promise 应该链式调用。也就是说所有的 then 方法都应该返回一个新的 promise 。所以上面代码的正确写法为：

function anAsyncCall() {
  var promise = doSomethingAsync();
  return promise.then(function() {
    somethingComplicated();
  });
}

集合

例如需要对一个集合中的每个元素执行异步操作：

function workMyCollection(arr) {
  var resultArr = [];
  function _recursive(idx) {
    if (idx >= resultArr.length) return resultArr;
    return doSomethingAsync(arr[idx]).then(function(res) {
      resultArr.push(res);
      return _recursive(idx + 1);
    });
  }
  return _recursive(0);
}

这里的问题在于需要遍历数组，其实可以用 promise.all 解决：

function workMyCollection(arr) {
  return q.all(
    arr.map(function(item) {
      return doSomethingAsync(item);
    })
  );    
}

总结

最容易犯的错误，没有使用 catch 去捕获 then 里抛出的报错：

// snippet1
somePromise().then(function () {
  throw new Error('oh noes');
}).catch(function (err) {
  // I caught your error! :)
});

// snippet2
somePromise().then(function resolve() {
  throw new Error('oh noes');
}, function reject(err) {
  // I didn't catch your error! :(
});

这里的问题在于 snippet2 在 function resolve 中出错时无法捕获。而 catch 则可以。

下面的两个示例返回结果是不一样的：

// example1
Promise.resolve('foo').then(Promise.resolve('bar')).then(function (result) {
  console.log(result);  // foo
});
// example2
Promise.resolve('foo').then(function () {
  return Promise.resolve('bar')
}).then(function (result) {
  console.log(result); // bar
});