Lesen Sie diesen Artikel über JS, wenn Sie Zeit haben

Funktionen sind die Grundlage für die modulare Programmierung. Um komplexe Ajax-Anwendungen zu schreiben, müssen Sie über ein tieferes Verständnis der Funktionen verfügen.

Funktionen in JavaScript unterscheiden sich von anderen Sprachen. Jede Funktion wird als Objekt verwaltet und ausgeführt. Über die Eigenschaften von Funktionsobjekten können Sie ganz einfach einer Variablen eine Funktion zuweisen oder die Funktion als Parameter übergeben. Bevor wir fortfahren, werfen wir einen Blick auf die Syntax für die Verwendung von Funktionen:

Das Folgende ist ein Zitatfragment:

function func1(…){…}
var func2=function(…){…};
var func3=function func4(…){…};
var func5=new Function();

Dies ist die korrekte Syntax für die Deklaration von Funktionen. Sie unterscheiden sich stark von gängigen Funktionen in anderen Sprachen oder den zuvor eingeführten Methoden zur Funktionsdefinition. Warum kann es also in JavaScript so geschrieben werden? Welcher Syntax folgt es? Diese werden im Folgenden beschrieben.

　Funktionsobjekt verstehen

Sie können das Funktionsschlüsselwort verwenden, um eine Funktion zu definieren, einen Funktionsnamen für jede Funktion angeben und sie über den Funktionsnamen aufrufen. Wenn JavaScript interpretiert und ausgeführt wird, werden Funktionen als Objekt verwaltet, bei dem es sich um das einzuführende Funktionsobjekt handelt.

Funktionsobjekte unterscheiden sich wesentlich von anderen benutzerdefinierten Objekten, z. B. Datumsobjekt (Date), Array-Objekt (Array) und String-Objekt (String All). sind interne Objekte. Die Konstruktoren dieser integrierten Objekte werden von JavaScript selbst definiert: Durch die Ausführung einer Anweisung wie new Array() zur Rückgabe eines Objekts verfügt JavaScript über einen internen Mechanismus zur Initialisierung des zurückgegebenen Objekts, anstatt dass der Benutzer angibt, wie das Objekt aufgebaut ist .

In JavaScript ist der entsprechende Typ eines Funktionsobjekts „Function“, genau wie der entsprechende Typ eines Array-Objekts „Array“ und der entsprechende Typ eines Datumsobjekts „Date“ ist. Sie können ein Funktionsobjekt über new Function() erstellen. Oder Sie können ein Objekt über das Funktionsschlüsselwort erstellen. Zum besseren Verständnis vergleichen wir die Erstellung von Funktionsobjekten mit der Erstellung von Array-Objekten. Schauen wir uns zuerst das Array-Objekt an: Die folgenden beiden Codezeilen erstellen beide ein Array-Objekt myArray:

Das Folgende ist ein Referenzfragment:

var myArray=[];
//等价于
var myArray=new Array();

Ähnlich sind die folgenden zwei Zeilen von Code erstellt auch eine Funktion.

function myFunction(a,b){
return a+b;
}
//等价于
var myFunction=new Function("a","b","return a+b");

Durch den Vergleich mit der Anweisung zum Erstellen eines Array-Objekts können Sie die Art des Funktionsobjekts deutlich erkennen Wenn Sie auf diese Syntax stoßen, wird im obigen Code und im Interpreter automatisch ein Funktionsobjekt erstellt, um die Funktion als internes Objekt zu speichern und auszuführen. Daraus ist auch ersichtlich, dass ein Funktionsobjektname (Funktionsvariable) und ein gewöhnlicher Variablenname dieselben Spezifikationen haben. Beide können über den Variablennamen auf die Variable verweisen, dem Funktionsvariablennamen können jedoch Klammern und ein Parameter folgen Liste, um den Funktionsaufruf auszuführen.

Es ist nicht üblich, eine Funktion in Form von new Function() zu erstellen, da ein Funktionskörper normalerweise mehrere Anweisungen enthält. Wenn diese als Parameter in Form einer Zeichenfolge übergeben werden, beeinträchtigt dies die Lesbarkeit des Codes wird arm sein. Das Folgende ist eine Einführung in die Verwendungssyntax:

Das Folgende ist ein Zitatfragment:

var funcName=new Function(p1,p2,...,pn,body);

Die Parametertypen sind alle Zeichenfolgen, p1 bis pn stellen die Parameternamenliste dar Die erstellte Funktion und der Körper stellen alle dar. Die Funktionskörperanweisung der erstellten Funktion. funcName ist der Name der erstellten Funktion. Sie können eine leere Funktion erstellen, ohne Parameter anzugeben, und eine unbenannte Funktion erstellen, ohne funcName anzugeben. Natürlich hat eine solche Funktion keine Bedeutung.

Es ist zu beachten, dass p1 bis pn Listen mit Parameternamen sind, d. h. p1 kann nicht nur einen Parameter darstellen, sondern auch eine durch Kommas getrennte Parameterliste sein. Beispielsweise sind die folgenden Definitionen äquivalent :

Das Folgende ist ein Referenzfragment:

new Function("a", "b", "c", "return a+b+c")
new Function("a, b, c", "return a+b+c")
new Function("a,b", "c", "return a+b+c")

JavaScript führt den Funktionstyp ein und stellt Syntax wie new Function() bereit, da Funktionsobjekte den Funktionstyp verwenden müssen, um Eigenschaften und Methoden hinzuzufügen .

Das Wesentliche einer Funktion ist ein internes Objekt, und der JavaScript-Interpreter bestimmt, wie es funktioniert. Die durch den obigen Code erstellte Funktion kann über den Funktionsnamen im Programm aufgerufen werden. Die am Anfang dieses Abschnitts aufgeführten Probleme bei der Funktionsdefinition werden ebenfalls erläutert. Beachten Sie, dass Sie direkt nach der Funktionsdeklaration Klammern hinzufügen können, um anzuzeigen, dass die Funktion unmittelbar nach der Erstellung aufgerufen wird, zum Beispiel:

Das Folgende ist ein Referenzfragment:

var i=function (a,b){
return a+b;
}(1,2);
alert(i);

Dieser Code wird Zeigen Sie die Variable i an. Der Wert ist gleich 3. i stellt den zurückgegebenen Wert dar, nicht die erstellte Funktion, da die Klammern „(“ eine höhere Priorität haben als das Gleichheitszeichen „=“. Solcher Code wird möglicherweise nicht häufig verwendet, aber wenn der Benutzer dies möchte, ist dies eine gute Lösung für modulare Design oder um Namenskonflikte zu vermeiden

Es ist zu beachten, dass die folgenden beiden Methoden zum Erstellen von Funktionen gleichwertig sind:

Die folgenden sind:

function funcName(){
//函数体
}
//等价于
var funcName=function(){
//函数体
}

Aber die erstere Methode erstellt eine benannte Funktion, während die letztere Methode eine unbenannte Funktion erstellt und lediglich eine Variable auf die unbenannte Funktion verweist. Es gibt nur einen Unterschied in der Verwendung: Für eine benannte Funktion kann sie danach definiert werden es wird aufgerufen; für eine unbenannte Funktion muss sie definiert werden, bevor sie aufgerufen wird:

Das Folgende ist ein Referenzfragment:

＜script language="JavaScript" type="text/javascript"＞
＜!--
func();
var func=function(){
alert(1)
}
//--＞
＜/script＞

<> Diese Anweisung generiert ein undefiniertes Fehler für func und:

Das Folgende ist ein Zitatfragment:

＜script language="JavaScript" type="text/javascript"＞
＜!--
func();
function func(){
alert(1)
}
//--＞
＜/script＞

　　则能够正确执行，下面的语句也能正确执行：

以下是引用片段：

＜script language="JavaScript" type="text/javascript"＞
＜!--
func();
var someFunc=function func(){
alert(1)
}
//--＞
＜/script＞

　　由此可见，尽管JavaScript是一门解释型的语言，但它会在函数调用时，检查整个代码中是否存在相应的函数定义，这个函数名只有是通过function funcName()形式定义的才会有效，而不能是匿名函数。

　　函数对象和其他内部对象的关系

　　除了函数对象，还有很多内部对象，比如：Object、Array、Date、RegExp、Math、Error。这些名称实际上表示一个类型，可以通过new操作符返回一个对象。然而函数对象和其他对象不同，当用typeof得到一个函数对象的类型时，它仍然会返回字符串“function”，而typeof一个数组对象或其他的对象时，它会返回字符串“object”。下面的代码示例了typeof不同类型的情况：

以下是引用片段：

alert(typeof(Function)));
alert(typeof(new Function()));
alert(typeof(Array));
alert(typeof(Object));
alert(typeof(new Array()));
alert(typeof(new Date()));
alert(typeof(new Object()));

　　运行这段代码可以发现：前面4条语句都会显示“function”，而后面3条语句则显示“object”，可见new一个function实际上是返回一个函数。这与其他的对象有很大的不同。其他的类型Array、Object等都会通过new操作符返回一个普通对象。尽管函数本身也是一个对象，但它与普通的对象还是有区别的，因为它同时也是对象构造器，也就是说，可以new一个函数来返回一个对象，这在前面已经介绍。所有typeof返回“function”的对象都是函数对象。也称这样的对象为构造器（constructor），因而，所有的构造器都是对象，但不是所有的对象都是构造器。

　　既然函数本身也是一个对象，它们的类型是function，联想到C++、Java等面向对象语言的类定义，可以猜测到Function类型的作用所在，那就是可以给函数对象本身定义一些方法和属性，借助于函数的prototype对象，可以很方便地修改和扩充Function类型的定义，例如下面扩展了函数类型Function，为其增加了method1方法，作用是弹出对话框显示"function"：

以下是引用片段：

Functiothod1=function(){
alert("function");
}
function func1(a,b,c){
return a+b+c;
}
func1.method1();
functhod1();

　　注意最后一个语句：funchotd1()，它调用了method1这个函数对象的method1方法。虽然看上去有点容易混淆，但仔细观察一下语法还是很明确的：这是一个递归的定义。因为method1本身也是一个函数，所以它同样具有函数对象的属性和方法，所有对Function类型的方法扩充都具有这样的递归性质。