好吧，标题有点说明了我的需要。因为在 Javascript 超时异步中，我需要知道什么时候变成真的。我不想要busyloop。
想出了：
function do_when(predicate, action, timeout_step) {
if (predicate()) {
action();
} else {
setTimeout(do_when, timeout_step, predicate, action, timeout_step);
}
}
它是好的 Javascript 还是我可以做得更好？
【问题讨论】：
标签： javascript
根据谓词是什么，您也许可以将您的问题放入observer pattern 的实现中。不久前，我写了一篇关于 creating JavaScript objects with observable properties 的博客文章。这实际上取决于谓词 是什么，但这可能会让您在大多数情况下使用如下代码：
var observable = createObservable({ propToWatch: false });
observable.observe('propToWatch', function (oldValue, newValue) {
alert('propToWatch has changed from ' + oldValue + ' to ' + newValue);
});
observable.propToWatch(true); // alert pops
当然，对于您的示例来说，这可能有点过头了。由于它从未明确列出（注：我不是一个很好的博主），以下是完成这项工作所需的完整代码：
var createMediator = function () {
var events = {};
return {
subscribe: function (eventName, callback) {
events[eventName] = events[eventName] || [];
events[eventName].push(callback);
},
publish: function (eventName) {
var i, callbacks = events[eventName], args;
if (callbacks) {
args = Array.prototype.slice.call(arguments, 1);
for (i = 0; i < callbacks.length; i++) {
callbacks[i].apply(null, args);
}
}
}
};
};
var createObservable = function (properties) {
var notifier = createMediator(), createObservableProperty, observable;
createObservableProperty = function (propName, value) {
return function (newValue) {
var oldValue;
if (typeof newValue !== 'undefined' &&
value !== newValue) {
oldValue = value;
value = newValue;
notifier.publish(propName, oldValue, value);
}
return value;
};
};
observable = {
register: function (propName, value) {
this[propName] = createObservableProperty(propName, value);
this.observableProperties.push(propName);
},
observe: function (propName, observer) {
notifier.subscribe(propName, observer);
},
observableProperties: []
};
for (propName in properties) {
observable.register(propName, properties[propName]);
}
return observable;
};
我的可观察对象在内部使用了我曾经为一个项目编写的小型事件框架（createMediator 函数）。 （在意识到 jQuery 支持自定义事件之前。D'oh！）再一次，这可能会或可能不会满足您的需求，但我认为这是一个有趣的 hack。享受吧！
【讨论】：
observable.propToWatch.observe(function () { ... })。那好吧。也许我以后可以多做一些修改。
如果你的谓词在变量改变时变为真，这里是另一种解决方案：
假设当对象 a 的值变为 2 时，我们想记录“老大哥在看着你”。
function observable (value, condition, callback){
this.value = value;
this.condition = condition;
this.callback = callback;
}
observable.prototype = {
get value () {
return this._value;
},
set value (value) {
this._value = value;
if (this.condition && this.callback && this.condition (value)) {
this.callback (value);
}
}
};
condition = function (value) {
console.log ('condition', value);
return value === 2;
}
callback = function (value) {
console.info ('Big Brother is watching you!');
}
var a = new observable (0, condition, callback);
console.log ('set value to 1');
a.value = 1;
console.log ('set value to 2');
a.value = 2;
console.log ('set value to 3');
a.value = 3;
你可以在firefox中试试这个例子
【讨论】：
它足够好，如果它足够容易阅读并且运行良好，那么它通常是好的 javascript。
在性能方面，通常最好在任何设置为 true 的情况下调用该函数。因此，无论执行什么使predicate() 返回true 的函数，您都可以在最后调用action()。但我敢肯定，如果可以的话，你会这样做，对吧？
您还可以考虑使用回调，将 javascript 函数注册到特定变量或函数参数，当函数运行时，它会执行设置为回调变量的任何函数。
【讨论】：