Javascript 的 this 用法

作者: 阮一峰

日期: 2010年4月30日

this是 JavaScript 语言的一个关键字。

它是函数运行时,在函数体内部自动生成的一个对象,只能在函数体内部使用。


function test() {
 this.x = 1;
}

上面代码中,函数test运行时,内部会自动有一个this对象可以使用。

那么,this的值是什么呢?

函数的不同使用场合,this有不同的值。总的来说,this就是函数运行时所在的环境对象。下面分四种情况,详细讨论this的用法。

情况一:纯粹的函数调用

这是函数的最通常用法,属于全局性调用,因此this就代表全局对象。请看下面这段代码,它的运行结果是1。


var x = 1;
function test() {
   console.log(this.x);
}
test();  // 1

情况二:作为对象方法的调用

函数还可以作为某个对象的方法调用,这时this就指这个上级对象。


function test() {
  console.log(this.x);
}

var obj = {};
obj.x = 1;
obj.m = test;

obj.m(); // 1

情况三 作为构造函数调用

所谓构造函数,就是通过这个函数,可以生成一个新对象。这时,this就指这个新对象。


function test() {
 this.x = 1;
}

var obj = new test();
obj.x // 1

运行结果为1。为了表明这时this不是全局对象,我们对代码做一些改变:


var x = 2;
function test() {
  this.x = 1;
}

var obj = new test();
x  // 2

运行结果为2,表明全局变量x的值根本没变。

情况四 apply 调用

apply()是函数的一个方法,作用是改变函数的调用对象。它的第一个参数就表示改变后的调用这个函数的对象。因此,这时this指的就是这第一个参数。


var x = 0;
function test() {
 console.log(this.x);
}

var obj = {};
obj.x = 1;
obj.m = test;
obj.m.apply() // 0

apply()的参数为空时,默认调用全局对象。因此,这时的运行结果为0,证明this指的是全局对象。

如果把最后一行代码修改为


obj.m.apply(obj); //1

运行结果就变成了1,证明了这时this代表的是对象obj

(完)

留言(91条)

this平常用的时候有点混乱。不过this是遵循OO语言的,只要把这点想清楚就很好了~

引用Shimu的发言:

this平常用的时候有点混乱。不过this是遵循OO语言的,只要把这点想清楚就很好了~

记住一条:当function被作为method调用时,this指向调用对象。另外,JavaScript并不是OO的,而是object based的一种语言。之所以你会觉得this用起来混乱,是因为你还没理解JavaScript的诸如全局对象、event handler等一些机制。 所以,阮大侠写的“纯粹函数调用”其实是不“准确”的。

原来  var o = {};是在新建对象。

js看来博大精深啊.呵呵
真正学习,虽然非常讨厌javascript.没办法

JS中一切皆是对象。
是不是可以简单的理解为:
1. this指向的是被调用的对象,
2. 当子对象没有重新赋值,最终就是父对象中该属性的值。

this还可以通过call方法改变

(function(){ alert(this); }).call("hello world");

this is a troublesome 'this'

一直对javascript的this很困惑,以至于一直都尽量避免使用。现在终于理解到了。

真不错。通俗易懂~~~~~

总结的很好。看懂了。谢谢

this只能在函数内部使用,很明显不正确
this.x = 1;
alert(this.x);
这样使用this有错么?this此时指代window对象

多谢博主的文章,我觉得是我看过的最好的javascript相关资料之一。

感觉JS里一些东西真的很混乱,里面的函数即要做爸(类)又要做儿子(类实例的方法)。比如下面的代码就让人感觉无比的混乱。
var x = 2;
function test()
{
     this.x = 1;
}
var o = new test();
alert("o.x: " + o.x); //1
o.x = 3;
test();
x*=10;
  alert("o.x: " + o.x); //3
alert("x: " + x); //10

