// 1
function test(){
    const name = ‘test1‘;
    console.log(this.name)
}
constname = ‘test2‘
test() // test2
// 当前函数调用指向了window，所以打印的为test2

// 2
var obj = {
    name:‘test1‘,
    get(){
        console.log(this.name)
    }
}
var name = ‘test2‘;
obj.get() // test1
// 当前通过对象调用。this指向obj，打印test1

// 3
var obj = {
    name:‘test1‘,
    get(){
        console.log(this.name)
    }
}
var name = ‘test2‘;
var fn = obj.get;
fn() // test2
// 将obj.get作为值赋值给fn，执行fn，这时候相当于通过函数执行，this重新指向

Function.prototype.myCall = function(thisArg, ...argumentArr){
    if(typeof this !== ‘function‘) {
        throw new TypeError(`${this} is not function`)
    };
    if(thisArg === undefined || thisArg === null){
        thisArg = window;
    }
　　//生成一个对象
    var obj = Object.create(thisArg)
    obj[‘fn‘] = this;
　　// 通过对象执行函数将this指向该对象
    var result = obj[‘fn‘](...argumentArr)
    delete obj[‘fn‘];
    return result
}

var obj = {
    name:‘test1‘,
    get(data1, data2){
        console.log(this.name, data1, data2)
    }
}
obj.get.myCall({name: ‘test2‘}, 1, 2, 3) // test2,1,2

// 原理就是通过传入的新的对象来执行这个函数，就是通过对象调用函数的方式

Function.prototype.myApply = function(thisArg, argumentArr){
    if(typeof this !== ‘function‘) {
        throw new TypeError(`${this} is not function`)
    };
    if(thisArg === undefined || thisArg === null){
        thisArg = window;
    }
    if(argumentArr === undefined || argumentArr === null){
        argumentArr = []
    }
    var obj = Object.create(thisArg)
    obj[‘fn‘] = this;
    var result = obj[‘fn‘](...argumentArr)
    delete obj[‘fn‘];
    return result
}

var obj = {
    name:‘test1‘,
    get(data1, data2){
        console.log(this.name, data1, data2)
    }
}
obj.get.myApply({name: ‘test2‘}, [1, 2, 3]) // test2,1,2

// 我们发现与call唯一的不同就是入参，call使用rest 参数，将多余的参数整合成argument形式，而apply入参直接是数组

Function.prototype.myBind = function(thisArg, ...argumentArr){
    if(typeof this !== ‘function‘) {
        throw new TypeError(`${this} is not function`)
    };
    if(thisArg === undefined || thisArg === null){
        thisArg = window;
    }
    var self = this
    var bindfn = function(){
        return self.call(thisArg, ...argumentArr)
    }
    bindfn.prototype = self.prototype
    return bindfn
}

var obj = {
    name:‘test1‘,
    get(data1, data2){
        console.log(this.name, data1, data2)
    }
}
const fn = obj.get.myBind({name: ‘test2‘}, 1, 2, 3)
fn() //  test2,1,2

// 相比于前两个bind会有不一样，bind使用到了闭包，
// 我们之前知道函数执行this是指向window，但是这里我们执行却指向了我们的目标对象，实现这样的方式就是闭包