Lassen Sie uns zunächst ein Beispiel geben. Die Funktion dieser Funktion besteht darin, die Summe der Array-Elemente zurückzugeben
.
var sum = 0;
for(var i = 0,aLength = arr.length;i < aLength;i++) {
sum += arr[i];
}
return sum; } Nach dem Schlüsselwort function steht ein sumArray . Seine Namenskonvention ist die gleiche wie bei Variablennamen: Er darf nicht mit beginnen eine Zahl und darf kein Schlüsselwort sein.
Die Parameter in Klammern, auch Formalparameter genannt, erfordern lediglich den Parameternamen. Parameter können 0 , 1 oder mehr sein, getrennt durch , und {} enthält den Funktionskörper . Enthält eine oder mehrere Anweisungen. Der Funktionskörper wird verwendet, um die Funktion der Funktion zu implementieren.
Auf das Schlüsselwort return folgt der Rückgabewert der Funktion, die Funktion kann aber auch keinen Rückgabewert haben. Nachdem die Ausführung der Funktion abgeschlossen ist, beendet die Anweisung „ return die Ausführung und die Anweisung unter return wird nicht mehr ausgeführt . Der Rückgabewert ist die Ausgabe der Funktion.
Eine auf diese Weise definierte Funktion kann sowohl vor als auch nach der Funktionsdefinition aufgerufen werden , sofern sich die Funktion und die die Funktion aufrufende Anweisung in derselben Quelldatei befinden.
, um eine Funktion mithilfe eines Ausdrucks zu definieren. Dies bedeutet, dass die Funktion mithilfe eines Zuweisungsausdrucks einer Variablen zugewiesen wird. Zu diesem Zeitpunkt kann die Funktion einen Namen oder keinen Namen haben. Eine Funktion ohne Namen wird als anonyme Funktion bezeichnet.
var funct = function getMax(a,b) {
return a>b?a:b; };//Beachten Sie, dass das Semikolon danach nicht fehlen darf, da wir eine Variable definieren. Anders als bei der Definition mit einer Funktionsanweisung kann die Funktion nur nach der Funktionsdefinitionsanweisung aufgerufen werden . Und beim Aufruf kann nur der Variablenname funct verwendet werden und der Funktionsname getMax kann nicht verwendet werden, wie zum Beispiel:
var funct = function getMax(a,b) {
return a>b?a:b;
};
console.log(funct(1,2));//Ausgabe 2 function :var funct = function(a,b) {
return a>b?a:b; Diese Funktion hat keinen Namen. Sie wird der Variablen funct zugewiesen und wird daher als anonyme Funktion bezeichnet. Ebenso kann diese Funktion erst nach dieser Anweisung aufgerufen werden.
var funct = function(a,b) {
return a>b?a:b; }; console.log(funct(1,2));// Zusammenfassung der Ausgabe 2: Die Definition einer Funktion mit einem Ausdruck kann nur dann verwendet werden, wenn sie definiert ist in dieser Anweisung verwendet werden Rufen Sie dann die Funktion
Im vierten Training haben wir eingeführt, dass Objekte ihre eigenen Methoden haben können, natürlich ist dies auch eine Funktion. Der Aufruf dieser Funktion unterscheidet sich geringfügig von den in den beiden vorherigen Ebenen definierten Funktionen.
//Definition der Funktion: Finden Sie den Maximalwert von drei Zahlen. Funktion max(a,b,c) {
if(a > b) {
if(a > c)
gib a zurück;
anders
return c;
}
anders {
if(b > c)
Rückkehr b;
anders
return c;
}
}
//Diese Funktion aufrufen var result = max(1,2,3);//result is 3
console.log(result);//Ausgabe 3 Beim Aufruf der Funktion müssen Sie die gleiche Anzahl spezifischer Werte wie die formalen Parameter übergeben. Die obige Funktion verfügt über 3 Parameter. Wenn Sie also unten aufrufen, übergeben Sie 3 spezifische Werte Werte, 1 wird an Parameter a übergeben, 2 wird an Parameter b übergeben 3 wird an Parameter c übergeben. Der Rückgabewert der Funktion wird über das Zuweisungssymbol = an die Variable result übergeben. Wenn im Funktionskörper kein Schlüsselwort return vorhanden ist, wird undefined zurückgegeben.
Im Objekt definierte Funktionen aufrufen:
var ob = {
ID:1,
getMax:function(a,b) {
return a>b?a:b;
} }; var result = ob.getMax(2,1);//Der Ergebniswert ist 2 var result1 = ob["getMax"](2,1);//Der Wert von result1 ist ebenfalls 2. Der Unterschied zu Das Obige ist, dass Sie hier zum Auffinden einer Funktion对象名.函数名oder对象名["函数名"] verwenden müssen, die anderen sind gleich.
In den meisten Programmiersprachen werden Anzahl und Typ der übergebenen Aktualparameter beim Aufruf einer Funktion überprüft, JavaScript prüft jedoch weder den Typ noch die Anzahl der Aktualparameter.
Die tatsächlichen Parameter in JavaScript stimmen in der Reihenfolge von links nach rechts mit den formalen Parametern überein, zum Beispiel:
function myFunction(a,b,c) {
console.log(a);
console.log(b);
console.log(c); } myFunction(1,2,3); Der Aktualparameter 1 wird an den Formalparameter a übergeben, der Aktualparameter 2 wird an den Formalparameter b übergeben und der Aktualparameter 3 wird an den übergeben formaler Parameter c . Wenn die Anzahl der tatsächlichen Parameter geringer ist als die der formalen Parameter, wird der Wert undefined an den rechten formalen Parameter übergeben. Zum Beispiel:
function myFunction(a,b,c) {
console.log(a);
console.log(b);
console.log(c); } myFunction(1,2); Der tatsächliche Parameter 1 wird an den formalen Parameter a übergeben, der tatsächliche Parameter 2 wird an den formalen Parameter b übergeben und undefined an den formalen Parameter c übergeben. Wenn Sie nur Daten an die Parameter auf der rechten Seite übergeben möchten, können Sie undefined an die ersten paar tatsächlichen Parameter übergeben. Zum Beispiel:
function myFunction(a,b,c){ console.log(a); console.log(c); die beiden oben genannten Methoden sind es nicht Wenn Sie streng genug sind, besteht die beste Vorgehensweise darin, einen Standardwert für formale Parameter festzulegen, denen möglicherweise undefined Werte übergeben werden. Zum Beispiel:
function getSum(a,b,c) {
if(c === undefiniert)
c = 0;
console.log(a+b+c); } myFunction(1,2); Alles JavaScript ist ein Objekt . Dieses arguments kann auch einen speziellen Namen haben als Array betrachtet werden. (Array-ähnlich, kein echtes Array), die tatsächlichen Parameter sind arguments[0]、arguments[1]... von links nach rechts repräsentiert arguments.length die Anzahl der tatsächlichen Parameter.
//Ermitteln Sie die Summe der Parameter function getSum() {
var aLength = arguments.length;
var sum = 0;
for(var i = 0;i < aLength;i++) {
Summe += Argumente[i];
}
return sum; } console.log(getSum(1,2,3,4,5))//Ausgabe 15. Die formalen Parameter werden hier direkt weggelassen und durch arguments[i] dargestellt.
Komplexe JavaScript
Entwickler müssen die Übereinstimmung zwischen jedem tatsächlichen Parameter und dem formalen Parameter überprüfen, was sehr ineffizient ist. Eine gute Lösung besteht darin, ein Objekt als Parameter zu verwenden, und die Funktion verarbeitet den Parameter basierend auf dem Eigenschaftsnamen des Objekts.
Funktion myFunction(obj) {
console.log(obj.name);
obj.number++;
return obj.number; } myObj = {name:"myObj",number:34}; myFunction(myObj);//Ausgabe myObj console.log(myObj.number);//Ausgabe 35 einer Funktion (zur Vereinfachung des Schreibens a genannt) können als Parameter einer anderen Funktion (Funktion b genannt) verwendet werden, und die Funktion b kann schließlich einen bestimmten Wert zurückgeben.
Im Prinzip ruft Funktion b Funktion a in ihrem eigenen Funktionskörper auf, daher muss der Name von Funktion a als tatsächlicher Parameter an Funktion b übergeben werden. Wie folgt:
// Finden Sie die Maximalwertfunktion getMax(a,b) {
return a>b?a:b; } //Finde die Minimalwertfunktion getMin(a,b) {
return a<b?a:b; } //Die folgende Funktion nimmt eine Funktion als Parameter und gibt schließlich einen Wert zurück function getM(func,num1,num2) {
return func(num1,num2); } getM(getMax,1,2);//Return 2 getM(getMin,1,2);//Return 1 Wir übergeben den Namen der Funktion a ( getMax oder getMin ) an Funktion b ( getM（） ) und rufen Sie dann die übergebene a Funktion innerhalb der b -Funktion auf, um die relevanten Ergebnisse zu erhalten.