Javascript之模拟实现

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

Function.prototype.myCall = function(context) {
  // 判断调用call的函数（也就是this）是否是函数
  if(typeof this === 'function') {
    throw new TypeError('Error')
  }
  context = context || window
  context.fn = this
  const args = [...argumments].slice(1)
  const result = context.fn(args)
  delete context.fn
  return result
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

Function.prototype.myApply = function(context) {
  if(typeof this === 'function') {
    throw new TypeError('Error')
  }
  context = context || window
  context.fn = this
  let result
  if(arguments[1]) {
    result = context.fn(arguments[1])
  } else {
    result = context.fn()
  }
  return result
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

Function.prototype.bind2 = function (context) {

    if (typeof this !== "function") {
      throw new Error("Function.prototype.bind - what is trying to be bound is not callable");
    }

    var self = this;
    var args = Array.prototype.slice.call(arguments, 1);

    var fNOP = function () {};

    var fBound = function () {
        var bindArgs = Array.prototype.slice.call(arguments);
        return self.apply(this instanceof fNOP ? this : context, args.concat(bindArgs));
    }

    fNOP.prototype = this.prototype;
    fBound.prototype = new fNOP();
    return fBound;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

function myNew() {
  let obj = {}
  // shift会改变原数组，所以arguments第一个元素会被去除，后面直接使用
  let Contructor = [].shift.call(arguments)
  // 继承
  obj.__proto__ = Contructor.prototype
  // 绑定this
  let result = Contructor.apply(obj, arguments)
  return typeof result === 'object'? result : obj
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

function myInstanceof(left, right) {
  let prototype = right.prototype
  left = left.__proto__
  while(true) {
    if(left === null || left === underfined) {
      return false
    }
    if(left === prototype) {
      return true
    }
    left = left.__prototype__
  }
}