javascript面向对象(三)
Prototype原型模式
通过构造函数的弊端引出原型概念
为了讲清楚原型，我们还是必须先回顾一下构造函数的问题，用一个简单的例子再次讲解一下,我们有一只猫的构造函数，如下:
function Cat(name,color){ this.name = name; this.color = color;} 这个构造函数很简单，不再多说，那么现在再为这个函数添加一个不变的属性"type"（种类），再添加一个方法eat（吃老鼠）。那么，Cat就变成了下面这样:
function Cat(name,color){ this.name = name; this.color = color; this.type = "猫科动物"; this.eat = function(){alert("吃老鼠");};} 生成实例:
var cat1 = new Cat("大毛","黄色");var cat2 = new Cat ("二毛","黑色");alert(cat1.type); // 猫科动物cat1.eat(); // 吃老鼠 表面上好像没什么问题，但是实际上这样做，有一个很大的弊端。那就是对于每一个实例对象，type属性和eat()方法都是一模一样的内容，每一次生成一个实例，都必须为重复的内容，多占用一些内存。这样既不环保，也缺乏效率。
alert(cat1.eat == cat2.eat); //false
因此，为了让type属性和eat()方法在内存中只生成一次，然后所有实例都指向那个内存地址，引出了原型
什么是原型？
原型对象实际上就是构造函数的一个实例对象，和普通的实例对象没有本质上的区别。可以包含特定类型的所有实例的共享属性或者方法。 这个prototype的属性值是一个对象（属性的集合），默认的只有一个叫做constructor的属性，指向这个函数本身。
比如我们简单定义一个SuperType名字的函数，里面什么属性也没有在函数内部是这个样子的
function SuperType(){} 
从上图我们看到，函数里面虽然什么都没有，但是有一个默认的prototype属性,它是一个对象，它指向的是自己的地址，而prototype这个对象本身里面又有一个属性constructor，而这个属性，又指向了函数本身,有点绕，你可以通过下面的代码做一下测试，看看效果
alert(SuperType.prototype) //objectalert(SuperType.prototype.constructor) //弹出函数本身function SuperType(){} prototype和constructor是原型最基本的概念,现在看可能还有点晕，没关系，我直接上以前的代码，看看区别,还是之前的Cat构造函数，将它修改一下:
function Cat(name,color){ this.name = name; this.color = color;}Cat.prototype.type = "猫科动物";Cat.prototype.eat = function(){alert("吃老鼠")}; 生成实例:
var cat1 = new Cat("大毛","黄色");var cat2 = new Cat("二毛","黑色");alert(cat1.type); // 猫科动物cat1.eat(); // 吃老鼠 这时所有实例的type属性和eat()方法，其实都是同一个内存地址，指向prototype对象，因此就提高了运行效率。
alert(cat1.eat == cat2.eat); //true
Prototype模式的验证方法
为了配合prototype属性，Javascript定义了一些辅助方法，帮助我们使用它。
isPrototypeOf()
这个方法用来判断，某个proptotype对象和某个实例之间的关系。
alert(Cat.prototype.isPrototypeOf(cat1)); //truealert(Cat.prototype.isPrototypeOf(cat2)); //true
hasOwnProperty()
每个实例对象都有一个hasOwnProperty()方法，用来判断某一个属性到底是本地属性，还是继承自prototype对象的属性。alert(cat1.hasOwnProperty("name")); // truealert(cat1.hasOwnProperty("type")); // false in运算符
in运算符可以用来判断，某个实例是否含有某个属性，不管是不是本地属性。alert("name" in cat1); // truealert("type" in cat1); // true in运算符还可以用来遍历某个对象的所有属性。
for(var prop in cat1) { alert("cat1["+prop+"]="+cat1[prop]); } 来看一下 javascript高级程序设计 书中对与原型的描述和说明
function Person(){ } //创建Person构造函数Person.prototype.name = "Nicholas";//创建共享属性name Person.prototype.age = 29; //创建共享属性age Person.prototype.job = "Software Engineer"; //创建共享属性job Person.prototype.sayName = function(){ //创建共享函数sayName alert(this.name); }; //分别创建了person1和person2,里面都有sayName函数，并且弹出的值都是一样var person1 = new Person(); person1.sayName(); //"Nicholas" var person2 = new Person();person2.sayName(); //"Nicholas" alert(person1.sayName == person2.sayName); //true 
alert(Person.prototype.isPrototypeOf(person1)); //truealert(Person.prototype.isPrototypeOf(person2)); //truefunction User(){};var person3 = new User();alert(Person.prototype.isPrototypeOf(person3)); //falsealert(User.prototype.isPrototypeOf(person3)); //true 对象的_proto_隐式原型
上面我们创建了两个对象,person1和person2,这两个对象，也都指向了Person构造函数的原型,这是因为每个对象都有一个隐藏的属性——“_proto_”，这个属性引用了创建这个对象的函数的prototype。即：person1._proto_ === Person.prototype这个_proto_是一个隐藏的属性，javascript不希望开发者用到这个属性值，有的低版本浏览器甚至不支持这个属性值。看下面的代码:
console.log(Object.prototype);var obj = new Object();console.log(obj.__proto__);
你会发现打印了相同的内容: 
obj这个对象本质上是被Object函数创建的，因此obj._proto_=== Object.prototype。我们可以用一个图来表示。 
关于隐式原型，主要涉及到原型继承的主要原理
javascript面向对象(四)
Prototype原型模式
上一章罗列一直知识点，但是主要是为了说明prototype原型，现在主要来看看，通过原型来创建对象的几种方式
基本原型
function Person(){ } Person.prototype.name = "Nicholas"; Person.prototype.age = 29; Person.prototype.job = "Software Engineer"; Person.prototype.sayName = function(){ alert(this.name); }; 当然这种方式只是说明原型的道理，实际使用中很少把属性写在原型中
更简单的方式
function Person(){ } Person.prototype = { name : "Nicholas", age : 29, job: "Software Engineer", sayName : function () { alert(this.name); } }; 这种方式只是上面方式的简单写法，通过对象字面量直接写完所有属性。效果和上面的写法是一样的，只是写法不一样。
但是直接全部把属性和方法全部写在原型中，这并不现实，看下面的列子:function Person(){ }Person.prototype = { constructor: Person, name : "Nicholas", age : 29, job : "Software Engineer", friends : ["Shelby", "Court"], sayName : function () { alert(this.name); } }; var person1 = new Person(); var person2 = new Person(); person1.friends.push("Van"); alert(person1.friends); //"Shelby,Court,Van" alert(person2.friends); //"Shelby,Court,Van" alert(person1.friends === person2.friends); //true 上面的列子很容易看出，讲属性写在原型中的问题,列子中的friends是个数组，引用数据类型在person1中修改了friends,添加了一个条数据之后，可以看到person1和person2对象的friends都发生了改变，这其实很好理解，因为prototype对象本身就是共享的，数组又是属于引用类型，改变了一个，其他的都会发生改变。
所以，在实际中使用的更多的方法是构造函数与原型结合的方式
构造函数与原型结合的方式
function Person(name, age, job){ this.name = name; this.age = age; this.job = job; this.friends = ["Shelby", "Court"]; } Person.prototype = { constructor : Person, sayName : function(){ alert(this.name); } } var person1 = new Person("Nicholas", 29, "Software Engineer"); var person2 = new Person("Greg", 27, "Doctor"); person1.friends.push("Van"); alert(person1.friends); //"Shelby,Count,Van" alert(person2.friends); //"Shelby,Count" alert(person1.friends === person2.friends); //false alert(person1.sayName === person2.sayName); //true 这里就可以看到，friends的属性在两个对象中就算改变了其中一个，并不会对另外一个产生影响。这种构造函数加原型的混成模式，是目前使用率，认可率最高的一种自定义类型的方式，所以，一般情况下，我们定义自定义类型默认都使用这种模式
动态原型模式
这种模式只是上面模式的变种，对于一些习惯书写面向对象语言的程序员来说，一个类要分开两个部分来写，是非常不习惯的，所以，就有了动态原型模式，其实无非就是，把之前分开两部分写的内容，全部提到函数中，加上判断就行了
function Person(name, age, job){ //属性 this.name = name; this.age = age; this.job = job; //方法 if (typeof this.sayName != "function"){ Person.prototype.sayName = function(){ alert(this.name); }; } } var friend = new Person("Nicholas", 29, "Software Engineer"); friend.sayName(); 注意上面的判断，这种方式只有在sayName函数不存在的情况下，才会将它添加到原型中，如果sayName函数已经存在，那么这段代码就不会再运行，而且就算有很多方法的话，if语句也不用全部判断，只是需要判断一个就行了。
这样的写法，对于java或者C#程序员相对来说感官上比较容易接受，而且写法也没有任何缺陷。但是，有一点不算是缺陷的缺点，javascript是一门动态语言，也就是说，属性和方法是随时可以添加的，如果全部写在构造函数里面去，反而看起来不是那么的灵活。所以，一般情况下，使用构造函数与原型的混合模式的还是比较多的