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); // < " > &ddd;
// alert(alert(b));// lt undefined quot undefined gt undefined ddd
return typeof r === "string" ? r : a;
});
}
}());
document.writeln("<">&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()); // Q2003.级联
一些方法，例如修改和设置，没有返回值，默认为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)); // 1105.记忆
函数可以让对象记住先前操作的结果，这样就避免了无谓的计算
下面来看一个例子
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