媒介

面试官出许多考题，基本都邑变着体式格局来考核this指向，看候选人对JS基本学问是不是踏实。
读者能够先拉到底部看总结，再谷歌（或各手艺平台）搜刮几篇相似文章，看笔者写的文章和他人有什么差别（迎接在批评区批评差别的地方），对照来看，考证与自身现有学问是不是有盲点，多看几篇，天然就会完美自身学问。

附上之前写文章写过的一段话：已经有许多关于
this的文章，为何自身还要写一遍呢。进修就好比是座大山，人们沿着差别的路爬山，分享着自身看到的景致。你不肯定能看到他人看到的景致，体味到他人的心境。只要自身去爬山，才看到不一样的景致，体味才越发深切。

函数的this在挪用时绑定的，完整取决于函数的挪用位置（也就是函数的挪用要领）。为了搞清楚this的指向是什么，必需晓得相干函数是如何挪用的。

全局上下文

非严厉形式和严厉形式中this都是指向顶层对象（浏览器中是window）。

this === window // true
'use strict'
this === window;
this.name = '轩辕Rowboat';
console.log(this.name); // 轩辕Rowboat

函数上下文

平常函数挪用形式

// 非严厉形式
var name = 'window';
var doSth = function(){
    console.log(this.name);
}
doSth(); // 'window'

你能够会误以为window.doSth()是挪用的，所所以指向window。虽然本例中window.doSth确切即是doSth。name即是window.name。上面代码中这是由于在ES5中，全局变量是挂载在顶层对象（浏览器是window）中。
事实上，并非云云。

// 非严厉形式
let name2 = 'window2';
let doSth2 = function(){
    console.log(this === window);
    console.log(this.name2);
}
doSth2() // true, undefined

这个例子中let没有给顶层对象中（浏览器是window）增加属性，window.name2和window.doSth都是undefined。

严厉形式中，平常函数中的this则表现差别，表现为undefined。

// 严厉形式
'use strict'
var name = 'window';
var doSth = function(){
    console.log(typeof this === 'undefined');
    console.log(this.name);
}
doSth(); // true，// 报错，由于this是undefined

看过的《你不晓得的JavaScript》上卷的读者，应当晓得书大将这类叫做默许绑定。
对call，apply熟习的读者会类比为：

doSth.call(undefined);
doSth.apply(undefined);

效果是一样的，call，apply作用之一就是用来修正函数中的this指向为第一个参数的。
第一个参数是undefined或许null，非严厉形式下，是指向window。严厉形式下，就是指向第一个参数。后文细致诠释。
常常有这类代码（回调函数），实在也是平常函数挪用形式。

var name = '轩辕Rowboat';
setTimeout(function(){
    console.log(this.name);
}, 0);
// 语法
setTimeout(fn | code, 0, arg1, arg2, ...)
// 也能够是一串代码。也能够通报其他函数
// 类比 setTimeout函数内部挪用fn或许实行代码`code`。
fn.call(undefined, arg1, arg2, ...);

对象中的函数（要领）挪用形式

var name = 'window';
var doSth = function(){
    console.log(this.name);
}
var student = {
    name: '轩辕Rowboat',
    doSth: doSth,
    other: {
        name: 'other',
        doSth: doSth,
    }
}
student.doSth(); // '轩辕Rowboat'
student.other.doSth(); // 'other'
// 用call类比则为：
student.doSth.call(student);
// 用call类比则为：
student.other.doSth.call(student);

但每每会有以下场景，把对象中的函数赋值成一个变量了。
如许实在又变成平常函数了，所以运用平常函数的划定规矩（默许绑定）。

var studentDoSth = student.doSth;
studentDoSth(); // 'window'
// 用call类比则为：
studentDoSth.call(undefined);

call、apply、bind 挪用形式

上文提到call、apply，这里细致解读一下。先经由过程MDN熟悉下call和apply
MDN 文档：Function.prototype.call()
语法

fun.call(thisArg, arg1, arg2, ...)

thisArg
在fun函数运转时指定的this值。须要注重的是，指定的this值并不肯定是该函数实行时真正的this值，假如这个函数处于非严厉形式下，则指定为null和undefined的this值会自动指向全局对象(浏览器中就是window对象)，同时价为原始值(数字，字符串，布尔值)的this会指向该原始值的自动包装对象。
arg1, arg2, …
指定的参数列表
返回值
返回值是你挪用的要领的返回值，若该要领没有返回值，则返回undefined。
apply和call相似。只是参数不一样。它的参数是数组（或许类数组）。

