JS关键字

此文研究JS中this关键字的作用（指向）。
学而时习之。

首先，JS里面，函数的几种调用方式:
普通函数调用
作为方法来调用
作为构造函数来调用
使用apply/call方法来调用
Function.prototype.bind方法
es6箭头函数

但是不管函数是按哪种方法来调用的，请记住一点：谁调用这个函数或方法,this关键字就指向谁。

普通函数调用

function person(){
this.name=”xl”;
console.log(this);
console.log(this.name);
}
person(); //输出 window xl

在这段代码中person函数作为普通函数调用，实际上person是作为全局对象window的一个方法来进行调用的,即window.person();
所以这个地方是window对象调用了person方法,那么person函数当中的this即指window,同时window还拥有了另外一个属性name,值为xl。

1
2
3
4
5
var name="xl";
function person(){
      console.log(this.name);
     }
    person(); //输出 xl

同样这个地方person作为window的方法来调用，在代码的一开始定义了一个全局变量name,值为xl，它相当于window的一个属性，即window.name=”xl”，又因为在调用person的时候this是指向window的，因此这里会输出xl。

作为方法来调用
在上面的代码中，普通函数的调用即是作为window对象的方法进行调用。显然this关键字指向了window对象.

再来看下其他的形式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 var name="XL";
 var person={
     name:"xl",
     showName:function(){
         console.log(this.name);
     }
 }
 person.showName();  //输出  xl
//这里是person对象调用showName方法，
很显然this关键字是指向person对象的，所以会输出name 
 var showNameA=person.showName;
 showNameA();    //输出  XL
 //这里将person.showName方法赋给showNameA变量，
 此时showNameA变量相当于window对象的一个属性，
 因此showNameA()执行的时候相当于window.showNameA(),
 即window对象调用showNameA这个方法，
 所以this关键字指向window

再换种形式：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
var personA={
    name:"xl",
    showName:function(){
        console.log(this.name);
    }
}
var personB={
    name:"XL",
    sayName:personA.showName
}
personB.sayName();  //输出 XL
//虽然showName方法是在personA这个对象中定义，
但是调用的时候却是在personB这个对象中调用，
因此this对象指向

作为构造函数来调用

1
2
3
4
5
6
7
8
9
10
11
12
13
 function  Person(name){
     this.name=name;
 }
  var personA=Person("xl");   
console.log(personA.name); // 输出  undefined
 console.log(window.name);//输出  xl
  //上面代码没有进行new操作，
  相当于window对象调用Person("xl")方法，
  那么this指向window对象，
  并进行赋值操作window.name="xl".    
var personB=new Person("xl");
console.log(personB.name);// 输出 xl  
//这部分代码的解释见下

new操作符

1
2
3
4
5
6
7
8
9
//下面这段代码模拟了new操作符(实例化对象)的内部过程
  function person(name){
      var o={};
      o.__proto__=Person.prototype;  //原型继承
      Person.call(o,name);
      return o;
  }
  var personB=person("xl");
  console.log(personB.name);  // 输出  xl

在person里面首先创建一个空对象o，将o的proto指向Person.prototype完成对原型的属性和方法的继承

Person.call(o,name)这里即函数Person作为apply/call调用(具体内容下方)，将Person对象里的this改为o，即完成了o.name=name操作

返回对象o。

因此person("xl")返回了一个继承了Person.prototype对象上的属性和方法，以及拥有name属性为”xl”的对象，并将它赋给变量personB.
所以console.log(personB.name)会输出”xl”
call/apply方法的调用
在JS里函数也是对象，因此函数也有方法。从Function.prototype上继承到Function.prototype.call/Function.prototype.apply方法
call/apply方法最大的作用就是能改变this关键字的指向.
Obj.method.apply(AnotherObj,arguments);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 var name="XL";
 var Person={
     name:"xl",
    showName:function(){
         console.log(this.name);
     }
 }
 Person.showName.call(); //输出 "XL"
 //这里call方法里面的第一个参数为空，默认指向window。
//虽然showName方法定义在Person对象里面，但是使用call方法后，
将showName方法里面的this指向了window。因此最后会输出"XL";
funtion FruitA(n1,n2){
    this.n1=n1;
    this.n2=n2;
    this.change=function(x,y){
        this.n1=x;
        this.n2=y;
    }
}     
var fruitA=new FruitA("cheery","banana");
var FruitB={
    n1:"apple",
    n2:"orange"
};
fruitA.change.call(FruitB,"pear","peach");     
console.log(FruitB.n1); //输出 pear
console.log(FruitB.n2);// 输出 peach

