js原型链接(二)

浏览数：41 / 时间：2015年06月09日

原型链的内部执行方式

<script>
function Myclass(){
    this.x=" x in Myclass";
}
var obj=new Myclass();
p(obj.x);
p(obj.z); //undefined
Myclass.prototype.z="z in Myclass";
p(obj.z);
//首先查找自身属性,如果没有找到 将沿着原型链接 查找构造函数(Myclass)的prototype对象里找
</script>

属性的重写与删除与原型链无关

<script>
function Myclass(){
    this.x=" x in Myclass";
}
Myclass.prototype.y="y in Myclass";
var obj=new Myclass();
p(obj.y);//y in Myclass
obj.y="override y";
p(obj.y);//override y
delete obj.y //true
p(obj.y);//y in Myclass
var obj2=new Myclass();
p(obj2.y);//y in Myclass
obj.z=‘zzz‘;  
p(obj.z);//zzz
p(obj2.z);//undefined
p(obj.prototype);//undefined
</script>

获取原型对象的三种方法

<script>
function Myclass(){}
var proto=Myclass.prototype;
var obj=new Myclass();
//通过第五版里加强
var proto=Object.getPrototypeOf(obj);
//通过对象实例获得
var proto=obj.__proto__;
//通过对象实例以及其构造函数
var proto=obj.constructor.prototype;
p(obj.constructor==Myclass); //true
</script>

通过constructor判定数据类型

<script>
var d=new Date();
p(d.constructor);//function Date() { [native code] }
var arr=[1,2,3];
p(arr.constructor);//function Array() { [native code] }
var obj={};
p(obj.constructor);//function Object() { [native code] }
</script>

constructor属性并不是对象的直接属性,而是通过原型链接查找到的
每个对象在创建时构造器会执行这样一句代码
this.prototype=
{
constructor:this,
__proto__:Object.prototype
}
通过改变prototype实现继承

<script>
function Derived(){}  //创建时 就有了Derived.prototype={constructor:Derived}
p(Derived.prototype.__proto__==Object.prototype);//true
p(Derived.__proto__);//function Empty() {}
function Base(){} //原理同上
Derived.prototype=new Base();
//此时Derived.prototype的原型链接__proto__改变了指向
p(Derived.prototype.__proto__==Base.prototype); //true
var obj=new Derived();
//此时
p(obj.__proto__==Derived.prototype);//true
//现在obj里找 ,没有,到Derived.prototype引用的对象Base里找,没有,就到Base.prototype里找了
p(obj.constructor); //function Base(){}
</script>

数据类型判定(instanceof与isPrototypeOf)

<script>
var d=new Date();
p(Date.__proto__);////function Empty() {}
p(d instanceof Date);//true
p(d instanceof Object);//true
p(Date instanceof Object);//true
p(Object instanceof Date);//false

function Derived(){}
function Base(){}
Derived.prototype=new Base();
var obj=new Derived();
p(obj instanceof Derived);//true
p(obj instanceof Base); //true
p(Derived instanceof Base);//false   Derived不是由 Base构造函数生成的
p(Derived.constructor);//function Function() { [native code] }
p(Derived instanceof Object);//true

p(Derived.prototype.isPrototypeOf(obj)); //true
Base.prototype.isPrototypeOf(obj);//true
Object.prototype.isPrototypeOf(obj)//true
</script>

属性的枚举
in 可以可判断本身属性和通过继承来的属性是否存在于某个对象
hasOwnProperty只列出本身可以枚举的属性
有些属性被枚举出来是因为enumerable属性为false
getOwnPropertyNames可以无视枚举属性，列举出所有属性

<script>
var obj={x:1,y:2};
p(Object.keys(obj));//x,y
obj.z=3;
//obj.prototype.p=‘pp‘;//实例 prototype属性
p(obj.prototype);//undefined
p(obj.__proto__==Object.prototype); //true
p(Object.keys(obj));//x,y,x
var arr=[1,2,3];
p(Object.keys(arr)); //0,1,2
p(Object.getOwnPropertyNames(arr)); //0,1,2,length
p(Object.keys(Object.prototype));//空
p(Object.getOwnPropertyNames(Object.prototype));
/*
constructor,toString,toLocaleString,valueOf,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,__defineGetter__,__lookupGetter__,__defineSetter__,__lookupSetter__,__proto__
*/
//对于enumerable可根据propertyIsEnumerable来判断
function Myclass(){
    this.x=1;this.y=2;
}
Myclass.prototype.z=3;
var obj=new Myclass();
p(Object.getOwnPropertyNames(obj)); //x,y 不列举通过继承获取的属性
p(Object.keys(obj));// x,y
for(var key in obj){
    p(key);
}
//x,y,x
</script>