prototype（二）

prototype
1、JavaScript是一种prototype based programming 的语言，与class based programming 有很大区别
有以下几点：（1）函数是first class object ，也就是说函数与对象具有相同的语言地位（2）没有类，只有对象
（3）函数也是一种对象，就是函数对象（4）对象是按引用来传递的
那么prototype based programming 语言实现继承，靠prototype
例子：

function foo(a,b,c){
     return a*b*c;
}
alert(foo.length);
alert(typeof foo.constructor);
alert(typeof foo.call);
alert(typeof foo.apply);
alert(typeof foo.prototype);

结果
1、length：提供的是函数的参数个数
2、prototype：是一个object
3、其他三个是function
对于任何一个函数的声明，它都将具有上面所述的5个prototype方法或属性

//prototype
function Person (name,gender){
     this.name =name;
     this.gender=gender;
     this.whoAreYou =function(){//这就是闭包，内部函数可以访问外部函数变量
          var res = "I'm " + this.name + " and I'm a " + this.gender +".";
          return res;
     };
}
//那么由Person创建的对象有几个属性
Person.prototype.age=24;
Person.prototype.getAge=function(){
     return this.age;
};
flag =true;
if(flag){
     var fun =new Person("Tower","male");
     alert(fun.name);
     alert(fun.gender);
     alert(fun.whoAreYou());
     alert(fun.getAge());
}
Person.prototype.salary=10000;
Person.prototype.getSalary = function(){
     return.this.name+" can earn about " + this.salary + "RMB each month.";
};
//改变了Person的prototype，这个改变在创建fun之后
//而这个改变是fun也具有相同的属性和方法
//继承的意味即此
if (flag){ 
    alert(fun.getSalary());
     alert(fun.constructor.prototype.age); //而这个相当于你直接调用 Person.prototype.age     alert(Person.prototype.age);}

从上面的示例中看到，对于prototype的方法或者属性，我们可以动态的增加，而由其创建的对象自动会继承相关的方法和属性
另外，每个对象都有一个constructor属性，用于指向创建其的函数对象，如上例中的fun.constructor指向的就是Person
那么一个疑问就自然产生了, 函数对象中自身声明的方法和属性与prototype声明的对象有什么差别?
差别：（1）自身声明的方法和属性是静态的，也就是在声明后，试图再去增加或者修改已有的方法并不会对其创建的对象产生影响，也即继承失败
（2）而prototype可以动态的增加新的方法或者修改已有的方法，从而是动态的，一旦父函数对象声明了相关的prototype属性，由其创建的对象会自动继承这些prototype属性。

flag = true;// 函数内部声明的方法是静态的,无法传递的
Person.school = "ISCAS";
Person.whoAreYou = function(){
  return "zhutao";
};//动态更改声明期的方法,并不会影响由其创建的对象的方法, 即所谓的 静态
if (flag){
     alert(Person.school);
     alert(fun.school);//输出的是 "undefined" 
    alert(Person.whoAreYou()); //输出 zhutao
     alert(fun.whoAreYou()); // I'm Tower and I'm a male.
}
Person.prototype.getSalary = function(){
     return "I can earn 1000000 USD";
};if (flag){ 
    alert(fun.getSalary());//已经继承了改变, 即所谓的 动态
}

创建的对象安装如下进行搜索相关属性：
（1）先去搜索函数对象本身的属性，如果找到立即执行
（2）如果在（1）中未找到，则会去搜索prototype属性，找到则直接执行，否则继续搜索，父对象的父对象的prototype，知道找到或者到达prototype chain的结尾（结尾会是Object对象）。

如果函数对象本身的属性与prototype属性相同(重名)时的解决方式, 函数本身的对象 优先

// 多重prototype链的例子function Employee(name){
     this.name = ""; 
    this.dept = "general";
     this.gender = "unknown";}
function WorkerBee(){
     this.projects = []; 
    this.hasCar = false;} 
    WorkerBee.prototype = new Employee; // 第一层prototype链 
    function Engineer(){
           this.dept = "engineer"; //覆盖了 "父对象"
           this.language = "javascript";  
   }Engineer.prototype = new WorkerBee; 
// 第二层prototype链var jay = new Engineer("Jay");
if (flag){
     alert(jay.dept);    //engineer, 找到的是自己的属性
     alert(jay.hasCar);  // false, 搜索到的是自己上一层的属性
     alert(jay.gender);  // unknown, 搜索到的是自己上二层的属性
}