Ich schreibe JavaScript-Code, um vom Benutzer eingegebene Funktionen zu analysieren (für Tabellenkalkulationsfunktionen). Nachdem ich die Formel analysiert hatte, konnte ich sie in JavaScript konvertieren und darauf ausführen eval(), um das Ergebnis zu erhalten.

Ich habe mich jedoch immer davor gescheut, es zu verwenden, eval()wenn ich es vermeiden kann, weil es böse ist (und zu Recht oder zu Unrecht habe ich immer gedacht, dass es in JavaScript noch böser ist, weil der zu bewertende Code vom Benutzer möglicherweise geändert wird ).

Also, wann ist es in Ordnung, es zu benutzen?

Ich möchte mir einen Moment Zeit nehmen, um die Prämisse Ihrer Frage anzusprechen - dass eval () " böse " ist. Das Wort " böse ", wie es von Programmiersprachenmenschen verwendet wird, bedeutet normalerweise "gefährlich" oder genauer "in der Lage, mit einem einfach aussehenden Befehl viel Schaden anzurichten". Wann ist es in Ordnung, etwas Gefährliches zu verwenden? Wenn Sie wissen, was die Gefahr ist, und wenn Sie die entsprechenden Vorsichtsmaßnahmen treffen.

Schauen wir uns die Gefahren bei der Verwendung von eval () an. Es gibt wahrscheinlich viele kleine versteckte Gefahren, genau wie alles andere, aber die beiden großen Risiken - der Grund, warum eval () als böse angesehen wird - sind Leistung und Code-Injection.

• Performance - eval () führt den Interpreter / Compiler aus. Wenn Ihr Code kompiliert ist, ist dies ein großer Erfolg, da Sie mitten in der Laufzeit einen möglicherweise schweren Compiler aufrufen müssen. JavaScript ist jedoch immer noch meistens eine interpretierte Sprache, was bedeutet, dass das Aufrufen von eval () im allgemeinen Fall kein großer Leistungseinbruch ist (siehe jedoch meine spezifischen Anmerkungen unten).
• Code-Injection - eval () führt möglicherweise eine Code-Zeichenfolge unter erhöhten Berechtigungen aus. Beispielsweise möchte ein Programm, das als Administrator / Root ausgeführt wird, niemals Benutzereingaben auswerten (), da diese Eingabe möglicherweise "rm -rf / etc / important-file" oder schlechter sein könnte. Auch hier hat JavaScript in einem Browser dieses Problem nicht, da das Programm ohnehin im eigenen Konto des Benutzers ausgeführt wird. Serverseitiges JavaScript könnte dieses Problem haben.

Weiter zu Ihrem speziellen Fall. Soweit ich weiß, generieren Sie die Zeichenfolgen selbst. Wenn Sie also darauf achten, dass keine Zeichenfolge wie "rm -rf etwas Wichtiges" generiert wird, besteht kein Risiko für die Code-Injektion (aber bitte denken Sie daran, es ist sehr, sehr im allgemeinen Fall schwer zu gewährleisten). Wenn Sie im Browser arbeiten, ist die Code-Injection meines Erachtens ein recht geringes Risiko.

Die Leistung muss gegen die einfache Codierung abgewogen werden. Ich bin der Meinung, dass Sie beim Parsen der Formel das Ergebnis genauso gut während des Parsens berechnen können, anstatt einen anderen Parser auszuführen (den in eval ()). Es kann jedoch einfacher sein, mit eval () zu codieren, und der Leistungseinbruch wird wahrscheinlich nicht bemerkt. Es sieht so aus, als ob eval () in diesem Fall nicht böser ist als jede andere Funktion, die Ihnen möglicherweise Zeit sparen könnte.

eval()ist nicht böse Oder wenn ja, ist es genauso böse wie Reflection, Datei- / Netzwerk-E / A, Threading und IPC in anderen Sprachen "böse".

Wenn für Ihren Zweck , eval()schneller als die manuelle Interpretation ist, oder macht den Code einfacher oder mehr klar ... dann sollten Sie es verwenden. Wenn beides nicht, dann solltest du es nicht. So einfach ist das.

Wenn Sie der Quelle vertrauen.