上面的那个很清晰啊,o.x是o对象的属性啊,而var x=2是window对象的属性啊,
执行完 var o=new test(); 后 o.x 就是1 ;
当执行完那个 o.x=3时 o对象的x 值变为3;
test()执行后 x变为1;
x*=10;执行后 x 变为10;改变的是全局对象的x值;
其他的o对象的x值不变;
这个主要是 把test()函数当做构造函数和一般函数的区别!


楼主写的很好,通过这种简单的例子,让我更改明白的昨天困惑了很久的问题

this确实很好用啊,用JQuery改变样式的时候深刻体会到

var x = 2;

function test(){

  this.x = 1;

}

test();

alert(x); //1

这时其实x发生了改变,与原文总结有出入

其实秘密花园里面总结的不错

1.当在全部范围内使用 this,它将会指向全局对象。


2.函数调用时,这里 this 也会指向全局对象。


3.方法调用 test.foo(); 这个例子中,this 指向 test 对象。

4.调用构造函数 new foo(); 如果函数倾向于和 new 关键词一块使用,则我们称这个函数是构造函数。在函数内部,this 指向新创建的对象。

上面这些规则在Nodejs上面好像不怎么准确。
比如:
var x = 1;

function test()
{
console.log(this.x);
}

test(); //不是1,因为nodejs没有全局这个概念,在一个js文件里,最上层的对象不是全局对象,而是对应于这个文件的module对象。所以在nodejs里面上面的规则就不适应了。

总之就是一个大原则,谁调用,this 就指向谁

原创:Javascript中的this关键字(详解)
http://hi.baidu.com/flondon/blog/item/1af6b36ffad4cafa81cb4a30.html

这些例子让人混乱
却没解释为什么
建议想看this用法的人适当参考

引用Yoya的发言:

感觉JS里一些东西真的很混乱,里面的函数即要做爸(类)又要做儿子(类实例的方法)。比如下面的代码就让人感觉无比的混乱。
var x = 2;
function test()
{
     this.x = 1;
}
var o = new test();
alert("o.x: " + o.x); //1
o.x = 3;
test();
x*=10;
  alert("o.x: " + o.x); //3
alert("x: " + x); //10

其实这里是这样的,第一个x=2是window的属性,第一个x=1,是o对象的属性,
到了o.x = 3;,明显o对象的属性x=3了,然后运行test(),这是,它等于window.test(),所以,这时test()里面的this指向的是window,所以改变的是window的x,所以window.x=1,所以x*=10就是x=1*10

引用Pitt Mak的发言:

上面这些规则在Nodejs上面好像不怎么准确。
比如:
var x = 1;

function test()
{
console.log(this.x);
}

test(); //不是1,因为nodejs没有全局这个概念,在一个js文件里,最上层的对象不是全局对象,而是对应于这个文件的module对象。所以在nodejs里面上面的规则就不适应了。

毕竟是基于nodejs的,每个js库都有其最上层的对象,这里所指的是底层的,原生的,原始的js吧

引用丁小倪的发言:
var x = 2; function test(){   this.x = 1; } test(); alert(x); //1 这时其实x发生了改变,与原文总结有出入 其实秘密花园里面总结的不错 1.当在全部范围内使用 this,它将会指向全局对象。

2.函数调用时,这里 this 也会指向全局对象。

3.方法调用 test.foo(); 这个例子中,this 指向 test 对象。

4.调用构造函数 new foo(); 如果函数倾向于和 new 关键词一块使用,则我们称这个函数是构造函数。在函数内部,this 指向新创建的对象。

小倪 说的非常正确。this的确值得大家详细讨论。lz也参与吧,不要仅仅写了博文不参与话题的讨论!期待……

引用Andy的发言:

记住一条:当function被作为method调用时,this指向调用对象。另外,JavaScript并不是OO的,而是object based的一种语言。之所以你会觉得this用起来混乱,是因为你还没理解JavaScript的诸如全局对象、event handler等一些机制。 所以,阮大侠写的“纯粹函数调用”其实是不“准确”的。

