这篇文章主要为大家展示了“JavaScript的this指向怎么用”，内容简而易懂，条理清晰，希望能够帮助大家解决疑惑，下面让小编带领大家一起研究并学习一下“JavaScript的this指向怎么用”这篇文章吧。

函数的this在调用时绑定的，完全取决于函数的调用位置（也就是函数的调用方法）。为了搞清楚this的指向是什么，必须知道相关函数是如何调用的。

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

this===window//true'usestrict'this===window;this.name='W3Cschool';console.log(this.name);函数上下文普通函数调用模式

//非严格模式varname='window';vardoSth=function(){console.log(this.name);}doSth();//'window'

你可能会误以为window.doSth()是调用的，所以是指向window。虽然本例中window.doSth确实等于doSth。name等于window.name。上面代码中这是因为在ES5中，全局变量是挂载在顶层对象（浏览器是window）中。 事实上，并不是如此。

//非严格模式letname2='window2';letdoSth3=function(){console.log(this===window);console.log(this.name2);}doSth3()//true,undefined

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

严格模式中，普通函数中的this则表现不同，表现为undefined。

//严格模式'usestrict'varname='window';vardoSth=function(){console.log(typeofthis==='undefined');console.log(this.name);}doSth();//true，//报错，因为this是undefined

看过的《你不知道的JavaScript》上卷的读者，应该知道书上将这种叫做默认绑定。 对call，apply熟悉的读者会类比为：

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

效果是一样的，call，apply作用之一就是用来修改函数中的this指向为第一个参数的。 第一个参数是undefined或者null，非严格模式下，是指向window。严格模式下，就是指向第一个参数。后文详细解释。经常有这类代码（回调函数），其实也是普通函数调用模式。

varname='W3Cschool';setTimeout(function(){console.log(this.name);},0);//语法setTimeout(fn|code,0,arg1,arg2,...)//也可以是一串代码。也可以传递其他函数//类比setTimeout函数内部调用fn或者执行代码`code`。fn.call(undefined,arg1,arg2,...);对象中的函数（方法）调用模式

varname='window';vardoSth=function(){console.log(this.name);}varstudent={name:'W3Cschool',doSth:doSth,other:{name:'other',doSth:doSth,}}student.doSth();//student.other.doSth();//'other'//用call类比则为：student.doSth.call(student);//用call类比则为：student.other.doSth.call(student.other);

但往往会有以下场景，把对象中的函数赋值成一个变量了。 这样其实又变成普通函数了，所以使用普通函数的规则（默认绑定）。

varstudentDoSth=student.doSth;studentDoSth();//'window'//用call类比则为：studentDoSth.call(undefined);call、apply、bind调用模式

上文提到call、apply，这里详细解读一下。先通过MDN认识下call和applyMDN 文档：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，并且执行这个函数，这也就使JavaScript灵活很多。严格模式下，thisArg是原始值是值类型，也就是原始值。不会被包装成对象。举个例子：

vardoSth=function(name){console.log(this);console.log(name);}doSth.call(2,'W3Cschool');//Number{2},'W3Cschool'vardoSth3=function(name){'usestrict';console.log(this);console.log(name);}doSth3.call(2,'W3Cschool');//2,'W3Cschool你'

虽然一般不会把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的。感兴趣的读者思考如何实现，再去看看笔者的实现。

