“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 

要正确理解“这”，就必须理解上下文和范围以及它们之间的区别。

作用域：在javascript中，作用域与变量的可见性有关，作用域通过使用函数实现。（阅读有关范围的更多信息）

上下文：上下文与对象相关。它指函数所属的对象。当您使用JavaScript“this”关键字时，它指的是函数所属的对象。例如，在函数内部，当你说：“this.accoutNumber”时，你指的是属性“accoutNumber”，该属性属于该函数所属的对象。

如果对象“myObj”有一个名为“getMyName”的方法，当JavaScript关键字“this”在“getMyName”中使用时，它将引用“myObj”。如果函数“getMyName”是在全局范围内执行的，那么“this”是指窗口对象（严格模式除外）。

现在让我们看看一些示例：

    <script>
        console.log('What is this: '+this);
        console.log(this);
    </script>

在浏览器输出中运行abobve代码将：

根据窗口对象上下文中的输出，也可以看到窗口原型引用了对象。

现在让我们尝试函数内部：

    <script>
        function myFunc(){
            console.log('What is this: '+this);
            console.log(this);
        }
        myFunc();
    </script>

输出：

输出是相同的，因为我们将“this”变量记录在全局范围中，并将其记录在函数范围中，我们没有更改上下文。在这两种情况下，上下文都是相同的，与寡妇对象相关。

现在让我们创建自己的对象。在javascript中，可以通过多种方式创建对象。

 <script>
        var firstName = "Nora";
        var lastName = "Zaman";
        var myObj = {
            firstName:"Lord",
            lastName:'Baron',
            printNameGetContext:function(){
                console.log(firstName + " "+lastName);
                console.log(this.firstName +" "+this.lastName);
                return this;
            }
        }

      var context = myObj.printNameGetContext();
      console.log(context);
    </script>

输出：

因此，从上面的示例中，我们发现“this”关键字引用的是与myObj相关的新上下文，而myObject也具有到Object的原型链。

让我们再举一个例子：

<body>
    <button class="btn">Click Me</button>
    <script>
        function printMe(){
            //Terminal2: this function declared inside window context so this function belongs to the window object.
            console.log(this);
        }
        document.querySelector('.btn').addEventListener('click', function(){
            //Terminal1: button context, this callback function belongs to DOM element 
            console.log(this);
            printMe();
        })
    </script>
</body>

输出：有道理吧？（阅读评论）

如果您无法理解上面的示例，让我们尝试使用自己的回调；

<script>
        var myObj = {
            firstName:"Lord",
            lastName:'Baron',
            printName:function(callback1, callback2){
                //Attaching callback1 with this myObj context
                this.callback1 = callback1;
                this.callback1(this.firstName +" "+this.lastName)
                //We did not attached callback2 with myObj so, it's reamin with window context by default
                callback2();
                /*
                 //test bellow codes
                 this.callback2 = callback2;
                 this.callback2();
                */
            }
        }
        var callback2 = function (){
            console.log(this);
        }
        myObj.printName(function(data){
            console.log(data);
            console.log(this);
        }, callback2);
    </script>

输出：

现在，让我们了解范围、自我、IIFE和THIS的行为

       var color = 'red'; // property of window
       var obj = {
           color:'blue', // property of window
           printColor: function(){ // property of obj, attached with obj
               var self = this;
               console.log('In printColor -- this.color: '+this.color);
               console.log('In printColor -- self.color: '+self.color);
               (function(){ // decleard inside of printColor but not property of object, it will executed on window context.
                    console.log(this)
                    console.log('In IIFE -- this.color: '+this.color);
                    console.log('In IIFE -- self.color: '+self.color); 
               })();

               function nestedFunc(){// decleard inside of printColor but not property of object, it will executed on window context.
                    console.log('nested fun -- this.color: '+this.color);
                    console.log('nested fun -- self.color: '+self.color);
               }

               nestedFunc(); // executed on window context
               return nestedFunc;
           }
       };

       obj.printColor()(); // returned function executed on window context
   </script> 

输出非常棒，对吧？

我对这个问题的看法与我希望有帮助的其他答案不同。

查看JavaScript的一种方法是看到只有一种方法可以调用函数1。它是

functionObject.call(objectForThis, arg0, arg1, arg2, ...);

始终为objectForThis提供一些值。

其他一切都是functionObject.call的语法糖

因此，其他一切都可以通过它如何转换为functionObject.call来描述。

如果你只是调用一个函数，那么这就是“全局对象”，在浏览器中就是窗口

函数foo（）{console.log（此）；}foo（）；//这是窗口对象

换句话说，

foo();

被有效地转化为

foo.call(window);

请注意，如果使用严格模式，则这将是未定义的

“使用严格”；函数foo（）{console.log（此）；}foo（）；//这是窗口对象

这意味着

换句话说，

foo();

被有效地转化为

foo.call(undefined);

在JavaScript中有+、-和*等运算符。还有点运算符。

这个运算符与右侧的函数和左侧的对象一起使用时，实际上意味着“将对象作为this传递给函数”。

实例

