Примусово запустити обчислену функцію властивостей

Дано обчислювану властивість

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здається, запам'ятовує останнє повернуте значення і оновлюється лише тоді, коли залежність оновлюється. Це стосується першого випадку, але не останнього.

Те, що я шукаю, - це спосіб змусити checkValueCount до повторного запуску. Щось, що я можу використовувати, наприклад:

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 дзвінка

Просто замініть function<T> (options: KnockoutComputedDefine<T>, context)на, function(options, context)якщо ви не використовуєте Typescript.

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 ​​() є функцією. Якби ви могли зробити це обчислюваним, ваш checkValueCount просто магічно почав би працювати.

Чи можете ви зробити так, щоб getCurrentValues ​​обчислювався замість функції?

оскільки немає прямого способу примусового оновлення обчислюваного, я створив спостережуваний з назвою toForceComputedUpdate, і я викликав його в обчислюваній функції, щоб обчислюваний прослуховував його оновлення, то для примусового оновлення я називаю це як ForceComputedUpdate (Math .random)