Gibt es eine einfache Methode, eine globale Var in eine lokale Variable zu verwandeln?

Question

Lassen Sie uns sagen, dass wir eine Funktion haben, die wie folgt aussieht:

const fn =() => x; 

Diese Funktion sollte den Wert von x zurück, wo x im globalen Bereich zur Verfügung steht. Zunächst ist dies undefined aber wenn wir x definieren:

const x = 42; 

Dann können wir fn erwarten 42 zurückzukehren.

Jetzt wollen wir fn als eine Zeichenfolge rendern. In JavaScript haben wir toString für diesen Zweck. Lassen Sie uns jedoch auch sagen, dass wir schließlich fn in einem neuen Kontext ausführen möchten (d. H. Unter Verwendung von eval), und daher sollten alle von ihr verwendeten globalen Referenzen entweder vor oder während unseres Aufrufs an toString verinnerlicht werden.

Wie können wir x eine lokale Variable machen, deren Wert den globalen Wert von x zu der Zeit widerspiegelt, die wir fn in eine Zeichenfolge konvertieren? Angenommen, wir können nicht wissen x heißt x. Das heißt, wir können davon ausgehen, dass die Variablen in demselben Modul enthalten sind.

Answer 1

Wir nicht xx benannt wissen kann. Dies ist das zentrale Stück dieses Puzzles und wird daher in der ursprünglichen Frage hervorgehoben. Es wäre zwar schön, wenn wir eine einfachere Lösung hätten, aber es scheint eine richtige Antwort zu sein, die sich auf die Implementierung einer Art Parser oder AST-Traversierung bezieht.

Warum ist das notwendig? Während wir annehmen können, dass x in einem Modul als global (es ist notwendigerweise zwischen Funktionen geteilt) lebt, können wir nicht davon ausgehen, dass es einen bekannten Namen hat. Also brauchen wir einen Weg, um x (oder alle Globals wirklich) aus unserem Modul zu extrahieren und es dann als Kontext bereitzustellen, wenn wir schließlich eval.

N.B .: Bereitstellung bekannter Variablen als Kontext ist trivial. Einige Antworten hier scheinen anzunehmen, dass dies ein schwieriges Problem ist, aber in der Tat ist es ziemlich einfach mit eval; Einfach den Kontext als String voranstellen.

Also, was ist dann die richtige Antwort hier? Wenn wir einen AST verwenden würden (Acorn könnte zum Beispiel ein praktikabler Startpunkt sein), könnten wir das Modul untersuchen und programmatisch alle darin enthaltenen Globals extrahieren. Dazu gehören x oder jede andere Variable, die zwischen unseren Funktionen geteilt werden kann; Wir können sogar die Funktionen untersuchen, um festzustellen, welche Variablen für ihre Ausführung notwendig sind.

Wieder war die Hoffnung, diese Frage ursprünglich zu stellen, eine einfachere Lösung zu destillieren oder den Stand der Technik aufzudecken, der an unsere Bedürfnisse angepasst werden könnte.Letztendlich geht meine Antwort und die Antwort, die ich akzeptiere, auf die nicht-triviale Aufgabe des Parsens und Extrahierens von Globalen aus einem JavaScript-Modul zurück; Es scheint keinen einfachen Weg zu geben. Ich denke, das ist eine faire Antwort, wenn nicht eine praktische, die wir heute umsetzen können. (Wir werden jedoch später darauf eingehen, wenn unser Projekt wächst.)

Answer 2

meinst du das? einzige Antwort kann Code veröffentlichen, so dass ich Antwort

var x = 42 
 

 
function fn() { 
 
    return x 
 
} 
 

 

 
(() => { 
 
    var x = 56 
 
    var localFn = eval('"use strict";(' + fn.toString()+')') 
 
    console.log(localFn) 
 
    console.log(localFn()) 
 
})()