依据参数thisArg的形貌，能够晓得，call就是转变函数中的this指向为thisArg，而且实行这个函数，这也就使JS天真许多。严厉形式下，thisArg是原始值是值范例，也就是原始值。不会被包装成对象。举个例子：

var doSth = function(name){
    console.log(this);
    console.log(name);
}
doSth.call(2, '轩辕Rowboat'); // Number{2}, '轩辕Rowboat'
var doSth2 = function(name){
    'use strict';
    console.log(this);
    console.log(name);
}
doSth2.call(2, '轩辕Rowboat'); // 2, '轩辕Rowboat'

虽然平常不会把thisArg参数写成值范例。但照样须要晓得这个学问。
之前写过一篇文章：面试官问：可否模仿完成JS的call和apply要领
就是运用对象上的函数this指向这个对象，来模仿完成call和apply的。感兴趣的读者思索如何完成，再去看看笔者的完成。

bind和call和apply相似，第一个参数也是修正this指向，只不过返回值是新函数，新函数也能当作组织函数（new）挪用。
MDN Function.prototype.bind

bind()要领建立一个新的函数， 当这个新函数被挪用时
this键值为其供应的值，其参数列表前几项值为建立时指定的参数序列。

语法：

fun.bind(thisArg[, arg1[, arg2[, …]]])

参数：

thisArg

挪用绑定函数时作为this参数通报给目的函数的值。 假如运用
new运算符组织绑定函数，则疏忽该值。当运用
bind在
setTimeout中建立一个函数（作为回调供应）时，作为
thisArg通报的任何原始值都将转换为
object。假如没有供应绑定的参数，则实行作用域的
this被视为新函数的
thisArg。

arg1, arg2, …

当绑定函数被挪用时，这些参数将置于实参之前通报给被绑定的要领。

返回值

返回由指定的
this值和初始化参数革新的原函数拷贝。

之前也写过一篇文章：面试官问：可否模仿完成JS的bind要领
就是运用call和apply指向这个thisArg参数，来模仿完成bind的。感兴趣的读者思索如何完成，再去看看笔者的完成。

组织函数挪用形式

function Student(name){
    this.name = name;
    console.log(this); // {name: '轩辕Rowboat'}
    // 相当于返回了
    // return this;
}
var result = new Student('轩辕Rowboat');

运用new操作符挪用函数，会自动实行以下步骤。

1. 建立了一个全新的对象。
2. 这个对象会被实行[[Prototype]]（也就是__proto__）链接。
3. 天生的新对象会绑定到函数挪用的this。
4. 经由过程new建立的每一个对象将终究被[[Prototype]]链接到这个函数的prototype对象上。
5. 假如函数没有返回对象范例Object(包括Functoin, Array, Date, RegExg, Error)，那末new表达式中的函数挪用会自动返回这个新的对象。

由此能够晓得：new操作符挪用时，this指向天生的新对象。
迥殊提示一下，new挪用时的返回值，假如没有显式返回对象或许函数，才是返回天生的新对象。

function Student(name){
    this.name = name;
    // return function f(){};
    // return {};
}
var result = new Student('轩辕Rowboat');
console.log(result); {name: '轩辕Rowboat'}
// 假如返回函数f，则result是函数f，假如是对象{}，则result是对象{}

许多人或许文章都疏忽了这一点，直接简单用typeof推断对象。虽然实际运用时不会显现返回，但面试官会问到。

之前也写了一篇文章面试官问：可否模仿完成JS的new操作符，是运用apply来把this指向到天生的新天生的对象上。感兴趣的读者思索如何完成，再去看看笔者的完成。

原型链中的挪用形式

function Student(name){
    this.name = name;
}
var s1 = new Student('轩辕Rowboat');
Student.prototype.doSth = function(){
    console.log(this.name);
}
s1.doSth(); // '轩辕Rowboat'

会发明这个素昧平生。这就是对象上的要领挪用形式。天然是指向天生的新对象。
假如该对象继续自别的对象。同样会经由过程原型链查找。
上面代码运用
ES6中class写法则是：

