Die Funktion von eval ist eigentlich sehr einfach. Sie besteht darin, eine Zeichenfolge an den JS-Interpreter zu übergeben, und der Javascript-Interpreter interpretiert die Zeichenfolge in Javascript-Code und führt ihn aus.
Nehmen Sie das einfachste Beispiel:
Kopieren Sie den Codecode wie folgt:
<script type="text/javascript">
eval("alert(1+1)");
Skript>
Es ist ganz einfach: Interpretieren Sie die Zeichenfolge in JS-Code und führen Sie sie aus. 2 wird angezeigt.
Natürlich ist das obige Beispiel nur ein Spielzeug, und niemand wäre dumm genug, es in der Praxis anzuwenden. Ich denke, die einfachste Möglichkeit, die Auswertungsfunktion zu verwenden, ist im DOM. Wenn wir beispielsweise div1, div2 und div3 haben, gibt es keine Möglichkeit, unsere ID zu erhalten, wenn wir document.getElementByID verwenden Verwenden Sie es in einer for-Schleife. Verwenden Sie eval, um ein solches Programm zu verbinden. Zum Beispiel:
Kopieren Sie den Codecode wie folgt:
<script type="text/javascript">
for (var Schleife = 1; Schleife < 10; Schleife++) {
eval('document.getElementById("div"+loop).innerHTML="123"');
}
Skript>
Nachdem ich über die grundlegendste Verwendung gesprochen habe, glaube ich, dass jeder immer noch an dieser Funktion interessiert ist. Wenn diese Funktion nur so wenige Verwendungsmöglichkeiten hat, wäre es zu langweilig. Dann schauen wir uns die Funktion eval() Stück für Stück an.
Beginnen wir mit dem Umfang von eval und schauen uns diese Funktion an:
Kopieren Sie den Codecode wie folgt:
<script type="text/javascript">
eval("var i=3");
alarm(i);
Skript>
Der Code ist sehr einfach und das Ergebnis kann angezeigt werden 3. Vergleichen Sie als Nächstes diesen Code:
Kopieren Sie den Codecode wie folgt:
<script type="text/javascript">
var test = function () {
eval("var i=3");
alarm(i);
}
prüfen();
alarm(i);
Skript>
Das Ergebnis ist, dass zuerst 3 und dann undefiniert angezeigt wird.
Erklären Sie also: Der von der Funktion eval () dynamisch ausgeführte Code erstellt keinen neuen Bereich, und sein Code wird im aktuellen Bereich ausgeführt. Mit anderen Worten: Die Funktion eval() kann auch dieses, Argument und andere Objekte im aktuellen Bereich verwenden.
Im IE wird eine Funktion unterstützt, die eval() sehr ähnlich ist: execScript(). Wir können einen einfachen Code schreiben.
Kopieren Sie den Codecode wie folgt:
<script type="text/javascript">
var test = function () {
execScript("var i=3");
alarm(i);
}
prüfen();
alarm(i);
Skript>
Als Ergebnis sind zwei 3s aufgetaucht. Dies zeigt auch die Eigenschaften der execScript-Funktion. Erstens ist sie ähnlich wie eval. Sie kann Zeichenfolgen in JS-Code interpretieren und ausführen, aber ihr Umfang entspricht nicht dem aktuellen Bereich der globale Geltungsbereich. Wenn wir den obigen Code in Firefox und Google Chrome ausprobieren, stellen wir fest, dass der Code in execScript in Firefox ungültig ist, was ebenfalls ein Problem mit der Browserkompatibilität des execScript-Codes darstellt.
Dann stellt sich die Frage, wie wir die „Vorteile“ dieser beiden Funktionen, also globale + Browserkompatibilität, zusammenbringen können. Ich habe online gesucht und es selbst zusammengefasst, was wahrscheinlich so ist:
Kopieren Sie den Codecode wie folgt:
<script type="text/javascript">
var StrongEval = Funktion (Code) {
if (window.navigator.userAgent.indexOf("MSIE") >= 1) {
execScript(code);
}
if (window.navigator.userAgent.indexOf("Firefox") >= 1) {
window.eval(code);
}
anders {
execScript(code);
}
};
var Test = function () {
StrongEval("var i=3");
}
Prüfen();
alarm(i);
Skript>
Auf diese Weise kann es perfekt mit FF und IE kompatibel sein. Der wesentliche Code ist, dass eval und window.eval in FF nicht gleichwertig sind.
Darüber hinaus können wir auch eval+with verwenden, um einige seltsame Tricks zu erreichen.
Im Allgemeinen können wir Code wie folgt schreiben:
Kopieren Sie den Codecode wie folgt:
var obj = Funktion () {
this.a = 1;
this.b = 2;
this.c = 5;
this.fun = function () {
this.c = this.a + this.b;
}
};
var o = neues obj();
o.fun();
alarm(oc);
Oder das hier:
Kopieren Sie den Codecode wie folgt:
var obj = {
a: 1,
b: 2,
c: 5,
Spaß: Funktion () {
this.c = this.a + this.b;
}
}
Oder das hier:
Kopieren Sie den Codecode wie folgt:
var obj = Funktion () {
this.a = 1;
this.b = 2;
this.c = 5;
};
obj.prototype.fun = function () {
this.c = this.a + this.b;
}
var o = neues obj();
o.fun();
alarm(oc);
Egal was passiert, haben Sie dieses Gefühl satt? Dann lasst uns einen ganz anderen Ansatz wählen, damit es zumindest für die Sinne angenehmer ist.
Kopieren Sie den Codecode wie folgt:
<script type="text/javascript">
var funtemp = function () {
c = a + b;
}
var obj = {
a: 1,
b: 2,
c: 5
};
Var Spaß;
mit (obj) {
eval("fun = " + funtemp);
}
Spaß();
alarm(obj.c);
Skript>
Dieser ist sehr forciert und so gut. Wir werden nicht darüber diskutieren, ob er bequem aussieht oder nicht. Lassen Sie uns eine solche Situation besprechen.
Kopieren Sie den Codecode wie folgt:
<Skript>
varDBCommon = function () {
alarm("1."); CreateConnection();
alarm("2."); OpenConnection();
alarm("3."); CreateCommand();
alarm("4."); ExcuteCommand();
alarm("5."); CloseConnection();
}
var SQLServerCommon = {
CreateConnection: function () { Alert("SQL Server-Verbindung herstellen" },
OpenConnection: function () { warning("SQL Server-Verbindung öffnen" },
CreateCommand: function () { Alert("SQL Server-Befehl erstellen" },
ExcuteCommand: function () { Alert("DSQL Server-Befehl ausführen" },
CloseConnection: function () { warning("SQL Server-Verbindung schließen" }
};
var OracleCommon = {
CreateConnection: function () { Alert("Oracle-Verbindung herstellen" },
OpenConnection: function () { Alert("Open aOracle Connection" },
CreateCommand: function () { Alert("Oracle-Befehl erstellen" },
ExcuteCommand: function () { Alert("DOracle-Befehl ausführen" },
CloseConnection: function () { Alert("Close?Oracle-Verbindung" }
};
mit (SQLServerCommon) {
eval("forSQLServer=" + DBCommon);
}
mit (OracleCommon) {
eval("forOracle=" + DBCommon);
}
forSQLServer();
forOracle();
Skript>
Können wir uns das als einfaches Vorlagenmethodenmuster vorstellen? hehe. Wir können dies auch mit eval und with aufrufen, um den Kontext einer Funktion zu ändern.
Aber andererseits wird Eval in allgemeinen Situationen selten verwendet und wir können es komplett vermeiden.