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

StackOverflow https://stackoverflow.com/questions/197769

  •  10-07-2019
  •  | 
  •  

Frage

Ich schreibe einig JavaScript-Code vom Benutzer eingegebenen Funktionen (für tabellenähnliche Funktionalität) zu analysieren. Nachdem die Formel analysiert I könnte wandelt es in JavaScript und führen eval() darauf das Ergebnis zu erhalten.

Allerdings habe ich scheue immer weg von der Verwendung eval() wenn ich es vermeiden kann, weil es böse ist (und zu Recht oder zu Unrecht, habe ich immer gedacht, es noch böse in JavaScript ist, da der Code ausgewertet werden konnte vom Benutzer geändert).

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

War es hilfreich?

Lösung

Ich möchte einen Moment Zeit nehmen, die Prämisse Ihrer Frage zu beantworten - das eval () ist „ böse “. Das Wort „ böser “, wie Programmiersprache Menschen verwendet wird, bedeutet in der Regel „gefährlich“, oder genauer gesagt „in der Lage viele Schaden mit einem einfachen aussehenden Befehl zu verursachen“. Also, wann ist es in Ordnung, etwas Gefährliches zu benutzen? Wenn Sie wissen, was die Gefahr ist, und wenn Sie die entsprechenden Vorsichtsmaßnahmen einnehmen.

Auf den Punkt gebracht, lassen Sie uns bei der Verwendung von eval auf die Gefahren sehen (). Es gibt wahrscheinlich viele kleine versteckte Gefahren wie alles andere, aber die beiden großen Risiken - der Grund, warum eval () Übel angesehen wird - sind Leistung und Code-Injektion

.
  • Performance - eval () führt den Interpreter / Compiler. Wenn Ihr Code kompiliert wird, dann ist dies ein großer Erfolg, weil Sie einen möglicherweise schweren Compiler in der Mitte der Laufzeit aufrufen müssen. Allerdings JavaScript ist meist noch eine interpretierte Sprache, was bedeutet, dass eval () aufrufen, ist keine große Leistungseinbußen im allgemeinen Fall (aber meine spezifischen Bemerkungen siehe unten).
  • Code-Injektion - eval () führt möglicherweise eine Reihe von Code unter erhöhten Privilegien. Zum Beispiel würde ein Programm läuft als Administrator / root will nie () Benutzereingaben eval, weil die Eingabe potenziell „rm -rf / etc / important-Datei“ oder noch schlimmer sein könnte. Wieder JavaScript in einem Browser nicht über dieses Problem, weil das Programm ohnehin in dem eigenen Benutzerkonto ausgeführt wird. Serverseitiges JavaScript könnte dieses Problem hat.

Auf Ihren speziellen Fall. Von dem, was ich verstehe, du bist die Saiten selbst zu erzeugen, so vorausgesetzt, sind Sie vorsichtig, nicht eine Zeichenfolge wie „rm -rf etwas wichtigen“ zu ermöglichen, erzeugt werden, gibt es keine Code-Injektion Risiko (aber bitte denken Sie daran, es ist sehr, sehr hart diese im allgemeinen Fall) zu gewährleisten. Auch, wenn Sie im Browser laufen dann Code-Injektion ist ein ziemlich geringeres Risiko, glaube ich.

Was die Leistung, werden Sie, um Gewicht haben, dass gegen eine einfache Codierung. Es ist meine Meinung, dass, wenn Sie die Formel sind Parsen, Sie könnte genauso gut das Ergebnis während der Parse berechnen, anstatt einen anderen Parser laufen (die eine Innen eval ()). Aber es kann einfacher sein, eval zu kodieren () verwendet, und die Leistung getroffen wird wahrscheinlich nicht wahrnehmbar sein. Es sieht aus wie eval () ist in diesem Fall nicht mehr Übel als jede andere Funktion, die möglicherweise Sie etwas Zeit sparen können.

Andere Tipps

eval() ist nicht böse. Oder, wenn es ist, es ist das Böse in der gleichen Weise, Reflexion, Datei / Netzwerk-I / O, Gewindeschneiden, und IPC sind „böse“ in anderen Sprachen.

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