Im Fall von JSON ist es mehr oder weniger schwierig, die Quelle zu manipulieren, da sie von einem von Ihnen kontrollierten Webserver stammt. Solange der JSON selbst keine Daten enthält, die ein Benutzer hochgeladen hat, gibt es keinen wesentlichen Nachteil bei der Verwendung von eval.

In allen anderen Fällen würde ich große Anstrengungen unternehmen, um sicherzustellen, dass vom Benutzer bereitgestellte Daten meinen Regeln entsprechen, bevor ich sie an eval () weitergebe.

Lassen Sie uns echte Leute bekommen:

1. Jeder große Browser verfügt jetzt über eine integrierte Konsole, mit der Ihr potenzieller Hacker jede Funktion mit beliebigem Wert aufrufen kann. Warum sollten sie sich die Mühe machen, eine Eval-Anweisung zu verwenden, selbst wenn dies möglich ist?

2. Wenn das Kompilieren von 2000 Zeilen JavaScript 0,2 Sekunden dauert, wie hoch ist mein Leistungsabfall, wenn ich vier Zeilen JSON auswerte?

Sogar Crockfords Erklärung für "Eval is Evil" ist schwach.

eval is Evil. Die eval-Funktion ist die am häufigsten missbrauchte Funktion von JavaScript. Vermeide es

Wie Crockford selbst sagen könnte: "Diese Art von Aussage führt tendenziell zu irrationaler Neurose. Kaufen Sie sie nicht."

Eval zu verstehen und zu wissen, wann es nützlich sein könnte, ist viel wichtiger. Beispielsweise ist eval ein sinnvolles Tool zur Auswertung von Serverantworten, die von Ihrer Software generiert wurden.

Übrigens: Prototype.js ruft eval fünfmal direkt auf (einschließlich evalJSON () und evalResponse ()). jQuery verwendet es in parseJSON (über den Funktionskonstruktor).

Ich neige dazu , folgen Crockford Beratung für eval()und vermeiden sie ganz. Selbst Wege, die dies zu erfordern scheinen, tun dies nicht. Mit können Sie beispielsweise setTimeout()eine Funktion übergeben, anstatt sie auszuwerten.

setTimeout(function() {
  alert('hi');
}, 1000);

Selbst wenn es sich um eine vertrauenswürdige Quelle handelt, verwende ich sie nicht, da der von JSON zurückgegebene Code möglicherweise verstümmelt ist, was bestenfalls etwas Wackeliges bewirken kann, im schlimmsten Fall etwas Schlechtes aufdeckt.

Ich habe gesehen, wie Leute befürwortet haben, eval nicht zu verwenden, weil es böse ist , aber ich habe gesehen, dass dieselben Leute Function und setTimeout dynamisch verwenden, also haben sie eval unter der Haube verwendet : D.

Übrigens, wenn Ihre Sandbox nicht sicher genug ist (z. B. wenn Sie an einer Site arbeiten, die Code-Injection ermöglicht), ist die Auswertung das letzte Ihrer Probleme. Die Grundregel der Sicherheit lautet, dass alle Eingaben böse sind, aber im Fall von JavaScript kann sogar JavaScript selbst böse sein, da Sie in JavaScript jede Funktion überschreiben können und einfach nicht sicher sein können, ob Sie die echte verwenden. Wenn ein bösartiger Code vor Ihnen gestartet wird, können Sie keiner integrierten JavaScript-Funktion vertrauen: D.

Der Nachwort zu diesem Beitrag lautet nun:

Wenn Sie es WIRKLICH brauchen (80% der Zeit wird keine Bewertung benötigt) und Sie sicher sind, was Sie tun, verwenden Sie einfach Bewertung (oder bessere Funktion;)), Verschlüsse und OOP decken die 80/90% der In dem Fall, in dem eval durch eine andere Art von Logik ersetzt werden kann, besteht der Rest aus dynamisch generiertem Code (z. B. wenn Sie einen Interpreter schreiben) und wie Sie bereits gesagt haben, JSON evaluiert (hier können Sie die sichere Crockford-Evaluierung verwenden;))