• warum localFn umbenennen, wenn Sie var fn=xx in diesem Bereich die äußere fn verwenden nie existiert!
• in nodejs? referenzieren nodejs vm
• passierender Kontext? Sie können nicht js Kontext es sei denn, Sie halten Ihren eigenen Rahmen wie AngularJS

Answer 3

Wenn Sie bereits „geht es“ von eval() auszuführen fn() im neuen Kontext, warum dann nicht definieren die Funktion speichern selbst mit eval()?

eval('const fn =() => ' + x + ';')

Answer 4

Wenn Sie Sperre bestimmte Variablen wollen, während Funktion Zeichenfolge konvertieren, müssen Sie die Variablen entlang der Zeichenfolge Funktion übergeben.

Es könnte wie folgt implementiert werden (geschrieben mit Typen - Typoskript Notation)

const prepareForEval = 
    (fn: Function, variablesToLock: { [varName: string]: any }): string => { 
    const stringifiedVariables = Object.keys(variablesToLock) 
     .map(varName => `var ${varName}=${JSON.stringify(variablesToLock[varName])};`); 

    return stringifiedVariables.join("") + fn.toString(); 
    } 

es dann so Jede eval erklären Zeichenfolgevariablen und funtion anstelle

const stringifiedFunction = prepareForEval(someFunction, { x: x, y: y }) 

// you can even simplify declaration of object, in ES6 you simply write 
const stringifiedFunction = prepareForEval(someFunction, { x, y }) 
// all variables you write into curly braces will be stringified 
// and therefor "locked" in time you call prepareForEval() 

verwenden, wo es wurde ausgeführt. Dies könnte ein Problem sein, Sie könnten eine Variable neu deklarieren, unbekannter Wert, Sie müssen den Namen der stringifizierten Funktion kennen, um sie aufrufen zu können, oder es kann einen Fehler erzeugen, wenn Sie die bereits deklarierte const Variable deklarieren.

dieses Problem zu überwinden, müssen Sie die Zeichenfolge Funktion implementieren als immediatelly anonyme Funktion mit einem eigenen Bereich ausgeführt werden, wie

const prepareForEval = 
    (fn: Function, variablesToLock: { [varName: string]: any }): string => { 
    const stringifiedVariables = Object.keys(variablesToLock) 
     .map(varName => `var ${varName}=${JSON.stringify(variablesToLock[varName])};`); 

    return ` 
     var ${fn.name} = (function() { 
     ${stringifiedVariables.join("")} 
     return ${fn.toString()}; 
    )(); 
    `; 
    } 

diese Modifikation Funktion und Variablen in separatem Umfang erklären wird und dann wird es diese Funktion zuzuweisen zu fn.name Konstante. Die Variablen werden den Bereich nicht polieren, wo Sie eval, es wird nur neue fn.name Variable deklarieren und diese neue Variable wird auf Deserialized-Funktion festgelegt werden.

Answer 5

können Sie verwenden OR Operator || aktuellen Wert von x-fn.toString() Anruf

const fn =() => x; 
 
const x = 42; 
 
const _fn = `${fn.toString()} || ${x}`; 
 
console.log(_fn, eval(_fn)());

Answer 6

Globale Variablen verketten können mit Verschlüssen aus lokalen (privat) werden. w3Schools

function myFunction() { 
    var a = 4; 
    return a * a; 
} 

Answer 7

Dank guest271314, sehe ich jetzt, was Sie wollen.

Dies ist sein Code, nur wenig verbessert:

const stringifiedFn = ` 
    (function() {   
     const _a = (${fn.toString()})(); 
     return _a !== undefined ? _a : ${JSON.stringify(fn())}; 
    })(); 
`; 

dieser Code fn in Kontext ausgeführt wird, in dem Sie eval, und wenn fn in diesem Zusammenhang undefined gibt es die Ausgabe von fn in Zusammenhang gibt, wo es gestrichen wurde.

Alle Kredit geht an guest271314