this作用域详解

　　大家在使用Javascript的时候经常被this这个家伙搞得晕头转向的。在Javascript中它却显得古灵精怪的，因为它不是固定不变的，而是随着它的执行环境的改变而改变。在Javascript中this总是指向调用它所在方法的对象。接下来我们一个一个方面，举例说明

一、全局的this(浏览器)

console.log(this.document === document) //true
console.log(this === window) //true
this.a = 37;
console.log(window.a); //37

二、一般函数的this(浏览器)

function f1(){
    return this;
}
f1()===window; //true,global object

三、作为对象方法的函数的this

var o = {
    prop:37,
    f:function(){
        return this.prop;
    }
};
console.log(o.f()); //37
f作为一个对象的方法，那么作为对象的方法去调用的时候，比如o.f调用的时候，这种情况，这个this,一般会指向对象

var o = {
    prop:37
};
function indepedent(){
    return this.prop;
}
o.f = indepedent;
console.log(o.f()); //37
这里并不是去看函数是再怎么样创建的，而是只要将这个函数作为对象的方法，这个o.f去调用的话，那么这个this就会指向这个o 

关于this，一般来说，谁调用了方法，该方法的this就指向谁，如：
function foo(){
  console.log(this.a)
}
var a = 3;
var obj = {
    a: 2,
    foo: foo
};
obj.foo(); // 输出2,因为是obj调用的foo，所以foo的this指向了obj，而obj.a = 2
 
如果存在多次调用，对象属性引用链只有上一层或者说最后一层在调用位置中起作用，如：
function foo() {
  console.log( this.a )
}
var obj2 = {
  a: 42,
  foo: foo
}
var obj1 = {
  a: 2,
  obj2: obj2
}
obj1.obj2.foo(); // 42

四、对象原型链上的this

var o = {
    f:function(){
        return this.a + this.b;
    }
}
var p = Object.create(o);
p.a = 2;
p.b = 6;
console.log(p.f()); //8
这里p的原型是o，那么p.f的时候调用的是对象o上面的函数属性f,this也指向p

五、get/set方法与this

function modules(){
　　return Math.sqrt(this.re * this.re + this.im * this.im);
}
var o = {
　　re :1,
　　im:-1,
　　get phase(){
　　　　return this.im+this.re;
　　}
};
Object.defineProperty(o,'modules',{
　　get:modules,enumerable:true,configurable:true
});
console.log(o.phase,o.modules); // 0 根号2

六、构造器中的this

function MyClass(){
    this.a = 37;
}
var o = new MyClass();
console.log(o.a); //37

function C2(){
    this.a = 37;
    return{
        a:38
    }
}
o=new C2();
console.log(o.a); //38
new一个MyClass空对象，如果没有返回值，默认会返回this,有返回值，那么o就指向返回的对象了

在传统面向类的语言中，使用new初始化类的时候会调用类中的构造函数，但是JS中new的机制实际上和面向类和语言完全不同。

使用new来调用函数，或者说发生构造函数调用时，会自动执行下面的操作：

创建（或者说构造）一个全新的对象
这个新对象会被执行[[Prototype]]连接
这个新对象会绑定到函数调用的this
如果函数没有返回其他对象，那么new表达式中的函数会自动返回这个新对象如：

function foo(a){
    this.a = a
}
 
var bar = new foo(2);
console.log(bar.a); // 2

使用new来调用foo(…)时，我们会构造一个新对象并把它绑定到foo(…)调用中的this上。new是最后一种可以影响函数调用时this绑定行为的方法，我们称之为new绑定。

七、bind方法与this

function f(){
　　return this.a;
}
var g = f.bind({
    a:'test'
});
console.log(g()); //test
var o = {
    a:37,
    f:f,    
    g:g
};
console.log(o.f(),o.g()); //37,test

八、call/apply方法与this

function add(c,d){
    return this.a + this.b+c+d;
}
var o = {
    a:1,
    b:3
};
add.call(o,5,7); //1+3+5+7 = 16 add(5,7)
add.apply(o,[10,20]); //1+3+10+20 = 34
function bar(){
    console.log(Object.prototype.toString.call(this));
}
bar.call(7); //[Objedt Number]

function foo( something ) {
    console.log( this.a, something)
    return this.a + something
}

var obj = {
    a: 2
}

var bar = function() {
    return foo.apply( obj, arguments)
}

var b = bar(3); // 2 3
console.log(b); // 5

这里简单做一下解释：在bar函数中，foo使用apply函数绑定了obj，也就是说foo中的this将指向obj，与此同时，使用arguments（不限制传入参数的数量）作为参数传入foo函数中；所以在运行bar(3)的时候，首先输出obj.a也就是2和传入的3，然后foo返回了两者的相加值，所以b的值为5