狭义上可以说是“纯粹的函数调用”,如果要更准确,这里所谓的纯粹函数应该是window对象的一个方法,也就是文章里提到的第二点

其实就是一个作用域的问题。搞清楚了什么时候代表window下的变量,什么时候代表对象的变量,什么时候代表“纯粹函数”中的变量。就可以了。就这么简单。

楼主写的这些基础的文章,总是能一下就点明我们这些刚接触语言的初学者!谢谢!!!

其实总结起来就一句话:

this,正在使用的对象。

多发一些javascript的博客哈,解释的简洁清析 易懂,顶一个

var x = 1;
  function test(){
    this.x = 0;
  }
  test();
  alert(x);
这个结果是1,x和this.x是两个,x是local的,this.x是window的

刚好读到 《javascript 语言精粹》,调用一章,就看到博客有摘录了

my god!!困扰我多年的偏头疼,我竟然懂了!!!特地留名感谢

引用rubatong的发言:

var x = 1;
  function test(){
    this.x = 0;
  }
  test();
  alert(x);
这个结果是1,x和this.x是两个,x是local的,this.x是window的


你这个答案绝对是0,怎么可能是1呢,不要误导其它的读者啊,有很多读者是初学者的,当执行test();的时候,this就代表了window对象,这个时候与window.test()是等价的!

引用Pitt Mak的发言:

上面这些规则在Nodejs上面好像不怎么准确。
比如:
var x = 1;

function test()
{
console.log(this.x);
}

test(); //不是1,因为nodejs没有全局这个概念,在一个js文件里,最上层的对象不是全局对象,而是对应于这个文件的module对象。所以在nodejs里面上面的规则就不适应了。

是咯
我也记得java语言精粹这么讲的,但写个小js文件,用node.js运行下,输出undefined

很好,写的深入人心啊,理解了

直接执行函数fn()时,就相当于window.fn()。

峰哥,这篇文章写的不好啊。感觉还是很模糊。
我的网站里有的内容是转载的你的,http://nodebook.info/book/view?bid=534c8f0519980e913e9be3e6

第二部分编程思想-》 第一章 面向对象编程

引用wencan的发言:

是咯
我也记得java语言精粹这么讲的,但写个小js文件,用node.js运行下,输出undefined

声明变量x的时候不加var就好

好文!

在Javascript:the good parts里的第4章有提到这几种用法,不过博主举得例子更通俗易懂!

引用tun的发言:

原来  var o = {};是在新建对象。

的确如此,var o=new Object()的另一中写法。

请问js的call方法和apply方法有什么不同呢?

‘那就是this指的是,调用函数的那个对象。’ 不准确吧
应该是 调用函数那个对象的上下文。

引用Andy的发言:

记住一条:当function被作为method调用时,this指向调用对象。另外,JavaScript并不是OO的,而是object based的一种语言。之所以你会觉得this用起来混乱,是因为你还没理解JavaScript的诸如全局对象、event handler等一些机制。 所以,阮大侠写的“纯粹函数调用”其实是不“准确”的。

没错,阮大侠确实写的不准确

引用Yoya的发言:

感觉JS里一些东西真的很混乱,里面的函数即要做爸(类)又要做儿子(类实例的方法)。比如下面的代码就让人感觉无比的混乱。
var x = 2;
function test()
{
     this.x = 1;
}
var o = new test();
alert("o.x: " + o.x); //1
o.x = 3;
test();
x*=10;
  alert("o.x: " + o.x); //3
alert("x: " + x); //10

其实按照阮老师所解释的来看,应该是比较好理解的吧

写的非常好。看过几个题再来回味就懂了

这个怎么解释?


var Foo = {};
Foo.method = function(){
var test = function(){
console.log(this);
}
test();
};
Foo.method();

引用 luchy的发言:

这个怎么解释?


var Foo = {};
Foo.method = function(){
var test = function(){
console.log(this);
}
test();
};
Foo.method();

