JavaScript语言精粹之函数篇(三)

1.回调
函数让不连续的事件处理变得容易起来
下面我们来看一个同步的传统的例子

var request = prepare_request();    // 请求预处理var response = send_request_sync(request);  // 发送请求到客户端display(response);      // 处理服务器响应

上述的例子是同步发送的，如果服务器响应过慢，那么会出现客户端假死的现象
因此我们需要使用异步的方式，完成客户端与服务器端的交互

var request = prepare_request();    // 请求预处理send_request_asyc(request, function (response) {    display(response);});// 我们传递函数作为参数发送给send_request_asyc，当服务器响应后进行处理

2.模块
模块是一个提供了接口但是隐藏了状态与实现函数的函数或者对象
我们可以用函数和闭包来构成模块
模块可以使我们完全摒弃全局变量的作用
下面我们来看一个有关与解析实体字符为html标签的例子

Function.prototype.method = function (name, fun) {    // 如果添加的方法不存在，才可以添加    if(!this.prototype[name]) {        this.prototype[name] = fun;        return this;    }}String.method("deentityify", function () {    // 私有属性对象    var entity = {        quot : '"',        lt : "<",         gt : ">"    }    // 创建可以返回且可以访问entity私有变量的特权方法    return function () {        // 匹配以&开始，以;结束，且中间的字符不能为&或者;开头的字符        // this代表调用此函数的字符串        return this.replace(/&([^&;]+);/g, function (a,  b) {            var r = entity[b];            // alert(a);    // &lt; &quot; &gt; &ddd;            // alert(alert(b));// lt undefined quot undefined gt undefined ddd            return typeof r === "string" ? r : a;        });    }}());document.writeln("&lt;&quot;&gt;&ddd;".deentityify());  // <">&ddd; 

模块的一般形式：
一个定义了私有变量或者函数的函数，
利用闭包创建可以访问到私有变量或者函数的特权方法，
最后返回这个特权方法，或者将其存放到一个可以访问的地方。
接下来我们要构建一个可以生成序列化的模块

var serial_maker = function () {    // 定义两个私有的变量，前缀和序列号    var prex = '';    var seq = 0;    // 返回一个可以访问私有变量的对象    return {        setPrex : function (p) {            prex = String(p);        },        setSeq : function (s) {            seq = Number(s);        },        gensyn : function () {            var result = prex + seq;            seq++;            return result;        }    };};var maker = serial_maker();maker.setPrex("U");maker.setSeq(200);alert(maker.gensyn());  // U200maker.setPrex("Q");alert(maker.gensyn());  // Q200

3.级联
一些方法，例如修改和设置，没有返回值，默认为undefined，
我们可以让他们返回this，这样这个方法就开启了级联，即可以依次调用同一个对象的许多方法

getElement("div").move(200, 200).setBackground("#ccc").....;    //这个div可以一次性完成许多工作

4.套用
套用允许我们将函数与传递给它的参数结合产生新函数

var add = function (a, b) {    return a + b;}Function.method("curry", function () {    var slice = Array.prototype.slice;    // 取得外部参数，即下面实例的10    var args = slice.apply(arguments);    alert(args);    // 10    var that = this;    alert(this);    // 调用curry的函数，即a下面实例的add()方法    return function () {        alert(this);    // [object Window]        return that.apply(null, args.concat(slice.apply(arguments)));    }});var add1 = add.curry(10);alert(add1(100));   // 110

5.记忆
函数可以让对象记住先前操作的结果，这样就避免了无谓的计算
下面来看一个例子

var fibonacci = function (n) {    return n < 2 ? n : arguments.callee(n - 1) + arguments.callee(n - 2);}var start = Date.now();for(var i = 0; i <= 30; i++) {    if (i == 30) {        document.writeln("// " + i + " : " + fibonacci(i) + "<br/>");    }}var end = Date.now();document.writeln("原始使用时间: " + (end - start) + "<br/>"); // 用时1360

据统计，fibonacci函数被调用了453次，我们调用了11次，
而自身调用了442次自身去计算之前计算过的值
因此我们可以用记忆的方式，来优化一下程序

var fibonacciMemory = function () {    var meo = [0, 1];    var fib = function (n) {        var result = meo[n];        if(typeof result !== 'number') {            result = arguments.callee(n - 1) + arguments.callee(n - 2);            meo[n] = result;        }        return result;    }    return fib;}();var start = Date.now();for(var i = 0; i <= 400; i++) {    if (i == 400) {        document.writeln("// " + i + " : " + fibonacciMemory(i) + "<br/>");    }}var end = Date.now();document.writeln("记忆优化时间: " + (end - start));

当然，我们可以将记忆这种形式一般化

var memoizer = function (memo, fundamental) {    var shell = function (n) {        var result = memo[n];        if (typeof result !== 'number') {            result = fundamental(shell, n);            memo[n] = result;        }        return result;    }    return shell;};var fibonacci = memoizer([0, 1], function (shell, n) {    return shell(n - 1) + shell(n - 2);});alert(fibonacci(10));       // 55alert(fibonacci(100));      // 354224848179262000000var factorial = memoizer([1, 1], function (shell, n) {    return shell(n - 1) * n;});alert(factorial(5));    // 120alert(factorial(50));   // 3.0414093201713376e+64