2010.03.26(2)——javascript 02

2010.03.26(2)——javascript 02
参考：http://www.iteye.com/topic/19748#119140


1.prototype 原型

prototype是对象一个对象性属性，该属性包含了该对象所有实例共有的所有属性和方法，prototype默认值只包含一个constructor属性，该属性指向对象对应的构造函数，
添加原型属性的方法，对象名.prototype.属性名，prototype只能通过对象名进行访问，所以使用Object()和对象直接量的方法无法定义原型属性。
Object()的方法

var student = new Object();
student.name="ff";
student.age = 23;

对象直接量

var student = {name:"ff",age:23};

他们都是直接定义的对象实例，不是对象描述

function Student(){
	this.name = "xiaodu";
	this.age = 23；
	this.f1 = function(){alert("hehe");};
}

var s1 = new Student(); //创建对象实例
Student.prototype.sex = "woman";//添加原型属性sex
Student.prototype.f2 = function(){alert("haha");};
alert(s1.age);
var s2 = new Student();
alert(s2.age);

原型属性是所有对象实例所共有的；


2.基于原型的继承

function People(){
	this.country = "china";
	this.language = "hanyu";
}

Student.prototype = new People();//Student继承了People
alert(s1.country);
alert(s2.language);

当把对象A的构造函数赋予对象B的prototype属性时，对象B就继承了对象A，对象B便有了对象A中定义的所有属性和方法了；
当对象B定义的属性和对象A里面的名字相同时，对象B继承来的属性就被覆盖或隐藏了；


3.

<

SCRIPT LANGUAGE="JavaScript">   
Object.prototype.toString = function () { return  'myToString'} ; //内建对象的原型扩展，这种影响只局限与当前程序文件范围内，									//不会影响其他程序文件中的Object对象  
function  Person(){   

} 
var  o = new  Person();   
o.name = 'zkj';   
o.age = 25 ;   
o.desc = function ()  { return  '姓名：' + this .name + ',年龄:' + this .age} ;   
 for ( var  key  in  o)  {   
    alert(key + ':' + o[key] + ' type:' + typeof (o[key]));   
  if ( typeof (o[key]) == 'function') {   
        alert('执行方法key：' + (o[key])());   
 }    
}    
alert(o); 
alert( new  Date());  
</SCRIPT>

alert(o)其实是执行了o.toString()，返回结果 "myToString"
如果把Object.prototype.toString = function () { return 'myToString'} ; 注释了，则返回结果的是 [object Object]

在这我想提出以下几个问题：
a、javascript对象也是单根继承的对象.但不是所有对象都继承自Object.如例子中的Date对象。
b、千万别乱定义Object.prototype原型对象。prototype.js中加了个extends被人说了半天。但我们自己写类库时，千万别尝试改Object的prototype。
c、别用javacript语言模仿java来写代码。想上面的，需要一个person的“类”，并不是非需要定义一个，注意javascript对象的属性是可以随意增加或删除的。并不象java那样在类中写死。
d、可以简单的说是person继承了Object”类“。javascript中对象的继承是用prototype来实现的，后面我们讨论prototype原型对象。
e、那我们应用的时候到底是否该自己定义自己的构造函数（如person）,还是直接使用Object呢？这是个复杂的问题，我个人来说喜欢多用Object.



4. Object function new Object() new Function()之间的关系

<SCRIPT LANGUAGE="JavaScript">   
Person.type = " person " ;   
Person.writeType = function ()  {   
    document.writeln( this .type);   
}    
 // var Person = function(){}//如果这样定义会报错,可以看看前面文章，函数的预编译。    
  function  Person()  {}    
Person.writeType();   
alert( typeof (Person));   
 for ( var  key  in  Person)  {   
    alert(key);
}    
 var  person = new  Person();   
</SCRIPT>

结果：
function
type
writeType
protoType

在这里Person是个函数，但我们还可以定义它的属性（type）。而Person有Object实例的特性(for in、可以定义属性)，但Person不是Object的实例，如

<SCRIPT LANGUAGE="JavaScript">   
Object.prototype.toString = function ()  { return  'myToString'} ;   
 function  Person()  {   

}    
 Person.prototype.toString = function ()  { return  'Person'} ;   

 var  o = new  Person();   
alert(o);   
alert(Person)   
Person.toString = function ()  { return  'Person toString'} ;   
alert(Person);   
alert(o);
</SCRIPT>

结果：

Person
function Person() {
}
Person toString
Person

我理解function返回的数据类型是和Object同等级的数据类型。它有Object实例（new Object()）的一些特性,但它不是Object的实例，因为它没有继承Object.prototype.toString=function(){return 'myToString'};
结论：

Object              function          同等级 function可以定义属性，可以(for in) 

new Object()        new function()    同等级 new function()继承Object的prototype,也会继承function的prototype 

5.prototype再次解释

<SCRIPT LANGUAGE="JavaScript">   
  var  Person = function  ()  {   
     this .name = 'Person的构造函数中属性name';   
     this .getName = function ()  {   
     return   this .name;   
 }    
  // this.toString=function(){}  //你把注释去掉看看效果    
 }    