常量bar={name:'bar'，foo（）｛console.log（此）；},};bar.foo（）；//这是酒吧

换句话说，bar.foo（）转换为consttemp=bar.foo；临时呼叫（bar）；

注意，函数的创建方式并不重要（主要是…）。所有这些都会产生相同的结果

常量bar={name:'bar'，fn1（）｛console.log（this）；｝，fn2:function（）｛console.log（this）；｝，fn3：其他函数，};函数otherFunction（）｛console.log（this）｝；bar.fn1（）；//这是酒吧bar.fn2（）；//这是酒吧bar.fn3（）；//这是酒吧

同样，这些都只是语法糖

{ const temp = bar.fn1; temp.call(bar); }
{ const temp = bar.fn2; temp.call(bar); }
{ const temp = bar.fn3; temp.call(bar); }

另一个褶皱是原型链。当您使用.b时，JavaScript首先查找属性b的a直接引用的对象。如果在对象上找不到b，则JavaScript将在对象的原型中查找b。

定义对象原型的方法多种多样，2019年最常见的是class关键字。出于这个目的，尽管这并不重要。重要的是，当它在对象a中查找属性b时，如果它在对象上找到属性b，或者在它的原型链中找到属性b（如果b最终是一个函数），那么上述规则同样适用。函数b引用将使用call方法调用，并将a作为objectForThis传递，如该答案顶部所示。

现在让我们想象一下，在调用另一个函数之前，我们创建了一个显式设置此值的函数，然后使用调用它。（点）运算符

函数foo（）{console.log（此）；}函数栏（）{const objectForThis=｛name:“moo”｝foo.call（objectForThis）；//显式传递objectForThis}常量对象={酒吧};obj.bar（）；

在转换为使用调用之后，obj.bar（）变为consttemp=obj.bar；临时调用（obj）；。当我们进入bar函数时，我们调用foo，但我们显式地为objectForThis传递了另一个对象，所以当我们到达foo时，这是内部对象。

这是bind和=>函数有效的作用。它们是语法糖。他们有效地构建了一个新的不可见函数，就像上面的bar一样，它在调用指定的函数之前显式地设置了这个函数。在绑定的情况下，这将设置为传递给绑定的任何值。

函数foo（）{console.log（此）；}const bar=foo.bind（｛name:“moo”｝）；//bind创建了一个新的不可见函数，该函数使用绑定对象调用foo。bar（）；//我们在这里传递给bar的objectForThis被忽略，因为//绑定创建的不可见函数将使用//我们在上面绑定的对象bar.call（｛name:“other”｝）；

注意，如果functionObject.bind不存在，我们可以像这样创建自己的

function bind(fn, objectForThis) {
  return function(...args) {
    return fn.call(objectForthis, ...args);
  };
}

然后我们可以这样称呼它

function foo() {
  console.log(this);
}

const bar = bind(foo, {name:'abc'});

箭头函数，=>运算符是绑定的语法糖

const a = () => {console.log(this)};

与

const tempFn = function() {console.log(this)}; 
const a = tempFn.bind(this);

与bind一样，会创建一个新的不可见函数，该函数使用objectForThis的绑定值调用给定函数，但与bind不同的是，要绑定的对象是隐式的。当使用=>运算符时，这就是发生的情况。

所以，就像上面的规则一样

const a = () => { console.log(this); }  // this is the global object

'use strict';
const a = () => { console.log(this); }  // this is undefined

function foo() {
  return () => { console.log(this); }
}

const obj = {
  foo,
};
const b = obj.foo();
b();

obj.foo（）转换为consttemp=obj.foo；临时调用（obj）；这意味着foo中的箭头运算符将obj绑定到一个新的不可见函数，并返回分配给b.b（）的新的不可视函数。该不可见函数忽略传递给它的this，并将obj作为objectForThis`传递给箭头函数。

上面的代码翻译为

function foo() {
  function tempFn() {
    console.log(this);
  }
  return tempFn.bind(this);
}

const obj = {
  foo,
};
const b = obj.foo();
b.call(window or undefined if strict mode);

1apply是另一个类似于调用的函数

functionName.apply(objectForThis, arrayOfArgs);

但从概念上讲，ES6甚至可以将其转换为

functionName.call(objectForThis, ...arrayOfArgs);

JavaScript中的this总是指正在执行的函数的“所有者”。

如果未定义显式所有者，则引用最顶层的所有者窗口对象。

所以如果我做了

function someKindOfFunction() {
   this.style = 'foo';
}

element.onclick=someKindOfFunction；

这将引用元素对象。但是要小心，很多人都会犯这个错误。

<element onclick=“someKindOfFunction（）”>

在后一种情况下，您只是引用函数，而不是将其交给元素。因此，这将引用窗口对象。

由于这篇文章的篇幅有所增加，我为读者整理了一些新的观点。

这个值是如何确定的？

我们使用这个词的方式与我们在英语等自然语言中使用代词的方式类似：“约翰跑得很快，因为他正在赶火车。”相反，我们可以写“……约翰正在赶火车”。

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