函数3

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());  // U200
maker.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));       // 55
alert(fibonacci(100));      // 354224848179262000000
var factorial = memoizer([1, 1], function (shell, n) {
    return shell(n - 1) * n;
});
alert(factorial(5));    // 120
alert(factorial(50));   // 3.0414093201713376e+64