Eval ist eine Ergänzung zur Kompilierung, die bei der Vorlage des Codes verwendet wird. Mit Vorlagen meine ich, dass Sie einen vereinfachten Vorlagengenerator schreiben, der nützlichen Vorlagencode generiert, der die Entwicklungsgeschwindigkeit erhöht.

Ich habe ein Framework geschrieben, in dem Entwickler EVAL nicht verwenden, aber sie verwenden unser Framework, und dieses Framework muss wiederum EVAL verwenden, um Vorlagen zu generieren.

Die Leistung von EVAL kann mithilfe der folgenden Methode gesteigert werden. Anstatt das Skript auszuführen, müssen Sie eine Funktion zurückgeben.

var a = eval("3 + 5");

Es sollte organisiert sein als

var f = eval("(function(a,b) { return a + b; })");

var a = f(3,5);

Das Zwischenspeichern von f wird sicherlich die Geschwindigkeit verbessern.

Auch Chrome ermöglicht das Debuggen solcher Funktionen sehr einfach.

In Bezug auf die Sicherheit wird die Verwendung von eval oder nicht kaum einen Unterschied machen.

1. Zunächst ruft der Browser das gesamte Skript in einer Sandbox auf.
2. Jeder Code, der in EVAL böse ist, ist im Browser selbst böse. Der Angreifer oder jeder andere kann problemlos einen Skriptknoten in DOM einfügen und alles tun, wenn er etwas bewerten kann. Wenn Sie EVAL nicht verwenden, macht dies keinen Unterschied.
3. Es ist meistens eine schlechte serverseitige Sicherheit, die schädlich ist. Eine schlechte Cookie-Validierung oder eine schlechte ACL-Implementierung auf dem Server verursacht die meisten Angriffe.
4. In Javas nativem Code war kürzlich eine Java-Sicherheitslücke usw. vorhanden. JavaScript wurde und wird für die Ausführung in einer Sandbox entwickelt, während Applets für die Ausführung außerhalb einer Sandbox mit Zertifikaten usw. entwickelt wurden, die zu Sicherheitslücken und vielen anderen Dingen führen.
5. Das Schreiben von Code zum Imitieren eines Browsers ist nicht schwierig. Sie müssen lediglich eine HTTP-Anfrage an den Server mit Ihrer bevorzugten Benutzeragentenzeichenfolge senden. Alle Testtools verspotten ohnehin Browser. Wenn ein Angreifer Ihnen Schaden zufügen möchte, ist EVAL das letzte Mittel. Sie haben viele andere Möglichkeiten, um mit Ihrer serverseitigen Sicherheit umzugehen.
6. Das Browser-DOM hat keinen Zugriff auf Dateien und keinen Benutzernamen. Tatsächlich kann nichts auf der Maschine, auf das eval zugreifen kann.

Wenn Ihre serverseitige Sicherheit solide genug ist, damit jeder von überall angreifen kann, sollten Sie sich keine Sorgen um EVAL machen. Wie bereits erwähnt, haben Angreifer unabhängig von der EVAL-Fähigkeit Ihres Browsers viele Tools, mit denen sie sich in Ihren Server hacken können, wenn EVAL nicht vorhanden wäre.

Eval eignet sich nur zum Generieren einiger Vorlagen für die Verarbeitung komplexer Zeichenfolgen, die auf etwas basieren, das nicht im Voraus verwendet wird. Zum Beispiel werde ich bevorzugen

"FirstName + ' ' + LastName"

Im Gegensatz zu

"LastName + ' ' + FirstName"

Als mein Anzeigename, der aus einer Datenbank stammen kann und der nicht fest codiert ist.

Beim Debuggen in Chrome (v28.0.1500.72) stellte ich fest, dass Variablen nicht an Abschlüsse gebunden sind, wenn sie nicht in einer verschachtelten Funktion verwendet werden, die den Abschluss erzeugt. Ich denke, das ist eine Optimierung der JavaScript-Engine.

ABER : Wenn eval()es innerhalb einer Funktion verwendet wird, die einen Abschluss verursacht, sind ALLE Variablen der äußeren Funktionen an den Abschluss gebunden, auch wenn sie überhaupt nicht verwendet werden. Wenn jemand die Zeit hat zu testen, ob dadurch Speicherlecks entstehen können, hinterlassen Sie mir bitte unten einen Kommentar.

