javascript面向对象(3、四)

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) //object alert(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)); //true alert(Cat.prototype.isPrototypeOf(cat2)); //true 

hasOwnProperty()
每一个实例对象都有一个hasOwnProperty()方法，用来判断某一个属性究竟是本地属性，仍是继承自prototype对象的属性。

alert(cat1.hasOwnProperty("name")); // true alert(cat1.hasOwnProperty("type")); // false

in运算符
in运算符能够用来判断，某个实例是否含有某个属性，不论是不是本地属性。

alert("name" in cat1); // true alert("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 

经过上面的图，能够看到，person1和person2，他们内部都有一个指向Person.prototype的指针，能够经过原型的isPrototype方法测试一下

alert(Person.prototype.isPrototypeOf(person1)); //true alert(Person.prototype.isPrototypeOf(person2)); //true function User(){}; var person3 = new User(); alert(Person.prototype.isPrototypeOf(person3)); //false alert(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是一门动态语言，也就是说，属性和方法是随时能够添加的，若是所有写在构造函数里面去，反而看起来不是那么的灵活。因此，通常状况下，使用构造函数与原型的混合模式的仍是比较多的