Detaillierte Erläuterung der Erstellung von JavaScript-Funktionsobjekten, Parametern und Bereichsinstanzen

" „Konstruktor“:

Die Parameterliste kann so viele Parameter enthalten, wie Sie möchten, gefolgt vom Funktionskörper, zum Beispiel:

gibt das Ergebnis aus:

6

var funcName = new Function( [argname1, [... argnameN,]] body );

Aber wer würde eine Funktion auf so schwierige Weise erstellen? Wenn der Funktionskörper komplex ist, ist das Zusammenfügen des Strings sehr aufwändig, sodass JavaScript eine Art Syntaxzucker bereitstellt. Das heißt, durch Literale So erstellen Sie eine Funktion:

var add = new Function("x", "y", "return(x+y)"); 
print(add(2, 4));

oder:


Tatsächlich ist es wahrscheinlicher, dass ein solcher syntaktischer Zucker von Programmierern in traditionellen Bereichen missverstanden wird Das Schlüsselwort function ruft Function auf, erstellt ein neues Objekt und übergibt die Parameterliste und den Funktionskörper genau an den Konstruktor der Funktion.

Im Allgemeinen bedeutet die Deklaration eines Objekts im globalen Bereich (der Bereich wird im nächsten Abschnitt ausführlich vorgestellt) lediglich die Zuweisung eines Werts zu einem Attribut. Beispielsweise fügt die Add-Funktion im obigen Beispiel tatsächlich nur einen Wert hinzu Das globale Objekt wird hinzugefügt, und der Attributname lautet „add“, und der Wert des Attributs ist „function(x, y){return x+y;}“. Die Syntax dieser Anweisung lautet wie folgt:

function add(x, y){ 
return x + y; 
}

Nicht anders. Sie alle fügen dem globalen Objekt dynamisch ein neues Attribut hinzu, das ist alles.

var add = function(x, y){ 
return x + y; 
}

Um zu veranschaulichen, dass Funktionen wie andere Objekte als unabhängige Objekte im laufenden JavaScript-System existieren, können wir uns auch dieses Beispiel ansehen:

Da ist nichts falsch, obwohl p wird in Anführungszeichen gesetzt Eine anonyme Funktion (Objekt), kann aber auch Attribute haben, genau wie andere Objekte:

var str = "This is a string";

1.2 Parameter der Funktion

function p(){ 
print("invoke p by ()"); 
} 
p.id = "func"; 
p.type = "function"; 
print(p); 
print(p.id+":"+p.type); 
print(p());

In JavaScript , die Parameter der Funktion Es ist sehr interessant, dass Sie beispielsweise eine beliebige Anzahl von Parametern an eine Funktion übergeben können, auch wenn die Funktion ohne Angabe formaler Parameter deklariert wird, zum Beispiel:

Die Funktion adPrint akzeptiert bei der Deklaration drei Formen der Parameter: die zu druckende Zeichenfolge, die zu druckende Länge und ob sie in Groß- und Kleinbuchstaben umgewandelt werden soll. Beim Aufruf können wir jedoch nacheinander einen Parameter, zwei Parameter oder drei Parameter an adPrint übergeben (Sie können sogar mehr als drei Parameter übergeben, das spielt keine Rolle). Die laufenden Ergebnisse sind wie folgt:

function (){ 
print("invoke p by ()"); 
} 
func:function 
invoke p by ()

Wenn JavaScript Funktionsparameter verarbeitet, unterscheidet es sich tatsächlich von anderen kompilierten Sprachen. Der Interpreter übergibt der Funktion einen arrayähnlichen internen Wert, der als Argumente bezeichnet wird . wird initialisiert. Wenn wir beispielsweise einen Parameter an adPrint übergeben, sind die anderen beiden Parameter undefiniert. Auf diese Weise können wir diese undefinierten Parameter innerhalb der adPrint-Funktion verarbeiten, die nach außen sichtbar gemacht werden können: Wir können jeden Parameter verarbeiten.

