let name = 'window'

function getName(param1, param2) {
  console.log(this.name)
  console.log(param1, param2)
}
let obj = {
  name: 'easylee',
}
getName.call(obj, 123, 23)
getName.apply(obj, [123, 23])

Function.prototype.myCall = function (context, ...args) {
  // 判斷調(diào)用myCall的是否為函數(shù)
  if (typeof this !== 'function') {
    throw new TypeError('Function.prototype.myCall - 被調(diào)用的對象必須是函數(shù)')
  }
  // 判斷是否傳入上下文對象,不傳入則指定默認全局對象
  context = context || (typeof global !== 'undefined' ? gloabl : typeof window !== 'undefined' ? window : undefined)

  // 在上下文對象上綁定當前調(diào)用的函數(shù),作為屬性方法
  // 不能直接調(diào)用this方法函數(shù),原因在于如果不將這個方法綁定到上下文對象上
  // 直接執(zhí)行this函數(shù),this函數(shù)里面的this上下文對象無法識別為綁定的對象
  let fn = Symbol('key')
  context[fn] = this
  const result = context[fn](...args)
  // 刪除這個函數(shù),避免對上下文對象造成影響
  delete context[fn]
  return result
}
const test = {
  name: 'xxx',
  hello: function () {
    console.log(`hello,${this.name}!`)
  },
  add: function (a, b) {
    return a + b
  },
}
const obj = { name: 'world' }
test.hello.myCall(obj) //hello,world!
test.hello.call(obj) //hello,world!
console.log(test.add.myCall(null, 1, 2)) //3
console.log(test.add.call(null, 1, 2)) //3

Function.prototype.myApply = function (context, argsArr) {
  // 判斷調(diào)用myApply的是否為函數(shù)
  if (typeof this !== "function") {
    throw new TypeError("Function.prototype.myApply - 被調(diào)用的對象必須是函數(shù)");
  }

  // 判斷傳入的參數(shù)是否為數(shù)組
  if (argsArr && !Array.isArray(argsArr)) {
    throw new TypeError("Function.prototype.myApply - 第二個參數(shù)必須是數(shù)組");
  }

  // 如果沒有傳入上下文對象，則默認為全局對象
  //global:nodejs的全局對象
  //window:瀏覽器的全局對象
  context =
    context ||
    (typeof global !== "undefined"
      ? global
      : typeof window !== "undefined"
      ? window
      : undefined);

  // 用Symbol來創(chuàng)建唯一的fn，防止名字沖突
  let fn = Symbol("key");

  // this是調(diào)用myApply的函數(shù)，將函數(shù)綁定到上下文對象的新屬性上
  context[fn] = this;

  // 傳入myApply的多個參數(shù)
  const result = Array.isArray(argsArr)
    ? context[fn](...argsArr)
    : context[fn]();

  // 將增加的fn方法刪除
  delete context[fn];

  return result;
};

// 測試一下
const test = {
  name: "xxx",
  hello: function () {
    console.log(`hello,${this.name}!`);
  },
};
const obj = { name: "world" };
test.hello.myApply(obj); //hello,world!
test.hello.apply(obj); //hello,world!
const arr = [2,3,6,5,1,7,9,5,0]
console.log(Math.max.myApply(null,arr));//9
console.log(Math.max.apply(null,arr));//9

let name = 'window'
function getName(param1, param2) {
  console.log(this.name)
  console.log(param1)
  console.log(param2)
}
let obj = {
  name: 'easylee',
}

let fn = getName.bind(obj, 123, 234)	// 通過綁定創(chuàng)建一個新函數(shù)，然后再調(diào)用新函數(shù)
fn()

let sum = (x, y) => x + y
let succ = sum.bind(null, 1) // 綁定時沒有指定對象,但是給函數(shù)的第一個參數(shù)指定為1
succ(2) // 3, 調(diào)用時只傳遞了一個參數(shù)2,會直接對應到y(tǒng),因為前面的1已經(jīng)綁定到x上了

Function.prototype.myBind = function (context, ...args) {
  // 判斷調(diào)用myBind的是否為函數(shù)
  if (typeof this !== "function") {
    throw new TypeError("Function.prototype.myBind - 被調(diào)用的對象必須是函數(shù)");
  }

  // 如果沒有傳入上下文對象，則默認為全局對象
  //global:nodejs的全局對象
  //window:瀏覽器的全局對象
 context =
    context || (typeof global !== "undefined"
      ? global
      : typeof window !== "undefined"
      ? window
      : undefined);

  // 保存原始函數(shù)的引用，this就是要綁定的函數(shù)
  const _this = this;

  // 返回一個新的函數(shù)作為綁定函數(shù)
  return function fn(...innerArgs) {
    // 判斷返回出去的函數(shù)有沒有被new
    if (this instanceof fn) {
      return new _this(...args, ...innerArgs);
    }
    // 使用apply方法將原函數(shù)綁定到指定的上下文對象上
    return _this.apply(context,args.concat(innerArgs));
  };
};

// 測試
const test = {
  name: "xxx",
  hello: function (a,b,c) {
    console.log(`hello,${this.name}!`,a+b+c);
  },
};
const obj = { name: "world" };
let hello1 = test.hello.myBind(obj,1);
let hello2 = test.hello.bind(obj,1); 
hello1(2,3)//hello,world! 6
hello2(2,3)//hello,world! 6
console.log(new hello1(2,3));
//hello,undefined! 6
// hello {}
console.log(new hello2(2,3));
//hello,undefined! 6
// hello {}