同样，本例也可以使用bind:

function foo( something ) {
    console.log( this.a, something)
    return this.a + something
}
 
var obj = {
    a: 2
}
 
var bar = foo.bind(obj)
 
var b = bar(3); // 2 3
console.log(b); // 5

九、隐式丢失

一个最常见的this绑定问题就是被隐式绑定的函数会丢失绑定对象，也就是说他回应用默认绑定，从而把this绑定到全局对象或者undefined上，取决于是否是严格模式。

function foo() {
    console.log( this.a )
}
 
var obj1 = {
    a: 2,
    foo: foo
}
 
var bar = obj1.foo; // 函数别名！
 
var a = "oops, global"; // a是全局对象的属性
 
bar(); // "oops, global"

虽然bar是obj.foo的一个引用，但是实际上，它引用的是foo函数本身，因此此时的bar()其实是一个不带任何修饰的函数调用，因此应用了默认绑定

一个更微妙、更常见并且更出乎意料的情况发生在传入回调函数时：

function foo() {
    console.log( this.a )
}
 
function doFoo( fn ){
    // fn 其实引用的是 foo
    fn(); //

参数传递其实就是一种隐式赋值，因此我们传入函数时也会被隐式赋值，所以结果和上一个例子一样，如果把函数传入语言内置的函数而不是传入自己声明的函数（如setTimeout等），结果也是一样的

十、this的优先级

毫无疑问，默认绑定的优先级是四条规则中最低的，所以我们可以先不考虑它。

隐式绑定和显式绑定哪个优先级更高？我们来测试一下：

function foo(a){
    console.log(this.a)
}
 
var obj1 = {
    a: 2,
    foo: foo
}
 
var obj2 = {
    a: 3,
    foo: foo
}
 
obj1.foo(); // 2
obj2.foo(); // 3
 
obj1.foo.call(obj2); // 3
obj2.foo.call(obj1); // 2

可以看到，显式绑定优先级更高，也就是说在判断时应当先考虑是否可以存在显式绑定。

现在我们要搞清楚new绑定和隐式绑定的优先级谁高谁低：

function foo(something){
    this.a = something
}
 
var obj1 = {
    foo: foo
}
 
var obj2 = {}
 
obj1.foo(2); 
console.log(obj1.a); // 2
 
obj1.foo.call(obj2,3);
console.log(obj2.a); // 3
 
var bar = new obj1.foo(4)
console.log(obj1.a); // 2
console.log(bar.a); // 4

可以看到new绑定比隐式绑定优先级高。但是new绑定和显式绑定谁的优先级更高呢？

function foo(something){
    this.a = something
}
 
var obj1 = {}
 
var bar = foo.bind(obj1);
bar(2);
console.log(obj1.a); // 2
 
var baz = new bar(3);
console.log(obj1.a); // 2
console.log(baz.a); // 3

可以看到，new绑定修改了硬绑定中的this，所以new绑定的优先级比显式绑定更高。

之所以要在new中使用硬绑定函数，主要目的是预先设置函数的一些参数，这样在使用new进行初始化时就可以只传入其余的参数。bind(…)的功能之一就是可以把除了第一个参数（第一个参数用于绑定this）之外的其他参数都传给下层的函数（这种技术称为“部分应用”，是“柯里化”的一种）。举例来说：

function foo(p1,p2){
    this.val = p1 + p2;
}
 
// 之所以使用null是因为在本例中我们并不关心硬绑定的this是什么
// 反正使用new时this会被修改
var bar = foo.bind(null,'p1');
 
var baz = new bar('p2');
 
baz.val; // p1p2
}

十三、this在箭头函数中的应用

箭头函数不使用this的四种标准规则，而是根据外层（函数或者全局）作用域来决定this。

我们来看一下箭头函数的词法作用域：

function foo() {
    // 返回一个箭头函数
    return (a) => {
        // this继承自foo()
        console.log(this.a)
    };
}
 
var obj1 = {
    a: 2
};
 
var obj2 = {
    a: 3
};
 
var bar = foo.call(obj1);
bar.call(obj2); // 2, 不是3！

foo()内部创建的箭头函数会捕获调用时foo()的this。由于foo()的this绑定到obj1，bar（引用箭头函数）的this也会绑定到obj1，箭头函数的绑定无法被修改。（new也不行!）

总结：

如果要判断一个运行中的函数的this绑定，就需要找到这个函数的直接调用位置。找到之后就可以顺序应用下面这四条规则来判断this的绑定对象。

由new调用？绑定到新创建的对象。
由call或者apply（或者bind）调用？绑定到指定的对象。
由上下文对象调用？绑定到那个上下文对象。
默认：在严格模式下绑定到undefined，否则绑定到全局对象。