Controllo contesto metodo/metodo JavaScript

Question

So come utilizzare i metodi per modificare il contesto di una chiamata funzione/metodo: applica, associa, chiama. La mia domanda è questa, c'è un modo per verificare se una funzione/metodo ha già avuto il suo contesto impostato?

// given 
var beta; 

function alpha() { 
    return this; 
} 

function isContextSet (fn) { 
    /* check for context binding on fn */ 
} 

beta = alpha.bind("hello"); 

isContextSet(alpha); // returns false 
isContextSet(beta); // returns true 

Penso di conoscere la risposta a questa già, ma ho pensato di chiedere in ogni caso, se non altro per ragioni diverse: 1. confermare la mia ipotesi, o 2. imparare qualcosa. Sono sicuro di non essere il primo a porre questa domanda, ma non ho avuto alcuna idea su come trovare effettivamente una risposta poiché tutto ciò che ottengo sono le risposte a come usare: .apply(), .call(), o. bind().

Answer 1

No.

In realtà, non è corretto riferirsi al binding come "cambiare" il contesto. Quello che fa è trasformare una funzione in un'altra che chiama il primo con un particolare contesto.

Le funzioni possono essere vincolate in molti modi. Per esempio, ho potuto legare da solo:

function bind(fn,ctxt){ 
    return function(){ 
     fn.apply(ctxt,arguments); 
    }; 
} 

Oppure, potrei legarlo con Function.prototype.bind, o di uno spessore che fa la stessa cosa, o _.bind di sottolineatura. Potrei legarlo agli argomenti iniziali oltre al contesto. In ogni caso, non c'è modo di dire cosa è successo senza essenzialmente eseguire la funzione.

Il binding è solo uno dei molti modi per trasformare una funzione in un'altra. Potrei anche trasformare una funzione per eseguire un secondo da ora, o essere eseguita due volte. Non c'è nulla di magico nel legare; crea solo una nuova funzione basata su quella vecchia. Non esiste una variabile speciale chiamata [[bound_to]] impostata sulla funzione che potresti essere in grado di esaminare (a meno che tu non usi la tua implementazione personalizzata di bind, come suggerisce un'altra risposta). Non esiste un modo post facto per determinare come è stata trasformata la funzione.

Il più vicino che posso immaginare è controllare la funzione associata a una versione non associata e vedere se sono uguali.

function log_this(){console.log(this);} 
var bound_func=log_this.bind(my_var); 
console.log(log_this===bound_func); // FALSE 

Answer 2

cosa si potrebbe fare è qualcosa di simile:

function f(context, whatever) { 
    if(this !== context) { 
     //context has been changed 
    } 
} 

var y = f.bind(thingy); 
y(otherThingy, something); 

Si potrebbe anche avere una funzione bind personalizzato e hanno una sorta di un hack come questo:

function bind(func, context) {  
    var newFunc = func.bind(context); 
    newFunc._this = context; 
    return newFunc; 
} 

function checkContext(func, context) { 
    return func._this !== context; 
} 

Answer 3

credo che questo sia domanda interessante per chi come l'amore JavaScirpt e spero che questa è la risposta che cosa state cercando:

var isContextSet = function (fn) { 
    var testThis = {}; //unique object for testing what is this inside fn 
    return fn.call(testThis) !== testThis; 
} 

cerco di "set" questo all'interno fn : fn.call(testThis); e se tale funzione ha restituito il riferimento all'oggetto appena creato (testThis), quindi non è vincolato. Spero che si ottiene :)

EDIT: Questo funziona quando fn Retuns questo (come mostrato in questione). Altrimenti non è possibile definire isContextSet correttamente.