Hier ist mein Testcode:

(function () {
    var eval = function (arg) {
    };

    function evalTest() {
        var used = "used";
        var unused = "not used";

        (function () {
            used.toString();   // Variable "unused" is visible in debugger
            eval("1");
        })();
    }

    evalTest();
})();

(function () {
    var eval = function (arg) {
    };

    function evalTest() {
        var used = "used";
        var unused = "not used";

        (function () {
            used.toString();   // Variable "unused" is NOT visible in debugger
            var noval = eval;
            noval("1");
        })();
    }

    evalTest();
})();

(function () {
    var noval = function (arg) {
    };

    function evalTest() {
        var used = "used";
        var unused = "not used";

        (function () {
            used.toString();    // Variable "unused" is NOT visible in debugger
            noval("1");
        })();
    }

    evalTest();
})();

Ich möchte hier darauf hinweisen, dass eval () nicht unbedingt auf die native eval()Funktion verweisen muss . Es hängt alles vom Namen der Funktion ab . Wenn Sie also den Native eval()mit einem Aliasnamen aufrufen (z. B. var noval = eval;und dann in einer inneren Funktion noval(expression);), schlägt die Auswertung von expressionmöglicherweise fehl, wenn auf Variablen verwiesen wird, die Teil des Abschlusses sein sollten, dies jedoch nicht ist.

Microsoft erklärt im IE-Blog, warum eval () in seinem Browser langsam ist. Leistungsempfehlungen für IE + JavaScript Teil 2: Ineffizienzen bei JavaScript-Code .

Endeffekt

Wenn Sie den Code erstellt oder bereinigt haben eval, ist er niemals böse .

Etwas detaillierter

evalist böse, wenn auf dem Server Eingaben ausgeführt werden, die von einem Client übermittelt wurden, der nicht vom Entwickler erstellt oder vom Entwickler nicht bereinigt wurde .

evalist nicht böse, wenn es auf dem Client ausgeführt wird, selbst wenn vom Client erstellte nicht bereinigte Eingaben verwendet werden .

Natürlich sollten Sie die Eingabe immer bereinigen, um die Kontrolle darüber zu haben, was Ihr Code verbraucht.

Argumentation

Der Client kann jeden gewünschten Code ausführen, auch wenn der Entwickler ihn nicht codiert hat. Dies gilt nicht nur für das, was bewertet wird, sondern auch für den Ruf an sich evalselbst .

Die einzige Instanz, in der Sie eval () verwenden sollten, ist, wenn Sie dynamisches JS im laufenden Betrieb ausführen müssen. Ich spreche von JS, das Sie asynchron vom Server herunterladen ...

... und 9 mal von 10 könnten Sie dies leicht vermeiden, indem Sie umgestalten.

evalist selten die richtige Wahl. Zwar gibt es zahlreiche Fälle geben kann , wo Sie erreichen können , was Sie ein Skript erreichen müssen gemeinsam durch Verketten und es on the fly läuft, müssen Sie in der Regel viel leistungsfähiger und wartbar Techniken zur Verfügung: assoziatives Array - Notation ( obj["prop"]ist die gleiche wie obj.prop) , Verschlüsse, objektorientierte Techniken, Funktionstechniken - verwenden Sie sie stattdessen.

Was das Client-Skript betrifft, denke ich, dass das Thema Sicherheit ein strittiger Punkt ist. Alles, was in den Browser geladen wird, kann manipuliert werden und sollte als solches behandelt werden. Die Verwendung einer eval () - Anweisung birgt kein Risiko, wenn es viel einfachere Möglichkeiten gibt, JavaScript-Code auszuführen und / oder Objekte im DOM zu bearbeiten, z. B. die URL-Leiste in Ihrem Browser.

javascript:alert("hello");

Wenn jemand sein DOM manipulieren will, sage ich wegschwingen. Die Sicherheit zur Verhinderung jeglicher Art von Angriff sollte immer in der Verantwortung der Serveranwendung liegen.

