चलाने के लिए एक कम्प्यूटेड संपत्ति फ़ंक्शन को बाध्य करें

Question 1

एक गणना की गई संपत्ति को देखते हुए

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

मान लीजिए कि getCurrentValues () वेधशालाओं के विभिन्न सेटों को वापस कर सकते हैं जो कोड में कहीं और संशोधित किए गए हैं (और एक अवलोकन योग्य से अधिक जटिल संरचना से आता है)।

मुझे checkedValueCountजब भी अपडेट करना होगा

इसकी एक निर्भरता बदल जाती है
getCurrentValues () वेधशालाओं का एक अलग सेट लौटाता है।

समस्या यह है कि ko.computedअंतिम रिटर्न मान को याद करने के लिए लगता है और केवल जब एक निर्भरता अद्यतन अद्यतन करता है। यह पहला मामला संभालता है लेकिन बाद वाला नहीं।

मैं जो खोज रहा हूं वह चेकवैल्यू को फिर से चलाने के लिए मजबूर करने का एक तरीका है। कुछ जो मैं उपयोग कर सकता हूं:

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

सबसे सरल शब्दों में कहें, तो यह मेरे पास है

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

मैं a()विभिन्न मूल्यों को वापस करने के लिए दो बार कैसे मजबूर कर सकता हूं ।

Question 2

मुझे एहसास हुआ कि मेरा पहला जवाब आपकी बात से चूक गया, और आपकी समस्या का समाधान नहीं होगा।

समस्या यह है कि एक गणना केवल पुनर्मूल्यांकन होगी यदि कुछ अवलोकन योग्य है जो इसे फिर से मूल्यांकन करने के लिए मजबूर करता है। गणना के लिए फिर से मूल्यांकन करने के लिए मजबूर करने का कोई मूल तरीका नहीं है।

हालाँकि, आप इसे डमी ऑब्जर्वेबल मान बनाकर कुछ हैकरी के साथ प्राप्त कर सकते हैं और फिर अपने ग्राहकों को बता सकते हैं कि यह बदल गया है।

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

}());

यहाँ एक फिडेल है जो इस दृष्टिकोण को दिखा रहा है

Question 3

नहीं है एक विधि तुम्हारा के आधार पर सभी observables के बल पुनर्गणना के लिए:

getCurrentValues.valueHasMutated()

Question 4

यह उत्तर वैचारिक रूप से वैसा ही है जैसा कि एक @ जोश ने दिया था, लेकिन एक अधिक सामान्य आवरण के रूप में प्रस्तुत किया। नोट: यह संस्करण एक 'लिखने योग्य' गणना के लिए है।

मैं टाइपस्क्रिप्ट का उपयोग कर रहा हूं इसलिए मैंने पहले tdd परिभाषा को शामिल किया है। इसलिए इस पहले भाग को नजरअंदाज करें यदि आप के लिए प्रासंगिक नहीं है।

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

सूचना-लेखन-संगणित

एक लिखने योग्य के लिए एक आवरण `observable`जो हमेशा ग्राहकों को सूचित करता है - भले ही कोई वेधशाला `write`कॉल के परिणामस्वरूप अपडेट नहीं की गई हो

यदि आप टाइपस्क्रिप्ट का उपयोग नहीं करते हैं तो बस इसके 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फ़ंक्शन द्वारा 'अवलोकन' किए गए अवलोकन में परिवर्तन को ट्रिगर नहीं करेगा ।

उदाहरण के लिए मैं कुछ मान सेट करने के लिए लोकलस्टोरेज का उपयोग कर रहा हूं, लेकिन पुनर्मूल्यांकन को ट्रिगर करने के लिए किसी भी अवलोकन के लिए कोई परिवर्तन नहीं है।

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

ध्यान दें कि सभी मैं परिवर्तन करने की जरूरत थी ko.computedकरने के लिए ko.notifyingWritableComputedऔर उसके बाद सब कुछ खुद का ख्याल रखता है।

जब मैं फोन करता हूं hasUserClickedFooButton(true)तो 'डमी' देखने योग्य किसी भी सब्सक्राइबर्स (और उनके सब्सक्राइबर) को नए मूल्य प्राप्त करने के लिए मजबूर किया जाता है, जब लोकलस्टोरेज में वैल्यू अपडेट होती है।

(नोट: आप सोच सकते हैं कि 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 ।

Question 5

मान लीजिए कि getCurrentValues () वेधशाला के विभिन्न सेट लौटा सकते हैं जो कोड में कहीं और संशोधित किए गए हैं

मुझे लगता है getCurrentValues () एक फ़ंक्शन है। यदि आप इसे एक संगणक बना सकते हैं, तो आपका CheckValueCount बस जादुई रूप से काम करना शुरू कर देगा।

आप कर सकते हैं getCurrentValues एक समारोह के बजाय एक गणना की जा सकती है?

Question 6

चूँकि किसी गणना को अद्यतन करने के लिए मजबूर करने का कोई सीधा आगे का तरीका नहीं है, इसलिए मैंने toForceComputedUpdate नाम का एक ऑब्जर्वेबल बनाया है, और मैंने इसे गणना की गई फ़ंक्शन के भीतर बुलाया है, इसलिए कंप्यूटर्स इसके अपडेट को सुनेगा, फिर अपडेट को बाध्य करने के लिए इसे इस तरह से toForceComputedUpdate (Math) )