这个笔记是自己练习时的记录，仅供参考
1.call
Function.prototype.mycall = function(context,...args){
//验证context是否存在，不存在指向window
let ctx = context || window;
//判断args是否存在,不存在赋值为空数组
args = args?args:[]
//在指定的上下文中加一个新的属性方法并将参数传递进去，最后执行
let func = Symbol(); // 确保这个属性是唯一的
ctx[func] = this; //将调用mycall的方法定义在ctx[func]上
let result = ctx[func](...args); //以对象形式调用this,这个时候方法的this指向ctx
delete ctx[func];//删除这个方法，避免对传入的对象造成污染，添加了这个方法
return result;
}
function a(...params){
console.log(this.scope+":"+params);
}
var b = {
scope:"bObject"
};
a.mycall(b,1,2);
a.call(b,1,2,3);
console.log(b);
执行结果：
result.png
2.apply
Function.prototype.myapply = function(context,args){
//验证context是否存在，不存在则绑定到window
let ctx = context || window;
//判断args是否为空
args = args ? args:[];
//声明一个唯一的值
let func =Symbol();
ctx[func] = this; // 将调用myapply的函数绑定到属性func上
let res = ctx[func](args); //这里func函数执行的this就在ctx上
delete ctx[func];
return res;
}
function testApply(params){
console.log(this.scope1+":"+params)
}
var c ={
scope1:"cObject"
};
testApply.myapply(c,[1,2,3]);
testApply.apply(c,[1,2,3]);
console.log(c);
执行结果：
result1.png
3.bind
Function.prototype.mybind = function (context, ...args) {
let ctx = context || window;
args = args ? args : [];
let func = this; // 这个this指的是调用mybind的函数，将它先存起来
//返回值是一个函数，这个函数的this已经指向了ctx
return function newFun(...newFunArgs) {
//当返回的这个函数作为构造函数的时候，进行原型继承
if (this instanceof newFun) {
return new func(...args, ...newFunArgs);
}
return func.myapply(ctx, [...args, ...newFunArgs]);
}
}
function a(...params) {
console.log(this.scope + ":" + params);
}
var b = {
scope: "bObject"
};
const z = a.mybind(b, 1, 2);
console.log(z);
//如果将bind后的新函数使用new，this会改变，
const w = new z();
console.log(w);
result2.png