Aus pragmatischer Sicht hat die Verwendung von eval () in einer Situation, in der Dinge anders gemacht werden können, keinen Vorteil. Es gibt jedoch spezielle Fälle, in denen eine Bewertung verwendet werden sollte. Wenn ja, kann dies definitiv ohne das Risiko einer Explosion der Seite durchgeführt werden.

<html>
    <body>
        <textarea id="output"></textarea><br/>
        <input type="text" id="input" />
        <button id="button" onclick="execute()">eval</button>

        <script type="text/javascript">
            var execute = function(){
                var inputEl = document.getElementById('input');
                var toEval = inputEl.value;
                var outputEl = document.getElementById('output');
                var output = "";

                try {
                    output = eval(toEval);
                }
                catch(err){
                    for(var key in err){
                        output += key + ": " + err[key] + "\r\n";
                    }
                }
                outputEl.value = output;
            }
        </script>
    <body>
</html>

Auf der Serverseite ist eval nützlich, wenn Sie mit externen Skripten wie SQL oder Influxdb oder Mongo arbeiten. Wo eine benutzerdefinierte Validierung zur Laufzeit durchgeführt werden kann, ohne dass Ihre Dienste erneut bereitgestellt werden müssen.

Zum Beispiel ein Leistungsservice mit folgenden Metadaten

{
  "568ff113-abcd-f123-84c5-871fe2007cf0": {
    "msg_enum": "quest/registration",
    "timely": "all_times",
    "scope": [
      "quest/daily-active"
    ],
    "query": "`SELECT COUNT(point) AS valid from \"${userId}/dump/quest/daily-active\" LIMIT 1`",
    "validator": "valid > 0",
    "reward_external": "ewallet",
    "reward_external_payload": "`{\"token\": \"${token}\", \"userId\": \"${userId}\", \"amountIn\": 1, \"conversionType\": \"quest/registration:silver\", \"exchangeProvider\":\"provider/achievement\",\"exchangeType\":\"payment/quest/registration\"}`"
  },
  "efdfb506-1234-abcd-9d4a-7d624c564332": {
    "msg_enum": "quest/daily-active",
    "timely": "daily",
    "scope": [
      "quest/daily-active"
    ],
    "query": "`SELECT COUNT(point) AS valid from \"${userId}/dump/quest/daily-active\" WHERE time >= '${today}' ${ENV.DAILY_OFFSET} LIMIT 1`",
    "validator": "valid > 0",
    "reward_external": "ewallet",
    "reward_external_payload": "`{\"token\": \"${token}\", \"userId\": \"${userId}\", \"amountIn\": 1, \"conversionType\": \"quest/daily-active:silver\", \"exchangeProvider\":\"provider/achievement\",\"exchangeType\":\"payment/quest/daily-active\"}`"
  }
}

Was dann erlaubt,

• Direkte Einfügung von Objekten / Werten durch eine Literalzeichenfolge in einen JSON, nützlich zum Vorlagen von Texten

• Kann als Vergleich verwendet werden, sagen wir, wir machen Regeln, wie Quest oder Ereignisse in CMS validiert werden

Con davon:

• Kann Fehler im Code sein und Dinge im Dienst auflösen, wenn sie nicht vollständig getestet wurden.

• Wenn ein Hacker ein Skript auf Ihrem System schreiben kann, sind Sie ziemlich durcheinander.

• Eine Möglichkeit, Ihr Skript zu validieren, besteht darin, den Hash Ihrer Skripte an einem sicheren Ort aufzubewahren, damit Sie sie vor dem Ausführen überprüfen können.

Ich denke, Fälle, in denen eine Bewertung gerechtfertigt ist, wären selten. Es ist wahrscheinlicher, dass Sie es verwenden, wenn Sie denken, dass es gerechtfertigt ist, als wenn Sie es verwenden, wenn es tatsächlich gerechtfertigt ist.

Die Sicherheitsprobleme sind die bekanntesten. Beachten Sie jedoch auch, dass JavaScript die JIT-Kompilierung verwendet und dies mit eval sehr schlecht funktioniert. Eval ist für den Compiler eine Art Blackbox, und JavaScript muss in der Lage sein, Code (bis zu einem gewissen Grad) im Voraus vorherzusagen, um Leistungsoptimierungen und Scoping sicher und korrekt anwenden zu können. In einigen Fällen kann sich die Auswirkung auf die Leistung sogar auf anderen Code außerhalb von eval auswirken.

