最近阅读《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;
};