FruitB调用fruitA的change方法，将fruitA中的this绑定到对象FruitB上。

Function.prototype.bind()方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
var name="XL";
function Person(name){
    this.name=name;
    this.sayName=function(){
        setTimeout(function(){
            console.log("my name is "+this.name);
        },50)
    }
}
var person=new Person("xl");
person.sayName()  //输出  “my name is XL”;
                   //这里的setTimeout()定时函数,
                   相当于window.setTimeout(),
                   由window这个全局对象对调用,
                   因此this的指向为window,
                   则this.name则为XL

那么如何才能输出”my name is xl”呢？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
var name="XL";
function Person(name){
    this.name=name;
    this.sayName=function(){
        setTimeout(function(){
            console.log("my name is "+this.name);
        }.bind(this),50)  
        //注意这个地方使用的bind()方法，
        绑定setTimeout里面的匿名函数的this
        一直指向Person对象
    }
}
var person=new Person("xl");
person.sayName(); //输出 “my name is xl”;

这里setTimeout(function(){console.log(this.name)}.bind(this),50);,匿名函数使用bind(this)方法后创建了新的函数，这个新的函数不管在什么地方执行，this都指向的Person,而非window,因此最后的输出为”my name is xl”而不是”my name is XL”

另外几个需要注意的地方：
setTimeout/setInterval/匿名函数执行的时候，this默认指向window对象，除非手动改变this的指向。在《javascript高级程序设计》当中，写到：“超时调用的代码(setTimeout)都是在全局作用域中执行的，因此函数中的this的值，在非严格模式下是指向window对象，在严格模式下是指向undefined”。本文都是在非严格模式下的情况。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
var name="XL";
  function Person(){
      this.name="xl";
      this.showName=function(){
          console.log(this.name);
      }
      setTimeout(this.showName,50);
  }
  var person=new Person(); //输出 "XL"
  //在setTimeout(this.showName,50)语句中，
  会延时执行this.showName方法
  //this.showName方法
  即构造函数Person()里面定义的方法。
  50ms后，执行this.showName方法，
  this.showName里面的this此时便指向了window对象。
  则会输出"XL";

修改上面的代码：

1
2
3
4
5
6
7
8
9
10
11
var name="XL";
   function Person(){
       this.name="xl";
      var that=this;
         this.showName=function(){
             console.log(that.name);
         }
         setTimeout(this.showName,50)
     }
    var person=new Person(); //输出 "xl"
    //这里在Person函数当中将this赋值给that，即让that保存Person对象，因此在setTimeout(this.showName,50)执行过程当中，console.log(that.name)即会输出Person对象的属性"xl"

匿名函数：

1 var name=”XL”;
2 var person={
3 name:”xl”,
4 showName:function(){
5 console.log(this.name);
6 }
7 sayName:function(){
8 (function(callback){
9 callback();
10 })(this.showName)
11 }
12 }
13 person.sayName(); //输出 XL
14 var name=”XL”;
15 var person={
16 name:”xl”,
17 showName:function(){
18 console.log(this.name);
19 }
20 sayName:function(){
21 var that=this;
22 (function(callback){
23 callback();
24 })(that.showName)
25 }
26 }
27 person.sayName() ; //输出 “xl”
28 //匿名函数的执行同样在默认情况下this是指向window的，除非手动改变this的绑定对象

Eval函数
该函数执行的时候，this绑定到当前作用域的对象上

1
2
3
4
5
6
7
8
9
10
var name="XL";
var person={
    name:"xl",
    showName:function(){
        eval("console.log(this.name)");
    }
}
person.showName();  //输出  "xl"   
var a=person.showName;
a();  //输出  "XL"

箭头函数
es6里面this指向固定化，始终指向外部对象，因为箭头函数没有this,因此它自身不能进行new实例化,同时也不能使用call, apply, bind等方法来改变this的指向

1
2
3
4
5
6
7
function Timer() {
     this.seconds = 0;
     setInterval( () => this.seconds ++, 1000);
 }   
 var timer = new Timer();    
 setTimeout( () => console.log(timer.seconds), 3100); 
 // 3

在构造函数内部的setInterval()内的回调函数，this始终指向实例化的对象，并获取实例化对象的seconds的属性,每1s这个属性的值都会增加1。否则最后在3s后执行setTimeOut()函数执行后输出的是0

JavaScript