Der Unterschied zwischen allgemeinen Funktionen, die in javascript_javascript skills definiert sind

Die Unterschiede zwischen den häufigeren in JavaScript definierten Funktionen werden hauptsächlich durch die folgenden drei Aspekte erklärt. Freunde in Not können sich darauf beziehen

1: Rufen Sie die Schlüsselwortfunktion auf, um
zu erstellen

Zum Beispiel:

function distance(x1,x2,y1,y2) 
　　{ 
　　　　var dx=x2-x1; 
　　　　var dy=y2-y1; 
　　　　return Math.sqrt(dx*dx+dy*dy); 
　　} 

2: Verwenden Sie den Function()-Konstruktor

Zum Beispiel:

var f=new Function*"x","y","return x*y"); 

Diese Codezeile erstellt eine neue Funktion, die im Wesentlichen einer Funktion entspricht, die mit der Ihnen vertrauten Syntax definiert wurde:

function f(x,y) 
　　{ 
　　  return x*y; 
　　} 

Der Functino()-Konstruktor kann eine beliebige Anzahl von String-Parametern akzeptieren. Ihr letzter Parameter ist der Hauptteil der Funktion, der beliebige, durch Semikolons getrennte JavaScript-Anweisungen enthalten kann. Die anderen Parameter sind Zeichenfolgen, die zur Beschreibung der Namen der formalen Parameter verwendet werden, die von der Funktion definiert werden sollen. Wenn die von Ihnen definierte Funktion keine Parameter hat, können Sie einfach eine Zeichenfolge (den Hauptteil der Funktion) an den Konstruktor übergeben.

Beachten Sie, dass keiner der an den Konstruktor Function() übergebenen Parameter den Namen der Funktion angibt, die er erstellt. Unbenannte Funktionen, die mit dem Function()-Konstruktor erstellt wurden, werden manchmal als „anonyme Funktionen“ bezeichnet.

Vielleicht sind Sie sehr neugierig, wofür der Function()-Konstruktor verwendet wird. Warum können wir nicht einfach Funktionsanweisungen verwenden, um alle Funktionen zu definieren? Der Grund dafür ist, dass der Function()-Konstruktor es uns ermöglicht, eine Funktion dynamisch zu erstellen und zu kompilieren, ohne uns auf den vorkompilierten Funktionskörper der Funktionsanweisung zu beschränken. Der Nebeneffekt davon ist, dass der Function()-Konstruktor bei jedem Aufruf einer Funktion diese kompilieren muss. Daher sollten wir diesen Konstruktor nicht häufig in Schleifenkörpern oder in häufig verwendeten Funktionen aufrufen.

Ein weiterer Grund für die Verwendung des Function()-Konstruktors besteht darin, dass er die Funktion als Teil eines JavaScript-Ausdrucks definieren kann, anstatt sie als Anweisung zu definieren.

3: Funktionsliteral

Ein Funktionsliteral ist ein Ausdruck, der eine anonyme Funktion definieren kann. Die Syntax eines Funktionsliterals ist der einer Funktionsanweisung sehr ähnlich, mit der Ausnahme, dass sie als Ausdruck und nicht als Anweisung verwendet wird und kein Funktionsname angegeben werden muss. Die folgenden drei Codezeilen definieren drei grundsätzlich gleiche Funktionen mithilfe der function()-Anweisung, des Function()-Konstruktors und des Funktionsliterals:

function f(x){return x*x}; 
　　var f=new Function("x","return x*x;"); 
　　var f=function(x){reurn x*x}; 

Obwohl das Funktionsliteral eine unbenannte Funktion erstellt, gibt seine Syntax auch an, dass es einen Funktionsnamen angeben kann, was beim Schreiben einer rekursiven Funktion, die sich selbst aufruft, sehr nützlich ist.

Zum Beispiel:

var f=function fact(x){if(x<=1)return 1;else return x*fact(x-1);}; 

Der obige Code definiert eine unbenannte Funktion und speichert einen Verweis darauf in der Variablen f. Dabei wird keine Funktion mit dem Namen fact() erstellt, sondern der Funktionskörper kann lediglich mit diesem Namen auf sich selbst verweisen. Beachten Sie jedoch, dass dieses benannte Funktionsliteral in Versionen vor JavaScript 1.5 nicht korrekt implementiert wurde.

Die Verwendung von Funktionsliteralen ist der Methode zum Erstellen von Funktionen mit dem Function()-Konstruktor sehr ähnlich. Da sie durch JavaScript-Ausdrücke und nicht durch Anweisungen erstellt werden, ist ihre Verwendung flexibler, insbesondere für Funktionen, die nur einmal verwendet werden und nicht benannt werden müssen. Beispielsweise kann eine mit einem Funktionsliteralausdruck angegebene Funktion in einer Variablen gespeichert, an andere Funktionen übergeben oder sogar direkt aufgerufen werden:

a[0]=function(x){return x*x;};//定义一个函数并保存它 
　　a.sort(function(a,b){return a-b;});//定义一个函数；把它传递给另一个函数 
　　var tensquared=(function(x){return x*x;})(10); 

　　和Function()构造函数一样，函数直接量创建的是未命名函数，而且不会自动地将这个函数存储在属性中。但是，比起Function()构造函数来说，函数直接量有一个重要的优点。由Function()构造函数创建的函数的主体必须用一个字符串说明，用这种方式来表达一个长而复杂的函数是狠笨拙的。但是函数直接量的主体使用的却是标准的JavaScript语法。而且函数直接量只被解析一次，而作为字符串传递给Function()构造函数的JavaScript代码则在每次调用构造函数时只需被解析一次和编译一次。

　　 　　在JavaScript1.1中，可以使用构造函数Function()来定义函数，在JavaScript1.2和其后的版本中，还可以使用函数直接量来构造函数。你应该注意这两种方法之间的重要差别。

　　首先，构造函数Function()允许在运行时动态地创建和编译JavaScript代码。但是函数直接量却是函数结构的一个静态部分，就像function语句一样。

　　其次，作为第一个差别的必然结果，每次调用构造函数Function()时都会解析函数体并且创建一个新东汉数对象。如果对构造函数的调用出现在一个循环中，或者出现在一个经常被调用的函数中，这种方法的效率非常低。另一个方面，函数直接量或出现在循环和函数中的嵌套函数不是在每次调用时都被重新编译，而且每当遇到一个函数直接量时也不创建一个新的函数对象。

　　Function()构造函数和函数之间量之间的第三点差别是，使用构造函数Function()创建的函数不使用词法作用域，相反的，它们总是被当作顶级函数来编译，就像下面代码所说明的那样：

　var y="global"; 
　　function constructFunction() 
　　{ 
　　　　var y="local"; 
　　　　return new Function("return y");//不捕捉局部作用域。 
　　} 
　　//这行代码将显示"global"，因为Function()构造函数返回的函数并不使用局部作用域。 
　　//假如使用一个函数直接量，这行代码则可能显示"local"。 
　　alert(constructFunction());