Person.name = " Person " ;   
Person.toString = function ()  { return   this .name + '的类方法'} ; // 我可以用this啊    
alert(Person.toString()); // 类方法    
var  o = new  Person();   
alert(o.getName()); // 构造函数中的方法    
alert(o); // 访问toString方法   先找对象中==>构造函数中==>Person的prototype中==>Object的prototype中    
Object.prototype.toString = function ()  { return  'Object的prototype中的toString'} ;   
alert(o); // Object的prototype中    
Person.prototype.toString = function ()  { return  'Person的prototpe中的toString'} ;   
alert(o);   
o.toString = function ()  { return  '我覆盖了toString方法了啊'}    
alert(o);   
alert('我不能访问前面的toString了。如果有super就好了！');   // 其实还是可以访问到被覆盖的原型的。那样太复杂了。
</SCRIPT>

结果：
Person 的类方法
Person的构造函数中属性name
[object Object]                      //undefined
Object的prototype中的toString        //undefined
Person的prototpe中的toString         //undefined

我覆盖了toString方法了啊
我不能访问前面的toString了。如果有super就好了


访问toString方法 先找对象中==>构造函数中==>Person的prototype中==>Object的prototype中

原型对象prototype是Object或与之同等级的对象如（function，Number)的一个属性，protorype是个对象。typeof的值是object。

在一个自定义“类”中有中有几个地方可以定义属性。
a、函数名中直接定义。 如Person.name。在这定义相当于类名的属性。静态的，访问的时候必须用Person.name来访问，不能用new Person().name访问，也访问不到。
b、构造函数的this.中。当你用new function()时，这些属性就是你所持对象的属性。用new Person().属性 来访问。
c、构建好对象以后，给对象增加属性。和构造函数中的属性使用类似。
d、函数名的prototype中
e、父类或Object 的prototype中


(1)对象属性优先级
通过运行以下代码，我们访问对象属性优先级如下：c>b>d>e
c种属性必须在定义以后访问才有效。a种属性实例访问不到。
javascrpt语言预定义的属性不能用for in 得到。如toString

<SCRIPT LANGUAGE="JavaScript">   
  Object.prototype.toString = function () {} ;   
Object.prototype.name = " Object " ;   
Object.prototype.porotype_name = " oObject " ;   
Object.prototype.parent_name = " pObject " ;   

Person.prototype.name = " Person " ;   
Person.prototype.porotype_name = " oPerson " ;   
 function  Person()  {   
     this .name = 'Person实例';   
}    
 var  o = new  Person();   
 for ( var  key  in  o)  {   
    alert(key + ':' + o[key]);   
}
</SCRIPT>

(2)prototype属性是只读的
看如下代码，你不要试图通过变量改变原型对象的属性。你也不可能改变，你只会通过c模式给对象增加一个属性。
另外原型对象是所有实例共享的。理论上也不可以改变。

<SCRIPT LANGUAGE="JavaScript">   
Person.prototype.name = " Person " ;   
 function  Person() {   

}    
 var  o = new  Person();   
 var  o1 = new  Person();   
alert('o.name:' + o.name + '  ' + 'o1.name:' + o1.name);   
o.name = 'zkj';   
alert('o.name:' + o.name + '  ' + 'o1.name:' + o1.name);
</SCRIPT>

6.继承
我只能说javascript的继承是模拟实现的。和java,c++中是不同的，是依靠prototype实现的。
我个人从来不用javascript的“继承”，始终认为javascript实现的继承不是真正的继承。可能是受java”毒害“够深。
在javascript中，我把继承分为两类： 类继承，对象继承。
a、prototype.js中的类继承

<SCRIPT LANGUAGE="JavaScript">   
Object.extend  =   function (destination, source)   {   
   for  (prototype in  source)   {   
    destination[prototype]  =  source[prototype];//这里要明白，prototype是对象一个对象性属性，也是一个对象   
  }    
   return  destination;   
}    

  function  Man()  {   
     this .name = 'zkj';   
}    
Man.prototype.type = '男人';   
Man.prototype.getType = function ()  {   
     return   this .type;   
}    
  function  Woman()  {}    

Object.extend(Woman.prototype,Man.prototype);   
 var  man = new  Man(); 
 var  woman = new  Woman();  
alert(man.getType());  
alert(man.name);   
alert(woman.getType());   
alert(woman.name);
</SCRIPT>

结果：
男人
zkj
男人
undefined

这种继承方法是继承了prototype中的属性和方法；
而Student.prototype = new People()这种继承方法是继承了所有的属性和方法；

看了以上代码，可能你会明白。直接拷贝类的原型对象确实可以实现某种概念上的继承。
但要注意：在继承体系中，Man的原型对象属性方法最好不要用Man的实例属性（name），因为可能Woman中并没有定义实例属性name;也最好不要用Man)原型对象属性字段（type）,虽然type也被拷贝过来了，但值还是”男人“。
虽然有解决办法，但javascript没有很好的语法检查工具，你用prototype.js的类继承时小心处理。