JavaScript 中的 this 全面解析

隐式绑定

关于this,一般来说,谁调用了方法,该方法的this就指向谁,如:


  1. function foo(){ 
  2.     console.log(this.a) 
  3.  
  4. var a = 3; 
  5.  
  6. var obj = { 
  7.     a: 2, 
  8.     foo: foo 
  9. }; 
  10.  
  11. obj.foo(); // 输出2,因为是obj调用的foo,所以foo的this指向了obj,而obj.a = 2 

如果存在多次调用,对象属性引用链只有上一层或者说最后一层在调用位置中起作用,如:


  1. function foo() { 
  2.     console.log( this.a ) 
  3.  
  4. var obj2 = {  
  5.     a: 42, 
  6.     foo: foo 
  7.  
  8. var obj1 = { 
  9.     a: 2, 
  10.     obj2: obj2 
  11.  
  12. obj1.obj2.foo(); // 42 

隐式丢失

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


  1. function foo() { 
  2.     console.log( this.a ) 
  3.  
  4. var obj1 = { 
  5.     a: 2, 
  6.     foo: foo 
  7.  
  8. var bar = obj1.foo; // 函数别名! 
  9.  
  10. var a = "oops, global"; // a是全局对象的属性 
  11.  
  12. bar(); // "oops, global" 

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

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


  1. function foo() { 
  2.     console.log( this.a ) 
  3.  
  4. function doFoo( fn ){ 
  5.     // fn 其实引用的是 foo 
  6.     fn(); // <-- 调用位置! 
  7.  
  8. var obj = { 
  9.     a: 2, 
  10.     foo: foo 
  11.  
  12. var a = "oops, global"; // a是全局对象的属性 
  13.  
  14. doFoo( obj.foo ); // "oops, global" 

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

显式绑定

简单的说,就是指定this,如:call、apply、bind、new绑定等

硬绑定


  1. function foo( something ) { 
  2.     console.log( this.a, something) 
  3.     return this.a + something 
  4.  
  5. var obj = { 
  6.     a: 2 
  7.  
  8. var bar = function() { 
  9.     return foo.apply( obj, arguments) 
  10.  
  11. var b = bar(3); // 2 3 
  12. console.log(b); // 5 

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

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


  1. function foo( something ) { 
  2.     console.log( this.a, something) 
  3.     return this.a + something 
  4.  
  5. var obj = { 
  6.     a: 2 
  7.  
  8. var bar = foo.bind(obj) 
  9.  
  10. var b = bar(3); // 2 3 
  11. console.log(b); // 5 

new绑定

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

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

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

  1. function foo(a){ 
  2.     this.a = a 
  3.  
  4. var bar = new foo(2); 
  5. console.log(bar.a); // 2 

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

this的优先级

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

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


  1. function foo(a){ 
  2.     console.log(this.a) 
  3.  
  4. var obj1 = { 
  5.     a: 2, 
  6.     foo: foo 
  7.  
  8. var obj2 = { 
  9.     a: 3, 
  10.     foo: foo 
  11.  
  12. obj1.foo(); // 2 
  13. obj2.foo(); // 3 
  14.  
  15. obj1.foo.call(obj2); // 3 
  16. obj2.foo.call(obj1); // 2 

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

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


  1. function foo(something){ 
  2.     this.a = something 
  3.  
  4. var obj1 = { 
  5.     foo: foo 
  6.  
  7. var obj2 = {} 
  8.  
  9. obj1.foo(2);  
  10. console.log(obj1.a); // 2 
  11.  
  12. obj1.foo.call(obj2,3); 
  13. console.log(obj2.a); // 3 
  14.  
  15. var bar = new obj1.foo(4) 
  16. console.log(obj1.a); // 2 
  17. console.log(bar.a); // 4 

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


  1. function foo(something){ 
  2.     this.a = something 
  3.  
  4. var obj1 = {} 
  5.  
  6. var bar = foo.bind(obj1); 
  7. bar(2); 
  8. console.log(obj1.a); // 2 
  9.  
  10. var baz = new bar(3); 
  11. console.log(obj1.a); // 2 
  12. console.log(baz.a); // 3 

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

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


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

柯里化:在直觉上,柯里化声称“如果你固定某些参数,你将得到接受余下参数的一个函数”。所以对于有两个变量的函数yx,如果固定了 y = 2,则得到有一个变量的函数 2x

This在箭头函数中的应用

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

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


  1. function foo() { 
  2.     // 返回一个箭头函数 
  3.     return (a) => { 
  4.         // this继承自foo() 
  5.         console.log(this.a) 
  6.     }; 
  7.  
  8. var obj1 = { 
  9.     a: 2 
  10. }; 
  11.  
  12. var obj2 = { 
  13.     a: 3 
  14. }; 
  15.  
  16. var bar = foo.call(obj1); 
  17. bar.call(obj2); // 2, 不是3! 

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

总结

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

由new调用?绑定到新创建的对象。

由call或者apply(或者bind)调用?绑定到指定的对象。

由上下文对象调用?绑定到那个上下文对象。

默认:在严格模式下绑定到undefined,否则绑定到全局对象。

作者:风雨后见彩虹

来源:51CTO

时间: 2024-07-30 02:11:11

JavaScript 中的 this 全面解析的相关文章

javascript中加载并解析XML字符串/xml文件

首先,我们需要加载这个xml文件,js中加载xml文件,是通过XMLDOM来进行的.  代码如下 复制代码 <?xml version="1.0" encoding="utf-8" ?> <DongFang>   <Company>     <cNname>1</cNname>     <cIP>1</cIP>   </Company>   <Company>

javascript中XMLDOM和parseXML解析xml实现代码

通常我们有如下的需求: 第一步: 我们可以定义一个方法:(只用有人调用,就直接返回解析器)    代码如下 复制代码 function parseXML(file){    try //Internet Explorer---ie浏览器的解析器创建方式如下:    {     xmlDoc = new ActiveXObject("Microsoft.XMLDOM");    }    catch (e) {     try //Firefox, Mozilla, Opera, etc

Javascript中Ajax JSON编码解析笔记

Ajax 请求返回的 JSON 数据,通过 JSON.parse 或 jQuery 提供的 parseJSON 解析后,就可以当成 JavaScript 对象处理:  代码如下 复制代码 $.get('http://www.111cn.net/ json', function(data) {     var response = JSON.parse(data);     console.log(response.result); }); 当然,事情要比上面这种说法复杂一些,这是由 HTTP 响

JavaScript中的正则表达式解析

javascript|正则 正则表达式是一个描述字符模式的对象. JavaScript的RegExp对象和String对象定义了使用正则表达式来执行强大的模式匹配和文本检索与替换函数的方法. 在JavaScript中,正则表达式是由一个RegExp对象表示的.当然,可以使用一个RegExp()构造函数来创建RegExp对象,也可以用JavaScript 1.2中的新添加的一个特殊语法来创建RegExp对象.就像字符串直接量被定义为包含在引号内的字符一样,正则表达式直接量也被定义为包含在一对斜杠(

JavaScript中Null与Undefined的区别解析

  这篇文章主要介绍了JavaScript中Null与Undefined的区别解析,本文给出了多个代码实例讲解它们之间的区别,需要的朋友可以参考下 在JavaScript中存在这样两种原始类型:Null与Undefined.这两种类型常常会使JavaScript的开发人员产生疑惑,在什么时候是Null,什么时候又是Undefined? Undefined类型只有一个值,即undefined.当声明的变量还未被初始化时,变量的默认值为undefined. Null类型也只有一个值,即null.nu

解析JavaScript中instanceof对于不同的构造器或许都返回true

 这篇文章主要是对JavaScript中instanceof对于不同的构造器或许都返回true进行了详细的解析,需要的朋友可以过来参考下,希望对大家有所帮助 我们知道 instanceof 运算符用来检查对象是否为某构造器的实例.下面列举它返回true的各种情景.   1.对象obj是通过new Constructor创建的,那么 obj instanceof Constructor 为true     代码如下: function Person(n, a) {      this.name =

JavaScript中原型链存在的问题解析_javascript技巧

我们知道使用原型链实现继承是一个goodway:)看个原型链继承的例子. function A () { this.abc = 44; } A.prototype.getAbc = function (){ return this.abc; }; function B() { } B.prototype = new A(); // B通过A的实例完成了继承,形成了原型链(B的原型就是A的实例) var b = new B(); b.getAbc(); 关系如下:b(实例) ->B.prototy

全面解析JavaScript中“&amp;&amp;”和“||”操作符(总结篇)_javascript技巧

1.||(逻辑或), 从字面上来说,只有前后都是false的时候才返回false,否则返回true. alert(true||false); // true alert(false||true); // true alert(true||true); // true alert(false||false); // false 这个傻子都知道~~ 但是,从深层意义上来说的话,却有另一番天地,试下面代码 alert(0||1);//1 显然,我们知道,前面0意味着false,而后面1意味着true,

JavaScript中的正则表达式解析_正则表达式

JavaScript中的正则表达式解析 正则表达式(regular expression)对象包含一个正则表达式模式(pattern).它具有用正则表达式模式去匹配或代替一个字符串(string)中特定字符(或字符集合)的属性(properties)和方法(methods).要为一个单独的正则表达式添加属性,可以使用正则表达式构造函数(constructor function),无论何时被调用的预设置的正则表达式拥有静态的属性(the predefined RegExp object has s