在js语言规范中并不存在方法这一概念,方便起见,将作为对象属性的函数成为方法
this引用的规则
a.在最外层代码中,this引用的是全局对象
b.在函数内,this引用根据函数调用方式不同而不同
函数内部的this引用 见下表
函数的调用方式 |
this引用的引用对象 |
构造函数调用 |
所生成的对象 |
方法调用 |
接收方对象 |
apply或call调用 |
由apply或call的参数指定的对象 |
其它方式调用 |
全局对象 |
接收方对象是这样一种对象
通过点运算符或者中括号运算符调用对象方法时,在运算符左侧所指定的对象
下面是一个关于方法和接收方对象的具体实例
<script> var obj={ x:3, doit:function(){ p("method is called: "+this.x); } }; obj.doit();//对象obj是接收方对象 doit是方法 obj['doit']();//对象obj是接收方对象 doit是方法 //结果一样 method is called: 3 </script>
this引用应注意的点
this的引用的引用对象会随着方法的调用方式不同而不同
<script> var obj={ x:3, doit:function(){ p("method is called: "+this.x); } }; var fn=obj.doit;//将obj.doit引用的Function对象赋值给全局变量 fn();//method is called: undefined 函数内的this引用引用了全局变量 var x=5; fn();//method is called: 5 var obj2={x:4,doit2:fn};//将obj的方法(Function对象的引用)赋值给了另一个对象obj2的属性 obj2.doit2();//method is called: 4 方法内的this引用引用了对象obj2 </script> <script> var obj={ x:3, doit:function(){ p("doit is called "+this.x);this.doit2(); }, doit2:function(){ p("doit2 is called "+this.x); } }; obj.doit(); //doit is called 3 //doit2 is called 3 //如果将doit2前面的this去掉,则会查找全局里的doit2 嵌套的函数将按照作用域顺序由内到外的顺序查找 </script>
apply与call
在Function对象中包含apply和call这两种方法,通过他们调用的函数的this引用可以指向任意的特定对象,也就是他们可以
显式指定接收方对象
<script> function f(a){ p(this.x+":"+a); } var obj={x:4}; f.apply(obj,[2]); //4 通过apply调用f函数内部this指向了obj f.call(obj,2); //4 通过call调用f函数内部this指向了obj var obj={ x:3, doit:function(){ p("method is called:"+this.x); } }; var obj2={x:4}; obj.doit.apply(obj2);//method is called:4 p(Math.max(4,5,1,2)); var arr=[1,3,2,0,99]; var mx=Math.max.apply(null,arr);//没提供第一个参数 则global对象将被用作ths.obj p(mx);//99 </script>
原型继承
形式上的理解
类名.prototype.方法名=function(参数){方法体}
<script> function Myclass(x,y){ this.x=x; this.y=y; this.say=function(){ p(this.x+":"+this.y); } } Myclass.prototype.show=function(){ p(this.x,this.y); } var obj1=new Myclass(1,2); obj1.show(); p('show' in obj1);//true p(obj1.hasOwnProperty('show')) //false p(obj1.hasOwnProperty('say')); //true p('show' in Myclass);//false p("say" in Myclass);//false p(typeof Myclass);//function </script>
原型链
原型继承支持一种称为原型链的功能,使用原型链有2个前提
a.所有的函数(对象)都具有名为prototype的属性(prototype属性所引用的对象则称为prototype对象)
【对象实例 如上代码中的obj1没有prototype属性】
<script> p( 'prototype' in obj1);//false p('__proto__' in obj1);//true p('prototype' in Myclass);//true p("__proto__" in Myclass);//true </script>
b.所有的对象都含有一个(隐藏的)链接,用以指向在对象生成过程中所使用的构造函数(Function对象)的prototype对象b.所有的对象都含有一个(隐藏的)链接,用以指向在对象生成过程中所使用的构造函数(Function对象)的prototype对象
<script> p(obj1.__proto__===Myclass.prototype);//true p(Myclass.__proto__);// function Empty() {} p(obj1.prototype);//undefined p('x' in Myclass);//false </script>
对象(类的实例)对属性的读取 查找顺序
1.对象自身的属性(通过实例化类获取的属性)
2.隐式链接所引用的对象(即构造函数的prototype对象)的属性 (obj1.__proto__=Myclass.prototype)
3.第二项中的对象的隐式链接所引用的对象的属性
4.反复按照第三步的规则查找直至全部查找完毕(查找的终点是Object.prototype对象)
当一个函数对象被创建时,Function构造器产生的函数对象会运行类似这样的一些代码
this.prototype={constructor:this}
新函数的对象被赋予一个prototype属性,他的值是包含constructor属性且属性值为该新函数的对象,这个prototype对象是存放继承特征的地方,
因为javascript语言没有提供一种方法去确定哪个函数是打算用来做构造器的,所以每个函数都会得到一个prototype对象
constructor没什么用
当采用构造器调用模式,即用new去调用一个函数,函数执行方式将发生改变
如果new 运算符是一个方法而不是一个运算符,它可能会这样执行
<script> function a(){ } p(a.prototype); //[object Object] p(a.prototype.constructor); //function a(){ } p(a.prototype.__proto__==Function.prototype);//false p(a.prototype.__proto__==Object.prototype);//true p('method' in Function);//false //伪代码 Function.method('new',function(){ //创建一个新对象,它继承自构造器函数的原型对象 var that=Object.create(this.prototype); //调用构造器函数,绑定 this到新对象上 var other=this.apply(that,arguments); //如果它的 返回值不是一个对象,就返回该新对象 return (typeof other==='object' && other)||that; }); </script>