Wenn Sie Vertrauen in der Quelle.

Bei JSON ist es mehr oder weniger schwer mit der Quelle zu manipulieren, weil sie von einem Web-Server kommen Sie steuern. Solange die JSON selbst keine Daten enthält, ein Benutzer hochgeladen hat, gibt es keinen großen Nachteil eval zu verwenden.

In allen anderen Fällen würde ich große Mühe, um Benutzer gelieferten Daten entsprechen meine Regeln zu gewährleisten vor der Fütterung es () eval.

Lassen Sie sich echt Leute bekommen:

  1. Jeder große Browser verfügt nun über eine integrierte Konsole, die Ihr Möchtegern-Hacker mit einer Fülle nutzen können jede Funktion mit einem beliebigen Wert aufzurufen - warum sollten sie eine eval-Anweisung verwenden plagen - auch wenn sie nur konnten

  2. Wenn es 0,2 Sekunden dauert 2000 Zeilen JavaScript zu kompilieren, was ist meine Leistungseinbuße, wenn ich vier Zeilen von JSON eval?

Auch Crockford Erklärung für ‚eval ist böse‘ ist schwach.

  

eval ist böse, die Funktion eval ist die missbräuchlich verwendete Merkmal   JavaScript. Vermeiden Sie es

Wie Crockford könnte sich sagen: „Diese Art von Aussage neigt irrational Neurose zu erzeugen. Verwenden Sie es nicht kaufen.“

Das Verständnis eval und zu wissen, wann es sinnvoll sein könnte, ist viel wichtiger. Zum Beispiel eval ist ein sinnvolles Tool Server-Antworten für die Bewertung, die von der Software generiert wurde.

BTW: Prototype.js ruft eval direkt fünfmal (einschließlich in evalJSON () und evalResponse ()). jQuery verwendet es in parseJSON (über Funktions Konstruktor).

neige ich dazu, Crockford Beratung eval() zu folgen, und es ganz zu vermeiden. Auch Möglichkeiten, die es nicht tun zu erfordern scheinen. Zum Beispiel ermöglicht die setTimeout() Sie eine Funktion zu übergeben, statt eval. 

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

Auch wenn es ein vertraut Quelle, ich verwende es nicht, da der Code von JSON zurückgegeben könnte verstümmelt werden, die bestenfalls wackelig etwas tun könnte, im schlimmsten Fall, etwas schlecht aus.

Eval ist komplementär zu Kompilation, die in Templating den Code verwendet wird. Durch Templating meine ich, dass Sie einen vereinfachtes Template-Generator schreiben, die nützlichen Template-Code erzeugt, die Entwicklungsgeschwindigkeit erhöht.

Ich habe einen Rahmen geschrieben, in denen Entwickler EVAL nicht verwenden, aber sie nutzen unsere Rahmen und wiederum, dass Rahmen EVAL zu verwenden hat Vorlagen zu erzeugen.

Performance von EVAL kann unter Verwendung des folgenden Verfahrens erhöht werden; stattdessen das Skript auszuführen, müssen Sie eine Funktion zurück. 

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

Es sollte organisiert werden 

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

var a = f(3,5);

Caching f wird sicherlich die Geschwindigkeit verbessern.

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

In Bezug auf Sicherheit, mit eval oder nicht, wird kaum einen Unterschied machen,

  1. Zunächst einmal ruft der Browser das gesamte Skript in einer Sandbox.
  2. Jeder Code, der in EVAL böse ist, ist das Böse im Browser selbst. Der Angreifer oder kann jeder leicht einen Skript Knoten in DOM injizieren und alles tun, wenn er / sie etwas eval kann. Nicht mit EVAL wird keinen Unterschied machen.
  3. Es ist vor allem eine schlechte serverseitige Sicherheit, die schädlich ist. Schlechte Cookies Validierung oder schlechte ACL-Implementierung auf dem Server verursacht die meisten Angriffe.
  4. Ein aktueller Java Verwundbarkeit usw. gab es in Java nativen Code. JavaScript war und ist so konzipiert, in einer Sandbox ausgeführt werden, während Applets usw. entworfen wurden mit Zertifikaten außerhalb einer Sandbox ausgeführt werden, die zu Schwachstellen und viele andere Dinge führen.
  5. Schreiben Code einen Browser zur Nachahmung ist nicht schwer. Alles was Sie tun müssen, ist eine HTTP-Anfrage mit Ihrem Lieblings-User-Agent-String an den Server. Alle Tests-Tools Mock-Browser sowieso; wenn ein Angreifer Ihnen schaden will, ist EVAL ihr letzter Ausweg. Sie haben viele andere Möglichkeiten, mit Ihrer serverseitigen Sicherheit zu befassen.
  6. Der Browser DOM hat keinen Zugriff auf Dateien und keinen Benutzernamen. In der Tat nichts an der Maschine, die eval Zugang zu geben.

