柯理化函数之简单封装call/bind方法

柯理化函数编程思想是一种预先处理的思想。主要是利用闭包的保存、保护的功能，保存私有上下文中的一些信息，供其下级上下文中调取使用，也就是我们把一些信息先预先保存下来，后期让其下级上下文使用。常见使用场景：大函数执行返回小函数。

闭包

当一个函数执行时，形成了一个私有作用域，保护里面的私有变量不受外界的干扰，这种机制就叫做闭包。大部分人口中的闭包是当一个函数执行的时候，里面有一个引用数据类型被外界占用了，形成了不销毁作用域。一说闭包是指有权访问另一个函数作用域中的变量的函数。而创建闭包的常见方式，就是在一个函数内部创建另一个函数。

let a=100;
function fn(){
    // a={};//不销毁
    return {};
}
let res=fn();//不销毁

封装call

function fn(){
    console.log(this);
    return 100;
}
let obj={name:100};
// call 核心
// obj.$fn=fn;
// obj.$fn();
// delete obj.$fn;

// fn.call(obj);
Function.prototype.myCall=function(context,...arg){
    //this->fn context->obj
    //当call执行的时候如果用户不传参，或者传null/undefined那fn函数的this指向都是window(非严格模式)
    context=context || window;
    let res=null;
    context.$fn=this;
    res=context.$fn(...arg);
    delete context.$fn;
    return res;
}
let res=fn.myCall(obj,1,2,3);
console.log(res);
console.log(obj);

封装bind

bind是预先处理函数的this指向，并不会让fn函数马上执行，而是bind函数的返回值是一个新的函数，当这个新的函数执行的时候会让fn执行，并且把fn的this指向你之前传递的第一个实参

// box.οnclick=ss.call(obj);//undefined
// box.οnclick=ss.bind(obj);
// function ss(){}

function fn(...arg){
    console.log(this);
    console.log(...arg);
    return 100;
}
let obj={ss:100};
Function.prototype.myBind=function(context,...arg1){
    //this->fn context->obj
    //bind函数执行形成不销毁的作用域，可以保护里边的变量不受外界干扰，还可以让变量一直存在，这样fn和context就一直被保存下来了
    //当以后bind返回的函数执行的时候，就可以拿到fn和context
    //所以bind返回的函数里做的就是call做的事
    let _this=this;
    return function(...arg2){
        // _this();
        return _this.call(context,...arg1,...arg2);//fn.call(obj)
    }
}
let res=fn.myBind(obj,1,2);//bind执行会返回一个新的函数，以后执行这个新函数的时候，在新函数内部会让fn执行
let res1=res(3,4);
console.log(res1);
//当前这种利用闭包的机制编程的思想就是柯理化函数编程思想

// Function.prototype();//undefined//Function的原型是一个函数，没有返回值