Knockout 可扩展性

你需要知道的*特性

Knockout 最棒的一个特点就是它的可扩展性。Knockout 存在大量的扩展点，包含大量的工具来创建我们的应用程序。许多开发者除了 Knockout 核心库之外没有使用任何其他的脚本库 ( 甚至包括 jQuery ) 就创建了非常棒的站点。

Subscribables

在创建我们的库存管理程序的时候，很容易发现在 Knockout 中 Observable 是一个核心对象。在 Observable，ObservableArray 和 Computed Observables 的底层是 Subscribable，Subscribable 是包含三个方法和一个 Subscriptions 数组的对象，这三个方法是：

• subscribe：这个方法添加一个订阅到主题对象上，当订阅的主题发出提醒的时候，订阅就会被调用，默认的提醒类型是 change。
• notifySubscribers：这个方法调用所有的订阅，并且会传递一个参数到订阅的回调方法中。
• extend：这个方法为主题对象添加一个扩展

下面的代码演示了前两个方法的使用，实现了发布和订阅。

var test = ko.observable();

// create a subscription for the "test-event"

test.subscribe(function (val) {

    console.log(val);

}, test, "test-event");

test.notifySubscribers("Hello World", "test-event");

Knockout 中订阅的一个很酷的特性是可以混合到任何的 Javascript 对象中，下面的代码演示了在普通代码中使用的方式。

// Dummy Subscribable
function PubSub() {
    // inherit Subscribable
    ko.subscribable.call(this);
}

// create an instance of our Subscribable
var pubsub = new PubSub();
// make a subscription
var subscription = pubsub.subscribe(function (val) {
    console.log(val);
}, pubsub, 'test-topic');

pubsub.notifySubscribers("hello world", "test-topic");
// console: "hello world"
// clean up things
subscription.dispose();

在调用可订阅对象的subscribe 方法之后，我们得到了一个 Subscription 对象，通常开发者可以忽略这个 subscribe 方法返回的订阅对象，但是需要注意的是通过这个订阅对象 Subscription ，我们可以释放订阅的回调方法和应用中对于回调的引用，直接调用 dispose 方法就可以确信你的程序不会造成内存的泄露。

现在，你已经理解了 Knockout 的一个核心处理机制，Subscribable，我们将学习 Knockout 如何扩展它的用法在其它的模式。

Observables

Knockout 的 Observable 对象是实现订阅机制的头等对象，也是 Knockout 库中最为简单，也最为强大的部分。下面的代码演示了实现 Observable 的基本思想。

// Very Simple Knockout Observable Implementation
// ko.observable is actually a function factory

ko.observable = function (initialValue) {

    // private variable to hold the Observable's value
    var _latestValue = initialValue;

    // the actual "Observable" function
    function observable() {
        // one or more args, so it's a Write
        if (arguments.length > 0) {
            // set the private variable
            _latestValue = arguments[0];
            // tell any subscribers that things have changed
            observable["notifySubscribers"](_latestValue);
            return this; // Permits chained assignments
        }

        else { // no args, so it's a Read
            // just hand back the private variable's value
            return _latestValue;
        }
    }

    // inherit from Subscribable
    ko.subscribable.call(observable);

    // return the freshly created Observable function
    return observable;
};

这是 Knockout 中 observable 的一个简单实现 ( 真正的实现代码中包含了大量的强壮性处理代码，验证，依赖检测等等 )，从这个实现中可以看到实际上 observable 是一个函数的工厂，当调用这个工厂方法的时候，它生成了一个新的函数。这里实现了一个简单的 set/get API。如果你在不提供参数的情况下调用返回的函数，就会返回 _initialValue ，如果调用的时候提供了一个参数，就会设置 _initialValue ，并且通知所有的订阅。

当你创建事件驱动的程序的时候，Observable 可以得到大量的应用。我们可以创建事件驱动的程序架构，仅仅依赖事件 ( 比如按钮的点击，或者输入元素的变化等等 )而不是过程化的方法。

Observable Array

我在前面已经提到过可观察的数组，而且提高还会深入讨论这个特性。前面的示例中已经演示了 Observable 比较简单，而可观察的数组也一样简单。下面的代码演示了实现的机制。

// Very Simple Knockout Observable Array Implementation
// function factory for observable arrays
ko.observableArray = function (initialValues) {

    // make sure we have an array
    initialValues = initialValues || [];

    // create a Knockout Observable around our Array
    var result = ko.observable(initialValues);

    // add our Observable Array member functions
    // like "push", "pop", and so forth
    ko.utils.extend(result, ko.observableArray['fn']);

    // hand back the Observable we've created
    return result;

};

如你所见，实际上还是一个可观察对象，除了这个可观察对象的值是一个数组而已。另外还添加了匹配数组本地方法的扩展方法。Knockout 的作者已经帮我们完成的这些工作，使得开发者可以像使用普通的数组一样使用可观察的数组。

