This

• this - MDN
• JavaScript 基础心法——this

一、定义

this 关键字是函数运行时自动生成的一个内部对象，只能在函数内部使用，总指向调用它的对象。

简单理解：在 JavaScript 中，this 的指向是调用时决定的，而不是创建时决定的

函数的 this 关键字在 JavaScript 中的表现略有不同，此外，在严格模式和非严格模式之间也会有一些差别。

在绝大多数情况下，函数的调用方式决定了 this 的值（运行时绑定）

举个例子：

function baz() {
  // 当前调用栈是：baz
  // 因此，当前调用位置是全局作用域
  console.log('baz');
  bar(); // <-- bar的调用位置
}
function bar() {
  // 当前调用栈是：baz --> bar
  // 因此，当前调用位置在baz中
  console.log('bar');
  foo(); // <-- foo的调用位置
}
function foo() {
  // 当前调用栈是：baz --> bar --> foo
  // 因此，当前调用位置在bar中
  console.log('foo');
}
baz(); // <-- baz的调用位置

同时，this 在函数执行过程中，this 一旦被确定了，就不可以再更改

var a = 10;
var obj = {
  a: 20
}
function fn() {
  this = obj; // 修改this，运行后会报错
  console.log(this.a);
}
fn();

二、绑定规则

根据不同的使用场合，this 有不同的值，主要分为下面几种情况：

• 默认绑定

• 隐式绑定

• new 绑定

• 显式绑定

2.1 默认绑定

全局环境中定义 person 函数，内部使用 this 关键字

var name = 'Jenny';
function person() {
  return this.name;
}
console.log(person()); // Jenny

上述代码输出 Jenny，原因是调用函数的对象在游览器中位 window，因此 this 指向 window，所以输出 Jenny。

注意：严格模式下，不能将全局对象用于默认绑定，this 会绑定到 undefined，只有函数运行在非严格模式下，默认绑定才能绑定到全局对象

2.2 隐式绑定

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

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

obj.m(); // 1

这个函数中包含多个对象，尽管这个函数是被最外层的对象所调用，this 指向的也只是它上一级的对象

var o = {
  a: 10,
  b: {
    fn: function () {
      console.log(this.a); // undefined
    }
  }
};
o.b.fn();

上述代码中，this 的上一级对象为b，b内部并没有a变量的定义，所以输出 undefined

这里再举一种特殊情况

var o = {
  a: 10,
  b: {
    a: 12,
    fn: function () {
      console.log(this.a); // undefined
      console.log(this); // window
    }
  }
};
var j = o.b.fn;
j();

此时 this 指向的是 window，这里的大家需要记住，this 永远指向的是最后调用它的对象，虽然fn是对象b的方法，但是fn赋值给j时候并没有执行，所以最终指向 window。

2.3 new 绑定

通过构建函数new关键字生成一个实例对象，此时this指向这个实例对象

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

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

上述代码之所以能过输出 1，是因为new关键字改变了this的指向。

这里再列举一些特殊情况：

new过程遇到return一个对象，此时this指向为返回的对象。

function fn() {
  this.user = 'xxx';
  return {};
}
var a = new fn();
console.log(a.user); // undefined

如果返回一个简单类型的时候，则 this 指向实例对象。

function fn() {
  this.user = 'xxx';
  return 1;
}
var a = new fn();
console.log(a.user); // xxx

注意的是null虽然也是对象，但是此时new仍然指向实例对象。

function fn() {
  this.user = 'xxx';
  return null;
}
var a = new fn();
console.log(a.user); // xxx

2.4 显式修改

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

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

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

apply、call、bind 三者的区别

三、箭头函数

在 ES6 的语法中还提供了箭头函数，让我们在代码书写时就能确定 this 的指向（编译时绑定）

举个例子：

const obj = {
  sayThis: () => {
    console.log(this);
  }
};

obj.sayThis(); // window 因为 JavaScript 没有块作用域，所以在定义 sayThis 的时候，里面的 this 就绑到 window 上去了
const globalSay = obj.sayThis;
globalSay(); // window 浏览器中的 global 对象

虽然箭头函数的this能够在编译的时候就确定了this的指向，但也需要注意一些潜在的坑

下面举个例子：

绑定事件监听