functionStudent(name){this.name=name;console.log(this);//{name:'W3Cschool'}//相当于返回了//returnthis;}varresult=newStudent('W3Cschool');

使用new操作符调用函数，会自动执行以下步骤。

创建了一个全新的对象。

这个对象会被执行[[Prototype]]（也就是__proto__）链接。

生成的新对象会绑定到函数调用的this。

通过new创建的每个对象将最终被[[Prototype]]链接到这个函数的prototype对象上。

如果函数没有返回对象类型Object(包含Functoin,Array,Date,RegExg,Error)，那么new表达式中的函数调用会自动返回这个新的对象。

由此可以知道：new操作符调用时，this指向生成的新对象。特别提醒一下，new调用时的返回值，如果没有显式返回对象或者函数，才是返回生成的新对象。

functionStudent(name){this.name=name;//returnfunctionf(){};//return{};}varresult=newStudent('W3Cschool');console.log(result);{name:'W3Cschool'}//如果返回函数f，则result是函数f，如果是对象{}，则result是对象{}

很多人或者文章都忽略了这一点，直接简单用typeof判断对象。虽然实际使用时不会显示返回，但面试官会问到。

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

functionStudent(name){this.name=name;}vars1=newStudent('W3Cschool');Student.prototype.doSth=function(){console.log(this.name);}s1.doSth();//'W3Cschool'

会发现这个似曾相识。这就是对象上的方法调用模式。自然是指向生成的新对象。 如果该对象继承自其它对象。同样会通过原型链查找。 上面代码使用ES6中class写法则是：

classStudent{constructor(name){this.name=name;}doSth(){console.log(this.name);}}lets1=newStudent('若川');s1.doSth();

babeles6转换成es5的结果，可以去babeljs网站转换测试自行试试。

'usestrict';var_createClass=function(){functiondefineProperties(target,props){for(vari=0;i<props.length;i++){vardescriptor=props[i];descriptor.enumerable=descriptor.enumerable||false;descriptor.configurable=true;if("value"indescriptor)descriptor.writable=true;Object.defineProperty(target,descriptor.key,descriptor);}}returnfunction(Constructor,protoProps,staticProps){if(protoProps)defineProperties(Constructor.prototype,protoProps);if(staticProps)defineProperties(Constructor,staticProps);returnConstructor;};}();function_classCallCheck(instance,Constructor){if(!(instanceinstanceofConstructor)){thrownewTypeError("Cannotcallaclassasafunction");}}varStudent=function(){functionStudent(name){_classCallCheck(this,Student);this.name=name;}_createClass(Student,[{key:'doSth',value:functiondoSth(){console.log(this.name);}}]);returnStudent;}();vars1=newStudent('W3Cschool');s1.doSth();

由此看出，ES6的class也是通过构造函数模拟实现的，是一种语法糖。

先看箭头函数和普通函数的重要区别：

1、没有自己的this、super、arguments和new.target绑定。 2、不能使用new来调用。 3、没有原型对象。 4、不可以改变this的绑定。 5、形参名称不能重复。

箭头函数中没有this绑定，必须通过查找作用域链来决定其值。 如果箭头函数被非箭头函数包含，则this绑定的是最近一层非箭头函数的this，否则this的值则被设置为全局对象。 比如：

varname='window';varstudent={name:'W3Cschool',doSth:function(){//varself=this;vararrowDoSth=()=>{//console.log(self.name);console.log(this.name);}arrowDoSth();},arrowDoSth3:()=>{console.log(this.name);}}student.doSth();//'W3Cschool'student.arrowDoSth3();//'window'

其实就是相当于箭头函数外的this是缓存的该箭头函数上层的普通函数的this。如果没有普通函数，则是全局对象（浏览器中则是window）。 也就是说无法通过call、apply、bind绑定箭头函数的this(它自身没有this)。而call、apply、bind可以绑定缓存箭头函数上层的普通函数的this。 比如：

varstudent={name:'W3Cschool',doSth:function(){console.log(this.name);return()=>{console.log('arrowFn:',this.name);}}}varperson={name:'person',}student.doSth().call(person);//'W3Cschool''arrowFn:''W3Cschool'student.doSth.call(person)();//'person''arrowFn:''person'DOM事件处理函数调用addEventerListener、attachEvent、onclick

<buttonclass="button">onclick</button><ulclass="list"><li>1</li><li>2</li><li>3</li></ul><script>varbutton=document.querySelector('button');button.onclick=function(ev){console.log(this);console.log(this===ev.currentTarget);//true}varlist=document.querySelector('.list');list.addEventListener('click',function(ev){console.log(this===list);//trueconsole.log(this===ev.currentTarget);//trueconsole.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就相等了。

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

第一个是button本身，所以是true，第二个是window。这里跟严格模式没有关系。 当然我们现在不会这样用了，但有时不小心写成了这样，也需要了解。

其实this的使用场景还有挺多，比如对象object中的getter、setter的this，new Function()、eval。 但掌握以上几种，去分析其他的，就自然迎刃而解了。 使用比较多的还是普通函数调用、对象的函数调用、new调用、call、apply、bind调用、箭头函数调用。 那么他们的优先级是怎样的呢。

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

varname='window';varperson={name:'person',}vardoSth=function(){console.log(this.name);returnfunction(){console.log('return:',this.name);}}varStudent={name:'W3Cschool',doSth:doSth,}//普通函数调用doSth();//window//对象上的函数调用Student.doSth();//'W3Cschool'//call、apply调用Student.doSth.call(person);//'person'newStudent.doSth.call(person);

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

UncaughtTypeError:Student.doSth.callisnotaconstructor

这是因为函数内部有两个不同的方法：[[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的绑定对象。

new调用：绑定到新创建的对象，注意：显示return函数或对象，返回值不是新创建的对象，而是显式返回的函数或对象。

call或者apply（ 或者bind） 调用：严格模式下，绑定到指定的第一个参数。非严格模式下，null和undefined，指向全局对象（浏览器中是window），其余值指向被new Object()包装的对象。

对象上的函数调用：绑定到那个对象。

普通函数调用： 在严格模式下绑定到undefined，否则绑定到全局对象。

ES6中的箭头函数：不会使用上文的四条标准的绑定规则， 而是根据当前的词法作用域来决定this， 具体来说， 箭头函数会继承外层函数，调用的 this 绑定（ 无论 this 绑定到什么），没有外层函数，则是绑定到全局对象（浏览器中是window）。 这其实和ES6之前代码中的self = this机制一样。

DOM事件函数：一般指向绑定事件的DOM元素，但有些情况绑定到全局对象（比如IE6~IE8的attachEvent）。

一定要注意，有些调用可能在无意中使用普通函数绑定规则。 如果想“ 更安全” 地忽略this绑 定， 你可以使用一个对象， 比如ø = Object.create(null)， 以保护全局对象。

以上是“JavaScript的this指向怎么用”这篇文章的所有内容，感谢各位的阅读！相信大家都有了一定的了解，希望分享的内容对大家有所帮助，如果还想学习更多知识，欢迎关注亿速云行业资讯频道！