Wenn Sie mehr wissen möchten: https://github.com/getify/You-Dont-Know-JS/blob/master/scope%20%26%20closures/ch2.md#eval

Es ist in Ordnung, es zu verwenden, wenn Sie die vollständige Kontrolle über den Code haben, der an die evalFunktion übergeben wird.

Wenn möglich nur während des Testens. Beachten Sie auch, dass eval () viel langsamer ist als andere spezialisierte JSON usw.-Evaluatoren.

Es gibt keinen Grund, eval () nicht zu verwenden, solange Sie sicher sein können, dass die Quelle des Codes von Ihnen oder dem tatsächlichen Benutzer stammt. Obwohl er manipulieren kann, was in die eval () - Funktion gesendet wird, ist dies kein Sicherheitsproblem, da er den Quellcode der Website manipulieren und daher den JavaScript-Code selbst ändern kann.

Also ... wann sollte man eval () nicht verwenden? Eval () sollte nur dann nicht verwendet werden, wenn die Möglichkeit besteht, dass Dritte dies ändern. Wie das Abfangen der Verbindung zwischen dem Client und Ihrem Server (aber wenn das ein Problem ist, verwenden Sie HTTPS). Sie sollten eval () nicht für das Parsen von Code verwenden, der von anderen wie in einem Forum geschrieben wurde.

Wenn es wirklich nötig ist, ist eval nicht böse. Aber 99,9% der Verwendungen von eval, über die ich stolpere, werden nicht benötigt (ohne setTimeout-Zeug).

Für mich ist das Böse keine Leistung oder gar ein Sicherheitsproblem (indirekt ist es beides). All diese unnötigen Verwendungen von eval tragen zu einer Wartungshölle bei. Refactoring-Tools werden abgeworfen. Die Suche nach Code ist schwierig. Unerwartete Auswirkungen dieser Bewertungen sind zahlreich.

Wann ist eval () von JavaScript nicht böse?

Ich versuche immer davon abzuraten, eval zu verwenden . Fast immer ist eine sauberere und wartbarere Lösung verfügbar. Eval wird nicht einmal für das JSON-Parsing benötigt . Eval trägt zur Hölle der Wartung bei . Nicht ohne Grund wird es von Meistern wie Douglas Crockford verpönt.

Aber ich habe ein Beispiel gefunden, wo es verwendet werden sollte :

Wenn Sie den Ausdruck übergeben müssen.

Zum Beispiel habe ich eine Funktion, die ein allgemeines google.maps.ImageMapTypeObjekt für mich erstellt, aber ich muss ihm das Rezept mitteilen, wie die Kachel-URL aus den Parametern zoomund erstellt coordwerden soll:

my_func({
    name: "OSM",
    tileURLexpr: '"http://tile.openstreetmap.org/"+b+"/"+a.x+"/"+a.y+".png"',
    ...
});

function my_func(opts)
{
    return new google.maps.ImageMapType({
        getTileUrl: function (coord, zoom) {
            var b = zoom;
            var a = coord;
            return eval(opts.tileURLexpr);
        },
        ....
    });
}

Mein Beispiel für die Verwendung von eval: import .

Wie es normalerweise gemacht wird.

var components = require('components');
var Button = components.Button;
var ComboBox = components.ComboBox;
var CheckBox = components.CheckBox;
...
// That quickly gets very boring

Aber mit Hilfe evalund einer kleinen Hilfsfunktion sieht es viel besser aus:

var components = require('components');
eval(importable('components', 'Button', 'ComboBox', 'CheckBox', ...));

importable könnte so aussehen (diese Version unterstützt nicht das Importieren konkreter Elemente).

function importable(path) {
    var name;
    var pkg = eval(path);
    var result = '\n';

    for (name in pkg) {
        result += 'if (name !== undefined) throw "import error: name already exists";\n'.replace(/name/g, name);
    }

    for (name in pkg) {
        result += 'var name = path.name;\n'.replace(/name/g, name).replace('path', path);
    }
    return result;
}

Eval ist nicht böse, nur missbraucht.

