强制计算属性函数运行

Question

给定一个计算属性

vm.checkedValueCount = ko.computed(function(){
  var observables = getCurrentValues();  //an array of ko.observable[]
  return _.filter(observables, function(v) { return v() }).length;
});

假设 getCurrentValues() 可以返回不同的 observable 集合，这些集合在代码的其他地方被修改（并且来自比 observableArray 更复杂的结构）。

我需要checkedValueCount随时更新

• 其中一个依赖项发生了变化
• getCurrentValues() 返回一组不同的 observables。

问题在于ko.computed 似乎记住了最后返回的值，并且仅在依赖项更新时才更新。这处理第一种情况，但不处理后者。

我正在寻找一种强制checkedValueCount 重新运行的方法。我可以使用的东西：

changeCurrentValues();
vm.checkeValueCount.recalculate();

简单地说，我有

a = ko.computed(function() { return Math.random() })

如何强制调用 a() 两次以返回不同的值。

Answer 1

我意识到我的第一个答案错过了您的观点，并且不会解决您的问题。

问题是，如果有一些 observable 迫使它重新评估，那么计算只会重新评估。没有本地方法可以强制计算重新评估。

但是，您可以通过创建一个虚拟的可观察值然后告诉它的订阅者它已经改变来解决这个问题。

(function() {

    var vm = function() {
        var $this = this;

        $this.dummy = ko.observable();

        $this.curDate = ko.computed(function() {
            $this.dummy();
            return new Date();
        });

        $this.recalcCurDate = function() {
            $this.dummy.notifySubscribers();
        };        
    };

    ko.applyBindings(new vm());

}());​

Here is a Fiddle 展示了这种方法

Answer 2

a method 可以根据你的情况强制重新计算所有 observables：

getCurrentValues.valueHasMutated()

Answer 3

这个答案在概念上与@josh 给出的答案相同，但呈现为更通用的包装器。注意：此版本适用于“可写”计算。

我使用的是 Typescript，所以我首先包含了 ts.d 定义。因此，如果与您无关，请忽略第一部分。

interface KnockoutStatic
{
    notifyingWritableComputed<T>(options: KnockoutComputedDefine<T>, context ?: any): KnockoutComputed<T>;
}

通知可写计算

一个可写的observable 的包装器，总是导致订阅者收到通知 - 即使没有任何 observable 因write 调用而更新

如果您不使用 Typescript，只需将 function<T> (options: KnockoutComputedDefine<T>, context) 替换为 function(options, context)。

ko.notifyingWritableComputed = function<T> (options: KnockoutComputedDefine<T>, context)
{
    var _notifyTrigger = ko.observable(0);
    var originalRead = options.read;
    var originalWrite = options.write;

    // intercept 'read' function provided in options
    options.read = () =>
    {
        // read the dummy observable, which if updated will 
        // force subscribers to receive the new value
        _notifyTrigger();   
        return originalRead();
    };

    // intercept 'write' function
    options.write = (v) =>
    {
        // run logic provided by user
        originalWrite(v);

        // force reevaluation of the notifyingWritableComputed
        // after we have called the original write logic
        _notifyTrigger(_notifyTrigger() + 1);
    };

    // just create computed as normal with all the standard parameters
    return ko.computed(options, context);
}

主要用例是当您更新不会触发 read 函数“访问”的 observable 更改的内容时。

例如，我正在使用 LocalStorage 设置一些值，但没有任何可观察到的变化来触发重新评估。

hasUserClickedFooButton = ko.notifyingWritableComputed(
{
    read: () => 
    {
        return LocalStorageHelper.getBoolValue('hasUserClickedFooButton');
    },
    write: (v) => 
    {
        LocalStorageHelper.setBoolValue('hasUserClickedFooButton', v);        
    }
});

请注意，我只需要将ko.computed 更改为ko.notifyingWritableComputed，然后一切都会自行处理。

当我调用 hasUserClickedFooButton(true) 时，'dummy' observable 会递增，强制任何订阅者（及其订阅者）在 LocalStorage 中的值更新时获取新值。

（注意：您可能认为notify: 'always' 扩展器是这里的一个选项 - 但这是不同的）。

---

对于只可读的计算 observable 有一个额外的解决方案：

ko.forcibleComputed = function(readFunc, context, options) {
    var trigger = ko.observable().extend({notify:'always'}),
        target = ko.computed(function() {
            trigger();
            return readFunc.call(context);
        }, null, options);
    target.evaluateImmediate = function() {
        trigger.valueHasMutated();
    };
    return target;
};


myValue.evaluateImmediate();

来自@mbest 评论https://github.com/knockout/knockout/issues/1019。

Answer 4

假设 getCurrentValues() 可以返回不同的 observables 集 在代码的其他地方进行了修改

我假设 getCurrentValues() 是一个函数。如果您可以将其设为计算值，您的 checkedValueCount 就会神奇地开始工作。

你能让 getCurrentValues 成为一个计算值而不是一个函数吗？

Answer 5

由于没有直接的方法来强制更新计算，我创建了一个名为 toForceComputedUpdate 的 observable，我在计算函数中调用它，因此计算将监听它的更新，然后强制更新我这样称呼它toForceComputedUpdate(Math.random)