Implementation of call, apply and bind

call

call Method is using a specified this A function or method is called before a value and several specified parameter values

var obj = {
    value:'vortestnail',
};

function fn(){
    console.log(this.value);
}


fn.call(obj);   //vortestnail

  adopt call Methods we have achieved the following two points :

1.call change this The direction of , Point to obj

2.fn The function executes

Write by yourself call Method

Function.prototype.mycall = function(context){
    // Judge the calling object 
    if(typeof this !== "function"){
        throw new Error("Type error")
    }
    // First get the parameters 
    let args = [...arguments].slice(1);
    let result = null;
    // Judge context Whether to introduce , If there is no transmission, it is set to window
    context = context || window;
    
    // Set the called method to context Properties of 
    //this  That is, the method we want to call 
    context.fn = this;
    // Execute the method to be called 
    result = context.fn(...args);
    
    delete context.fn;
    // The execution result returns 
    return result;
}

apply 

We will call After the realization of ,apply It becomes very simple , They make no difference , In addition to the way of parameter transmission

Function.prototype.myApply = function(context){
    if(typeof this !== "function"){
        throw new Error("Type error");
        
    }

    let result = null;
    context = context || window;
    // Compared with the above code , We use Symbol To ensure that the attribute is unique 
    // That is to ensure that the user's original definition in... Will not be rewritten context Property with the same name in 
    
    const fnymbol = Symbol();
    context[fnSymbol] = this;
    // Implement the method to be transferred 
    if(argument[1]){
        result = context[fnSymbol](...argument[1]);
    }else{
        result = context[fnSymbol]
    }

    delete context[fnSymbol]();
    return result;

}

bind 

bind Returns a function

Function.prototype.myBind = function(context){
    // Determine whether the calling object is a function 
    if(typeof this !== "function"){
           throw new Error('Type error')
    }
    
// To obtain parameters 
    const args = [...arguments].slice(1),
    const fn = this;
    return function Fn(){
        return fn.apply(
            this instanceof Fn ? this:context,
            // The current one arguments Refer to Fn Parameters of 
            args.concat(...arguments)
        )
    }
}