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