神刀安全网

Promise 反模式

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
});

example2 改变了返回值,因而 result 发生了变化。

更多关键词

async flow control, event loop, callback, promises, generators, async/wait, coroutines

Promises 所做的承诺是保证异步代码顺序执行,并能够链式管理异常和错误。相比使用 event loop 和回调(callback)来控制异步代码的顺序执行,Promises 能够让代码更加清晰易懂。generator 更是从语言级别上提供了更好的支持。

V8 优化

V8 有两个编译器:通用编译器和优化编译器。也就是V8 中的 JavaScript 代码总是被编译成机器码后才执行的。

例如 a + b 编译成汇编代码为:

mov eax, a
mov ebx, b
call RuntimeAdd

但如果 ab 都是整数的话,则会被编译成:

mov eax, a
mov ebx, b
add eax, ebx

这样编译后的代码性能会快很多,因为跳过了 JavaScript 对不同类型数据相加的处理。

通用编译器会得到前一种汇编码,优化编译器会得到后一种汇编码。两种汇编代码性能很容易产生 100 倍的差异。但是存在一些模式,这些模式下的代码优化编译器不会去处理(称为 bail out )。Promises 属于一种被 bail out 的模式。

他山之石

Python greenlets(基于gevent)

go coroutine

转载本站任何文章请注明:转载至神刀安全网,谢谢神刀安全网 » Promise 反模式

分享到:更多 ()

评论 抢沙发

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址