因为javascript设计上的失误。像这种对象方法里面还有函数的情况下,这个对象方法内的函数内部this本应该指向对象(这里是Foo),但是却指向了global对象也就是window,解决的办法是在Foo.method方法内部通过vat that = this;内部函数引用that的形式来避免这个问题。

小弟的拙见,js中的this很好理解,只要一句话就可以,this指向离它最近的包含对象,
比如test(),其实是window.test(),所以this就是window,
var o={};
  o.x = 1;
  o.m = test;
这时test里的this指的就是o

看了这么久的this终于在你这里搞明白了,多谢大虾~

醍醐灌顶。

引用Yoya的发言:

感觉JS里一些东西真的很混乱,里面的函数即要做爸(类)又要做儿子(类实例的方法)。比如下面的代码就让人感觉无比的混乱。
var x = 2;
function test()
{
     this.x = 1;
}
var o = new test();
alert("o.x: " + o.x); //1
o.x = 3;
test();
x*=10;
  alert("o.x: " + o.x); //3
alert("x: " + x); //10

这哪里混乱了,如果觉得混乱只能说你基础太差。

情况一是错误的

var Foo = {};
Foo.method = function(){
var test = function(){
console.log(this);
}
test();
};
Foo.method();

//留住this
var Foo = {};
Foo.method = function(){
vaar me=this;
var test = function(){
console.log(me);
}
test();
};
Foo.method();

//bind绑定this
var Foo = {};
Foo.method = function(){
var test = function(){
console.log(this);
}.bind(this)
test();
};
Foo.method();
这样两种方法绑定的this指向的都是Foo,而不再是window了

老实说,其实就是列出了几个经典的例子。并不是很详细。我觉得结合书本《你不知道的javascript》这本书会稍微好点。即使如此,真的遇到一些神绕的代码,有时候也很难一目了然。js就是一个磨人的小妖精。

发现很多问题,最后给我充分解释的,都是大神的博客。

引用Andy的发言:

记住一条:当function被作为method调用时,this指向调用对象。另外,JavaScript并不是OO的,而是object based的一种语言。之所以你会觉得this用起来混乱,是因为你还没理解JavaScript的诸如全局对象、event handler等一些机制。 所以,阮大侠写的“纯粹函数调用”其实是不“准确”的。

大牛真是到处都有啊。你这一句话和阮老师写这一大篇等价。膜拜!

引用rubatong的发言:

var x = 1;
  function test(){
    this.x = 0;
  }
  test();
  alert(x);
这个结果是1,x和this.x是两个,x是local的,this.x是window的


建议加上console.log(arguments);检查一下上下文,我在在线js检测网站上查出来也是这个结果,原因是因为他们会把你输入的js放在window.onload中

引用xr的发言:

老实说,其实就是列出了几个经典的例子。并不是很详细。我觉得结合书本《你不知道的javascript》这本书会稍微好点。即使如此,真的遇到一些神绕的代码,有时候也很难一目了然。js就是一个磨人的小妖精。

你不知道的Javascript这本书真的超赞!!!我看过的最好的JS类书籍。

通俗易懂,案例都是浓缩再浓缩;真不错

引用Yoya的发言:

感觉JS里一些东西真的很混乱,里面的函数即要做爸(类)又要做儿子(类实例的方法)。比如下面的代码就让人感觉无比的混乱。
var x = 2;
function test()
{
     this.x = 1;
}
var o = new test();
alert("o.x: " + o.x); //1
o.x = 3;
test();
x*=10;
  alert("o.x: " + o.x); //3
alert("x: " + x); //10

new test()和test()是不一样的,在执行new test()时会自动执行这样几个操作
1、创建一个新对象
2、新对象执行prototype连接
3、将对象绑定到函数调用中this
4、返回新对象(如果函数没有返回值)
因此,执行了new test()实际上是返回了一个新的对象并赋值给o,而其中的this代表的是这个新对象,所以o.x的改变不会影响全局变量x,直接调用test()就不一样了,此时的函数调用相当于是在浏览器环境下执行window.test(),因此this.x就是全局变量x

