This指向问题

小婉子啊
1,068 阅读6分钟

image.png

This指向问题

this指向什么，跟函数所处得位置是没有关系的

跟函数得调用者有关系

在严格模式下，与调用位置无关

独立函数调用

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

首先this指向全局，所以a被解析成了全局变量，且在代码中foo()是直接使用不带任何修饰的函数引用进行调用的，所以只能使用默认绑定

隐式绑定

调用位置是否有上下文对象，或者是否被某个对象拥有或者包含

function foo() {
 console.log(this.a);
}
 var obj = {
  a:2,
  foo:foo//取别名
 };
 obj.foo();//2

注意foo()的声明方式，被当作引用属性添加到obj中，但是不管是直接在obj中定义还是被当作引用属性，这个函数严格来说都不属于obj对象

调用位置会使用obj上下文来引用函数，也就是说函数被调用时obj对象拥有或者包含他

当foo()被调用时-->obj对象

即函数引用有上下文对象时-->this绑定到这个上下文对象

用foo()时this被绑定到obj,和this.a和this.b是一样的

我们必须在一个函数内部包含一个指向函数得属性，并通过这个属性间接引用函数，从而把this间接（隐式）绑定到这个对象上

显示绑定

在某个对象上强制调用函数，而不想在对象内部包含引用函数 call() apply() 

两个方法得工作原理：他的第一个参数是一个对象，他们会把这个对象绑定到this，接着再调用这个this。这个可以直接指定this对象，所以我们称之为显示绑定

function foo(){
 console.log( this.a )
}
 var obj = {
  a:2
 };
 foo.call(obj);//2
硬绑定：
function foo() {
 console.log(this.a)
}
var obj = {
 a:2
};
var bar = function() {
  foo.call( obj )
}
 bar();//2
 setTimeout(bar,100);//2
 //硬绑定的bar不可能再修改它的this
 bar.call(window);//2

在创建的bar()中手动调用foo.call(obj),即把foo中的this强制绑定到了obj，之后不管如何调用bar,他总会手动在obj上调用foo

硬绑定典型案例包裹函数

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

硬绑定典型案例，创建i 可以重复使用的辅助函数

function foo(something) {
    console.log( this.a, something );
    return this.a + something;
}
// 简单的辅助绑定函数
  function bind(fn, obj) {
    return function() {
    return fn.apply( obj, arguments );
};
}
    var obj = {
    a:2
};
    var bar = bind( foo, obj );
    var b = bar( 3 ); // 2 3
    console.log( b ); // 5
​

new绑定

在javascript中，构造函数只是使用new操作符时被调用的函数，并不属于某个类，也不会实例化一个类，甚至不能说是一种那个特殊的函数类型，他们只是被new操作符调用的普通函数而已。

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

  1. 创建（或者说构造）一个全新的对象
  2. 这个对象会被执行[[原型]]连接
  3. 这个新对象会绑定到函数调用的this
  4. 如果函数没有返回其他对象，那么new表达式中得 函数调用会自动返回这个新对象
function foo(a){
  this.a=a
}
 var bar = new foo(2);
 console.log(bar.a)//2

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

我们通过new关键字调用一个函数时（构造器），这个时候this是在调用这个构造器时创建出来得对象

this=创建出来得对象

这个绑定过程就是new绑定

优先级

显示绑定和隐式绑定同时存在时，显示绑定得优先级大于隐式绑定

硬绑定高于new绑定

new绑定高于隐式绑定

总结判断this

  1. new绑定--------->this指向新创建得对象(var bar = new foo())
  2. call,apply(显示绑定)---------->this指向指向的对象(var bar = foo.call(obj2))
  3. 在某个上下文对象中调用(隐式绑定)----------->this绑定上下文对象(var bar = obj1.foo())
  4. 以上都不是，使用默认绑定，在严格模式下绑定到undefined,否则绑定到全局对象(var bar = foo())

this词法

箭头函数不使用this得四种规则，根据外层或者全局作用域来解决

也就是说箭头函数会继承外层函数调用得this绑定（无论this绑定到什么，这其实和ES6之前得代码self=this机制一样）

箭头函数不绑定this

不绑定作用域，上层作用域是window

()独立调用，就一个空括号，this指向window

var _this = this原因
var  obj = {
data:[],
getData: function(){
  //发送网络请求，将结果放到上面data属性中
  //var _this=this
  setTimeout(function(){
  //setTimeout里面的this是window
    var result = ["abc","cba","nba"]
    _this.data=result//obj.data=result
  },2000)
  
  
  法二：在箭头函数中这样写
  setTimeout(()=>{
  var result = ["abc","cba","nba"]
  this.data = result
  },2000)
  
  
  }
}
obj.getData()

下面的getData()是一个隐式绑定 this是obj ， _this引用外层函数，是个闭包，也就是 _this就是this，不这样得话，里面的this指向window

setTimeout()的回调函数里面的this默认指向window对象，并不是undefined

因为this指向的是window所以想把他绑定到obj上，用隐式绑定，绑定上下文对象，通过那个var _this=this，还有一种方法就是箭头函数，因为箭头函数不遵循this的四种规则，箭头函数相当于不绑定this，所以直接去他的上层作用域中查找，也就是getData中的this,而getData中的this是通过obj来调用的，也就是隐式绑定到了obj对象上

面试题

var person1 = {
  name:'person1',
  foo1:function(){
  console.log(this.name)
  },
  foo2:()=> console.log(this.name),
  foo3:function (){
  return function(){
  console.log(this.name)
  }
  },
  foo4:function(){
  return()=>{
  console.log(this.name)
  }
  }
}
var person2 = {
  name:'person2'
}
​
//问题
person1.foo1();//person1    隐式调用
person1.foo1.call(person2);//person2   显式调用
​
person1.foo2(); //window     不绑定作用域，上层作用域是全局
person1.foo2.call(person2); //window
​
person1.foo3()();//window     独立函数调用
person1.foo3.call(person2)();//window     独立函数调用
person1.foo3().call(person2)//person2    最终是调用返回函数，使用的是显示绑定
​
person1.foo4()();//person1   箭头函数不绑定this ,上层作用域是person1
person1.foo4.call(person2)();//person2     上层作用域被显示绑定了一个person2
person1.foo4().call(person2)//person1   上层找到person1

var name ="window"
​
var person ={
  name:"person",
  sayName:function(){
  console.log(this.name)
  }
};
functionsayName(){
var sss= person.sayName;
sss();//window    独立函数调用
person.sayName();//person   隐式调用
(person.satname)();//person    隐式调用
(b=person.sayName)();//window    数值表达式（独立函数调用）     赋值表达式把值赋值给b，间接函数引用，属于独立函数调用，特殊在有个数值表达式，把整个结果赋值给b再进行打印，不建议开发中写
}

和我交流

image.png

avatar
文章
阅读
粉丝