javascript中this指向

在简单函数中，this是指向当前对象，可用来获取当前对象某个属性，但随着函数变复杂，this很多情况不指向当前对象，而是指向window。

1、在独立调用函数中，具有全局执行环境，this指向window。

  var name="evan";

  function Name(){

     this.name="evan2";

4     console.log(this.name) //evan2

  }

 Name();

 console.log(this.name)  //evan2

2. 匿名函数中，this都指向window对象

  function ftn(){

        ( function(){

             console.log(this);// window

         })();

     }

   ftn();

  function ftn0(){

         var ftn1 = function(){

             console.log(this);// window

         };

         ftn1();

     }

     ftn0();

3、被嵌套的独立函数，this指向window

  var a = 0;

  var obj = {

     a : 2,

     foo:function(){

             function test(){

                 console.log(this.a);

             }

             test();

     }

  }

  obj.foo();//

在闭包中，也很容易出现这样,函数时立即调用，this指向window

 var a=0;

 var obj={

    a:2,

    fn:function foo(){

5        return function(){

6           console.log(this.a)

   }

 } }

 obj.fn()(); //0

这经常是不想得到的结果，用that=this就可以解决

  var a=0;

  var obj={

    a:2,

    fn:function foo(){

       var that=this;

       return function(){

         console.log(that.a)

       }

    }

  }

  obj.fn()(); //

闭包可以访问所在父函数的变量，所以先在父函数保存this，传递给闭包函数。

注意：函数的传递

   var a = 0;

   function foo(){

       console.log(this.a);

   };

   var obj = {

       a : 2,

       foo:foo

   }

 9   var bar = obj.foo; //这行表示把foo函数体传给bar

10   bar();//

这相当于

 var a = 0;

 var bar = function foo(){

     console.log(this.a);

 }

 bar();//

内置函数

  var a = 0;

  function foo(){

       console.log(this.a);

  };

  var obj = {

       a : 2,

       foo:foo

  }

  setTimeout(obj.foo,100);//

这相当于

  var a = 0;

  setTimeout(function foo(){

       console.log(this.a);

4  },100);//

间接引用

  function foo() {

       console.log( this.a );

  }

  var a = 2;

  var o = { a: 3, foo: foo };

  var p = { a: 4 };

    o.foo(); //

  //将o.foo函数赋值给p.foo函数，然后立即执行。相当于仅仅是foo()函数的立即执行

  (p.foo = o.foo)(); //

 1  function foo() {

      console.log( this.a );

   }

  var a = 2;

  var o = { a: 3, foo: foo };

  var p = { a: 4 };

   o.foo(); //

  //将o.foo函数赋值给p.foo函数，之后p.foo函数再执行，是属于p对象的foo函数的执行

 9  p.foo = o.foo;

  p.foo();//

call() 把方法绑定到某个对象中

  var a = 0;

  function foo(){

      console.log(this.a);

  }

  var obj = {

      a:2

7  };

  foo();//

  foo.call(obj);//2   把foo方法绑定到obj对象。

   function ftn(name){

         console.log(name);

         console.log(this);

     }

     ftn("101");

     var obj = {

       name:"xtq"

     };

     ftn.call(obj,"102");

    输出：101

         Window

         102

         Object {name: "xtq"}

 var name = "I am window";

 var obj = {

     name:"sharpxiajun",

     job:"Software",

     ftn01:function(obj){

         obj.show();

     },

     ftn02:function(ftn){

         ftn();

     },

     ftn03:function(ftn){

         ftn.call(this);

     }

 };

 function Person(name){

     this.name = name;

     this.show = function(){

         console.log("姓名:" + this.name);

         console.log(this);

     }

 }

 var p = new Person("Person");

 obj.ftn01(p);

 obj.ftn02(function(){

    console.log(this.name);

    console.log(this);

 });

 obj.ftn03(function(){

     console.log(this.name);

     console.log(this);

 });

 输出：

 姓名:Person

 Person {name: "Person"}

 I am window

 Window

 sharpxiajun

 Object {name: "sharpxiajun", job: "Software"}

new出一个对象时，this指向新生成的对象。

  function foo(something) {

      this.a = something;

  }

  var obj1 = {foo: foo};

  var obj2 = {};

  obj1.foo( 2 );

  console.log( obj1.a ); //

  obj1.foo.call(obj2,3);

  console.log( obj2.a ); //

   //在下列代码中，隐式绑定obj1.foo和new绑定同时出现。最终obj1.a结果是2，而bar.a结果是4，说明this被绑定在bar上

  var bar = new obj1.foo( 4 );

  console.log( obj1.a ); //

  console.log( bar.a ); //

简单说就是：

有对象就指向调用对象（如对象的方法）
没调用对象就指向全局对象（如setTimeout、对象的方法中的方法）
用new构造就指向新对象
通过 apply 或 call 或 bind 来改变 this 的所指。

这篇文章是用于笔记记录，如有错误，望指正

参考:http://www.cnblogs.com/xiaohuochai/p/5735901.html

巴特西

javascript中this指向

最新文章

热门文章