this 指向的是 变量 或 方法所在的域

也就是在牵扯到跨域时 建议用
var self = this
来替代

引用ANTIK的发言:

new test()和test()是不一样的,在执行new test()时会自动执行这样几个操作
1、创建一个新对象
2、新对象执行prototype连接
3、将对象绑定到函数调用中this
4、返回新对象(如果函数没有返回值)
因此,执行了new test()实际上是返回了一个新的对象并赋值给o,而其中的this代表的是这个新对象,所以o.x的改变不会影响全局变量x,直接调用test()就不一样了,此时的函数调用相当于是在浏览器环境下执行window.test(),因此this.x就是全局变量x

大神的解说直接明了,我想如下方式应该是 Yoya 想要的吧:

var Foo = {};
Foo.method = function(){
console.log(this);
var test = function(){
console.log(this);
var abc = function(){
console.log(this);
}
new abc();
}
new test();
};
Foo.method();

引用黑幕困兽的发言:

this只能在函数内部使用,很明显不正确
this.x = 1;
alert(this.x);
这样使用this有错么?this此时指代window对象

我怎么感觉,这时候你这种写法this就相当于是个保存对象的变量,而this是关键字。

引用 luchy的发言:

这个怎么解释?


var Foo = {};
Foo.method = function(){
var test = function(){
console.log(this);
}
test();
};
Foo.method();

我觉得你这种写法本身就有错,在函数里面再定义函数,感觉有点抠脚。

var x = 1;                  // 我认为最混淆的是这一句,这是最特殊的情况。不加说明、一而再地
                            // 用它举例,等于是在向我这样的菜鸟强化 var x 即 this.x 的印象。
function test() {
  var x = 2;                // 于是就很不理解为什么这里的 var x 不其作用。
  console.log(this.x);
}

test(); // 1

引用newbie66的发言:

var x = 1;// 我认为最混淆的是这一句,这是最特殊的情况。不加说明、一而再地
// 用它举例,等于是在向我这样的菜鸟强化 var x 即 this.x 的印象。
function test() {
var x = 2;// 于是就很不理解为什么这里的 var x 不其作用。
console.log(this.x);
}

test(); // 1


分享下我的理解:
定义x=1 和定义test()函数,实际上都是在window对象上定义的。即x 实际上是window.x,test() 实际上是window.test();

在test()被调用的时候,实际上执行的是window.test()方法,这个方法只会在window对象上寻找变量名称为“x”的对象(1是基本类型,也是对象)。在test()内部定义的 x(var x=2;)并不在window上。在这里就被忽略了。

所以执行结果是1;

this 1. 非常赞同 阮哥所说的 "this指的是,调用函数的那个对象" 2. js this 的取值不像 java 这些传统 oo 语言直接指向所在类 3. js拥有函数式特性,this 可以被指定 (call apply bind)

var x = 1;
  function test(){
    this.x = 0;
  }
  test();
  alert(x); //0
这个输出 是 1 不是 0 感觉还是理解不对呢

非常感谢大神的指导!!!

引用易枫的发言:

var x = 1;
  function test(){
    this.x = 0;
  }
  test();
  alert(x); //0
这个输出 是 1 不是 0 感觉还是理解不对呢

引用fygate的发言:

你这个答案绝对是0,怎么可能是1呢,不要误导其它的读者啊,有很多读者是初学者的,当执行test();的时候,this就代表了window对象,这个时候与window.test()是等价的!

答案是0,建议学者自己去 google的工具里面执行一下

对所有执行结果有异议的去页面jsfiddle上 把代码粘进去,执行一下,用事实说话

仔细读了文章和下面大家的评论,茅塞顿开,谢了!^_^

一句话总结:这是谁家孩子(this),家长也不管管

