(1, eval) ('questo') vs eval ('questo') in JavaScript?

Comincio a leggere i pattern JavaScript , alcuni codici mi hanno confuso.

var global = (function () {
    return this || (1, eval)('this');
}());

Ecco le mie domande:

Q1:

(1, eval) === eval?

Perché e come funziona?

Q2: Perché non solo

var global = (function () {
    return this || eval('this');
}());

o

 var global = (function () {
    return this;
}());

La differenza tra (1,eval)e plain old evalè che il primo è un valore e il secondo è un lvalue. Sarebbe più ovvio se fosse qualche altro identificatore:

var x;
x = 1;
(1, x) = 1; //  syntax error, of course!

Questa è (1,eval)un'espressione che produce eval(proprio come dire, (true && eval)o (0 ? 0 : eval)sarebbe), ma non è un riferimento a eval.

Perché ti interessi?

Ebbene, il Ecma spec considera un riferimento ad evalessere una "chiamata eval diretta", ma un'espressione che semplicemente cede evalad essere uno indiretto - e le chiamate eval indiretti sono garantiti da eseguire in ambito globale.

Cose che ancora non so:

1. In quali circostanze una chiamata eval diretta non viene eseguita in ambito globale?
2. In quale circostanza il thisdi una funzione a ambito globale non può produrre l'oggetto globale?

Ulteriori informazioni possono essere raccolte qui .

MODIFICARE

Apparentemente, la risposta alla mia prima domanda è "quasi sempre". Un direct evalviene eseguito dall'ambito corrente . Considera il codice seguente:

var x = 'outer';
(function() {
  var x = 'inner';
  eval('console.log("direct call: " + x)'); 
  (1,eval)('console.log("indirect call: " + x)'); 
})();

Non sorprende (heh-heh), questo stampa:

direct call: inner
indirect call: outer

MODIFICARE

Dopo ulteriori esperimenti, dirò provvisoriamente che thisnon può essere impostato su nullo undefined. Può essere impostato su altri valori falsi (0, ", NaN, false), ma solo molto deliberatamente.

Dirò che la tua fonte soffre di una lieve e reversibile inversione cranio-rettale e potresti prendere in considerazione l'idea di trascorrere una settimana a programmare ad Haskell.

Il frammento,

var global = (function () {  
    return this || (1, eval)('this');  
}());  

valuterà correttamente l'oggetto globale anche in modalità rigorosa. In modalità non rigorosa il valore di thisè l'oggetto globale ma in modalità rigorosa lo è undefined. L'espressione (1, eval)('this')sarà sempre l'oggetto globale. La ragione di ciò coinvolge le regole sui versi indiretti diretti eval. Le chiamate dirette a evalhanno l'ambito del chiamante e la stringa thisrestituirà il valore di thisnella chiusura. I messaggi indiretti vengono evalvalutati nell'ambito globale come se fossero eseguiti all'interno di una funzione nell'ambito globale. Poiché quella funzione non è di per sé una funzione in modalità rigorosa, l'oggetto globale viene passato come thise quindi l'espressione 'this'restituisce l'oggetto globale. L'espressione (1, eval)è solo un modo elegante per forzare ileval essere indiretto e restituire l'oggetto globale.

A1: (1, eval)('this')non è la stessa a eval('this')causa delle regole speciali sulle chiamate dirette verso indiretto a eval.

A2: L'originale funziona in modalità rigorosa, le versioni modificate no.

A Q1:

Penso che questo sia un buon esempio di operatore virgola in JS. Mi piace la spiegazione dell'operatore virgola in questo articolo: http://javascriptweblog.wordpress.com/2011/04/04/the-javascript-comma-operator/

L'operatore virgola valuta entrambi i suoi operandi (da sinistra a destra) e restituisce il valore del secondo operando.

A Q2:

(1, eval)('this')è considerata una chiamata eval indiretta, che in ES5 esegue il codice a livello globale. Quindi il risultato sarà il contesto globale.

Vedi http://perfectionkills.com/global-eval-what-are-the-options/#evaling_in_global_scope

D1: Più istruzioni javascript consecutive separate da una virgola assumono il valore dell'ultima istruzione. Così:

(1, eval)prende il valore dell'ultimo che è un riferimento alla eval()funzione. Apparentemente lo fa in questo modo per trasformare la eval()chiamata in una chiamata di valutazione indiretta che verrà valutata nell'ambito globale in ES5. Dettagli spiegati qui .

D2: Deve essere presente un ambiente che non definisce un globale this, ma definisce eval('this'). Questa è l'unica ragione a cui riesco a pensare per questo.