javascript中的'this'是什么意思?

我不确定JavaScript中的这一点。我举两个例子。 你能帮我分析一下吗?非常感谢你。
//exmp1
function f1()
{
  alert(this);
  function f2()
  {
    alert(this);
  }
  f2();
}
f1();

//exmp2
var jsn = 
{
  name : "b",
  func : function() // closure
  {
    alert(this); 
    return function()
    {
      return this;
    }
  }
}

alert(jsn.func()());
    
已邀请:
this
在JavaScript中与在C ++或Java等其他语言中的不同。第一个示例中的
this
的值始终是全局对象(browsers3ѭ,在浏览器上)。第二个例子中的
this
是第一个警报的
jsn
对象,第二个是
window
。这是因为
this
完全取决于函数的调用方式,而不是函数的定义。 如果在调用函数时没有做任何特殊操作,则
this
是全局对象。通过对象属性(
jsn.func()
)调用函数时,将
this
设置为属性所来自的对象。 (但是没有得到错误的印象,
func
绝不是特别依赖于
jsn
; JavaScript没有方法,只有函数;细节。)然后返回一个函数,在最终的
alert
中调用;由于该调用不是通过对象属性,因此将
this
设置为全局对象。 一些例子:
// Simple function
function foo() {
    alert(this === window);
}
foo(); // true, within the call, `this` === `window`

// Object example, and twist at the end
var obj = {
    func: function() {
        alert(this === obj);
    },
};
obj.func();    // true, within the call, `this` === `obj`
obj["func"](); // true, within the call, `this` === `obj`

var f = obj.func; // Not calling it, just getting a reference to the function
f(); // false, within the call `this` !== `obj` (`this` === `window`)

// Creating functions on the fly, returning them, and how that has
// nothing whatsoever to do with how `this` gets set:
var obj = {
    func: function() {
        return function() {
            alert("I'm a generated function");
            alert(this === obj);
        };
     }
};
obj.func()(); // alerts the "I'm a generated function", then false; `this` !== `obj`
obj.bar = obj.func();
obj.bar();    // alerts the "I'm a generated function", then true; `this` === `obj`
还有第二种方法来控制函数中的
this
:使用JavaScript函数的
.call
.apply
特性:
var obj = {
    func: function() {
        alert(this === obj);
    }
};
function foo(a, b) {
    alert(this === obj); // Yes, really obj; see below
    alert(a);
    alert(b);
}
foo(1, 2);               // alerts false (`this` !== `obj`), then 1, then 2
obj.func();              // alerts true, `this` === `obj`
foo.call(obj, 3, 4);     // alerts true (`this` === `obj`), then 3, then 4
foo.apply(obj, [5, 6]);  // alerts true (`this` === `obj`), then 5, then 6
如您所见,
call
apply
的第一个参数是在函数调用中使
this
的对象。
call
apply
之间的唯一区别是你如何指定传递给目标函数的参数:使用
call
,你只需在第一个参数之后提供它们;使用apply,您将它们作为数组提供。 最后,还有第三种方式:
new
关键字。 JavaScript具有构造函数的概念。构造函数的目的是创建以特定方式初始化的对象的实例。这是一个例子:
function Foo(b) {
    this.bar = b;
}
var f = new Foo();
从技术上讲,任何函数都可以用作构造函数。惯例是给出用于以大写字母开头的
new
名称的函数,只是为了强化我们以特殊的方式称它们。 通过
new
调用函数会创建一个新的对象实例,并使该对象成为函数调用中的
this
值。所以
function Foo(b) {
    alert(this === window);
}
var f = new Foo(); // alerts false, `this` !== `window` (it points to the new object created for the call)
var f = Foo();     // alerts true, `this` === `window` because we didn't use `new`
如您所见,以正确的方式调用函数非常重要。如果它设计用于
new
,请通过
new
调用;如果不是,不要。 (
new
不只是创建一个空白对象;创建的对象还有一些其他方面以某种方式设置。我不会在这里详细介绍,但我不想给你留下这样的印象确实创建了一个新的对象实例。)     
在你的最后一个例子(json对象里面的函数)中,
this
指的是持有该函数的json对象。 在你的第一个例子中,第一个
this
指的是持有
f1
的对象,它碰巧是全局窗口对象。
f2
中的第二个
this
也指向全局对象而不是f1,这是javascript中的一个已知错误,当​​你在另一个中定义了一个函数时。 一个常见的解决方法是这个(没有双关语):
function f1() {
  alert (this);
  var that = this;
  function f2() {
    alert (that);
  }
  f2();
}
请注意,如果在json对象中定义一个函数,它仍然可以“移动”,并且
this
的上下文将会改变。例如:
var car1 = {
  color: "red",
  f: function () { alert (this.color); }
}

car1.f(); // prints "red"

var car2 = {
  color: "blue",
}

car2.f = car1.f;

car2.f(); // prints "blue"
    
在JavaScript中,“this”总是指“拥有”该函数的对象,或者更确切地说,是指函数在被调用时通过属性绑定到的对象。考虑这个例子:
var f = function() { alert(this); }
f(); // Alerts the "DOM window" (global) object, which
     // is implied if there is no explicit owner.
var o = {toString:function(){return "Foo!";}}
o.func = f;
o.func(); // Alerts the "Foo!" object (o) since the
          // function then belongs to it as a member.
现在关于您的具体示例,以下是发生的情况:
//exmp1
function f1() {
  alert(this);
  function f2() {
    alert(this);
  }
  f2(); // Alerts "the global object", since f2
        // is not bound to any object's property.
}
f1(); // Alerts "the global object" (probably DOM window)
      // for same reason as above.

//exmp2
var jsn = {
  name : "b",
  func : function() {
    alert(this); // Will alert the "jsn" object, since it
                 // owns the function in its "func" member.
    return function() {
      return this; // Returns whoever is calling it!
    };
  }
}
alert(jsn.func()()); // "jsn.func()" returns a function which gets
                     // called by the global "DOM window" object.
    
当您使用函数作为构造函数时,它指向您正在构造的对象。
function Test() {
  this.test = true;
}

t = new Test();
alert(t.test);
    

要回复问题请先登录注册