Wenn Sie den darin enthaltenen Code erstellt haben oder ihm vertrauen können, ist dies in Ordnung. Die Leute reden immer wieder darüber, dass Benutzereingaben bei eval keine Rolle spielen. Na irgendwie ~

Wenn Benutzereingaben an den Server gesendet werden, wird diese an den Client zurückgegeben, und dieser Code wird in eval verwendet, ohne bereinigt zu werden. Herzlichen Glückwunsch, Sie haben die Pandora-Box geöffnet, damit Benutzerdaten an jeden gesendet werden können.

Je nachdem, wo sich die Bewertung befindet, verwenden viele Websites SPAs, und die Bewertung könnte dem Benutzer den Zugriff auf Anwendungsinternale erleichtern, die sonst nicht einfach gewesen wären. Jetzt können sie eine gefälschte Browser-Erweiterung erstellen, die diese Auswertung aufzeichnet und erneut Daten stiehlt.

Ich muss nur herausfinden, wozu Sie die Bewertung verwenden. Das Generieren von Code ist nicht wirklich ideal, wenn Sie einfach Methoden erstellen können, um solche Dinge zu tun, Objekte zu verwenden oder dergleichen.

Nun ein schönes Beispiel für die Verwendung von eval. Ihr Server liest die von Ihnen erstellte Swagger-Datei. Viele der URL-Parameter werden im Format erstellt {myParam}. Sie möchten also die URLs lesen und sie dann in Vorlagenzeichenfolgen konvertieren, ohne komplexe Ersetzungen vornehmen zu müssen, da Sie über viele Endpunkte verfügen. Sie können also so etwas tun. Beachten Sie, dass dies ein sehr einfaches Beispiel ist.

const params = { id: 5 };

const route = '/api/user/{id}';
route.replace(/{/g, '${params.');

// use eval(route); to do something

Codegenerierung. Ich habe kürzlich eine Bibliothek namens Hyperbars geschrieben, die die Lücke zwischen Virtual-Dom und Lenker schließt . Dazu wird eine Lenkervorlage analysiert und in Hyperskript konvertiert . Das Hyperskript wird zuerst als Zeichenfolge generiert und vor der Rückgabe eval()in ausführbaren Code umgewandelt. Ich habe eval()in dieser besonderen Situation das genaue Gegenteil des Bösen gefunden.

Grundsätzlich aus

<div>
    {{#each names}}
        <span>{{this}}</span>
    {{/each}}
</div>

Dazu

(function (state) {
    var Runtime = Hyperbars.Runtime;
    var context = state;
    return h('div', {}, [Runtime.each(context['names'], context, function (context, parent, options) {
        return [h('span', {}, [options['@index'], context])]
    })])
}.bind({}))

Die Leistung von eval()ist auch in einer solchen Situation kein Problem, da Sie die generierte Zeichenfolge nur einmal interpretieren und dann die ausführbare Ausgabe mehrmals wiederverwenden müssen.

Sie können sehen, wie die Codegenerierung erreicht wurde, wenn Sie neugierig sind .

Meiner Meinung nach ist eval eine sehr leistungsfähige Funktion für clientseitige Webanwendungen und sicher ... So sicher wie JavaScript, die es nicht sind. :-) Die Sicherheitsprobleme sind im Wesentlichen ein serverseitiges Problem, da Sie jetzt mit einem Tool wie Firebug jede JavaScript-Anwendung angreifen können.

Eval ist nützlich für die Codegenerierung, wenn Sie keine Makros haben.

Zum Beispiel (ein dummes) Beispiel, wenn Sie einen Brainfuck- Compiler schreiben , möchten Sie wahrscheinlich eine Funktion erstellen, die die Befehlsfolge als Zeichenfolge ausführt, und sie auswerten, um eine Funktion zurückzugeben.

Wenn Sie eine JSON-Struktur mit einer Analysefunktion analysieren (z. B. jQuery.parseJSON), wird eine perfekte Struktur der JSON-Datei erwartet (jeder Eigenschaftsname steht in doppelten Anführungszeichen). JavaScript ist jedoch flexibler. Daher können Sie eval () verwenden, um dies zu vermeiden.