用js实现 类 想到的
原文地址http://www.cnblogs.com/chingho/archive/2010/03/06/1679792.html
写js用类的方法实现,我觉得主要是好管理吧
方法一:构造方法。
1: function coder(){
2: this.name = '小王';
3: this.job = '程序员';
4: this.coding = function ()
5: {
6: alert('我正在写代码');
7: }
8: }
9:
10: var coder=new coder();
11: alert(coder.name);
12: coder.coding();
方法二:工厂方法。
1: function createCoderFactory(){
2: var obj=new Object();
3: obj.name = '小王';
4: obj.job = '程序员';
5: obj.coding = function (){
6: alert('我正在写代码');
7: };
8: return obj;
9: }
10: var coder = createCoderFactory();
11: alert(coder.name);
12: coder.coding();
但工厂方法和构造方法都有着一个相同的缺点,就是每创建一个实例,都会实例化该类的每个函数。所以可以用原形链。
方法三:原形链。
1: function coder(){}
2: coder.prototype.name = '小王';
3: coder.prototype.job = '程序员';
4: coder.prototype.coding = function(){
5: alert('我正在写代码');
6: };
7: var coder = new coder();
8: alert(coder.name);
9: coder.coding();
方法四:混合方式。
以上三种都有着各自的缺点,所以我们要加以改进。
1: function coder(){
2: this.name = '小王';
3: this.job = '程序员';
4: }
5: coder.prototype.coding = function(){
6: alert('我正在写代码');
7: };
方法五:动态原链。
要解决前三种的缺点,还有一种方法。
1: function coder(){
2: this.name = '小王';
3: this.job = '程序员';
4: if (typeof(coder._init) == 'undefined'){
5: this.coding = function ()
6: {
7: alert('我正在写代码');
8: };
9: this._init = true;
10: }
11: }
这个方法呢,当第一次使用时,由于_init没初始化,就会执行以下的代码,实例化coding函数。以后就不会再执行,这样就只实例化函数一次。
关于原型链:
<script type="text/javascript">
/*
每个对象实例都有个属性成员用于指向到它的instanceof 对象(暂称为父对象)的原型(prototype)
我们把这种层层指向父原型的关系称为[原型链 prototype chian]
原型也具有父原型,因为它往往也是一个对象实例,除非我们人为地去改变它
在JavaScript中,"一切都是对象,函数是第一型。"
Function和Object都是函数的实例。
Function的父原型指向到Function的原型,Function.prototype的父原型是Object的原型
Object的父原型也指向到Function的原型,Object.prototype是所有父原型的顶层
在spiderMonkey引擎中,父原型可以通过 __proto__ 进行访问
*/
Function.prototype.hi = function(){alert('hi Function');}
Object.prototype.hi = function(){alert('hi Object');}
var a = function(){
this.txt = "a";
}
a.prototype = {
say:function(){alert('a');}
}
alert(a instanceof Function);//a是Function的实例;
alert(a.__proto__ === Function.prototype);//a的父原型指向到Function的原型;
alert(Function instanceof Object);//Function是Object的实例;
alert(Function.__proto__ === Function.prototype);//Function的父原型指向到Function的原型;
alert(Function.prototype.__proto__ === Object.prototype);//Function的原型的父原型指向到Object的原型
alert(Object.__proto__ === Function.prototype);//Object的父原型指向到Function的原型;
alert(Object.prototype.__proto__);//Object的原型是所有父原型的顶端,它不再具有父原型;
alert(a.prototype instanceof Object);//a的原型也是一个对象
alert(a.prototype.__proto__ === Object.prototype);//a的原型的父原型指向Object的原型
var A = function(){};
A.prototype = new a();
A.prototype.say = function(){
alert('A');
}
alert(A instanceof Function);//A是Function的实例
alert(A.__proto__ === Function.prototype);//A的父原型指向到Function的原型
alert(A.prototype instanceof a);//A的原型是a的实例
alert(A.prototype.__proto__ === a.prototype);//A的原型的父原型指向到a的原型
var iA = new A();//iA是A的实例,iA.__proto__ === A.prototype
var iB = new a();//iB是a的实例,iB.__proto__ === a.prototype
iA.hi();
/*
iA本身没有hi方法(构造中没有,自己也没有定义过),
于是找iA.__proto__即A.prototype,也没有找到,
于是再找A.prototype.__proto__即a.prototype,仍然没有发现,
继续查找a.prototype.__proto__即Object.prototype,哇,发现了hi,于是调用它,停止查找
输出:hi Object
*/
iB.hi();
/*
iB本身没有hi方法(构造中没有,自己也没有定义过),
于是找iB.__proto__即a.prototype,仍然没有发现,
继续查找a.prototype.__proto__即Object.prototype,哇,发现了hi,于是调用它,停止查找
输出:hi Object
*/
a.hi();
/*
a本身没有hi方法(构造中没有,自己也没有定义过),
于是找a.__proto__既Function.prototype,哇,发现了hi,于是调用它,停止查找
输出:hi Function
*/
iA.say();
/*
iA本身没有say方法(构造中没有,自己也没有定义过),
于是找iA.__proto__即A.prototype,哇,发现了say,于是调用它,停止查找
所以,这里调用的是A.prototype.say
输出:A
*/
iB.say();
/*
iB本身没有say方法(构造中没有,自己也没有定义过),
于是找iB.__proto__即a.prototype,哇,发现了say,于是调用它,停止查找
所以,这里调用的是a.prototype.say
输出:a
*/
iA.bad();
/*
iA本身没有bad方法(构造中没有,自己也没有定义过),
于是找iA.__proto__即A.prototype,也没有找到,
于是再找A.prototype.__proto__即a.prototype,仍然没有发现,
继续查找a.prototype.__proto__即Object.prototype,终于是找不到了,停止查找
返回错误,iA.bad不是一个function
*/
</script>