可观察数组的一个扩展点是它的 fn 属性，你可以添加自己的函数到这个属性中，那么就可以使得应用中所有的可观察数组都提供这个方法，下面的代码演示了如何添加一个过滤方法来过滤数组中的元素。

ko.observableArray.fn['filter'] = function (filterFunc) {

    // get the array
    var underlyingArray = this();
    var result = [];

    for (var i = 0; i < underlyingArray.length; i++) {
        var value = underlyingArray[i];

        // execute filter logic
        if (filterFunc(value)) {
            result.push(value);
        }
    }
    return result;
};
var list = ko.observableArray([1, 2, 3]);

// filter down the list to only odd numbers
var odds = list.filter(function (item) {
    return (item % 2 === 1);
});

console.log(odds); // [1, 3]

使用 fn 函数在许多脚本库中是常见的模式，包括 jQuery 脚本库，Knockout 也不例外。fn 也存在于 Observable 中，所以你也可以通过同样的方式进行扩展。

Computed Observable

计算出的可观察对象可以说是 Knockout 中最强大的特性。在你学会使用 Observable 和 Observable Array 而不是用其他技术来创建视图模型之后，已经是一个巨大的进步，但是，更棒的是你可以创建仅仅依赖于其他 Observable 和 Observalbe Array 的属性，而且在底层属性发生变化的时候，计算的结果会同时发生变化。

计算出的可观察对象类似于普通的可观察对象，除了没有保存自己的值之外，它提供了一个方法来计算应该返回的值，这个函数仅仅在所依赖的底层对象发生变化的时候重新计算返回值，下面的代码演示了实现的机制。

var a = ko.observable(1);

var b = ko.observable(2);
var sum = ko.computed(function () {
    var total = a() + b();
    // let's log every time this runs
    console.log(total);
    return total;
});

// console: 3
a(2); // console: 4
b(3); // console: 5
b(3); // (nothing logged)

计算出的可观察对象有着非常有趣和巧妙的实现，你可以自己挖掘一下，初次之外，还有一些需要注意的要点。

首先，计算出的可观察对象创建了一个依赖列表 ( 或者订阅 )，当你的计算函数执行的时候，如果你希望依赖于某个对象，就需要保证在计算函数中调用这个 Observable ，下面的代码演示了如何设置依赖和动态改变计算对象的依赖对象。

var dep1 = ko.observable(1);
var dep2 = ko.observable(2);
var skipDep1 = false;
var comp = ko.computed(function () {

    dep2(); // register dep2 as dependency
    if (!skipDep1) {
        dep1(); // register dep1 as dependency
    }
    console.log('evaluated');
});

// console: evaluated
dep1(99); // console: evaluated
skipDep1 = true;
dep2(98); // console: evaluated
dep1(97); // (nothing logged)

一般来说，上面的代码不是什么好注意，这使得代码更难调试，使其他的开发人员更加难以直观地意识到发生的状况。相反，建议的处理方式是首先从依赖对象中获取所有的值，然后，使用私有的变量来评估处理逻辑问题。

第二点，这一点使用所有的可观察对象，订阅的回调函数仅仅在属性的值发生变化的时候，每个可观察对象都拥有一个名为equalityComparer 的属性，用来检测属性之前和之后的值是否不同，如果你注意前面的例子，最后一个调用什么都没有做，这是因为第二次设置的值还是 3。默认的equalityComparer 实现仅仅比较 javascript 的基础值，如果可计算对象依赖所有的对象，包括复杂的或者不复杂的，那么，这个函数就会执行多次，下面的代码演示了这个重要的概念。

var depPrimitive = ko.observable(1);
var depObj = ko.observable({ val: 1 });
var comp = ko.computed(function () {

    // register dependencies
    var prim = depPrimitive();
    var obj = depObj();
    console.log("evaluated");
});

// console: evaluated
depPrimitive(1); // (nothing logged)

var previous = depObj();
depObj(previous); // console: evaluated

重要的是理解这一点，很多 Knockout 的新手创建了复杂的可计算对象，导致应用的性能降低。

最后一点，计算的可观察对象也可以拥有自己的 set/get ，这一点很有用，因为这允许我们在视图模型上拥有私有的可观察对象，可以通过公共的 set/get 类似于普通的可观察对象一样使用，下面的代码演示了这个技术。

var _val = ko.observable(1);

var vm = {
    val: ko.computed({

        read: function () {
            return _val();
        },

        write: function (newVal) {
            _val(newVal);
        }
    })
};

vm.val(2);
console.log(_val()); // console: 2
_val(3);
console.log(vm.val()); // console: 3

 

 

分类: ASP.NET MVC, javascript