const button = document.getElementById('mngb');
button.addEventListener('click', () => {
  console.log(this === window); // true
  this.innerHTML = 'clicked button';
});

上述可以看到，我们其实是想要this为点击的button，但此时this指向了window

包括在原型上添加方法时候，此时this指向window

Cat.prototype.sayName = () => {
  console.log(this === window); //true
  return this.name;
};
const cat = new Cat('mm');
cat.sayName();

同样的，箭头函数不能作为构建函数

四、优先级

隐式绑定 VS 显式绑定

function foo() {
  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 绑定 VS 隐式绑定

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绑定 VS 显式绑定

因为new和apply、call无法一起使用，但硬绑定也是显式绑定的一种，可以替换测试

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

bar被绑定到 obj1 上，但是new bar(3) 并没有像我们预计的那样把obj1.a修改为 3。但是，new修改了绑定调用bar()中的this

我们可认为new绑定优先级>显式绑定

综上，new 绑定优先级 > 显示绑定优先级 > 隐式绑定优先级 > 默认绑定优先级

五、This 指向

• 全局上下文：window 对象
• 函数上下文：
  • 直接调用：this指向全局变量，即 window。
  • call()、apply()：this指向绑定的对象上。
  • bind()：this将永久地被绑定到了bind的第一个参数。
  • 箭头函数：箭头函数会捕获其所在上下文的 this 值，作为自己的this值。
  • 作为对象的一个方法：this指向调用函数的对象。
  • 作为一个构造函数：this被绑定到正在构造的新对象。
  • 作为一个DOM事件处理函数：this指向触发事件的元素，也就是始事件处理程序所绑定到的DOM节点。
  • HTML 标签内联事件处理函数：this指向所在的 DOM 元素
  • jQuery 的 this：在许多情况下JQuery的this都指向DOM元素节点。

六、call/apply/bind

通过 call、apply、bind 来将 this 绑定到指定的对象上。三者都是用来改变函数的 this 指向。

注意：第一个参数是 undefined 或 null 时它会被替换成全局对象

call 与 applay 唯一区别：后面的参数，其中 call 以一个一个的形式传递，apply 以数组的形式传递。

bind: bind() 方法会创建一个新函数（称之为绑定函数），原函数的一个拷贝，也就是说不会像 call 和 apply 那样立即执行。

我们先来看几个函数调用的场景

function foo() {
  console.log(this.a);
}
var a = 1;
foo();

const obj = {
  a: 2,
  foo: foo
};
obj.foo();

const c = new foo();

• 对于直接调用 foo 来说，不管 foo 函数被放在了什么地方，this 一定是window
• 对于 obj.foo() 来说，我们只需要记住，谁调用了函数，谁就是 this，所以在这个场景下 foo 函数中的 this 就是 obj 对象
• 对于 new 的方式来说，this 被永远绑定在了 c 上面，不会被任何方式改变 this

说完了以上几种情况，其实很多代码中的 this 应该就没什么问题了，下面让我们看看箭头函数中的 this

function a() {
  return () => {
    return () => {
      console.log(this);
    };
  };
}
console.log(a()()());

• 首先箭头函数其实是没有 this 的，箭头函数中的 this 只取决包裹箭头函数的第一个普通函数的 this。在这个例子中，因为包裹箭头函数的第一个普通函数是 a，所以此时的 this 是 window。另外对箭头函数使用 bind这类函数是无效的。
• 最后种情况也就是 bind 这些改变上下文的 API 了，对于这些函数来说，this 取决于第一个参数，如果第一个参数为空，那么就是 window。
• 那么说到 bind，不知道大家是否考虑过，如果对一个函数进行多次 bind，那么上下文会是什么呢？

let a = {};
let fn = function () {
  console.log(this);
};
fn.bind().bind(a)(); // => ?

如果你认为输出结果是 a，那么你就错了，其实我们可以把上述代码转换成另一种形式

// fn.bind().bind(a) 等于
let fn2 = function fn1() {
  return function () {
    return fn.apply();
  }.apply(a);
};
fn2();

可以从上述代码中发现，不管我们给函数 bind 几次，fn 中的 this 永远由第一次 bind 决定，所以结果永远是 window

let a = { name: 'poetries' };
function foo() {
  console.log(this.name);
}
foo.bind(a)(); // => 'poetries'