淘汰订阅洞察:检测是否处置

Question

我在我的ko模型中有一个订阅管理,通过拦截它们并保存对它们的引用来保存任何订阅.

我然后处理它们,但是我有时需要理解子物质是否已被处理掉.成员Gb是订阅对象的布尔值,是活动 - 非活动标志吗？我看到,有时当我处理订阅时,它的Gb变得虚假,有时不会.我是否必须将此解释为处置失败？

一旦我处理订阅,订阅对象,是否已准备好进行垃圾回收？

编辑:我只需要了解订阅是否已经处理,如标题中所述.我以我所知道的唯一方式获得订阅,在声明时保存对它的引用:

var mySub = myObservable.subscribe(function(){/*do something*/});

一段时间后我需要一种方法来确定mySub是否已经处理掉了.

function isDisposed(mySubscription) {
    // if is disposed return true else return false
}

我需要在此基础上执行一些逻辑,不仅在没有处理的情况下处理它(或者我可以简单地再次调用dispose方法).是否有可能确定订阅处置状态？

Answer 1

关于手动订阅

Knockout源代码是使用Google Closure Compiler编译的,因此只有在源代码中明确导出的属性和方法才会出现在已编译的库代码中.

据说订阅具有"私有"属性isDisposed,但不会导出.因此,为订阅导出的唯一API是dispose.

Glimps的源代码 - ko.subscription(knockout-3.1.0.debug):

ko.subscription = function (target, callback, disposeCallback) {
    this.target = target;
    this.callback = callback;
    this.disposeCallback = disposeCallback;
    this.isDisposed = false;
    ko.exportProperty(this, 'dispose', this.dispose);
};
ko.subscription.prototype.dispose = function () {
    this.isDisposed = true;
    this.disposeCallback();
};

关于内存泄漏和计算

1)关于计算的一个有趣的事实 - 考虑以下计算

var myObservable1 = ko.observable(true);
var myObservable2 = ko.observable('foo');

var myComputed = ko.computed(function () {
    if (myObservable1()) {
        return myObservable2() + 'bar';
    }
});

在这个例子中myComputed有2个依赖.但是,如果我们assing false到myObservable1 myComputed会重新评估和reevalution后只会有1依赖性和订阅myObservable2将被布置.

为何处置:

解释在于如何计算compute - 它以下列方式注册依赖项 - 如果myObservable1()在评估期间读取任何observable(意味着代码) - 计算得到带有此observable的回调,检查其id并将其存储在新的依赖项数组中.评估完成后 - 处理旧的依赖关系数组.在我们的示例中,当myObservable1设置为false时myObservable2,永远不会读取 - 因为我们永远不会输入if块.所以它不是一个新的依赖和旧的依赖被处置.

2)另一个有趣的事实.考虑片段:

(function () {
    var myObservable = ko.observable(0);
    var myModel = {
        myComputed: ko.computed(function () {
            console.log(myObservable());
        })
    };
    myModel = undefined;
    myObservable(42); // Outputs 42
})();

垃圾收集器不会收集计算结果,因为实际上对它的引用存在于它的依赖项中.

源代码的一瞥 - ko.computed(knockout-3.1.0.debug):

function addSubscriptionToDependency(subscribable, id) {
    if (!_subscriptionsToDependencies[id]) {
        _subscriptionsToDependencies[id] = subscribable.subscribe(evaluatePossiblyAsync);
        ++_dependenciesCount;
    }
}
...
function evaluatePossiblyAsync() {
    var throttleEvaluationTimeout = dependentObservable['throttleEvaluation'];
    if (throttleEvaluationTimeout && throttleEvaluationTimeout >= 0) {
        clearTimeout(evaluationTimeoutInstance);
        evaluationTimeoutInstance = setTimeout(evaluateImmediate, throttleEvaluationTimeout);
    } else if (dependentObservable._evalRateLimited) {
        dependentObservable._evalRateLimited();
    } else {
        evaluateImmediate();
    }
}

保留对dependentObservable的引用,因为保留了对evaluatePossiblyAsync的引用(Closures,JS和所有Jazz).

哇,这就是我不得不说的.希望有些想法浮现在脑海中.