class Student{
    constructor(name){
        this.name = name;
    }
    doSth(){
        console.log(this.name);
    }
}
let s1 = new Student('轩辕Rowboat');
s1.doSth();

babel es6转换成es5的效果，能够去babeljs网站转换测试自行尝尝。

'use strict';

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var Student = function () {
    function Student(name) {
        _classCallCheck(this, Student);

        this.name = name;
    }

    _createClass(Student, [{
        key: 'doSth',
        value: function doSth() {
            console.log(this.name);
        }
    }]);

    return Student;
}();

var s1 = new Student('轩辕Rowboat');
s1.doSth();

由此看出，ES6的class也是经由过程组织函数模仿完成的，是一种语法糖。

箭头函数挪用形式

先看箭头函数和平常函数的主要区分：

1、没有自身的
this、
super、
arguments和
new.target绑定。

2、不能运用
new来挪用。

3、没有原型对象。

4、不能够转变
this的绑定。

5、形参称号不能反复。

箭头函数中没有this绑定，必需经由过程查找作用域链来决议其值。
假如箭头函数被非箭头函数包括，则this绑定的是近来一层非箭头函数的this，不然this的值则被设置为全局对象。
比方：

var name = 'window';
var student = {
    name: '轩辕Rowboat',
    doSth: function(){
        // var self = this;
        var arrowDoSth = () => {
            // console.log(self.name);
            console.log(this.name);
        }
        arrowDoSth();
    },
    arrowDoSth2: () => {
        console.log(this.name);
    }
}
student.doSth(); // '轩辕Rowboat'
student.arrowDoSth2(); // 'window'

实在就是相当于箭头函数外的this是缓存的该箭头函数上层的平常函数的this。假如没有平常函数，则是全局对象（浏览器中则是window）。
也就是说没法经由过程call、apply、bind绑定箭头函数的this(它自身没有this)。而call、apply、bind能够绑定缓存箭头函数上层的平常函数的this。
比方：

var student = {
    name: '轩辕Rowboat',
    doSth: function(){
        console.log(this.name);
        return () => {
            console.log('arrowFn:', this.name);
        }
    }
}
var person = {
    name: 'person',
}
student.doSth().call(person); // '轩辕Rowboat'  'arrowFn:' '轩辕Rowboat'
student.doSth.call(person)(); // 'person' 'arrowFn:' 'person'

DOM事宜处置惩罚函数挪用

addEventerListener、attachEvent、onclick

<button class="button">onclick</button>
<ul class="list">
    <li>1</li>
    <li>2</li>
    <li>3</li>
</ul>
<script>
    var button = document.querySelector('button');
    button.onclick = function(ev){
        console.log(this);
        console.log(this === ev.currentTarget); // true
    }
    var list = document.querySelector('.list');
    list.addEventListener('click', function(ev){
        console.log(this === list); // true
        console.log(this === ev.currentTarget); // true
        console.log(this);
        console.log(ev.target);
    }, false);
</script>

onclick和addEventerListener是指向绑定事宜的元素。
一些浏览器，比方IE6~IE8下运用attachEvent，this指向是window。
趁便提下：面试官也常常考核ev.currentTarget和ev.target的区分。
ev.currentTarget是绑定事宜的元素，而ev.target是当前触发事宜的元素。比方这里的分别是ul和li。
但也能够点击的是ul，这时候ev.currentTarget和ev.target就相等了。

内联事宜处置惩罚函数挪用

<button class="btn1" onclick="console.log(this === document.querySelector('.btn1'))">点我呀</button>
<button onclick="console.log((function(){return this})());">再点我呀</button>

第一个是button自身，所所以true，第二个是window。这里跟严厉形式没有关系。
固然我们如今不会如许用了，但偶然不小心写成了如许，也须要相识。

实在this的运用场景另有挺多，比方对象object中的getter、setter的this，new Function()、eval。
但控制以上几种，去剖析其他的，就天然水到渠成了。
运用比较多的照样平常函数挪用、对象的函数挪用、new挪用、call、apply、bind挪用、箭头函数挪用。
那末他们的优先级是如何的呢。

优先级

而箭头函数的this是上层平常函数的this或许是全局对象（浏览器中是window），所以消除，不算优先级。

