写在前面
看到好多书评和读书笔记都说《JavaScript语言精粹》字字珠玑，名不虚传。。当然，要看得懂才行
其实个人认为函数化部分不是很好，举的例子不是十分恰当，之前看不懂是因为被成功误导了，就像《Head First》设计模式第一章《策略模式》一样，作者有些偏离章节主题，读者容易被误导
声明：姑且把函数化部分给出的用来创建对象的函数称为“创造函数”吧，为了与“构造函数”区分开。。不是很好听，将就着用吧
一.源码中需要注意的点
很容易就能拿到源码，和中文版书上的代码一样，仔细看了一遍发现了一个很精妙的地方，当然，不是很好理解
P.S.源码有点小问题：“创造函数”cat花括号不匹配，中文版54页，return that;之前少了};
Object的原型函数superior内部有一个很精妙的地方
Object.method(‘superior‘, function (name) {
var that = this,
method = that[name];
return function ( ) {
return method.apply(that, arguments);
};
});
亮点就是最后一句的arguments，看似无心，其实是有意为之的，表明用superior调用父类方法时也可以传参。当然，传参的话需要修改调用方式，测试代码如下：
Function.prototype.method = function (name, func) {
this.prototype[name] = func;
return this;
};
var mammal = function (spec) {
var that = {};
that.get_name = function ( ) {
return spec.name;
};
that.says = function ( ) {
return spec.saying || ‘‘;
};
return that;
};
var cat = function (spec) {
spec.saying = spec.saying || ‘meow‘;
var that = mammal(spec);
that.purr = function (n) {
var i, s = ‘‘;
for (i = 0; i < n; i += 1) {
if (s) {
s += ‘-‘;
}
s += ‘r‘;
}
return s;
};
that.get_name = function ( ) {
alert("cat.get_name :" + arguments.length);///
return that.says( ) + ‘ ‘ + spec.name +
‘ ‘ + that.says( ) + "[" + arguments.length + "]";
};
return that;
};
Object.method(‘superior‘, function (name) {
var that = this,
method = that[name];
return function ( ) {
alert("superior :" + arguments.length);///
return method.apply(that, arguments);
};
});
var coolcat = function (spec) {
var that = cat(spec),
super_get_name = that.superior(‘get_name‘);
that.get_name = function () {
alert("coolcat.get_name :" + arguments.length);///
return ‘like ‘ + super_get_name.apply(this, arguments) + ‘ baby‘;
};
return that;
};
var myCoolCat = coolcat({name: ‘Bix‘});
var name = myCoolCat.get_name(1, 2, 3);
// ‘like meow Bix meow baby‘
alert(name); // ‘like meow Bix meow[3] baby‘
P.S.开始以为superior函数最后的arguments是作者的错误，觉得应该需要把外面的arguments对象传给method而不是里面的，绕了一大圈发现是自己错了，道行不够，没能秒懂道格拉斯大爷的意思。。
二.函数化的初衷
函数化部分开篇就说明了初衷：为了实现私有属性，创建最后提到的“防伪对象”
目的无可厚非，实现私有属性太有必要了。但举的例子mammal -> cat -> coolcat太不合适了，作者想说明用函数化的方式可以实现继承
当然，不是严格意义上的继承，因为函数化方式没有用到自定义类型，子类实例与父类实例的is-a关系也就无从谈起了
P.S.看第一遍的时候cat的例子就把我带到沟里去了，以为函数化就是要抛弃new，完全用函数来实现继承。。自然是在沟里越走越深了
三.函数化的思想
直接看代码，代码自己会说话：
/*
* 函数化的思想：
* 1.创建对象
* 2.添加私有属性
* 3.公开接口（添加公有属性）
* 4.返回该对象
*/
/*
* method: getSuper
* @param spec 规格说明对象，提供创建对象所需的基本数据
* @param my “创造函数”之间共享数据的容器
*/
function getSuper(spec, my){
var obj; // 要返回的对象
var my = my || {}; // 没传入就创建一个
// 私有属性
var attr = spec.value; // 从规格说明对象取数据
var fun = function(){
alert(attr);
}
// [可选]把需要与其它“创造函数”共享的数据装入my
// 创建对象，可以用任意方式，比如new、字面量、调用其它“创造函数”
obj = {
name: "SuperObject"
};
// 公开接口
obj.fun1 = fun;
// 返回obj
return obj;
}
/*
* method: getSub
* 参数同上
*/
function getSub(spec, my){
var obj;
var my = my || {};
// 私有属性
var attr = spec.value + 1;
var fun = function(){
alert(attr);
}
// [可选]共享
// 创建对象
obj = getSuper(spec, my); // 可以直接传过去，当然也可以改一改再传，或者传别的什么
// 公开接口
obj.fun2 = fun;
// 返回obj
return obj;
}
// 测试
var spec = {
value: 1
};
var sub = getSub(spec); // 不用传入my，my只应该在“创造函数”之间用
sub.fun1(); // 1
sub.fun2(); // 2
P.S.又是“创建对象 -> 增强 -> 返回新对象”这个套路，不就是尼古拉斯所说的由道格拉斯发明的“模块模式”吗？
四.防伪对象（持久性的对象）
函数化部分的核心就是它了，注意上面例子中公开接口的方式：
// 私有属性
var myFun = function(){/* ... */};
// 公开接口
obj.fun = myFun;
而不直接用：
// 公开接口
obj.fun = function(){/* ... */};
第一种方式更安全，因为即便从外界修改了fun，内部其它调用了myFun的方法仍然可以正常工作，这样的函数对象就是所谓的防伪对象了
完整定义：
防伪对象的属性可以被替换或者删除，但该对象的完整性不会受到损害
也被称为持久性的对象，一个持久性对象就是一个简单功能函数的集合
后话
到这里《JavaScript语言精粹》的学习笔记就告一段落了，补好了[函数化]的空缺，学习笔记的其它部分请查看黯羽轻扬：《JavaScript语言精粹》学习笔记