function foo() {
setTimeout(function (){
console.log('id1:', this.id);
}, 100);
}
var id = 0;
foo.call({id:23}); // 输出0,而不是23
能解释一下为什么吗?

function foo() {
setTimeout(function (){
console.log('id1:', this.id);
}, 100);
}
var id = 0;
foo.call({id:23}); // 输出0,而不是23

this指向的是window,不是foo的this,
输出的值相当于是window.id //0

function foo() {
setTimeout(function (){
console.log('id1:', this.id);
}, 100);
}

foo里面嵌套了一个匿名函数,this指向的是当前的匿名函数,而非foo
可以改成
function foo() {
var that = this;
setTimeout(function (){
console.log('id1:', that .id);
}, 100);
}//23

var Foo = {};
Foo.method = function(){
return function(){
console.log(this);
}
};
Foo.method()();//window
这种怎么解释

引用 luchy的发言:

这个怎么解释?


var Foo = {};
Foo.method = function(){
var test = function(){
console.log(this);
}
test();
};
Foo.method();

感谢你提出这个问题

引用yohuu的发言:

var Foo = {};
Foo.method = function(){
return function(){
console.log(this);
}
};
Foo.method()();//window
这种怎么解释

不知道可不可以这么理解:
1.Foo.method()相当于Foo.method中return的那个函数,是一个函数,这个时候他还没有执行
2.把Foo.method()想象成类似于function a() {……}中a一样的函数名,这样Foo.method()()就相当于a(),此时的执行环境就是全局,所以输出的this也就是window了

引用Andy的发言:

记住一条:当function被作为method调用时,this指向调用对象。另外,JavaScript并不是OO的,而是object based的一种语言。之所以你会觉得this用起来混乱,是因为你还没理解JavaScript的诸如全局对象、event handler等一些机制。 所以,阮大侠写的“纯粹函数调用”其实是不“准确”的。

在浏览器里试了一下,发现这种纯函数调用时,这个函数其实是window的方法,那么执行window.test()是得到一样的效果,于是,this按照指向调用对象的原则,this指向的当然是window

代表函数运行时,自动生成的一个内部对象,只能在函数内部使用

这种说法的根据是什么?为什么可以在函数体外部调用this呢,这个时候this都指向全局变量。

var x = 1;
function test() {
console.log(this.x);
}
test();

不知道为什么第一个事例代码在浏览器打印出来是undefined,而不是1

this始终指向调用者,所以理解this就去分析谁在调用它。

引用涂涂的发言:

var x = 1; //全局变量
function test() {
console.log(this.x);
}
test();

不知道为什么第一个事例代码在浏览器打印出来是undefined,而不是1

引用飞天的鱼的发言:

回答一下上面这位老哥,打印出undefined可能是因为把var写成let了,因为var定义的变量会把变量挂载到全局对象window下面,而let不会把定义的变量挂载到window下面,所以this.x打印出来是undefined。如果写的是var,打印出来就是1.

x = 1; //全局变量
function test() {
console.log(this.x);
}
test();

去掉var输出1

引用张冲的发言:

x = 1; //全局变量
function test() {
console.log(this.x);
}
test();

去掉var输出1

nodejs 调试运行的test.js脚本情况下

阮老师讲课就是通俗易懂

总结:
首先this必须在函数里
①在上层除了全局对象外,没有被其他对象包裹的时候,this指向全局对象
②在上层除了全局对象外,被其他对象包裹的时候,this指向上一层对象
③在构造函数里, 被创建出一个实例后,this指向那个实例
④函数使用apply方法后, this指向此方法的第一个参数(参数为空时默认指向全局对象)

还没看完,但是有一部分阮哥写错了var x = 2;
function test() {
this.x = 1;
}

var obj = new test();这部分代码运行结果应该是1,而不是2,如果是2,那就说明this指代的是全局对象了

我要发表看法

«-必填

«-必填,不公开

«-我信任你,不会填写广告链接