prototype
听说prototype是JavaScript中最难的部分，最近学习了相关知识，感觉确实挺复杂，主要是比较难理解。为了避免遗忘，将最近的学习做一个简单的总结。
prototype类似java中的静态方法和静态变量。可以实现共享。对象中的proto指针指向prototype，prototype保存着该类的“静态属性和方法和constructor”。constructor 可以获取构造函数本身。
构造函数中的方法分为实例方法和原型方法，构造函数中定义的方法是实例方法。prototype指向的方法是原型方法。
//定义原型方法和原型属性
function Person(){}
Person.prototype.height = 180;
Person.prototype.sex = "man";
Person.prototype.fun = function (){
return this.height+this.sex;
};直接输出constructor会输出构造函数的函数体。
alert(tom.__proto__.constructor);使用时的执行流程： 现在实例对象中找，如果找不到再到原型对象中找。（访问–>实例对象–>原型对象）
删除原型属性:
delete Person.prototype.name;
isPrototypeOf()
判断一个属性是否指向自己的原型
Box.prototype.isPrototypeOf(属性);
var tom = new Person();
var jerry = new Person();
var obj = new Object();
var flag = Person.prototype.isPrototypeOf(tom); // true
var flag = Person.prototype.isPrototypeOf(obj); // true
var flag = Object.prototype.isPrototypeOf(tom); // false因此，所有对象都指向Object的原型。如果改变object对象指向的原型，就改变了所有对象的原型。但是原型是单向的，所有对象都指向Object，但是Object不会指向其他对象
Object.prototype.name = "zhangsan";hasOwnProperty(属性名) // ???
判断是否存在指定的实例属性。
in
查找实例和原型中的属性，只要存在就返回
属性名 in 对象名
只判断原型中的属性（自定义函数）
hasOwnProperty返回false && in返回true 时满足要求
封装
对象的属性分为实例属性和原型属性，为了将类封装成一个整体，可以把原型属性写在构造函数内,但是这种方式每次创建对象时都会创建原型属性，比较浪费资源:
function Fun(name , age){
this.name = name ;
this.age = age;
Fun.prototype.run = function (){
return this.name+this.age+"#";
};
}可以采取这种优化的方法,判断原型对象是否被创建过，只在第一次使用时创建原型属性：
function Fun2(name , age){
this.name = name ;
this.age = age;
if(typeof Fun2.prototype.run != 'function'){ alert("#");
Fun2.prototype.run = function(){
return this.name + this.age+"#";
}
}
}继承
原型链继承
被继承叫做超类型，继承的函数叫做子类型,继承的对象可以使用父类的实例和原型属性。
所有对象都是继承自Object对象
// 继承
function A(){
this.name = "a";
this.age = 20;
}
A.prototype.name = "prototype_a"; // 原型属性
function B(){
this.name = "b";
}
B.prototype = new A(); // 使 B 继承 A
var obj = new B();
alert(obj.age); // 20
alert(obj.name); // b 本地属性覆盖父类属性对象冒充
对象冒充无法继承父类的prototype属性，只能冒充构造函数中的信息。冒充的对象类型不变
function C(name){
this.name = name;
this.age = 100;
this.sss = new Array(1,2,3,4,5);
}
C.prototype.family = "family";
function D(name ,age ){
C.call(this,name);
}
var d = new D("zhangsan",20);
alert(d.name); //zhangsan
alert(d.age); //100
alert(d.family); //1,2,3,4,5
alert(d instanceof D); //true
组合模式
在冒充的基础上使用继承，这样就可以继承原型方法
function E(name){
this.name = name;
this.sss = [1,2,3,4,5];
}
E.prototype.family = "prototype_family";
function F(name , age){
E.apply(this,[name]);
}
F.prototype = new E();
var f = new F("lisi",40);
alert(f.family); // 1,2,3,4,5原型式继承
对象时采用引用的关系。
// 原型式继承
function G(obj){
var Temp = function (){}
Temp.prototype = obj;
return new Temp();
}
var data = {
name:"zhangsanG",
age:20,
family:[1,2,3,4,5]
};
var g = new G(data);
g.family.push(6);
alert(data.family); //1,2,3,4,5,6
var gg = new G(data);
alert(gg.family); // 1,2,3,4,5,6
