一网打尽this，对执行上下文说Yes

本文主要是介绍一网打尽this，对执行上下文说Yes，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

	**话不多说，直接上**

1：全局中的this

function fn(){console.log(this)
}
function fn2(){"use strict"console.log(this)
}
fn()  // window
fn2()   // undefined

结论：正常情况下，全局this都是指向window，而在严格模式下this指向undefined

2对象中的this

const foo = {bar: 10,fn: function () {console.log(this)console.log(this.bar)}
}
let fn1 = foo.fn()
fn1()
两个log会分别打印 window 和 undefined
结论：foo.fn()情况下this指向foo。而把它赋值给一个全局变量fn1时，那this就会指向window************************************分割*********************************稍作改动一下：
const foo = {bar: 10,fn: function () {console.log(this)console.log(this.bar)}
}
foo.fn()
两个log会分别打印 {bar:10, fn()} 和 10

3上下文中this

const student = {name: '张三',fn: function () {return this}
}
console.log(student.fn() === student)    // true
return之后，指向一样了************************************分割*********************************const student = {name: '张三',person:{name:'李四',fn: function (){return this.name}}
}
console.log(student.person.name)    // 李四在嵌套关系中，this也指向最后一个调用者。return之后this指向person************************************分割*********************************好，下面请猜一下 下面代码运行结果const one = {text: 'one',fn: function(){return this.text}
}const two = {text: 'two',fn: function(){return one.fn()}
}const three = {text: 'three',fn: function(){let fn = one.fnreturn fn()}
}console.log(one.fn())   // one
console.log(two.fn())   // one
console.log(three.fn())  // undefined第一个最简单，不再解释
第二个 tow.fn()的最终调用还是 one.fn() ，因此结果也依然是 one
第三个 采用了let fn = one.fn的赋值进行了"裸奔"调用，
因此这里的this指向了window，全局中没有.text，所以是undefined************************************分割*********************************const obj = {text: 'obj',fn: function(){return this.text}
}const obj2 = {text: 'obj2',fn: obj.fn
}
console.log(obj2.fn())   // obj2最后打印时将fn()挂载到obj2上，所以this也指向了obj2

4通过bind，apply，call改变this

用代码总结，下面三段代码可以说是等价的call / apply / bind 他们会将调用他们对象的this指向参数const target = {fn.call(taiget, 'alg1','alg2')
}const target = {fn.apply(target, ['alg1', 'alg2']
}const target = {fn.bind(target, 'alg1', 'alg2')
}************************************分割*********************************const foo = {name:'张三',fn: function (){console.log(this.name)}
}const bar = {name: '李四'
}
console.log(foo.fn.call(bar))      // 李四

5构造函数中的this

function Foo(){this.bar = '张三'
}
let obj = new Foo()
console.log(obj.bar)     // 张三关于new操作符做了什么
1：创建一个对象
2：将构造函数的this指向该对象
3：为这个对象添加属性和方法
4：返回这个对象
也可以用代码表示let obj = {}
obj.__proto__ = Foo.prototype
Foo.call(obj)************************************分割*********************************构造函数中出现return时1:
function Foo(){this.user = '张三'const obj = {}return obj
}
const inst = new Foo()
console.log(inst.user)     // undefined
因为 return的是obj空对象2:
function Foo(){this.user = '张三',return 1
}
const inst = new Foo()
console.log(inst.user)    // 张三当return一个值，或者是一个对象（复杂类型），那this就指向返回的这个对象
如果是基本类型，this仍然指向实例

6箭头函数中的this

*箭头函数中，this的指向由外层（函数/全局）作用域决定*const foo = {fn: function(){/*window.*/setTimeout(function(){console.log(this)  // window})}
}
foo.fn() const foo = {fn: function(){setTimeout(()=>{console.log(this)     // foo})}
}
foo.fn()单纯的this指向就很简单，如果综合所有情况并结合this优先级，就很难搞了

7this优先级

当把call，apply，bind，new 对this绑定成为显示绑定
而根据调用关系确定this指向的情况称为隐士绑定上代码function foo(a){console.log(this.a)
}const obj1 = {a: 1,foo: foo
}const obj2 = {a: 2,foo: foo
}obj1.foo.call(obj2)     // 2
obj2.foo.call(obj1)     // 1可见 call apply 的显示绑定，一般情况下优先级较高************************************分割*********************************function foo(a){this.a = a
}
const obj1 = {}
let bar = foo.bind(obj1)
bar(2)
console.log(obj1.a)      //2foo使用bind将this指向了obj1，而后又赋值给了bar，并修改值为2. 织自然打印值为2结合上面代码let bar2 = new bar(3)
console.log(bar2.a)     // 3bar是通过bind方法构造的函数，this指向了obj1。
当它再次当做构造函数通过new调用时，返回的实例会和obj1解绑。
也就是new的绑定修改了bind绑定中this的指向。new比bind优先级高************************************分割*********************************function foo(){return a => {console.log(this.a)}
}
const obj1 = {a: 2
}
const obj2 = {a: 3
}
const bar = foo.call(obj1)    
console.log(bar.call(obj2))    // 2为什么是2呢？foo中的this绑定到了obj1上。所以bar引用的就是箭头函数中的this了，而这个this也绑定到了obj1上
但是箭头函数中的绑定是不能被修改的  （还不理解的可以百度一下详细）如果写成这样let a = 123
const foo = () => a => {console.log(this.a)
}
const obj1 = {a: 2
}
const obj2 = {a: 3
}
const bar = foo.call(obj1)    
console.log(bar.call(obj2))    // 123但如果把 let a = 123  改成   const a = 123   想一下会怎么样当const声明的常量时，不会挂载到window全局对象上。自然this指向window，也找不到挂载不了window上的const

8例题，实现一个bind函数

this的指向涉及的规范繁多，优先级也很混乱面试时，被故意刁难很难脱颖而出这里一个典型的题目： 实现一个bind函数Function.prototype.bind = Function.prototype.bind || function(context){let that = thislet args = Array.prototype.slice.call(arguments, 1)return function bound(){let innerArgs = Array.prototype.slice.call(arguments)let finalArgs = args.concat(innerArgs)return that.apply(context, finalArgs)}
}这样的实现较为很好，相比之前在this优先级分析那里展示的规则： bind返回的函数如果作
为构造函数new关键字的话。绑定的this就会被 ‘忽略’为实现这样规则，只需考虑两种调用方式。 在bound函数中进行this.instanceof判断另一个细节是 函数又length属性，表示形参个数。上面代码中形参的个数显然会失真。
改进实现方式就是对length属性进行还原，难点也在于length属性值是不可重写的这一般属于‘超纲’内容！

害~
漏了一块
就在这里补齐了function setName(obj){obj.name = '张三'obj = new Object()obj.name = '李四'
}
let person = new Object()
setName(person)
console.log(person.name)    // 张三看似没有this至于打印的是张三，就是因为obj在函数内部重写之后，变成了指向本地的指针，会随着函数执行完毕而销毁

这篇关于一网打尽this，对执行上下文说Yes的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！

---