作者：
    作者：xl

    1. // call
    2. Function.prototype.myCall = function (context) {
    3.   // 获取参数
    4.   let args = [...arguments].slice(1);
    5.   // 保存调用结果
    6.   let result  = null;
    8.   // 判断 context 是否传入，如果未传入则设置为 window
    9.   context = context || window;
    10.   // 将函数设为对象的方法
    11.   context.fn = this;
    13.   // 调用函数
    14.   result = context.fn(...args);
    15.   // 属性删除
    16.   delete context.fn;
    17.   return result;
    18. }
    20. // apply
    21. Function.prototype.myApply = function (context) {
    22.   let result = null;
    23.   // 判断 context 是否传入，如果未传入则设置为 window
    24.   context = context || window;
    25.   // 将函数设为对象的方法
    26.   context.fn = this;
    27.   if (arguments[1]) {
    28.     result = context.fn(...arguments[1]);
    29.   } else {
    30.     result = context.fn();
    31.   }
    32.   // 属性删除
    33.   delete context.fn;
    34.   return result;
    35. }

    作者：奥兰度

    1. function myCall(fn, thisArg, ...args) {
    2.   if (typeof this !== "function") {
    3.     console.log("type error");
    4.   }
    5.   let res;
    6.   thisArg = thisArg || window;
    7.   thisArg.fn = fn;
    8.   result = thisArg.fn(...args);
    9.   delete thisArg.fn;
    10.   return result;
    11. };
    13. function myApply(fn, thisArg, argAry) {
    14.   if (typeof this !== "function") {
    15.     console.log("type error");
    16.   }
    17.   let res;
    18.   thisArg = thisArg || window;
    19.   thisArg.fn = fn;
    20.   result = thisArg.fn(argAry);
    21.   delete thisArg.fn;
    22.   return result;
    23. };

    作者：
    作者：安静

    1. Function.prototype.myCall = function (context, ...args) {
    2.   //这里默认不传就是给window,也可以用es6给参数设置默认参数
    3.   context = context || window
    4.   args = args ? args : []
    5.   //给context新增一个独一无二的属性以免覆盖原有属性
    6.   const key = Symbol()
    7.   context[key] = this
    8.   //通过隐式绑定的方式调用函数
    9.   const result = context[key](...args)
    10.   //删除添加的属性
    11.   delete context[key]
    12.   //返回函数调用的返回值
    13.   return result
    14. }
    16. Function.prototype.myApply = function (context, array) {
    17.   //这里默认不传就是给window,也可以用es6给参数设置默认参数
    18.   context = context || window
    19.   args = array ? array : []
    20.   //给context新增一个独一无二的属性以免覆盖原有属性
    21.   const key = Symbol()
    22.   context[key] = this
    23.   //通过隐式绑定的方式调用函数
    24.   const result = context[key](...args)
    25.   //删除添加的属性
    26.   delete context[key]
    27.   //返回函数调用的返回值
    28.   return result
    29. }
    31. function a (...args) {
    32.   console.log(args);
    33.   console.log(this.name);
    34. }
    36. a.myApply({name: 'zhangsan'}, [1,2,3])

    作者：
    作者：