Node.js / Backbone 是否异步?
Node.js / Backbone async or not?
在我的 node.js backbone 应用程序中,我正在遍历集合并在页面加载时对每个模型执行计算。每个函数都抓取不同的变量来执行计算,并通过restfulapi保存模型。现在我的想法是下面的代码在页面加载和资源方面太 'expensive' 了。但这是异步处理还是将它们合并为一个函数会更好?
render: function() {
this.trigger('calculateSpread');
this.trigger('checkClose');
}
calculateSpread: function() {
stocks.models.forEach(function(model) {
var x = this.model.get('')....
.....calculations
this.model.save()
}
checkClose: function() {
stocks.models.forEach(function(model) {
var x = this.model.get('')....
.....calculations
this.model.save()
}
是的,触发事件是同步的。来源:
trigger: function(name) {
if (!this._events) return this;
var args = slice.call(arguments, 1);
if (!eventsApi(this, 'trigger', name, args)) return this;
var events = this._events[name];
var allEvents = this._events.all;
if (events) triggerEvents(this, events, args);
if (allEvents) triggerEvents(this, allEvents, arguments);
return this;
},
导入函数是triggerEvents,它看起来像一个优化的调度器。请注意,他们都在调用 .call()
和 .apply()
,因此回调将在控制权交还给调用者之前完成。
var triggerEvents = function(obj, events, args) {
var ev, i = -1, l = events.length;
switch (args.length) {
case 0: while (++i < l) (ev = events[i]).callback.call(ev.ctx);
return;
case 1: while (++i < l) (ev = events[i]).callback.call(ev.ctx, args[0]);
return;
case 2: while (++i < l) (ev = events[i]).callback.call(ev.ctx, args[0], args[1]);
return;
case 3: while (++i < l) (ev = events[i]).callback.call(ev.ctx, args[0], args[1], args[2]);
return;
default: while (++i < l) (ev = events[i]).callback.apply(ev.ctx, args);
}
};
因此,处理程序是否 'expensive' 取决于处理程序代码本身。
我认为将它们结合起来会更好,这样就不会为每个模型保存两次,而且也会更干净。这应该同步发生,除非您的计算部分进行异步工作 (ajax)
render: function() {
this.trigger('calculate');
}
calculate: function () {
stocks.models.forEach(function(model) {
this.calculateSpread(model);
this.checkClose(model);
this.model.save()
}
}
calculateSpread: function(model) {
var x = model.get('')....
...calculations
}
checkClose: function(model) {
var x = model.get('')....
.....calculations
}
在我的 node.js backbone 应用程序中,我正在遍历集合并在页面加载时对每个模型执行计算。每个函数都抓取不同的变量来执行计算,并通过restfulapi保存模型。现在我的想法是下面的代码在页面加载和资源方面太 'expensive' 了。但这是异步处理还是将它们合并为一个函数会更好?
render: function() {
this.trigger('calculateSpread');
this.trigger('checkClose');
}
calculateSpread: function() {
stocks.models.forEach(function(model) {
var x = this.model.get('')....
.....calculations
this.model.save()
}
checkClose: function() {
stocks.models.forEach(function(model) {
var x = this.model.get('')....
.....calculations
this.model.save()
}
是的,触发事件是同步的。来源:
trigger: function(name) {
if (!this._events) return this;
var args = slice.call(arguments, 1);
if (!eventsApi(this, 'trigger', name, args)) return this;
var events = this._events[name];
var allEvents = this._events.all;
if (events) triggerEvents(this, events, args);
if (allEvents) triggerEvents(this, allEvents, arguments);
return this;
},
导入函数是triggerEvents,它看起来像一个优化的调度器。请注意,他们都在调用 .call()
和 .apply()
,因此回调将在控制权交还给调用者之前完成。
var triggerEvents = function(obj, events, args) {
var ev, i = -1, l = events.length;
switch (args.length) {
case 0: while (++i < l) (ev = events[i]).callback.call(ev.ctx);
return;
case 1: while (++i < l) (ev = events[i]).callback.call(ev.ctx, args[0]);
return;
case 2: while (++i < l) (ev = events[i]).callback.call(ev.ctx, args[0], args[1]);
return;
case 3: while (++i < l) (ev = events[i]).callback.call(ev.ctx, args[0], args[1], args[2]);
return;
default: while (++i < l) (ev = events[i]).callback.apply(ev.ctx, args);
}
};
因此,处理程序是否 'expensive' 取决于处理程序代码本身。
我认为将它们结合起来会更好,这样就不会为每个模型保存两次,而且也会更干净。这应该同步发生,除非您的计算部分进行异步工作 (ajax)
render: function() {
this.trigger('calculate');
}
calculate: function () {
stocks.models.forEach(function(model) {
this.calculateSpread(model);
this.checkClose(model);
this.model.save()
}
}
calculateSpread: function(model) {
var x = model.get('')....
...calculations
}
checkClose: function(model) {
var x = model.get('')....
.....calculations
}