js的面试和笔试---JS中this关键字详解

港控/mmm° 2022-05-18 03:35 216阅读 0赞

本文主要解释在JS里面this关键字的指向问题(在浏览器环境下)。

阅读此文章，还需要心平气和的阅读完，相信一定会有所收获，我也会不定期的发布，分享一些文章，共同学习

首先，必须搞清楚在JS里面，函数的几种调用方式:

普通函数调用

作为方法来调用

作为构造函数来调用

使用apply/call方法来调用

Function.prototype.bind方法

es6箭头函数

但是不管函数是按哪种方法来调用的，请记住一点：谁调用这个函数或方法,this关键字就指向谁。

接下来就分情况来讨论下这些不同的情况：

普通函数调用  
复制代码  
1 function person()\{  
2 this.name=”xl”;  
3 console.log(this);  
4 console.log(this.name);  
5 \}  
6  
7 person(); //输出 window xl  
8  
复制代码

在这段代码中person函数作为普通函数调用，实际上person是作为全局对象window的一个方法来进行调用的,即window.person();  
所以这个地方是window对象调用了person方法,那么person函数当中的this即指window,同时window还拥有了另外一个属性name,值为xl.

1 var name=”xl”;  
2 function person()\{  
3 console.log(this.name);  
4 \}  
5 person(); //输出 xl

同样这个地方person作为window的方法来调用，在代码的一开始定义了一个全局变量name，值为xl,它相当于window的一个属性,即window.name=”xl”,又因为在调用person的时候this是指向window的，因此这里会输出xl.

作为方法来调用  
在上面的代码中，普通函数的调用即是作为window对象的方法进行调用。显然this关键字指向了window对象.

再来看下其他的形式

复制代码  
var name=”XL”;  
var person=\{  
name:”xl”,  
showName:function()\{  
console.log(this.name);  
\}  
\}  
person.showName(); //输出 xl  
//这里是person对象调用showName方法，很显然this关键字是指向person对象的，所以会输出name

var showNameA=person.showName;
    showNameA();    //输出  XL
    //这里将person.showName方法赋给showNameA变量，此时showNameA变量相当于window对象的一个属性，因此showNameA()执行的时候相当于window.showNameA(),即window对象调用showNameA这个方法，所以this关键字指向window

复制代码

再换种形式：

复制代码  
var personA=\{  
name:”xl”,  
showName:function()\{  
console.log(this.name);  
\}  
\}  
var personB=\{  
name:”XL”,  
sayName:personA.showName  
\}

personB.sayName();  //输出 XL
    //虽然showName方法是在personA这个对象中定义，但是调用的时候却是在personB这个对象中调用，因此this对象指向

复制代码

作为构造函数来调用  
复制代码  
1 function Person(name)\{  
2 this.name=name;  
3 \}  
4 var personA=Person(“xl”);  
5 console.log(personA.name); // 输出 undefined  
6 console.log(window.name);//输出 xl  
7 //上面代码没有进行new操作，相当于window对象调用Person(“xl”)方法，那么this指向window对象，并进行赋值操作window.name=”xl”.  
8  
9 var personB=new Person(“xl”);  
10 console.log(personB.name);// 输出 xl  
11 //这部分代码的解释见下  
复制代码

new操作符  
复制代码  
//下面这段代码模拟了new操作符(实例化对象)的内部过程  
function person(name)\{  
var o=\{\};  
o.**proto**=Person.prototype; //原型继承  
Person.call(o,name);  
return o;  
\}  
var personB=person(“xl”);

console.log(personB.name);  // 输出  xl

复制代码  
这段代码涉及到了*proto*及prototype的概念，如果有需要了解，请点击链接

在person里面首先创建一个空对象o，将o的proto指向Person.prototype完成对原型的属性和方法的继承

Person.call(o,name)这里即函数Person作为apply/call调用(具体内容下方)，将Person对象里的this改为o，即完成了o.name=name操作

返回对象o。

因此`person("xl")`返回了一个继承了`Person.prototype`对象上的属性和方法，以及拥有`name`属性为”xl”的对象，并将它赋给变量`personB`.  
所以`console.log(personB.name)`会输出”xl”  
call/apply方法的调用  
在JS里函数也是对象，因此函数也有方法。从Function.prototype上继承到Function.prototype.call/Function.prototype.apply方法  
call/apply方法最大的作用就是能改变this关键字的指向.

Obj.method.apply(AnotherObj,arguments);

复制代码  
1 var name=”XL”;  
2 var Person=\{  
3 name:”xl”,  
4 showName:function()\{  
5 console.log(this.name);  
6 \}  
7 \}  
8 Person.showName.call(); //输出 “XL”  
9 //这里call方法里面的第一个参数为空，默认指向window。  
10 //虽然showName方法定义在Person对象里面，但是使用call方法后，将showName方法里面的this指向了window。因此最后会输出”XL”;  
11 funtion FruitA(n1,n2)\{  
12 this.n1=n1;  
13 this.n2=n2;  
14 this.change=function(x,y)\{  
15 this.n1=x;  
16 this.n2=y;  
17 \}  
18 \}  
19  
20 var fruitA=new FruitA(“cheery”,”banana”);  
21 var FruitB=\{  
22 n1:”apple”,  
23 n2:”orange”  
24 \};  
25 fruitA.change.call(FruitB,”pear”,”peach”);  
26  
27 console.log(FruitB.n1); //输出 pear  
28 console.log(FruitB.n2);// 输出 peach  
复制代码