Wenn Ihr serverseitige Sicherheits solide genug ist, um für jedermann von überall angreifen, sollten Sie nicht über EVAL kümmern. Wie bereits erwähnt, würde, wenn EVAL nicht vorhanden ist, haben Angreifer viele Werkzeuge in Ihren Server hacken, unabhängig von Ihrem Browser EVAL-Fähigkeit.

Eval ist nur gut für einige Vorlagen Erzeugung komplexe Stringverarbeitung, etwas zu tun, basierend auf, die nicht im Voraus verwendet wird. Zum Beispiel wird es vorziehen, I 

"FirstName + ' ' + LastName"

Im Gegensatz zu 

"LastName + ' ' + FirstName"

Als meine Anzeigenamen, die aus einer Datenbank kommen können und die fest einprogrammiert nicht.

Ich sah Menschen befürworten eval nicht zu verwenden, da ist böse , aber ich sah die gleichen Leute verwenden Funktion und SetTimeout dynamisch, so dass sie verwenden eval unter den Hauben : D

BTW, wenn die Sandbox nicht sicher genug ist (zum Beispiel, wenn Sie auf einer Website arbeiten, die Code-Injektion erlauben) eval ist die letzte Ihre Probleme. Die Grundregel der Sicherheit ist, dass alle Eingang ist schlecht, aber im Fall von JavaScript noch JavaScript selbst böse sein könnte, weil in JavaScript Sie jede Funktion überschreiben und Sie können einfach ‚t sein, dass Sie die wirkliche verwenden, so, wenn ein böswilliger Code starten, bevor Sie, Sie kein JavaScript eingebaute Funktion vertrauen können: D

Nun ist der Epilog zu diesem Beitrag ist:

Wenn Sie wirklich müssen sie (80% der Zeit eval ist nicht erforderlich) und Sie sind sicher, was du tust‘, nur eval (oder bessere Funktion;)), Verschlüsse und OOP decken die 80/90% des Falles, wo eval ersetzt werden kann, eine andere Art von Logik, der Rest wird dynamisch generierten Code (zum Beispiel, wenn Sie einen Dolmetscher gerade schreiben) und wie Sie sagte bereits JSON Bewertung (hier gibt es die Crockford sichere Auswertung verwenden kann;))

Wenn in Chrome (v28.0.1500.72) Debuggen, fand ich, dass Variablen nicht zu Schließungen gebunden, wenn sie nicht in einer verschachtelten Funktion verwendet werden, die die Schließung erzeugt. Ich denke, das ist eine Optimierung der JavaScript-Engine.

ABER : Wenn eval() wird in einer Funktion verwendet, die einen Verschluss bewirkt, Alle die Variablen der äußeren Funktionen zur Schließung gebunden sind, auch wenn sie nicht verwendet werden, alle. Wenn jemand hat die Zeit zu testen, ob Speicherlecks durch die hergestellt werden können, lassen Sie mir einen Kommentar unten.

Hier ist mein Test-Code: 

(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();
})();

Was Ich mag hier darauf hinzuweisen ist, dass eval () muss nicht unbedingt auf die native eval() Funktion beziehen. Es hängt alles von dem Namen der Funktion . Also, wenn das native eval() mit einem Aliasnamen aufrufen (sagen var noval = eval; und dann in einer inneren Funktion noval(expression);) dann die Auswertung der expression fehlschlagen kann, wenn es um Variablen bezieht, die Teil des Verschlusses sein sollte, ist aber eigentlich nicht.

