Spiegazione di una riga in MDN bind polyfill

Question

Il polyfill MDN binding è mostrato di seguito.

sto cercando di capire lo scopo della

this instanceof fNOP ? this : oThis 

nel fToBind.apply invocazione.

Non riesco a capirlo. Qualcuno può aiutare a far luce?

Function.prototype.bindMdn = function(oThis) { 
    if (typeof this !== 'function') { 
     // closest thing possible to the ECMAScript 5 
     // internal IsCallable function 
     throw new TypeError('Function.prototype.bind - what is trying to be bound is not callable'); 
    } 
    var aArgs = Array.prototype.slice.call(arguments, 1) 
     , fToBind = this 
     , fNOP = function() {} 
     , fBound = function() { 
     return fToBind.apply(this instanceof fNOP ? this : oThis, aArgs.concat(Array.prototype.slice.call(arguments))); 
    } 
    ; 
    if (this.prototype) { 
     // Function.prototype doesn't have a prototype property 
     fNOP.prototype = this.prototype; 
    } 
    fBound.prototype = new fNOP(); 
    return fBound; 
}; 

sembra essere un cortocircuito se un'istanza della funzione legata è fornito come bersaglio quando si richiama la funzione vincolato, ma il controllo typeof dovrebbe prendere questo, quindi non comprendono la sua presenza.

Link alla pagina MDN:

https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_objects/Function/bind

Edit: Questa è una domanda diversa da quella suggerita duplicato. Il duplicato suggerito chiede perché è necessario fNOP. L'ho completamente bruciato.

Questa domanda spiega perché è necessario il controllo instanceof e quale funzione serve. Presento sopra la mia ipotesi di cortocircuito, insieme a una ragione per cui ciò non ha pienamente senso.

Answer 1

se si utilizza il risultato di una .bind per creare una nuova istanza con new:

function TestClass(a,b,c,d) { 
} 

var TestClassBound = TestClass.bindMdn(null, 1, 2, 3); 

new TestClassBound(); 

Poi this instanceof fNOP è true.

Il typeof this !== 'function' è solo lì per verificare se è stato chiamato un modo regolare su una funzione e non con call o apply o per assicurarsi che non è stato copiato un altro prototipo oggetti. Quindi prevenire solo qualcosa come

Function.prototype.bind.call("Not a function", 1, 2, 3); 

O

var testObj = {}; 
testObj.bind = Function.prototype.bind; 

testObj.bind(1,2,3); 

Per ogni chiamata regolare di bind su una funzione del typeof this sarà sempre function.

Quindi il typeof this !== 'function' è per verificare se l'oggetto bind è chiamato è davvero una funzione.

E il this instanceof fNOP all'interno dello fBind assicura che il comportamento sia corretto quando viene utilizzato il risultato del collegamento.