Call, Apply, Bind

Function.prototype.myCall = function(obj, ...args) {
  // 1.判断参数合法性
  if (obj === null || obj === undefined) {
    //指定为 null 和 undefined 的 this 值会自动指向全局对象(浏览器中为window)
    obj = window;
  } else {
    obj = Object(obj);//创建一个可包含数字/字符串/布尔值的对象
  }

  // 2.搞定this的指向

  //利用Symbol()创建一个不重复的常量,以免覆盖obj原有的属性
  const specialMethod = Symbol(); 
  // 如果调用myCall的函数名是func，即以func.myCall()形式调用；
  // 那么myCall函数体内的this指向func

  //给obj对象建一个临时属性来储存this（也即func函数）
  obj[specialMethod] = this; 
  // func作为obj对象的一个方法被调用，那么func中的this指向obj对象
  let result = obj[specialMethod](...args);
  //3.收尾
  delete obj[specialMethod]; //删除临时方法
  return result; //返回临时方法的执行结果
};

let obj = {
  name: "hello"
};

function func() {
  console.log(this.name);
}

func.myCall(obj);//>> hello

let arrayLike = {
    0: 1,
    1: 2,
    2: 3,
    length: 3
};

Function.prototype.myApply = function(obj) {
  if (obj === null || obj === undefined) {
    obj = window;
  } else {
    obj = Object(obj);
  }

  //判断是否为【类数组对象】
  function isArrayLike(o) {
    if (
      o && // o不是null、undefined等
      typeof o === "object" && // o是对象
      isFinite(o.length) && // o.length是有限数值
      o.length >= 0 && // o.length为非负值
      o.length === Math.floor(o.length) && // o.length是整数
      o.length < 2**32  // o.length < 2^32
    ) return true;
    else return false;
  }

  const specialMethod = Symbol();
  obj[specialMethod] = this;
  // 获取第二个参数，即数组（或类数组）
  let args = arguments[1];
  let result;

  // 处理传进来的第二个参数
  if (args) {
    // 是否传递第二个参数
    if (!Array.isArray(args) && !isArrayLike(args)) {
      throw new TypeError(
        "第二个参数既不是数组，也不是类数组对象。抛出错误"
      );
    } else {
      // 转为数组
      args = Array.from(args); 

      // 执行函数并展开数组，传递函数参数
      result = obj[specialMethod](...args);
    }
  } else {
    result = obj[specialMethod]();
  }

  delete obj[specialMethod];
  return result; // 返回函数执行结果
};

Function.prototype.myBind = function (obj, ...params) {
    // 调用myBind()的对象不是函数，则抛出异常
    if (typeof this !== "function") {
        throw new TypeError(
            "Function.prototype.bind was called on which is not a function"
        );
    }
    const tempFn = this; //用一个变量临时存储原函数，以及函数参数(上方的params)
    //对返回的新函数 secondParams 二次传参
    let copiedFunc = function (...secondParams) {
        // 若是new调用的，原函数this指向新函数中创建的实例对象
        // 若不是new调用，依然是调用myBind时，传递的第一个参数
        const isNew = this instanceof copiedFunc;

        //new调用就绑定到this上,否则就绑定到传入的obj上
        const thisArg = isNew ? this : Object(obj);

        // 用call调用临时存储的原函数，绑定this的指向，并传递参数，返回执行结果。
        return tempFn.call(thisArg, ...params, ...secondParams);
    };

    //通过Object.create，以原函数prototype为原型，创建新对象。
    //使新函数继承原函数原型上的属性
    copiedFunc.prototype = Object.create(tempFn.prototype);
    return copiedFunc;//返回拷贝的函数
};

function func(name){
    console.log(this); // {a: 1}
    this.name = name;
}

func.prototype.hello = function(){
    console.log(this.name); // undefined
}


let newFunc = func.myBind({a:1});
let o = new newFunc('lily');

o.hello();
// 打印：{name:'lily'}
// 打印：'lily'