含义

既不指向函数本身，也不指向函数的词法作用域。
运行时动态绑定，并不是编写绑定，上下文取决于函数调用的各种条件。
指向取决于函数被调用的位置，也是在函数调用时候发生绑定。

解析

调用栈(可以比拟成函数调用链)

指到达当前执行位置所调用的所有函数
so调用位置(函数被调用的位置，而不是声明位置)就是当前执行函数的前一个调用


function foo() {
    // 当前调用栈 => foo
    // 当前调用位置 => global全局作用域
    
    console.log('foo')
    bar() // bar调用位置
}

function bar() {
    // 当前调用栈 => foo -> bar
    // 当前调用位置 foo
    
    console.log('bar')
}

绑定规则

默认 => 独立函数调用
- this默认绑定,指向全局对象
隐式 => 是否存在上下文 / 被某个对象拥有或包含
- 当函数引用存在上下文,this会被隐式绑定到这个上下文对象
- 对象属性引用链只对调用位置的(上一层 / 最后一层)有效
```
function foo() {
    return this.a
}

const obj = {
    a: 'hello',
    foo, // 函数引用,当前上下文是obj
}

obj.foo()
    
```

显式绑定 => call, apply, bind

硬绑定

function foo() {
    return this.a
}

const obj = {
    a: 'hello
}

const bar = function() {
    foo.call(obj) // 显式的强制绑定
}
setTimeout(bar, 300)
bar.call(window) // 2 => 硬绑定之后this无法再修改

new绑定 => 构造函数调用，实际上并不存在“构造函数”,是对函数的“构造调用”
- 创建(构造)一个全新的对象
- 这个对象会被执行[[Prototype]]连接
- 这个对象会绑定到函数调用的this
- 如果函数没有返回对象，直接返回这个新对象

注意点

隐式绑定会丢失绑定对象,从而应用默认绑定，分别有以下两种情况。

函数别名 => 引用函数本身,so默认绑定

function foo() {
    return this.a
}

const obj = {
    a: 'hello',
    foo, // 函数引用,当前上下文是obj
}

const a = 'on no, this is global'
const bar = obj.foo // 函数别名
bar() // 'on no, this is global'

参数传递 => 隐式赋值,同上

function foo() {
    return this.a
}

function doFoo(fn) {
    
    fn() // fn => foo
}

const obj = {
    a: 'hello',
    foo, // 函数引用,当前上下文是obj
}

const a = 'on no, this is global'
doFoo(obj.foo) // 'on no, this is global'

优先级

显式 > 隐式
new > 隐式

new可以修改显式的this

    function foo(some) {
        this.a = some
    }
    
    const obj = {}
    
    const bar =  foo.bind(obj)
    bar(2)
    console.log(obj.a) // 2
    
    const baz = new bar(3)
    console.log(obj.a) // 2
    console.log(baz.a) // 3 => new 修改了this绑定

new中使用硬绑定 => 函数柯理化

    function foo(a, b) {
        this.value = a + b
    }
    
    const bar = foo.bind(null, 'hello ') //这里 this不指定,new时会修改
    const baz = new bar('world')
    baz.value // 'hello world'