javascript 对象及原型继承有关的属性:constructor、prototype、isPrototypeOf、instanceof、in 、hasOwnProperty 等等
constructor:对象的构造器,是一个函数。
prototype:构造器的原型,只有函数才具有这个属性。
isPrototypeOf:如果对象 A 存在于 对象obj的原形链中,则 A.isPrototypeOf(obj)返回true,而obj必定继承了A 的属性。
__proto__:访问对象的原型链在当前对象的上一级对象,即对象的父级对象,非W3C 或 ECMAscript 标准,是浏览器对原型继承 的一种实现手段,存在于firefox 和 chrome ,IE下不存在这个属性。js 对象的原形链应当是由 js 引擎维护的,属于“引擎级”的数据,__proto__ 属性的出现使原形链可以被修改,这使得在 js 语法范围内讨论 js 对象的原型链称为可能。
在对象的继承关系中,对象obj的构造器 constructor 其实是存在于原型链中的,即 obj.constructor 实际上 是 obj.__proto__.constructor, obj.hasOwnProperty('constructor'); 为 false
function Y() {this.y=99;} var obj = new Y(); console.log(obj.constructor); //Y console.log(obj.hasOwnProperty('constructor')); //false console.log(obj.__proto__.hasOwnProperty('constructor')); //true //===== function X(){this.x=88; } function Y() {this.y=99;} Y.prototype = new X(); var obj = new Y(); console.log(obj.constructor); //X console.log(obj.hasOwnProperty('constructor'));//false console.log(obj.__proto__.hasOwnProperty('constructor')); //false console.log(obj.__proto__.__proto__.hasOwnProperty('constructor')); //true
//============
//访问对象时,对于 obj.__proto__.x=value 则必定有 obj.x=value, //obj.constructor.prototype 上的属性将被保存在obj.__proto__中。 function Y() {this.y=99;} Y.prototype = {a:11}; var obj = new Y(); obj.__proto__.hasOwnProperty("a");//true Y.prototype.a=77; console.log([obj.a,obj.__proto__.a,obj.y,obj.__proto__.y]); //77,77,99,undefined,y 属性是由对象构造器直接产生的而不是从原形链继承来的*/
//new 运算构造obj对象之后,obj访问继承来的属性时,是通过__proto__ 访问的,而不是通过obj.constructor.prototype 访问,obj.__proto.__ 并非简单指向 obj.constructor.prototype,而是与它指向同一个对象
//因此,如果修改obj.constructor.prototype指向另一个对象,并不会影响obj继承原有的属性。
Y.prototype = {b:22};
console.log(obj.b); //undefined
console.log(obj.a); //77
//另一例子,可能会带来一点迷惑 function ClassA(){ var prop = 'hello'; arguments.callee.prototype={ getProp:function(){ return prop; } } } var obj1 = new ClassA(); obj1.getProp(); // error,Object #<ClassA> has no method 'getProp' var obj2 = new ClassA(); obj2.getProp(); // hello 因为初始化 obj1 时,ClassA.prototype 被修改,而修改前,obj1 已经实例化了
in:如果对象 obj 有属性 property(包括继承来的和不可列举属性,不同于 for in 循环中的 in,for in 忽略了 不可列举属性), 则'property' in obj 返回 true,这个运算不存在于初期版本的javascript。
propertyIsEnumerable:如果对象obj上的属性property可以被列举出来(可被 for in 循环遍历), 则 obj.propertyIsEnumerable('property') 返回true,值得注意的 是,propertyIsEnumerable对继承来的属性一律判断为false,这一般被认为是ECMA Script 规范的一个设计上的错误。
hasOwnProperty:如果对象obj 上的属性 property 不是继承的来的,则 obj.hasOwnProperty('property') 返回true。
delete:删除对象自身上的属性,不能删除继承来的属性,不能删除使用 var 声明的变量 ,不能删除函数声明,但是在如果在 firebug 和 IE9 的调试器里面执行代码,会发现全局变量被删除了,实际上这在页面上的代码中是不会发生的事。
var f = function(){}; f.prototype = { x:99 }; var o = new f; console.log(o.hasOwnProperty('x')); //false console.log(o.x); //99 delete o.x ; console.log(o.x); //99 var x = 1; window.hasOwnProperty('x'); //true delete window.x; console.log(x); // error,x is not defined in firefox bug , it will be 1 in chrome
instanceof:如果obj对象是构造函数Fun的一个实例,则 obj instanceof Fun 返回 true,
值得注意的是,instanceof 并不检查 Fun 函数,其检测是基于"原形链"的,如果 fun.prototype == obj.__proto__ 为 true, 或者 fun.prototype.isPrototypeOf(obj.__proto__) 为 true , 则 obj instcaneof fun 返回 true,即 fun.prototype.isPrototypeOf(obj) 为 true . (之前这里写 instanceof 以 fun.prototype.constructor==obj.__proto__.constructor 是否为 true 作为 依据是错误的 )
因此,即使 obj instanceof Fun 返回 true,obj 也可能不具有 Fun 构造器中定义的属性,因为 Fun 不一定是 obj 的构造器。
试看下面代码:
function f(){}; function g(){}; function k(){} f.prototype = new g(); var obj = new f(); console.log(obj instanceof f,obj instanceof g,f.prototype==obj.__proto__,g.prototype.isPrototypeOf(obj.__proto__)) ; //true true true true k.prototype = f.prototype; console.log(obj instanceof k); //true var o = {}; o.__proto__ = obj; console.log(o instanceof f); //true function P(){} P.prototype.constructor = obj.__proto__.constructor; console.log(obj instanceof P.prototype.constructor, obj instanceof P); //true false obj.__proto__ = {}; console.log(obj instanceof f); //false g.prototype = {}; console.log(obj instanceof g); //false
//另一个例子 function A(){ this.a='a'; } function B(){ this.b = 'b'; } B.prototype.constructor = A; var obj = new B(); console.log(obj instanceof B, obj instanceof A); //true ,false console.log(B.prototype==obj.__proto__); //true console.log(obj.constructor === A,obj.__proto__.constructor ===A, obj instanceof A); //true true false , 这说明 instanceof 不以构造器为判断依据
关于instanceof,试考察下面代码:
function P(){this.p=11;}; var pro = new P(); function X() {this.x=88;} function Y() {this.y=99;} Y.prototype =pro; var obj = new Y();
1、对象构造器在哪
console.log(obj.hasOwnProperty('constructor')); //false console.log(obj.constructor); //P console.log(obj.__proto__.constructor);//P console.log(obj.__proto__.constructor === Y.prototype.constructor); //true
这说明执行new时,obj.constructor 即 obj.__proto__.constructor ,obj.__proto__ == Y.prototype;
因此 obj.constructor 实际是 Y.prototype.constructor 而不是 Y,
因此,“对象构造器” 实质上应是 “对象原型的构造器”, 即, 当 obj 对象的构造函数的 prototype.constructor 不是指向自身时, obj.constructor 不是指向 obj 的构造器,而是 obj 对像的原型的构造器。
2、对象构造器修复
但是,有一点小问题,考察一下 y 属性:
console.log(obj.y); // 99 console.log(obj.__proto__.y); //undefined
y 属性既然不是来自于“原型链”,那自然是来自于对象构造器,但是 P 函数中并没有定义 y 属性,
从“类式继承” 形成的“继承链” 看来,P 只是“继承链”的源头,也就是最顶级的 “基类”, obj 对象实例的的构造来源于“子类” y 函数,
这是 js 对象继承系统中 “模拟类式继承” new 与“原型继承” prototype 之间的一点裂缝,
很多人执着于修复这个裂缝,于是有了构造器修复的做法.
默认状态下声明一个函数fun,有 fun.prototype.constructor===fun,于是:
obj.constructor = Y ; //修复构造器,赋一个constructor 属性来覆盖掉继承链上的constructor console.log(obj.hasOwnProperty('constructor')); //true console.log(obj.constructor); //Y console.log(obj.__proto__.constructor); //P
//或者向下面这个构造器处理方式
var fun = (function(){
var f = function(){
this.a =1;
};
f.prototype = {
constructor:f, //修复构造器为函数 f,因为直接将一个对象直接量赋给 f.prototype,fun构造的对象的constructor 将是对象直接量的constructor,即 Object函数
method1:function(){
return this.a;
}
};
return f;
})();
var obj = new fun();
3、obj instancof Fun 为 true 并不意味着 Fun 一定是 obj 对象的构造器,Fun 可能并不存在于 obj 的继承链中:
X.prototype = pro; console.log(obj instanceof X); //true console.log(obj.x);//undefined , X 不是 obj 的构造器 console.log(obj instanceof Y); //true console.log(obj.y);//99
4、Object.create()
新版本的 ECMAScript 为 Object 对象扩展了一些方法,
Object.create(pro)可以基于 pro 为原型创建一个对象,其效果相当于
var f = function(){}; f.prototype = pro; var obj = new f();
//try: function P(){this.p=11;} function K(){this.k=22;} function F(){this.f=33;} var pro = new K(); P.prototype = pro; var o= new P(); var obj = Object.create(o); console.log(o,obj); // 都是 {p:11,k:22} console.log(obj.constructor); // K console.log(obj.__proto__.constructor); //k console.log(obj instanceof P); //true console.log(obj instanceof K); //true console.log(obj instanceof F); //false F.prototype = pro; console.log(obj instanceof F); //true
5、Object 与 Function:
console.log(Function instanceof Object); //true console.log(Object instanceof Function); //true
先有 Function 还是先有 Object ?下面这个现象或许能解释,Object 才是“最顶级”的对象
console.log(Object.__proto__.__proto__===Function.prototype) ; // false console.log(Function.__proto__.__proto__ === Object.prototype); // true console.log(Object.prototype.__proto__); // null ,Object 的对象原型已经是女娲级的了