强制运行计算属性函数

给定计算属性

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

假设getCurrentValues（）可以返回不同的可观察对象集，这些可观察对象集在代码的其他位置进行了修改（并且来自比observableArray更复杂的结构）。

我需要checkedValueCount随时更新

• 其依赖项之一更改
• getCurrentValues（）返回一组不同的可观察值。

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

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

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

简而言之，鉴于我有

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

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

我意识到我的第一个答案错过了您的意思，也无法解决您的问题。

问题在于，只有在存在一些可观察到的迫使其重新评估的情况下，计算者才会重新评估。没有原生方法可以强制计算结果重新评估。

但是，您可以通过创建虚拟的可观察值并告诉其订户它已更改来解决一些黑客问题。

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

}());​

这是显示这种方法的小提琴

有一种方法可以根据您的要求强制重新计算所有可观测值：

getCurrentValues.valueHasMutated()

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

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

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

通知可写计算

一个可写的包装器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函数“访问”的可观察对象的更改。

例如，我正在使用LocalStorage设置一些值，但是对任何可观察到的值均未进行更改以触发重新评估。

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

请注意，所有我需要的变化是ko.computed对ko.notifyingWritableComputed，然后一切都需要自己照顾自己。

当我打电话时hasUserClickedFooButton(true)，“虚拟”可观察值将增加，从而迫使任何订户（及其订户）在更新LocalStorage中的值时获取新值。

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

还有一个仅可读取的可计算可观察值的附加解决方案：

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。

假设getCurrentValues（）可以返回不同的可观察对象集，这些可观察对象集在代码中的其他地方进行了修改

我假设getCurrentValues（）是一个函数。如果您可以对其进行计算，那么您的checkedValueCount就会神奇地开始工作。

您可以使getCurrentValues成为计算的而不是函数的吗？

由于没有直接强制更新计算的直接方法，因此我创建了一个名为toForceComputedUpdate的可观察对象，并在计算函数中调用了它，以便计算机将侦听其更新，然后强制更新，我将其称为toForceComputedUpdate（Math 。随机）