本文详细解析JavaScript中this关键字的指向机制，涵盖全局环境、构造函数及对象方法中的不同表现。重点讨论this指向的可变性，并针对多层嵌套、数组处理及回调函数中this丢失的常见问题，提供使用that变量、严格模式及bind方法等解决方案，帮助开发者避免常见陷阱。
梳理知识清单有助于理清思路，这是一种高效的学习方法，值得推荐。
以下内容篇幅较长，请读者耐心阅读。
文章将按以下结构展开：
this的基本涵义与指向变化
1. 基本涵义
1.1：this的基本定义
1.2：this指向的动态变化
2. 常见使用场景
2.1：全局环境下的this
2.2：构造函数中的this
2.3：对象方法中的this
3. 使用注意事项
3.1：避免多层嵌套导致的this指向问题
3.2：数组处理方法中this的使用限制
3.3：回调函数中this指向的变更
1. 基本涵义
1.1：this的基本定义
在讨论构造函数与new关键字的关系时，我们了解到new总会返回一个对象。该对象可能是构造函数执行后返回的空对象，也可能是通过return语句返回的复杂数据类型（如对象或数组）。
与new类似，this关键字也始终指向一个对象。更准确地说，它指向属性或方法“当前”所在的对象。
var Keith = {
firstName: 'Chou',
describe: function() {
return this.firstName;
}
};
console.log(Keith.describe()); //'Chou'在上述代码中，表示describe方法当前所在对象的firstName属性。当在全局作用域调用describe方法时，由于该方法属于Keith对象，因此this.firstName实际上是在访问Keith.firstName。
1.2：this指向的动态变化
由于对象的属性可以被赋值给其他对象，属性所在的当前对象是可以变化的，这意味着this的指向也是动态可变的。
var Keith = {
firstName: 'Chou',
describe: function() {
return this.firstName;
}
};
var Rascal={
firstName: 'King'
}
Rascal.describe=Keith.describe;
console.log(Rascal.describe()); //'King'在上述代码中，将Keith对象中的describe属性赋值给Rascal。此时，describe方法中this所在的对象变为Rascal，因此this.firstName指向Rascal。由于是传址引用，修改firstName会影响原对象。若此例难以理解，可参考后续示例。
function f(){
return this.firstName;
}
var Keith = {
firstName: 'Chou',
describe:f
};
var Rascal={
firstName: 'King',
describe:f
}
console.log(Keith.describe()); //'Chou'
console.log(Rascal.describe()); //'King'在上述代码中，将方法移至全局作用域，函数f内部使用了this。随着f被赋予不同的对象，this的指向也随之改变。
在全局作用域中，this关键字指向顶层对象（即window对象）。
var name='keith';
function person(){
var name='rascal';
return this.name;
}
console.log(person()); //'keith'在上述代码中，返回的是keith而非rascal。原因在于this指向全局作用域。在全局定义函数时，默认指向window对象，而非函数本身。但若在函数内部不使用var声明局部变量，结果将不同。
var name='keith';
function person(){
name='rascal';
return this.name;
}
console.log(person()); //'rascal'在上述代码中，函数内部未使用var声明局部变量，此时name属性成为全局变量，从而覆盖了之前的name属性。若对局部与全局变量概念不清，可参考相关文章。
只要函数被赋值给另一个变量，this的指向就会发生改变。
var Keith={
name:'keith',
describe:function(){
return this.name;
}
}
var name='rascal';
var f=Keith.describe;
console.log(f()) //'rascal'在上述代码中，返回的是rascal而非keith。因为Keith.describe被赋值给变量f，且全局作用域中存在name变量，所以Keith内部函数的this指向f运行时所在的对象（即顶层对象window）。
总结如下：
1. 在JavaScript语言中，除undefined和null外，一切皆为对象，运行环境也是对象。函数在特定对象中运行，this即代表该对象（环境）。
2. this的指向是动态的。若函数位于全局作用域，this指向全局环境；若函数位于某个对象中，this指向该对象。
this的常见使用场景
2. 常见使用场景
this的使用场景主要包含以下几种情况。
2.1：全局环境（全局作用域）
在全局作用域中使用this对象，它指向顶层对象，即window对象。
function keith() {
return (this === window)
}
console.log(keith()) //true在上述代码中，无论是否在函数内部，只要在全局作用域下运行，this都指向顶层对象window。
2.2：构造函数
构造函数中的this，指向的是即将创建的对象实例。
function Keith() {
this.sex = 'boy';
}
var person = new Keith();
console.log(person.sex); //'boy'在上述代码中，在全局作用域下定义了Keith构造函数，随后调用构造函数并赋值给person对象实例。
构造函数创建需满足三个基本条件：函数名首字母大写；构造函数内部使用this关键字指向即将生成的对象实例；使用new关键字调用构造函数并返回对象实例。
若需深入了解构造函数与new关键字的关系，可参考相关文章。
2.3：对象的方法
当A对象的方法被赋值给B对象时，该方法中的this从指向A对象变为指向B对象。因此，将某个对象的方法赋值给另一个对象时，需特别注意this指向的改变。
var keith = {
sex: 'boy',
foo: function() {
return this.sex;
}
};
var rascal = {
sex: 'girl'
};
rascal.foo = keith.foo;
console.log(keith.foo()); //'boy'
console.log(rascal.foo()); //'girl'在上述代码中，将keith的foo函数赋值给rascal，此时this的指向从keith变为rascal。
若某个方法位于多层对象内部，为简化书写将其赋值给变量，往往会导致不同的结果。
var a = {
b: {
p: 'keith',
c: function() {
return this.p;
}
}
};
var person = a.b.c;
console.log(person()); //undefined在上述代码中，c是两层对象中的一个方法。为简便起见，将其赋值给全局变量person，调用时this指向顶层对象window。而在window中，变量p默认值为undefined。
解决此问题的方法可以是仅将c所在的对象赋值给person变量，或直接调用该方法。
var person = a.b;
console.log(person.c()); //'keith'
console.log(a.b.c()); //'keith'this使用的注意事项与解决方案
3. 使用注意事项
3.1：避免多层嵌套导致的this指向问题
当在闭包中使用多层this时，this通常会指向window。
function keith() {
console.log(this);
return function() {
return this;
}
}
keith(); //window
keith()(); //window在上述代码中，在一个函数中返回另一个匿名函数是闭包的特征之一。可以看出，当在闭包中使用this对象时，它都会指向全局作用域中的window对象。
若在函数外包含一个对象，则内部this指向全局作用域，而外部this对象指向当前作用域。
var o = {
f1: function() {
console.log(this);
(function() {
console.log(this)
})();
}
};
o.f1(); //Object , Window在上述代码中，包含两层this，运行结果显示第一层指向当前对象，第二层指向全局对象。
实际执行逻辑如下所示。
function keith() {
console.log(this);
}
var o = {
f1: function() {
console.log(this);
var f2 = keith();
}
};
o.f1(); //Object , Window要实现多层this嵌套，有两种解决方法：
一是在第二层中改用一个指向外层this的变量。
var o = {
f1: function() {
console.log(this);
var that = this;
(function() {
console.log(that);
})();
}
};
o.f1(); //Object , Object在上述代码中，定义了局部变量that，固定指向外层的this，然后在内层中使用that，即可避免this指向的改变。但如果函数外部嵌套了对象，this仍会指向全局。
二是利用JavaScript中的严格模式。在严格模式下，如果内部函数的this指向window对象，将会报错。
var a = {
count: 0,
fun: function() {
'use strict';
return this.count++;
}
}
var f = a.fun;
console.log(f()) //'TypeError: this is undefined'在上述代码中，fun方法使用严格模式声明。将a对象中的fun方法赋值给全局变量f，此时this指向window对象，在严格模式下会报错。若函数外部没有嵌套对象，则不会报错，而是返回undefined。
3.2：数组处理方法中this的使用限制
数组的map和forEach方法允许提供一个函数作为参数。该函数内部不应使用this。
var keith = {
a: 'Hello',
b: ['b1', 'b2'],
c: function() {
this.b.forEach(function(item) {
console.log(this.a + ' ' + item);
})
}
};
keith.c();
//undefined b1
//undefined b2在上述代码中，forEach方法的回调函数中的this，实际上指向的是window对象，因此无法获取keith.a的值。这也属于避免多层嵌套this的情况，即内层的this不指向外部函数，而是指向顶层对象。
解决此问题的方法可以使用that变量来代替回调函数中的this。
var keith = {
a: 'Hello',
b: ['b1', 'b2'],
c: function() {
var that = this;
this.b.forEach(function(item) {
console.log(that.a + ' ' + item);
})
}
};
keith.c();
//Hello b1
//Hello b2另一种方法是让this作为forEach方法的第二个参数，以固定其运行环境。
var keith = {
a: 'Hello',
b: ['b1', 'b2'],
c: function() {
this.b.forEach(function(item) {
console.log(this.a + ' ' + item);
}, this)
}
};
keith.c();
//Hello b1
//Hello b23.3：回调函数中this指向的变更
回调函数中的this往往会改变指向。
var o = {
f: function() {
console.log(this === o);
}
};
o.f(); // true;
在上述代码中，调用o对象的f方法，返回true。
然而，如果将f方法指定给某个按钮的click事件，this的指向就会发生变化。
$('button').on('click',o.f);
在上述代码中，使用了jquery方法来获取button元素，并绑定click事件。点击按钮后控制台会显示false。原因是此时this不再指向o对象，而是指向按钮的DOM对象，因为f方法是在按钮对象的环境中被调用的。
总结如下：
a：若需处理多层嵌套this关键字，最常用的解决方法是使用that变量，固定指向外层的this，然后在内层中使用that变量，即可避免内层this指向全局的问题。
b：若在回调函数中使用this关键字，需注意this的指向问题。
以上就是本文的全部内容，希望本文的内容对大家的学习或者工作能带来一定的帮助，同时也希望多多支持本站！