实现call

  1. call 会立即调用函数
  2. 第一个参数是指定对象，后面的都是传入的参数
  3. 如果第一个参数传入 undefined、null 会指向window
  1. Function.prototype.myCall = function (thisArg, ...args) {
  2.   const fn = this
  4.   thisArg = thisArg !== undefined && thisArg !== null ? Object(thisArg) : window
  6.   thisArg.fn = fn
  7.   const result = thisArg.fn(...args)
  8.   delete thisArg.fn
  10.   return result
  11. }
  13. function sum(num1, num2) {
  14.   console.log(this)
  15.   return num1 + num2
  16. }
  18. const res = sum.myCall('123', 20, 30)
  19. console.log(res)

实现apply

  1. apply 会立即调用函数
  2. 第一个参数是指定对象，传参是以数组的方式
  3. 如果第一个参数传入 undefined、null 会指向window
  1. Function.prototype.myApply = function (thisArg, arrArg) {
  3.     const fn = this
  5.     thisArg = (thisArg !== undefined && thisArg != null) ? Object(thisArg) : window
  7.     thisArg.fn = fn
  8.     arrArg = arrArg || []
  9.     const res = thisArg.fn(...arrArg)
  10.     delete thisArg.fn
  11.     return res
  12. }
  14. function sum(num1, num2) {
  15.     return num1 + num2
  16. }
  18. const res = sum.myApply("123", [20, 30])
  19. console.log(res);

实现bind

  1. 不会立即调用函数，会返回一个变更后的函数
  2. 第一个参数是指定对象，后面的都是传入的参数
  3. 如果第一个参数传入 undefined、null 会指向window
  4. 可以分开传参，const foo = bind(this,1,2);foo(3,4)
  1. Function.prototype.myBind = function (thisArg, ...arrArgs) {
  2.     const fn = this
  3.     thisArg = (thisArg !== null && thisArg !== undefined) ? Object(thisArg) : window
  5.     function proxyFn(...args) {
  6.         thisArg.fn = fn
  7.         const res = thisArg.fn(...arrArgs, ...args)
  8.         delete thisArg.fn
  9.         return res
  10.     }
  12.     return proxyFn
  14. }
  16. function foo(num1, num2) {
  17.     console.log(this);
  18.     console.log(num1, num2);
  19.     return num1 + num2
  20. }
  22. // foo.myBind("123", 10, 20)
  24. const bar = foo.myBind("123", 10, 20)
  25. console.log(bar());