function adPrint(str, len, option){ 
var s = str || "default"; 
var l = len || s.length; 
var o = option || "i"; 
s = s.substring(0, l); 
switch(o){ 
case "u": 
s = s.toUpperCase(); 
break; 
case "l": 
s = s.toLowerCase(); 
break; 
default: 
break; 
} 

print(s); 
} 

adPrint("Hello, world"); 
adPrint("Hello, world", 5); 
adPrint("Hello, world", 5, "l");//lower case 
adPrint("Hello, world", 5, "u");//upper case

Wir diskutieren diese magischen Argumente anhand eines anderen Beispiels:

Hello, world 
Hello 
hello 
HELLO

Die Funktion sum hat keine expliziten formalen Parameter und wir können ihr dynamisch so viele Parameter übergeben, wie wir möchten. Also, wie Um auf diese Parameter in der Summenfunktion zu verweisen, müssen Sie das Pseudoarray von Argumenten verwenden:

Funktionsbereich

function sum(){ 
var result = 0; 
for(var i = 0, len = arguments.length; i < len; i++){ 
var current = arguments[i]; 
if(isNaN(current)){ 
throw new Error("not a number exception"); 
}else{ 
result += current; 
} 
} 
return result; 
} 

print(sum(10, 20, 30, 40, 50)); 
print(sum(4, 8, 15, 16, 23, 42));//《迷失》上那串神奇的数字 
print(sum("new"));

Das Konzept des Bereichs In fast allen Mainstream-Sprachen hat es seine Besonderheit: Der Variablenbereich in JavaScript ist innerhalb des Funktionskörpers gültig, und es gibt keinen Blockbereich. In der Java-Sprache können wir den for-Schleifenblock wie diese Subscript-Variablen definieren in:

150 
108 
Error: not a number exception

Und in JavaScript:

JavaScript-Funktionen werden im lokalen Bereich ausgeführt, und Funktionen werden im lokalen Bereich ausgeführt. Der Körper kann auf seine äußere (möglicherweise) zugreifen (globaler Geltungsbereich) Variablen und Funktionen. Der Geltungsbereich von JavaScript ist der lexikalische Geltungsbereich. Der sogenannte lexikalische Geltungsbereich bedeutet, dass sein Geltungsbereich bei der Definition (lexikalische Analyse) und nicht bei der Ausführung bestimmt wird, wie im folgenden Beispiel:

public void method(){ 
for(int i = 0; i < obj1.length; i++){ 
//do something here; 
} 
//此时的i为未定义 
for(int i = 0; i < obj2.length; i++){ 
//do something else; 
} 
}

Wie lautet das Laufergebnis? Anfänger erhalten wahrscheinlich diese Antwort:

function func(){ 
for(var i = 0; i < array.length; i++){ 
//do something here. 
} 
//此时i仍然有值，及I == array.length 
print(i);//i == array.length; 
}

Und das richtige Ergebnis sollte sein:

var str = "global"; 
function scopeTest(){ 
print(str); 
var str = "local"; 
print(str); 
} 
scopeTest();

Weil in der Definition Wenn bei der Funktion „scopeTest“ im Voraus auf die nicht deklarierte Variable str zugegriffen wird und dann die Variable str initialisiert wird, gibt der erste Ausdruck (str) einen undefinierten Fehler zurück. Warum greift die Funktion zu diesem Zeitpunkt nicht auf die externe str-Variable zu? Dies liegt daran, dass nach Abschluss der lexikalischen Analyse beim Erstellen der Bereichskette die in der Funktion definierte var-Variable in die Kette eingefügt wird, also str Im gesamten Funktionsumfang sind alle sichtbar (von der ersten bis zur letzten Zeile des Funktionskörpers). Da die str-Variable selbst undefiniert ist, wird das Programm sequentiell ausgeführt und gibt in der ersten Zeile undefiniert zurück Wert auf str, also die dritte Zeile Der print(str) der Zeile gibt „local“ zurück.

global 
local

Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung der Erstellung von JavaScript-Funktionsobjekten, Parametern und Bereichsinstanzen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!