Microsoft erklärt, warum eval () in ihrem Browser auf dem IE Blog langsam ist, IE + JavaScript Leistungsempfehlungen Teil 2:. JavaScript-Code Ineffizienzen

Die einzige Instanz, wenn Sie sollten mit eval () ist, wenn Sie dynamische JS on the fly ausführen müssen. Ich spreche von JS, die Sie asynchron vom Server herunterladen ...

... Und 9 mal von 10 könnte man leicht vermeiden, dass dabei durch Refactoring.

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

eval ist 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"] die gleiche wie obj.prop), Verschlüsse, objektorientierte Techniken, funktionelle Techniken -. verwenden sie stattdessen

Was Client-Skript geht, denke ich, das Thema Sicherheit ein strittiger Punkt ist. Alles geladen in den Browser unterliegt Manipulation und sollten als solche behandelt werden. Es gibt null Risiko eine eval () Anweisung in Verwendung, wenn es viel einfache Möglichkeiten, JavaScript-Code und / oder zu manipulieren Objekte im DOM, wie die URL-Leiste in Ihrem Browser.

auszuführen 
javascript:alert("hello");

Wenn jemand will, um ihren DOM manipulieren, sage ich weg schwingen. Sicherheit jede Art von Angriff verhindern sollte immer in der Verantwortung der Server-Anwendung, Punkt.

Aus pragmatischer Sicht gibt es keinen Vorteil ein eval () verwendet in einer Situation, wo Dinge anders getan werden. Allerdings gibt es bestimmte Fälle, in denen ein eval verwendet werden soll. Wenn ja, kann es auf jeden Fall ohne Gefahr der Sprengung 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>

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

Ich versuche immer verwenden eval entmutigen. Fast immer eine saubere und wartbare Lösung zur Verfügung steht. Eval ist nicht einmal für JSON Parsen benötigt. Eval fügt Wartung Hölle . Nicht ohne Grund ist es verpönt von Meistern wie Douglas Crockford.

Aber ich fand ein Beispiel, wo es sollte verwendet:

Wenn Sie den Ausdruck übergeben müssen.

Zum Beispiel, ich habe eine Funktion, die eine allgemeine google.maps.ImageMapType für mich Objekt, aber ich brauche es das Rezept zu sagen, wie soll es die Kachel-URL aus den zoom und coord Parameter konstruieren: 

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 eval:. Import

Wie es in der Regel getan. 

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

Aber mit Hilfe von eval und eine kleinen Helferfunktion es einen viel besseren Blick bekommt: 

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

importable aussehen könnte (diese Version nicht unterstützt Betonbauteile zu importieren). 

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;
}

Auf der Serverseite eval ist nützlich, wenn mit externen Scripts wie SQL oder influxdb oder Mongo handelt. Wo benutzerdefinierte Validierung zur Laufzeit kann ohne erneute Bereitstellung Ihre Dienste gemacht werden.

Zum Beispiel einer Leistung Service mit Metadaten folgenden 

{
  "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\"}`"
  }
}

, die dann erlauben,

  • Die direkte Injektion von Objekt / Wert durch Zeichenkette in einem json, nützlich für die Texte Templating

  • Kann die Verwendung als Komparator sein, sagen wir Regeln machen, wie Suche oder Veranstaltungen im CMS zu validieren

Con dieses:

  • Können Fehler im Code sein und die Dinge in dem Dienst brechen, wenn nicht vollständig getestet.

  • Wenn ein Hacker-Skript auf Ihrem System schreiben kann, dann sind Sie ziemlich viel geschraubt.

  • Eine Möglichkeit, das Skript zu validieren ist, den Hash Ihrer Skripte irgendwo sicher zu halten, so dass Sie sie vor der Ausführung überprüfen.

Ich denke, dass alle Fälle von eval gerechtfertigt wäre wäre selten. Du bist eher, es zu benutzen denken, dass es gerechtfertigt ist, als Sie sind, es zu benutzen, wenn es wirklich gerechtfertigt.

