Cosa fa Function.prototype.toMethod()?

Question

Ho notato che lo Function.prototype ha un metodo toMethod() in JavaScript sperimentale, ma cosa fa effettivamente? E come lo uso?

Answer 1

Aggiornamento: il metodo toMethod era solo sperimentale e non lo ha fatto nello standard. L'oggetto casa è essenzialmente statica ora, l'unico modo per manipolare super è quello di cambiare la [[prototype]]:

var base = {…}; // as below 
var obj = Object.setPrototypeOf({ 
    foo() { // needs to use method definition syntax 
     super.foo(); 
    } 
}, base); 
obj.foo(); 

---

E 'molto simile al metodo di oggetti funzione bind. Tuttavia, invece di creare una nuova funzione con un valore associato this, crea una nuova funzione con un balzo [[HomeObject]], che è il riferimento che viene utilizzato per super chiamate:

[[HomeObject]] (Object): If the function uses super , this is the object whose [[GetPrototypeOf]] provides the object where super property lookups begin.

consideri questo esempio (non utilizzando qualsiasi classe sintassi):

var base = { 
    foo: function() { 
     console.log("base foo called on", this); 
    } 
}; 
base.foo(); // base foo called on base 
var obj = Object.create(base); 
obj.foo(); // base foo called on obj 

obj.foo = function() { 
    super.foo(); 
}; 
obj.foo(); // ReferenceError: this method has no home 
obj.bar = obj.foo.toMethod(obj); 
obj.bar(); // base foo called on obj 

obj.baz = function() { 
    super(); 
}; 
obj.baz(); // ReferenceError: this constructor has no parent class 
Reflect.setPrototypeOf(obj.baz, base.foo); 
obj.baz(); // base foo called on obj 

Answer 2

mia comprensione è che .toMethod è come la clonazione di una funzione. Si consideri l'esempio nella fonte che ho postato,

class P { } 
class C extends P { 
    foo() { 
     console.log("f"); 
     super(); 
    } 
} 
P.prototype.foo=C.prototype.foo; 
(new C).foo(); 

Qui si fa riferimento a un metodo di sottoclasse .foo nella superclasse, in modo che quando si chiama .foo, si farà riferimento P 's .foo che è C' s .foo e basta creato un ciclo.

Sembra che per risolvere questo problema, è possibile utilizzare .toMethod che "cloni" la funzione e dargli un diverso super/"casa" che si specifed:

P.prototype.foo = C.prototype.foo.toMethod(P.prototype); 

ora chiamando (new C).foo() non sarebbe andare avanti per sempre.