纯计算监控（Pure computed observables）

纯计算监控，在knockout 3.2.0里才有，提供了对性能和内存更好的管理。这是因为纯计算监控不包含对他的依赖的订阅。特点有：

防止内存泄漏
降低计算开销：值不再是observed，是一个不会重新计算的computed observables.

根据是否有订阅，pure computed observable会自动在两状态间进行切换：

1. 当没有订阅者（subscribers）时，是sleeping状态。当进入sleeping状态时，会释放所有依赖的订阅。在这个状态期间，它不会订阅任何在函数中使用到的observable属性（但是通过getDependenciesCount()还是得到的数值是包括它的）。如果在sleeping期间，computed observable的值被读取了，它马上就会被重新计算。

2. 当有订阅者（subscriber）时，会变成listening。当进入listening状态，马上应该会调用计算函数。在这种状态下，它就和普通的computed observable是一样的。具体可以参见 how dependency tracking works.

为什么使用 "pure" ？

先来看下网上介绍的“纯函数”的介绍：

纯函数（Pure Function）与外界交换数据只有唯一渠道——参数和返回值。其在逻辑上没有副作用（译注：副作用就是潜在地和函数的外部环境交换数据）——这当然只是从抽象角度来说。从现实角度讲，任何函数在CPU级别上都存在副作用，大多数函数在堆级别上也有副作用。可就算有这些副作用，这种在逻辑层面上的抽象也是有意义的。

纯函数不读写全局变量，无状态、无IO，不改变传入的任何参数。理想情况下，不会给他传入任何外部数据，因为一旦传入一个诸如allMyGlobals的指针，上面的这些规则就都被打破了。

这里借用pure functions因为它们的特殊很像：

1. 执行computed observable不会产生任何的副作用。

2. computed observable的值不依赖于其他隐藏的信息，它的值应该是基于其他的observables的，这些值都可以看作是定义computed observable函数的参数。

语法

标准的语法是使用ko.pureComputed:

this.fullName = ko.pureComputed(function() {
    return this.firstName() + " " + this.lastName();
}, this);

另外，也可以使用ko.computed选项：

this.fullName = ko.computed(function() {
    return this.firstName() + " " + this.lastName();
}, this, { pure: true });

更多的语法说明，请参见 computed observable reference.

何时使用pure computed observable

当程序设计中包括可持久性的view model被其他temporary views和viewmodels使用时，使用pure computed observables在可持久化的view model中，可提高性能（但不总是这样）。在temporary view models中使用会优化内存。（还没感觉到这两点带来的好处）。

下面的例子，是一个简单的wizard的示例，先输入first name，再输入 last name，最后会显示 full name:

(由于Full Name在一开始不显示，Full name在输入它的依赖项时，并不会调用，只有当full name显示出来时，才会调用。就不贴图了，挺麻烦的，直接把html和js放到一个html里就可以运行了，或者参见knockout网站http://knockoutjs.com/documentation/computed-pure.html，不过这里给的界面和HTML对不上，但功能是一样的)：

<div class="log" data-bind="text: computedLog"></div>
<!--ko if: step() == 0-->
    <p>First name: <input data-bind="textInput: firstName" /></p>
<!--/ko-->
<!--ko if: step() == 1-->
    <p>Last name: <input data-bind="textInput: lastName" /></p>
<!--/ko-->
<!--ko if: step() == 2-->
    <div>Prefix: <select data-bind="value: prefix, options: ['Mr.', 'Ms.','Mrs.','Dr.']"></select></div>
    <h2>Hello, <span data-bind="text: fullName"> </span>!</h2>
<!--/ko-->
<p><button type="button" data-bind="click: next">Next</button></p>

function AppData() {
    this.firstName = ko.observable('John');
    this.lastName = ko.observable('Burns');
    this.prefix = ko.observable('Dr.');
    this.computedLog = ko.observable('Log: ');
    this.fullName = ko.pureComputed(function () {
        var value = this.prefix() + " " + this.firstName() + " " + this.lastName();
        // Normally, you should avoid writing to observables within a pure computed 
        // observable (avoiding side effects). But this example is meant to demonstrate 
        // its internal workings, and writing a log is a good way to do so.
        this.computedLog(this.computedLog.peek() + value + '; ');
        return value;
    }, this);
 
    this.step = ko.observable(0);
    this.next = function () {
        this.step(this.step() === 2 ? 0 : this.step()+1);
    };
};
ko.applyBindings(new AppData());

（可以试着把computedLog.peek()改成computedLog()，运行时，会提示不可以循环调用。但是把pureComputed改成computed，然后再使用computedLog()就不会有这个提示。不知道为什么。）

何时不使用pure computed observable

副作用

当依赖的属性改变时需要马上执行一定操作时，例如：

在computed observable中要调用callback函数

ko.computed(function () {
    var cleanData = ko.toJS(this);
    myDataClient.update(cleanData);
}, this);

在绑定的init函数中，使用computed observable更新绑定元素

ko.computed({
    read: function () {
        element.title = ko.unwrap(valueAccessor());
    },
    disposeWhenNodeIsRemoved: element
});

使用pure computed的一个明显的副作用是计算函数并不是在订阅者的值改变时就会调用（因为它是sleeping的）。当依赖的值改变时一定要调用计算函数时，这种情况下是不可以使用pure computed的，应该使用regular computed。

性能

使用pure computed observable也可能引起比较大的性能开销，正常的computed observable会在依赖的值改变时才会触发，但是pure computed observable每一次访问都会计算一次。这在某些情况下可能导至性能开销过大。