이 글에서는 코드 예제를 사용하여 호출, 적용 및 바인딩 구현 방법에 대한 심층 분석을 제공합니다. 이러한 메소드의 구체적인 사용법은 MDN 또는 사이트의 기사에 이미 명확하게 설명되어 있으므로 생략하겠습니다. 여기서 자세히 설명하지 마세요.
ES3 버전
Function.prototype.myCall = function(thisArg){ if(typeof this != 'function'){ throw new Error('The caller must be a function') } if(thisArg === undefined || thisArg === null){ thisArg = globalThis } else { thisArg = Object(thisArg) } var args = [] for(var i = 1;i < arguments.length;i ++){ args.push('arguments[' + i + ']') } thisArg.fn = this var res = eval('thisArg.fn(' + args + ')') delete thisArg.fn return res }
ES6 버전
Function.prototype.myCall = function(thisArg,...args){ if(typeof this != 'function'){ throw new Error('The caller must be a function') } if(thisArg === undefined || thisArg === null){ thisArg = globalThis } else { thisArg = Object(thisArg) } thisArg.fn = this const res = thisArg.fn(...args) delete thisArg.fn return res }
call
을 통해 함수를 호출할 때 에 전달할 수 있습니다. >call
의 thisArg는 함수에서 이를 지정합니다. 그리고 이는 우리의 주요 목표인 thisArg를 통해 함수가 호출되는 한 달성될 수 있습니다. call
调用函数的时候,可以通过传给 call
的 thisArg 指定函数中的 this。而只要使得函数是通过 thisArg 调用的,就能实现这一点,这就是我们的主要目标。
实现要点
最终是通过函数去调用 myCall
的,所以 myCall
和 call
一样挂载在函数原型上。同时,也正因为是通过函数去调用 myCall
的,所以在 myCall
内部我们可以通过 this 拿到 myCall
的调用者,也就是实际执行的那个函数。
按理说,myCall
是挂载在函数原型上,当我们通过一个非函数去调用 myCall
的时候,肯定会抛出错误,那么为什么还要在 myCall
中检查调用者的类型,并自定义一个错误呢?这是因为,当一个调用者 obj = {}
是一个对象,但是继承自 Function
的时候(obj.__proto__ = Function.prototype
),它作为一个非函数实际上也是可以调用 myCall
方法的,这时候如果不进行类型检查以确保它是个函数,那么后面直接将它当作函数调用的时候,就会抛出错误了
传给 call
的 thisArg 如果是 null 或者 undefined,那么 thisArg 实际上会指向全局对象;如果 thisArg 是一个基本类型,那么可以使用 Object()
做一个装箱操作,将其转化为一个对象 —— 主要是为了确保后续可以以方法调用的方式去执行函数。那么可不可以写成 thisArg = thisArg ? Object(thisArg) : globalThis
呢?其实是不可以的,如果 thisArg 是布尔值 false,那么会导致 thisArg 最终等于 globalThis,但实际上它应该等于 Boolean {false}
。
前面说过,可以在 myCall
里通过 this 拿到实际执行的那个函数,所以 thisArg.fn = this
相当于将这个函数作为 thisArg 的一个方法,后面我们就可以通过 thisArg 对象去调用这个函数了。
thisArg.fn = this
相当于是给 thisArg 增加了一个 fn 属性,所以返回执行结果之前要 delete 这个属性。此外,为了避免覆盖 thisArg 上可能存在的同名属性 fn,这里也可以使用 const fn = Symbol('fn')
构造一个唯一属性,然后 thisArg[fn] = this
。
ES3 版本和 ES6 版本主要的区别在于参数的传递以及函数的执行上:
ES6 因为引入了剩余参数,所以不管实际执行函数的时候传入了多少个参数,都可以通过 args 数组拿到这些参数,同时因为引入了展开运算符,所以可以展开 args 参数数组,把参数一个个传递给函数执行
但在 ES3 中没有剩余参数这个东西,所以在定义 myCall
的时候只接收一个 thisArg 参数,然后在函数体中通过 arguments 类数组拿到所有参数。我们需要的是 arguments 中除第一个元素(thisArg)之外的所有元素,怎么做呢?如果是 ES6,直接[...arguments].slice(1)
myCall
은 함수를 통해 호출되므로 myCall</code > <code>call
과 같은 함수 프로토타입에 탑재됩니다. 동시에 myCall
이 함수를 통해 호출되기 때문에 myCall
내부에서 이를 통해 myCall
의 호출자를 얻을 수 있습니다. 실제로 실행되는 함수입니다. myCall
이 함수 프로토타입에 탑재되어 있는 것은 당연합니다. 함수가 아닌 것을 통해 myCall
을 호출하면 오류가 발생합니다. ? 또한 myCall
에서 호출자의 유형을 확인하고 사용자 정의 오류를 정의하시겠습니까? 이는 호출자 obj = {}
가 객체이지만 Function
(obj.__proto__ = Function.prototype</code >)에서 상속받는 경우, 함수가 아닌 경우 실제로 <code>myCall
메서드를 호출할 수 있습니다. 이때 함수인지 확인하기 위한 유형 검사가 수행되지 않으면 나중에 함수로 직접 호출될 때 오류가 발생합니다call
에 전달된 thisArg가 null이거나 정의되지 않은 경우 thisArg는 실제로 전역 객체를 가리킵니다. thisArg가 기본 유형이면 Object는 Used()
는 박싱 작업을 수행하고 이를 개체로 변환합니다. 이는 주로 나중에 메서드 호출을 통해 함수가 실행될 수 있도록 보장하기 위한 것입니다. 그러면 thisArg = thisArg ? Object(thisArg) : globalThis
로 쓸 수 있나요? 실제로는 불가능합니다. thisArg가 부울 값 false인 경우 thisArg는 결국 globalThis와 같아지지만 실제로는 Boolean {false}
와 같아야 합니다. 🎜🎜🎜🎜앞서 언급한 것처럼 myCall
에서 this를 통해 실제로 실행되는 함수를 얻을 수 있으므로 thisArg.fn = this
는 이 함수를 thisArg A 메소드로 사용하는 것과 같습니다. , 나중에 thisArg 개체를 통해 이 함수를 호출할 수 있습니다. 🎜🎜🎜🎜thisArg.fn = this
는 thisArg에 fn 속성을 추가하는 것과 동일하므로 실행 결과를 반환하기 전에 이 속성을 삭제해야 합니다. 또한 thisArg에 존재할 수 있는 동일한 이름으로 fn 속성을 덮어쓰는 것을 방지하려면 const fn = Symbol('fn')
을 사용하여 고유한 속성을 구성한 다음 < 코드>thisArg[fn] = this< /code>. 🎜🎜🎜🎜ES3 버전과 ES6 버전의 주요 차이점은 매개변수 전달과 함수 실행입니다. 🎜myCall
을 정의할 때 thisArg 매개변수 하나만 받고, 함수 본문의 인수 클래스 배열을 통해 모든 매개변수를 가져옵니다. 우리에게 필요한 것은 첫 번째 요소(thisArg)를 제외한 인수의 모든 요소입니다. ES6이라면 [...arguments].slice(1)
만으로도 충분하지만 이는 ES3이므로 인덱스 1부터 시작하는 인수만 순회한 다음 이를 인수 배열. 여기에 푸시된 매개변수는 문자열 형식이라는 점에 유의해야 합니다. 이는 주로 나중에 eval을 통해 함수를 실행할 때 매개변수를 함수에 하나씩 전달하기 위한 것입니다. 🎜🎜🎜🎜함수를 실행하려면 왜 eval을 전달해야 하나요? 함수가 실제로 수신해야 하는 매개변수 수를 모르고 확장 연산자를 사용할 수 없기 때문에 실행 가능한 문자열 표현식만 구성하고 함수의 모든 매개변수를 명시적으로 전달할 수 있습니다. 🎜🎜🎜🎜🎜🎜🎜apply의 손글씨 구현은 호출과 매우 유사하므로 구현도 매우 유사합니다. 주목해야 할 차이점은 호출이 thisArg 매개변수를 승인한 후에는 여러 매개변수를 수신할 수도 있고(즉, 매개변수 목록을 승인함) 적용이 thisArg 매개변수를 수신한 후에는 일반적으로 두 번째 매개변수가 배열 또는 배열이라는 점입니다. -유사 객체: 🎜fn.call(thisArg,arg1,arg2,...) fn.apply(thisArg,[arg1,arg2,...])
如果第二个参数传的是 null 或者 undefined,那么相当于是整体只传了 thisArg 参数。
ES3 版本
Function.prototype.myApply = function(thisArg,args){ if(typeof this != 'function'){ throw new Error('the caller must be a function') } if(thisArg === null || thisArg === undefined){ thisArg = globalThis } else { thisArg = Object(thisArg) } if(args === null || args === undefined){ args = [] } else if(!Array.isArray(args)){ throw new Error('CreateListFromArrayLike called on non-object') } var _args = [] for(var i = 0;i < args.length;i ++){ _args.push('args[' + i + ']') } thisArg.fn = this var res = _args.length ? eval('thisArg.fn(' + _args + ')'):thisArg.fn() delete thisArg.fn return res }
ES6 版本
Function.prototype.myApply = function(thisArg,args){ if(typeof thisArg != 'function'){ throw new Error('the caller must be a function') } if(thisArg === null || thisArg === undefined){ thisArg = globalThis } else { thisArg = Object(thisArg) } if(args === null || args === undefined){ args = [] } // 如果传入的不是数组,仿照 apply 抛出错误 else if(!Array.isArray(args)){ throw new Error('CreateListFromArrayLike called on non-object') } thisArg.fn = this const res = thisArg.fn(...args) delete thisArg.fn return res }
实现要点
基本上和 call 的实现是差不多的,只是我们需要检查第二个参数的类型。
bind
也可以像 call
和 apply
那样给函数绑定一个 this,但是有一些不同的要点需要注意:
bind
不是指定完 this 之后直接调用原函数,而是基于原函数返回一个内部完成了 this 绑定的新函数bind
的时候作为第二个参数传入,第二批可以在调用新函数的时候传入,这两批参数最终会合并在一起,一次传递给新函数去执行bind
的时候传入的 thisArg。换句话说,这种情况下的 bind
相当于是无效的ES3 版本
这个版本更接近 MDN 上的 polyfill 版本。
Function.prototype.myBind = function(thisArg){ if(typeof this != 'function'){ throw new Error('the caller must be a function') } var fnToBind = this var args1 = Array.prototype.slice.call(arguments,1) var fnBound = function(){ // 如果是通过 new 调用 return fnToBind.apply(this instanceof fnBound ? this:thisArg,args1.concat(args2)) } // 实例继承 var Fn = function(){} Fn.prototype = this.prototype fnBound.prototype = new Fn() return fnBound }
ES6 版本
Function.prototype.myBind = function(thisArg,...args1){ if(typeof this != 'function'){ throw new Error('the caller must be a function') } const fnToBind = this return function fnBound(...args2){ // 如果是通过 new 调用的 if(this instanceof fnBound){ return new fnToBind(...args1,...args2) } else { return fnToBind.apply(thisArg,[...args1,...args2]) } } }
实现要点
1.bind
实现内部 this 绑定,需要借助于 apply
,这里假设我们可以直接使用 apply
方法
2.先看比较简单的 ES6 版本:
1). 参数获取:因为 ES6 可以使用剩余参数,所以很容易就可以获取执行原函数所需要的参数,而且也可以用展开运算符轻松合并数组。
2). 调用方式:前面说过,如果返回的新函数 fnBound 是通过 new 调用的,那么其内部的 this 会是 fnBound 构造函数的实例,而不是当初我们指定的 thisArg,因此 this instanceof fnBound
会返回 true,这种情况下,相当于我们指定的 thisArg 是无效的,new 返回的新函数等价于 new 原来的旧函数,即 new fnBound 等价于 new fnToBind,所以我们返回一个 new fnToBind 即可;反之,如果 fnBound 是普通调用,则通过 apply 完成 thisArg 的绑定,再返回最终结果。从这里可以看出,bind 的 this 绑定,本质上是通过 apply 完成的。
3.再来看比较麻烦一点的 ES3 版本:
1). 参数获取:现在我们用不了剩余参数了,所以只能在函数体内部通过 arguments 获取所有参数。对于 myBind
,我们实际上需要的是除开第一个传入的 thisArg 参数之外的剩余所有参数构成的数组,所以这里可以通过 Array.prototype.slice.call
借用数组的 slice 方法(arguments 是类数组,无法直接调用 slice),这里的借用有两个目的:一是除去 arguments 中的第一个参数,二是将除去第一个参数之后的 arguments 转化为数组(slice 本身的返回值就是一个数组,这也是类数组转化为数组的一种常用方法)。同样地,返回的新函数 fnBound 后面调用的时候也可能传入参数,再次借用 slice 将 arguments 转化为数组
2). 调用方式:同样,这里也要判断 fnBound 是 new 调用还是普通调用。在 ES6 版本的实现中,如果是 new 调用 fnBound,那么直接返回 new fnToBind()
,这实际上是最简单也最容易理解的方式,我们在访问实例属性的时候,天然就是按照 实例 => 实例.__proto__ = fnToBind.prototype
这样的原型链来寻找的,可以确保实例成功访问其构造函数 fnToBInd 的原型上面的属性;但在 ES3 的实现中(或者在网上部分 bind 方法的实现中),我们的做法是返回一个 fnToBind.apply(this)
,实际上相当于返回一个 undefined 的函数执行结果,根据 new 的原理,我们没有在构造函数中自定义一个返回对象,因此 new 的结果就是返回实例本身,这点是不受影响的。这个返回语句的问题在于,它的作用仅仅只是确保 fnToBind 中的 this 指向 new fnBound 之后返回的实例,而并没有确保这个实例可以访问 fnToBind 的原型上面的属性。实际上,它确实不能访问,因为它的构造函数是 fnBound 而不是 fnToBind,所以我们要想办法在 fnBound 和 fnToBind 之间建立一个原型链关系。这里有几种我们可能会使用的方法:
// 这里的 this 指的是 fnToBind fnBound.prototype = this.prototype
这样只是拷贝了原型引用,如果修改 fnBound.prototype
,则会影响到 fnToBind.prototype
,所以不能用这种方法
// this 指的是 fnToBind fnBound.prototype = Object.create(this.prototype)
通过 Object.create
可以创建一个 __proto__
指向 this.prototype
的实例对象,之后再让 fnBound.prototype
指向这个对象,则可以在 fnToBind 和 fnBound 之间建立原型关系。但由于 Object.create
是 ES6 的方法,所以无法在我们的 ES3 代码中使用。
// this 指的是 fnToBind const Fn = function(){} Fn.prototype = this.prototype fnBound.prototype = new Fn()
这是上面代码采用的方法:通过空构造函数 Fn 在 fnToBind 和 fnBound 之间建立了一个联系。如果要通过实例去访问 fnToBind 的原型上面的属性,可以沿着如下原型链查找:
实例 => 实例.__proto__ = fnBound.prototype = new Fn() => new Fn().__proto__ = Fn.prototype = fnToBind.prototype
更多编程相关知识,请访问:编程教学!!
위 내용은 이 기사에서는 호출, 적용 및 바인드 메소드 구현에 대한 심층적인 이해를 제공합니다.의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!