javascript 语言精髓 学习笔记

 最近阅读《javascript语言精髓》这本书，所以把里面一些代码摘出来，整理整理思路。

/**
 *method是放在Function的原型中，也就是唯一的 Function的原型function(){}中，这样每次声明一个函数直接量，
 *该函数就可以调用method方法给自己的原型添加方法。每次声明一个函数直接量，Function会执行类似这样的一行代码：
 *this.prototype = {constructor:this},也就是给这个函数直接量（由Function构造的函数对象）添加一个原型属性，
 *是一个对象。
 * 
 */
Function.prototype.method = function(name,func){
 if(!this.prototype[name]){
  this.prototype[name] = func;
  return this; 
 }
};
/**
 * Object.beget
 * 功能是给定一个对象，然后获得以这个对象为原型的一个实例。
 */
if(typeof Object.beget !== 'function'){
	Object.beget = function(o){
		var F = function (){};
		F.prototype = o;
		return new F();
	};
}

/**
 * 
 * 模块模式
 * 一般形式：一个定义了私有变量和函数的函数，利用闭包创建可以访问私有变量和函数特权的函数，最后返回这个特权函数，
 * 或者把它们保存到一个可以访问到的地方。
 */
var serial_maker = function(){
  var prefix = '';
  var seq = 0;
  return {
	  set_prefix: function(p){
		  prefix = String(p);
	  },
	  set_seq: function(s){
		  seq = s;
	  },
	  gensym:function(){
		  var result = prefix + seq;
		  seq += 1;
		  return result;
	  }
  };
};
var seqer = serial_maker();

/**
 * 带记忆功能的函数
 * 返回的shell功能是取得第n个结果，如果取不到，则用用户传入的函数产生第n个结果并把该结果放入记忆数组中，最后返回。
 * 传入的参数中，memo是存放记忆的数据的数组，fundamental(shell,n)的功能产生第n个结果，并返回该结果。
 */
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;
};

/**
 * 继承的方法1
 * 
 * 伪类,也就是把新的构造器的prototype指向一个对象作为它的原型。
 * 这里把它放在Function的原型里，这样每次声明一个函数直接量，它都可以用函数直接量.inherits(原型);来继承原型。
 * 伪类的缺点是，每次新建一个构造器层次，它都得重复它的父类在构造器中所做的工作（一般为初始化工作），尽管它
 * 继承了原型中的成员。
 */
Function.method('inherits', function(Parent){
	this.prototype = new Parent();
	return this;
});

/**
 * 继承方法2
 * 原型
 * 用Object.beget方法，获得一个基于某个对象为原型的对象，然后再定制新的对象的属性和方法。
 * 是一种差异化继承
 */

/**
 * 继承的方法3
 * 
 * 函数化，步骤，用模块化的方法返回一个对象。
 * spec是一个对象说明符，例如{name:'hack',sex:'female'}
 * 
 * */
var constructor = function(spec, my){
	//var that 及其他私有变量;
	my = my || {};
	//把共享的变量和函数添加到my中
	that = {}//that 是一个新对象，可以用其它构造器生成等
	//添加that里面的特权方法，that里面的特权方法可以现在外面声明，然后再添加到that里面去，好处是要是that被覆盖等
	//特权方法还是不会被破坏
	return that;
	
};
/**
 * 函数化中的调用父类的方法,这样，在上面的函数化构造器中， 如果需要调用父类的方法，就可以用这个
 */
Object.method('superior',function(name){
    var that = this;
    method = this[name];
    return function(){
    	return method.apply(that, arguments);
    };
});

/**
 * 部件
 */
var eventuality = function(that){
	var registry = {};
	
	that.fire = function(event){
		var array,func,handler,i,
		    type = typeof event === 'string'?
		    		event:event.type;
		if(registry.hasOwnProperty(type)){
		    array = registry[type];
		    for(i=0;i<array.length;i++){
		    	handler = array[i];
		    	func = handler.method;
		    	if(typeof func === 'string'){
		    		func = this[func];
		    	}
		    	func.apply(this, handler.parameters || [event]);
		    }
		}
		
		return this;
	};
	
	that.on = function(type, method, parameters){
		var handler = {
				method:method,
				parameters:parameters
				};
		if(registry.hasOwnProperty(type)){
			registry[type].push(handler);
		}else{
			registry[type] = [handler];
		}
		
		return this;
	};
	
	return that;
};

/**
 * 函数化的实践
 * @param config
 * config格式如
 * {
 *   name:{
 *     rw:'rw',
 *     value:'hackooo'
 *   },
 *   sex:{              //这里可以用一个对象来存放，用一个rw属性，放置它的读写权限。
 *     rw:'r',          //属性的读写权限
 *     value:18         //属性的值
 *   }
 * }
 */
var panel = function(config){
	var config = config || {};//注意这里左边的config是局部变量，右边的config是形参，
	                          //原因是语法分析期后局部变量config值为undefined
	//也可以 config = config || {}，不用var
	var that = {};

	that.get = function(name){
		var value = config[name] && 
		            ( (typeof config[name] === 'object' && config[name]['rw'].indexOf('r') >= 0)?
						config[name]['value']:
						undefined
				    );
		return value;
	};
	
	that.set = function(name,value){
		(typeof config[name] === 'object')?
				(
				  (config[name]['rw'].indexOf('w') >= 0) ?
				  config[name]['value'] = value:
				  void 0
				):
				(
				  (config[name] = {} ) &&
				  (config[name]['rw'] = value['rw'] || 'rw') &&    //没有定义访问权限，则默认给它可读可写权限
				  (config[name]['value'] = value['value'] || value)
				 );
		return this;
	};
	
	return that;
};

//var p_test = panel();
//p_test.set('name', 'hackooo');
//p_test.set('age',{rw:'r',value:18});
//p_test.set('age',20);//为只读属性，因此赋值不成功
//alert(p_test.get('age'));

/**
 *将上面这个方法组件化,相当于给定一个对象和或提供一个容器，然后这个方法就会把这个对象的get和set方法绑定到这个容器去 
*/
var bind_get_and_set = function(that,config){
	var config = config || {};//注意这里左边的config是局部变量，右边的config是形参，
	                          //原因是语法分析期后局部变量config值为undefined
	//也可以 config = config || {}，不用var

	that.get = function(name){
		var value = config[name] && 
		            ( (typeof config[name] === 'object' && config[name]['rw'].indexOf('r') >= 0)?
						config[name]['value']:
						undefined
				    );
		return value;
	};
	
	that.set = function(name,value){
		(typeof config[name] === 'object')?
				(
				  (config[name]['rw'].indexOf('w') >= 0) ?
				  config[name]['value'] = value:
				  void 0
				):
				(
				  (config[name] = {} ) &&
				  (config[name]['rw'] = value['rw'] || 'rw') &&    //没有定义访问权限，则默认给它可读可写权限
				  (config[name]['value'] = value['value'] || value)
				 );
		return this;
	};
	
	return that;
};