FruitB调用fruitA的change方法，将fruitA中的this绑定到对象FruitB上。

Function.prototype.bind()方法  
复制代码  
var name=”XL”;  
function Person(name)\{  
this.name=name;  
this.sayName=function()\{  
setTimeout(function()\{  
console.log(“my name is “+this.name);  
\},50)  
\}  
\}  
var person=new Person(“xl”);  
person.sayName() //输出 “my name is XL”;  
//这里的setTimeout()定时函数,相当于window.setTimeout(),由window这个全局对象对调用,因此this的指向为window, 则this.name则为XL  
复制代码

那么如何才能输出”my name is xl”呢？

复制代码  
var name=”XL”;  
function Person(name)\{  
this.name=name;  
this.sayName=function()\{  
setTimeout(function()\{  
console.log(“my name is “+this.name);  
\}.bind(this),50) //注意这个地方使用的bind()方法，绑定setTimeout里面的匿名函数的this一直指向Person对象  
\}  
\}  
var person=new Person(“xl”);  
person.sayName(); //输出 “my name is xl”;  
复制代码

这里setTimeout(function()\{console.log(this.name)\}.bind(this),50);,匿名函数使用bind(this)方法后创建了新的函数，这个新的函数不管在什么地方执行，this都指向的Person,而非window,因此最后的输出为”my name is xl”而不是”my name is XL”

另外几个需要注意的地方：  
setTimeout/setInterval/匿名函数执行的时候，this默认指向window对象，除非手动改变this的指向。在《javascript高级程序设计》当中，写到：“超时调用的代码(setTimeout)都是在全局作用域中执行的，因此函数中的this的值，在非严格模式下是指向window对象，在严格模式下是指向undefined”。本文都是在非严格模式下的情况。

复制代码  
var name=”XL”;  
function Person()\{  
this.name=”xl”;  
this.showName=function()\{  
console.log(this.name);  
\}  
setTimeout(this.showName,50);  
\}  
var person=new Person(); //输出 “XL”

//在setTimeout(this.showName,50)语句中，会延时执行this.showName方法
    //this.showName方法即构造函数Person()里面定义的方法。50ms后，执行this.showName方法，this.showName里面的this此时便指向了window对象。则会输出"XL";

复制代码

修改上面的代码：

复制代码  
复制代码  
1 var name=”XL”;  
2 function Person()\{  
3 this.name=”xl”;  
4 var that=this;  
5 this.showName=function()\{  
6 console.log(that.name);  
7 \}  
8 setTimeout(this.showName,50)  
9 \}  
10 var person=new Person(); //输出 “xl”  
11  
12  
13  
14 //这里在Person函数当中将this赋值给that，即让that保存Person对象，因此在setTimeout(this.showName,50)执行过程当中，console.log(that.name)即会输出Person对象的属性”xl”  
复制代码

复制代码  
匿名函数：

复制代码  
1 var name=”XL”;  
2 var person=\{  
3 name:”xl”,  
4 showName:function()\{  
5 console.log(this.name);  
6 \}  
7 sayName:function()\{  
8 (function(callback)\{  
9 callback();  
10 \})(this.showName)  
11 \}  
12 \}  
13 person.sayName(); //输出 XL  
14 var name=”XL”;  
15 var person=\{  
16 name:”xl”,  
17 showName:function()\{  
18 console.log(this.name);  
19 \}  
20 sayName:function()\{  
21 var that=this;  
22 (function(callback)\{  
23 callback();  
24 \})(that.showName)  
25 \}  
26 \}  
27 person.sayName() ; //输出 “xl”  
28 //匿名函数的执行同样在默认情况下this是指向window的，除非手动改变this的绑定对象  
复制代码

Eval函数  
该函数执行的时候，this绑定到当前作用域的对象上

复制代码  
var name=”XL”;  
var person=\{  
name:”xl”,  
showName:function()\{  
eval(“console.log(this.name)”);  
\}  
\}

person.showName();  //输出  "xl"
    
    var a=person.showName;
    a();  //输出  "XL"

复制代码

箭头函数  
es6里面this指向固定化，始终指向外部对象，因为箭头函数没有this,因此它自身不能进行new实例化,同时也不能使用call, apply, bind等方法来改变this的指向

复制代码  
function Timer() \{  
this.seconds = 0;  
setInterval( () => this.seconds ++, 1000);  
\}

var timer = new Timer();
    
    setTimeout( () => console.log(timer.seconds), 3100);
    
    // 3

// 在构造函数内部的setInterval()内的回调函数，this始终指向实例化的对象，并获取实例化对象的seconds的属性,每1s这个属性的值都会增加1。否则最后在3s后执行setTimeOut()函数执行后输出的是0