var name = 'window';
var person = {
    name: 'person',
}
var doSth = function(){
    console.log(this.name);
    return function(){
        console.log('return:', this.name);
    }
}
var Student = {
    name: '轩辕Rowboat',
    doSth: doSth,
}
// 平常函数挪用
doSth(); // window
// 对象上的函数挪用
Student.doSth(); // '轩辕Rowboat'
// call、apply 挪用
Student.doSth.call(person); // 'person'
new Student.doSth.call(person);

试想一下，假如是Student.doSth.call(person)先实行的状况下，那new实行一个函数。是没有问题的。
但是事实上，这代码是报错的。运算符优先级是new比点号低，所所以实行new (Student.doSth.call)(person)
而Function.prototype.call，虽然是一个函数（apply、bind也是函数），跟箭头函数一样，不能用new挪用。所以报错了。

Uncaught TypeError: Student.doSth.call is not a constructor

这是由于函数内部有两个差别的要领：[[Call]]和[[Constructor]]。
当运用平常函数挪用时，[[Call]]会被实行。当运用组织函数挪用时，[[Constructor]]会被实行。call、apply、bind和箭头函数内部没有[[Constructor]]要领。

从上面的例子能够看出平常函数挪用优先级最低，其次是对象上的函数。
call（apply、bind）挪用体式格局和new挪用体式格局的优先级，在《你不晓得的JavaScript》是对照bind和new，引用了mdn的bind的ployfill完成，new挪用时bind以后的函数，会疏忽bind绑定的第一个参数，(mdn的完成实在另有一些问题，感兴趣的读者，能够看我之前的文章：面试官问：可否模仿完成JS的bind要领)，申明new的挪用的优先级最高。
所以它们的优先级是new 挪用 > call、apply、bind 挪用 > 对象上的函数挪用 > 平常函数挪用。

总结

假如要推断一个运转中函数的 this 绑定， 就须要找到这个函数的直接挪用位置。 找到以后
就能够递次运用下面这四条划定规矩来推断 this 的绑定对象。

1. new 挪用：绑定到新建立的对象，注重：显现return函数或对象，返回值不是新建立的对象，而是显式返回的函数或对象。
2. call 或许 apply（ 或许 bind） 挪用：严厉形式下，绑定到指定的第一个参数。非严厉形式下，null和undefined，指向全局对象（浏览器中是window），其余值指向被new Object()包装的对象。
3. 对象上的函数挪用：绑定到谁人对象。
4. 平常函数挪用： 在严厉形式下绑定到 undefined，不然绑定到全局对象。

ES6 中的箭头函数：不会运用上文的四条范例的绑定划定规矩， 而是依据当前的词法作用域来决议this， 具体来说， 箭头函数会继续外层函数，挪用的 this 绑定（ 不管 this 绑定到什么），没有外层函数，则是绑定到全局对象（浏览器中是window）。 这实在和 ES6 之前代码中的 self = this 机制一样。

DOM事宜函数：平常指向绑定事宜的DOM元素，但有些状况绑定到全局对象（比方IE6~IE8的attachEvent）。

肯定要注重，有些挪用能够在无意中运用平常函数绑定划定规矩。 假如想“ 更平安” 地疏忽 this 绑
定， 你能够运用一个对象， 比方 ø = Object.create(null)， 以庇护全局对象。

面试官考核this指向就能够考核new、call、apply、bind，箭头函数等用法。从而扩大到作用域、闭包、原型链、继续、严厉形式等。这就是面试官乐此不疲的缘由。

读者发明有不妥或可改良的地方，迎接指出。别的以为写得不错，能够点个赞，也是对笔者的一种支撑。

考题

this指向考题常常连系一些运算符等来考核。看完本文，无妨经由过程以下两篇面试题测试一下。
小小沧海：一道常被人轻蔑的前端JS面试题
从这两套题，重新熟悉JS的this、作用域、闭包、对象

扩大浏览

你不晓得的JavaScript 上卷
冴羽：JavaScript深切之从ECMAScript范例解读this
这波能反杀：前端基本进阶（五）：全方位解读this

关于

作者：常以轩辕Rowboat若川为名混迹于江湖。前端路上 | PPT爱好者 | 所知甚少，唯善学。
个人博客
segmentfault前端视野专栏，开通了前端视野专栏，迎接关注
掘金专栏，迎接关注
知乎前端视野专栏，开通了前端视野专栏，迎接关注
github，迎接follow~