Die Sicherheitsprobleme sind die bekanntesten. Aber auch darüber im Klaren sein, dass JavaScript JIT-Kompilierung verwendet und das funktioniert sehr schlecht mit eval. Eval ist ein wenig wie ein Blackbox an den Compiler, und JavaScript muss in der Lage sein, Code zur Vorhersage vor der Zeit (bis zu einem gewissen Grad), um eine sichere und korrekte Leistung Optimierungen und Scoping gelten. In einigen Fällen kann die Auswirkungen auf die Leistung auch anderen Code außerhalb eval beeinflussen.

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

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

Code-Generierung. Ich schrieb vor kurzem eine Bibliothek namens Hyperbar , die die Lücke zwischen virtual-dom und Lenker . Es tut dies durch einen Lenker Template-Parsing und es hyperscript konvertieren. Die hyperscript wird als Zeichenkette erzeugte erste und bevor es zurückkehrt, eval() es es in ausführbaren Code zu drehen. Ich habe eval() in dieser besonderen Situation genau das Gegenteil des Bösen gefunden.

Im Grunde genommen von 

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

Um dies zu 

(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 kein Problem in einer Situation wie diese zu, weil Sie nur die generierte Zeichenfolge einmal interpretieren müssen und dann die ausführbare Ausgabe über viele Male wiederverwendet werden.

Sie können sehen, wie der Code-Generierung erreicht wurde, wenn Sie neugierig sind hier .

Es gibt keinen Grund, nicht eval () zu verwenden, solange Sie sicher sein können, dass die Quelle des Codes von Ihnen kommt oder den tatsächlichen Benutzer. Auch wenn er manipulieren kann, was in die Funktion eval () gesendet wird, das ist kein Sicherheitsproblem, weil er in der Lage ist, den Quellcode der Website zu manipulieren und damit den JavaScript-Code ändern könnte selbst.

Also ... wenn sie nicht verwenden eval ()? Eval () soll nicht nur verwendet werden, wenn es eine Chance gibt, dass ein Dritter sie ändern könnte. Wie Abfangen die Verbindung zwischen dem Client und dem Server (aber wenn das ein Problem ist, verwenden HTTPS). Sie sollten nicht eval () für das Parsen von Code, der von anderen wie in einem Forum geschrieben wird.

Wenn es wirklich benötigt wird eval ist nicht böse. Aber 99,9% der Verwendung von eval, die ich über stolpern ist nicht erforderlich (ohne SetTimeout Sachen).

Für mich ist das Böse ist keine Leistung oder sogar ein Sicherheitsproblem (na ja, indirekt ist es beides). All diese unnötige Verwendung von eval in einer Wartungs Hölle hinzuzufügen. Refactoring-Tools werden abgeworfen. für die Code-Suche ist hart. Unerwartete Auswirkungen dieser evals sind Legion.

Meine Überzeugung ist, dass eval ist eine sehr leistungsfähige Funktion für die clientseitige Web-Anwendungen und sicher ... So sicher wie JavaScript, die es nicht sind. :-) Die Sicherheitsprobleme sind im Wesentlichen ein serverseitige Problem, weil jetzt mit Werkzeug wie Firebug, Sie jede JavaScript-Anwendung angreifen können.

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

(ein dummes) Beispiel, wenn Sie ein Brainfuck Compiler, Sie ‚ll wahrscheinlich eine Funktion konstruieren möchten, dass die Abfolge von Anweisungen als String führt, und eval es eine Funktion zurückzukehren.

Wenn Sie eine JSON-Struktur mit einer Auswerte-Funktion (zum Beispiel jQuery.parseJSON) analysieren, erwartet es eine perfekte Struktur der JSON-Datei (jede Eigenschaft Namen in doppelten Anführungszeichen). Allerdings ist JavaScript flexibler. Daher können Sie eval () verwenden, um es zu vermeiden.

Lizenziert unter: CC-BY-SA mit Zuschreibung
Nicht verbunden mit StackOverflow
scroll top