Question

好的标题有点说我需要的东西。因为在Javascript超时异步中我需要知道什么时候变成了现实。我不想要忙碌。

提出：

function do_when(predicate, action, timeout_step) {
    if (predicate()) {
        action();
    } else {
        setTimeout(do_when, timeout_step, predicate, action, timeout_step);
    }
}

这是好的Javascript还是我可以做得更好？

Answer 1

根据谓词的不同，您可以将问题纳入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

当然，这可能对你的例子来说太过分了。由于它从未明确列出（n.b.我不是一个非常好的博客），这里是完成这项工作所需的完整代码：

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'哦！）同样，这可能会或可能不会超出您的需求，但我认为这是一个有趣的黑客。享受！

Answer 2

它足够好，如果它很容易阅读并且它工作得很好那么它通常是很好的javascript。

在性能方面，无论何时设置为true都会调用该函数通常会更好。因此，无论执行什么函数使predicate()返回true，您最后都可以调用action()。但我敢肯定，如果可以，那就是你会做的，对吧？

您还可以查看使用回调函数，其中您将javascript函数注册到特定的变量或函数参数，并且当函数运行时，它会执行为回调变量设置的任何函数。

Answer 3

如果你的谓词在变量变化时变为真，那么这是另一个解决方案：

当对象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，等待某事真实然后运行动作

3 个答案: