我希望找到一个“this”关键字的明确解释，以及如何正确使用它。
它的行为似乎很奇怪，我不完全明白为什么。
这是如何工作的，何时使用？
当前回答
由于这篇文章的篇幅有所增加，我为读者整理了一些新的观点。
这个值是如何确定的？
我们使用这个词的方式与我们在英语等自然语言中使用代词的方式类似：“约翰跑得很快，因为他正在赶火车。”相反，我们可以写“……约翰正在赶火车”。
var person = {
firstName: "Penelope",
lastName: "Barrymore",
fullName: function () {
// We use "this" just as in the sentence above:
console.log(this.firstName + " " + this.lastName);
// We could have also written:
console.log(person.firstName + " " + person.lastName);
}
}
在对象调用定义它的函数之前，不会为其赋值。在全局范围中，所有全局变量和函数都在窗口对象上定义。因此，这在全局函数中引用（并且具有的值）全局窗口对象。
当使用strict时，在未绑定到任何对象的全局函数和匿名函数中，它的值为undefined。
this关键字在以下情况下最容易被误解：1）我们借用了一个使用this的方法，2）我们将一个使用它的方法分配给一个变量，3）使用this的函数作为回调函数传递，4）这在闭包内部使用-一个内部函数。(2)
未来是什么
在ECMA脚本6中定义，箭头函数采用来自封闭（函数或全局）范围。
function foo() {
// return an arrow function
return (a) => {
// `this` here is lexically inherited from `foo()`
console.log(this.a);
};
}
var obj1 = { a: 2 };
var obj2 = { a: 3 };
var bar = foo.call(obj1);
bar.call( obj2 ); // 2, not 3!
虽然箭头函数提供了使用bind（）的替代方法，但需要注意的是，它们实际上是在禁用传统的this机制，以支持更广泛理解的词汇范围。(1)
参考文献：
凯尔·辛普森（Kyle Simpson）的《this&Object Prototypes》。©2014 Getify解决方案。javascriptissxy.com-http://goo.gl/pvl0GX 安格斯·克罗尔http://goo.gl/Z2RacU
其他回答
“this”的值取决于执行函数的“上下文”。上下文可以是任何对象或全局对象，即窗口。
因此，“this”的语义不同于传统的OOP语言。这会导致问题：1.当一个函数传递给另一个变量时（很可能是回调）；和2。当从类的成员方法调用闭包时。
在这两种情况下，这都设置为window。
与其他语言相比，this关键字在JavaScript中的行为有所不同。在面向对象语言中，this关键字指的是类的当前实例。在JavaScript中，这个值由函数的调用上下文（context.function（））及其调用位置决定。
1.在全局上下文中使用时
当您在全局上下文中使用它时，它将绑定到全局对象（浏览器中的窗口）
document.write(this); //[object Window]
当您在全局上下文中定义的函数中使用此函数时，它仍然绑定到全局对象，因为该函数实际上是全局上下文的方法。
function f1()
{
return this;
}
document.write(f1()); //[object Window]
f1以上是全局对象的方法。因此，我们也可以在window对象上调用它，如下所示：
function f()
{
return this;
}
document.write(window.f()); //[object Window]
2.在对象方法内部使用时
当您在对象方法中使用此关键字时，它将绑定到“立即”封闭对象。
var obj = {
name: "obj",
f: function () {
return this + ":" + this.name;
}
};
document.write(obj.f()); //[object Object]:obj
上面我把单词immediate用双引号括起来。这是为了指出，如果您将对象嵌套在另一个对象中，那么这将绑定到直接父对象。
var obj = {
name: "obj1",
nestedobj: {
name:"nestedobj",
f: function () {
return this + ":" + this.name;
}
}
}
document.write(obj.nestedobj.f()); //[object Object]:nestedobj
即使您将函数作为方法显式添加到对象中，它仍然遵循上述规则，即这仍然指向直接父对象。
var obj1 = {
name: "obj1",
}
function returnName() {
return this + ":" + this.name;
}
obj1.f = returnName; //add method to object
document.write(obj1.f()); //[object Object]:obj1
3.调用无上下文函数时
当您使用这个在没有任何上下文的情况下调用的内部函数（即，不在任何对象上）时，它将绑定到全局对象（浏览器中的窗口）（即使函数是在对象内部定义的）。
var context = "global";
var obj = {
context: "object",
method: function () {
function f() {
var context = "function";
return this + ":" +this.context;
};
return f(); //invoked without context
}
};
document.write(obj.method()); //[object Window]:global
使用函数尝试所有功能
我们也可以用函数来尝试以上几点。然而，存在一些差异。
上面我们使用对象文字表示法向对象添加了成员。我们可以通过使用这个向函数添加成员。以指定它们。对象文字表示法创建了一个我们可以立即使用的对象实例。对于函数，我们可能需要首先使用新运算符创建其实例。同样，在对象文字方法中，我们可以使用点运算符将成员显式添加到已定义的对象中。这将仅添加到特定实例。然而，我已经向函数原型添加了变量，以便它在函数的所有实例中得到反映。
下面，我尝试了我们使用Object和上面所做的所有事情，但首先创建了函数，而不是直接编写对象。
/*********************************************************************
1. When you add variable to the function using this keyword, it
gets added to the function prototype, thus allowing all function
instances to have their own copy of the variables added.
*********************************************************************/
function functionDef()
{
this.name = "ObjDefinition";
this.getName = function(){
return this+":"+this.name;
}
}
obj1 = new functionDef();
document.write(obj1.getName() + "<br />"); //[object Object]:ObjDefinition
/*********************************************************************
2. Members explicitly added to the function protorype also behave
as above: all function instances have their own copy of the
variable added.
*********************************************************************/
functionDef.prototype.version = 1;
functionDef.prototype.getVersion = function(){
return "v"+this.version; //see how this.version refers to the
//version variable added through
//prototype
}
document.write(obj1.getVersion() + "<br />"); //v1
/*********************************************************************
3. Illustrating that the function variables added by both above
ways have their own copies across function instances
*********************************************************************/
functionDef.prototype.incrementVersion = function(){
this.version = this.version + 1;
}
var obj2 = new functionDef();
document.write(obj2.getVersion() + "<br />"); //v1
obj2.incrementVersion(); //incrementing version in obj2
//does not affect obj1 version
document.write(obj2.getVersion() + "<br />"); //v2
document.write(obj1.getVersion() + "<br />"); //v1
/*********************************************************************
4. `this` keyword refers to the immediate parent object. If you
nest the object through function prototype, then `this` inside
object refers to the nested object not the function instance
*********************************************************************/
functionDef.prototype.nestedObj = { name: 'nestedObj',
getName1 : function(){
return this+":"+this.name;
}
};
document.write(obj2.nestedObj.getName1() + "<br />"); //[object Object]:nestedObj
/*********************************************************************
5. If the method is on an object's prototype chain, `this` refers
to the object the method was called on, as if the method was on
the object.
*********************************************************************/
var ProtoObj = { fun: function () { return this.a } };
var obj3 = Object.create(ProtoObj); //creating an object setting ProtoObj
//as its prototype
obj3.a = 999; //adding instance member to obj3
document.write(obj3.fun()+"<br />");//999
//calling obj3.fun() makes
//ProtoObj.fun() to access obj3.a as
//if fun() is defined on obj3
4.在构造函数内部使用时。
当函数用作构造函数时（即使用new关键字调用时），此内部函数体指向正在构造的新对象。
var myname = "global context";
function SimpleFun()
{
this.myname = "simple function";
}
var obj1 = new SimpleFun(); //adds myname to obj1
//1. `new` causes `this` inside the SimpleFun() to point to the
// object being constructed thus adding any member
// created inside SimipleFun() using this.membername to the
// object being constructed
//2. And by default `new` makes function to return newly
// constructed object if no explicit return value is specified
document.write(obj1.myname); //simple function
5.在原型链上定义的函数内部使用时
如果该方法位于对象的原型链上，则此类方法中的这个引用该方法所调用的对象，就像该方法是在对象上定义的一样。
var ProtoObj = {
fun: function () {
return this.a;
}
};
//Object.create() creates object with ProtoObj as its
//prototype and assigns it to obj3, thus making fun()
//to be the method on its prototype chain
var obj3 = Object.create(ProtoObj);
obj3.a = 999;
document.write(obj3.fun()); //999
//Notice that fun() is defined on obj3's prototype but
//`this.a` inside fun() retrieves obj3.a
6.内部call（）、apply（）和bind（）函数
所有这些方法都在Function.prototype上定义。这些方法允许编写一次函数并在不同的上下文中调用它。换句话说，它们允许指定在执行函数时使用的this值。当原始函数被调用时，它们还接受传递给它的任何参数。fun.apply（obj1[，argsArray]）将obj1设置为fun（）内部的值，并调用fun（（）传递argsArray元素作为其参数。fun.call（obj1[，arg1[，arg2[，arg3[，…]]]）-将obj1设置为fun（）内部的值，并调用fun（，传递arg1，arg2，arg3，…）。。。作为其论点。fun.bind（obj1[，arg1[，arg2[，arg3[，…]]]）-返回对函数fun的引用，此函数内部fun绑定到obj1，fun的参数绑定到指定的参数arg1，arg2，arg3，。。。。到目前为止，apply、call和bind之间的区别肯定已经很明显了。apply允许将参数指定为类似数组的对象，即具有数字长度属性和相应的非负整数财产的对象。而调用允许直接指定函数的参数。apply和call都会在指定的上下文中使用指定的参数立即调用函数。另一方面，bind只返回绑定到指定this值和参数的函数。我们可以通过将返回的函数分配给变量来获取对该函数的引用，以后我们可以随时调用它。
function add(inc1, inc2)
{
return this.a + inc1 + inc2;
}
var o = { a : 4 };
document.write(add.call(o, 5, 6)+"<br />"); //15
//above add.call(o,5,6) sets `this` inside
//add() to `o` and calls add() resulting:
// this.a + inc1 + inc2 =
// `o.a` i.e. 4 + 5 + 6 = 15
document.write(add.apply(o, [5, 6]) + "<br />"); //15
// `o.a` i.e. 4 + 5 + 6 = 15
var g = add.bind(o, 5, 6); //g: `o.a` i.e. 4 + 5 + 6
document.write(g()+"<br />"); //15
var h = add.bind(o, 5); //h: `o.a` i.e. 4 + 5 + ?
document.write(h(6) + "<br />"); //15
// 4 + 5 + 6 = 15
document.write(h() + "<br />"); //NaN
//no parameter is passed to h()
//thus inc2 inside add() is `undefined`
//4 + 5 + undefined = NaN</code>
7.此内部事件处理程序
当您将函数直接分配给元素的事件处理程序时，直接在事件处理函数内部使用该函数将引用相应的元素。这种直接函数分配可以使用addeventListener方法或通过传统的事件注册方法（如onclick）完成。类似地，当您在元素的事件属性（如<button onclick=“…this…”>）中直接使用它时，它引用的是元素。但是，通过在事件处理函数或事件属性内调用的其他函数间接地使用该函数将解析为全局对象窗口。当我们使用Microsoft的event Registration模型方法attachEvent将函数附加到事件处理程序时，可以实现上述相同的行为。它不是将函数分配给事件处理程序（从而生成元素的函数方法），而是在事件上调用函数（在全局上下文中有效地调用它）。
我建议最好在JSFiddle中尝试一下。
<script>
function clickedMe() {
alert(this + " : " + this.tagName + " : " + this.id);
}
document.getElementById("button1").addEventListener("click", clickedMe, false);
document.getElementById("button2").onclick = clickedMe;
document.getElementById("button5").attachEvent('onclick', clickedMe);
</script>
<h3>Using `this` "directly" inside event handler or event property</h3>
<button id="button1">click() "assigned" using addEventListner() </button><br />
<button id="button2">click() "assigned" using click() </button><br />
<button id="button3" onclick="alert(this+ ' : ' + this.tagName + ' : ' + this.id);">used `this` directly in click event property</button>
<h3>Using `this` "indirectly" inside event handler or event property</h3>
<button onclick="alert((function(){return this + ' : ' + this.tagName + ' : ' + this.id;})());">`this` used indirectly, inside function <br /> defined & called inside event property</button><br />
<button id="button4" onclick="clickedMe()">`this` used indirectly, inside function <br /> called inside event property</button> <br />
IE only: <button id="button5">click() "attached" using attachEvent() </button>
8.这在ES6箭头函数中
在箭头函数中，它的行为类似于公共变量：它将从其词法范围继承。函数的this，其中定义了箭头函数，将是箭头函数的this。
因此，这与以下行为相同：
(function(){}).bind(this)
请参见以下代码：
const globalArrowFunction = () => {
return this;
};
console.log(globalArrowFunction()); //window
const contextObject = {
method1: () => {return this},
method2: function(){
return () => {return this};
}
};
console.log(contextObject.method1()); //window
const contextLessFunction = contextObject.method1;
console.log(contextLessFunction()); //window
console.log(contextObject.method2()()) //contextObject
const innerArrowFunction = contextObject.method2();
console.log(innerArrowFunction()); //contextObject
在伪经典术语中，许多讲座教授“this”关键字的方式是作为类或对象构造函数实例化的对象。每次从一个类构造一个新对象时，想象一下在后台创建并返回一个“this”对象的本地实例。我记得它是这样教的：
function Car(make, model, year) {
var this = {}; // under the hood, so to speak
this.make = make;
this.model = model;
this.year = year;
return this; // under the hood
}
var mycar = new Car('Eagle', 'Talon TSi', 1993);
// ========= under the hood
var this = {};
this.make = 'Eagle';
this.model = 'Talon TSi';
this.year = 1993;
return this;
总结此Javascript：
它的值取决于函数的调用方式，而不是创建位置！通常，该值由点左侧的对象确定。（全球空间中的窗口）在事件侦听器中，this的值引用调用事件的DOM元素。当使用new关键字调用函数时，this的值引用新创建的对象您可以使用以下函数操纵此值：call、apply、bind
例子：
let对象={prop1:function（）｛console.log（this）；｝}object.prop1（）；//对象位于点的左侧，因此这是对象constmyFunction=object.prop1//我们将函数存储在变量myFunction中myFunction（）；//我们在全球空间//myFunction是全局对象的属性//因此，它记录窗口对象
事件侦听器示例：
document.querySelector（'.foo'）.addEventListener（'click'，函数（）{console.log（this）；//这是指调用eventListener的DOM元素})document.querySelector（'.foo'）.addEventListener（'click'，（）=>{console.log（this）；//提示，es6箭头函数没有自己的绑定到此v})//因此，这将记录全局对象.foo：悬停{颜色：红色；光标：指针；}<div class=“foo”>单击我</div>
示例构造函数：
职能人员（姓名）{this.name=名称；}const me=新人（'Willem'）；//当使用new关键字时，构造函数中的this将引用新创建的对象console.log（me.name）；//因此，name属性被放置在使用new关键字创建的对象上。
JavaScript中的this总是指正在执行的函数的“所有者”。
如果未定义显式所有者，则引用最顶层的所有者窗口对象。
所以如果我做了
function someKindOfFunction() {
this.style = 'foo';
}
element.onclick=someKindOfFunction；
这将引用元素对象。但是要小心，很多人都会犯这个错误。
<element onclick=“someKindOfFunction（）”>
在后一种情况下，您只是引用函数，而不是将其交给元素。因此，这将引用窗口对象。
推荐文章
- 如何在Typescript中解析JSON字符串
- Javascript reduce()在对象
- 在angularJS中& vs @和=的区别是什么
- 错误"Uncaught SyntaxError:意外的标记与JSON.parse"
- JavaScript中的querySelector和querySelectorAll vs getElementsByClassName和getElementById
- 给一个数字加上st, nd, rd和th(序数)后缀
- 如何以编程方式触发引导模式?
- setTimeout带引号和不带括号的区别
- 在JS的Chrome CPU配置文件中，'self'和'total'之间的差异
- 用javascript检查输入字符串中是否包含数字
- 如何使用JavaScript分割逗号分隔字符串?
- 在Javascript中~~(“双波浪号”)做什么?
- 谷歌chrome扩展::console.log()从后台页面?
- 未捕获的SyntaxError:
- [].slice的解释。调用javascript?
