Die vorherigen Wörter
Die Parameter von JavaScript -Funktionen unterscheiden sich von denen der Funktionen in den meisten anderen Sprachen. Funktionen haben nichts dagegen, wie viele Parameter übergeben werden, und sie kümmern sich auch nicht um den Datentyp der übergebenen Parameter, und sie können sogar keine Parameter übergeben.
Argumente
Die Funktionsdefinition in JavaScript gibt den Typ der Funktionsparameter nicht an, und der Funktionsaufruf führt keine Typ -Überprüfung der übergebenen Parameterwerte aus. Tatsächlich überprüfen die Aufrufe von JavaScript -Funktionen nicht einmal die Anzahl der eingehenden formalen Parameter.
Funktion add (x) {return x+1;} console.log (add (1)); // 2console.log (add ('1'); // '11'console.log (add ()); // nanconsole.log (add (1,2)); // 2Formale Parameter gleicher Name
Im Nicht-Streng-Modus kann in der Funktion ein formaler Parameter gleicher Name erscheinen, und nur der letzte formale Parameter des angezeigten Namens kann zugegriffen werden
Funktion add (x, x, x) {return x;} console.log (add (1,2,3)); // 3Im strengen Modus tritt ein Syntaxfehler auf, wenn der gleiche Name am Syntaxfehler beteiligt ist.
Funktion add (x, x, x) {'strikt verwenden'; return x;} console.log (add (1,2,3)); // syntaxError: duplizierter Parametername, der in diesem Kontext nicht zulässig istAnzahl der Parameter
Wenn die angegebene Anzahl formaler Parameter, die von der realen Referenzfunktion deklariert sind, gering ist, werden die verbleibenden formalen Parameter auf undefinierte Werte festgelegt
Funktion add (x, y) {console.log (x, y); // 1 undefined} add (1);Verwenden Sie Logik oder Bediener häufig, um einen angemessenen Standardwert für weggelassene Parameter festzulegen
Funktion add (x, y) {y = y || 2; console.log (x, y); // 1 2} add (1);[Anmerkung] Tatsächlich verwenden Sie y || 2 ist nicht streng und setzt explizit falsche Werte (undefiniert, null, false, 0, -0, '', Nan). Daher sollte es angemessen auf dem tatsächlichen Szenario festgelegt werden
Wenn es viele wirkliche Argumente gibt, können die verbleibenden wirklichen Argumente nicht direkt erhalten werden. Sie müssen das in Kürze erwähnte Argumenteobjekt verwenden.
Parameter in JavaScript werden intern durch ein Array dargestellt. Die Funktion empfängt dieses Array immer und kümmert sich nicht darum, welche Parameter im Array enthalten sind. Auf dieses Parameter -Array kann über das Argumenteobjekt in der Funktionskörper zugegriffen werden, wodurch jeder an die Funktion übergebene Parameter erhalten wird. Das Argumenteobjekt ist keine Instanz von Array, sondern ein Array -Objekt, das mithilfe einer quadratischen Klammersyntax auf jedes Element zugreifen kann.
Funktion add (x) {console.log (Argumente [0], Argumente [1], Argumente [2]) // 1 2 3return x+1;} add (1,2,3);Das Längenattribut des Argumenteobjekts zeigt die Anzahl der realen Parameter an, und das Längenattribut der Funktion zeigt die Anzahl der formalen Parameter an
Funktion add (x, y) {console.log (argumente.length) // 3return x+1;} add (1,2,3); console.log (add.length); // 2Formale Parameter sind nur bequem, aber nicht notwendig
Funktion add () {Rückgabeargumente [0] + Argumente [1];} console.log (add (1,2)); // 3Objektparameter
Wenn eine Funktion mehr als 3 formale Parameter enthält, ist es wirklich Kopfschmerzen, sich zu beachten, dass die richtige Reihenfolge der tatsächlichen Parameter in der Funktion aufgerufen wird.
Funktion ArrayCopy (/*Array*/von,/*index*/form_start,/*array*/to,/*index*/to_start,/*Integer*/Länge) {// Todo}Geben Sie die Parameter in Form von Namen/Wertpaaren über, sodass die Reihenfolge der Parameter irrelevant ist. Beim Definieren einer Funktion werden die in realen Parametern übergebenen Funktionen in ein separates Objekt geschrieben. Ein Objekt wird eingeleitet, wenn er aufgerufen wird. Die Namen/Wertpaare im Objekt sind die realen Parameterdaten, die wirklich benötigt werden.
Funktion EasyCopy (args) {ArrayCopy (args.from, args.form_start || 0, args.to, args.to_start || 0, argsgth);} var a = [1,2,3,4], b = []; EasyCopy ({Form: a, b, b, länge: 4});synchron
Wenn die Anzahl der tatsächlichen Parameter des Formulars, die an derselben Form beteiligt sind
Funktionstest (num1, num2) {console.log (num1, argumente [0]); // 1 1Argumente [0] = 2; console.log (num1, arguments [0]); // 2 2num1 = 10; console.log (Num1, Argumente [0]); // 10 10} test (1);[Anmerkung] Obwohl die benannten Parameter und der Wert des entsprechenden Argumente des Objekts gleich sind, sind sie nicht der gleiche Namespace. Ihre Namespaces sind unabhängig, aber die Werte sind synchron
Im strengen Modus sind die Werte des Argumenteobjekts und die Werte der formalen Parameter jedoch unabhängig
Funktionstest (Num1, Num2) {'strikt verwenden'; Konsole.log (Num1, Argumente [0]); // 1 1Argumente [0] = 2; console.log (Num1, Argumente [0]); // 1 2num1 = 10; console.log (num1, arguments [0]); // 10 2} (1);Wenn die formalen Parameter nicht entsprechende tatsächliche Parameter aufweisen, entspricht der Wert des Argumenteobjekts nicht dem Wert der formalen Parameter
Funktionstest (Num1, Num2) {console.log (Num1, Argumente [0]); // undefined, undefinedNum1 = 10; Argumente [0] = 5; console.log (Num1, Argumente [0]); // 10,5} Test ();Interne Eigenschaften
【Callee】
Das Argumenteobjekt hat eine Eigenschaft namens Callee, die ein Zeiger auf die Funktion ist, die das Argumenteobjekt besitzt.
Unten finden Sie die klassische faktorielle Funktion
Funktion factorial (num) {if (num <= 1) {return 1;} else {return num* factorial (num-1);}} console.log (factorial (5)); // 120Die Ausführung der obigen Funktion ist jedoch eng mit dem Funktionsnamen verbunden, und die Funktionskopplung kann mit Argumenten beseitigt werden.
Funktion factorial (num) {if (num <= 1) {return 1;} else {return num* argumente.callee (num-1);}} console.log (faktorial (5)); // 120Im strengen Modus wirft der Zugriff auf diese Eigenschaft jedoch einen TypenErrorfehler auf
Funktionsfaktor (num) {'strikt verwenden'; if (num <= 1) {return 1;} else {return num* argumente.callee (num-1);}} // TypeRror: 'Anrufer', 'Callee' und 'Argumente' Eigenschaften sind möglicherweise nicht auf Strict-Mode-Funktionen zugegriffen (5).Zu diesem Zeitpunkt kann ein benannter Funktionsausdruck verwendet werden
var factorial = Funktion fn (num) {if (num <= 1) {return 1;} else {return num*fn (num-1);}}; console.log (faktorial (5)); // 120【Anrufer】
Es gibt tatsächlich zwei Anruferattribute
【1】 Funktion Anrufer
Die Anrufereigenschaft der Funktion enthält einen Verweis auf die Funktion, die die aktuelle Funktion aufruft. Wenn die aktuelle Funktion im globalen Bereich aufgerufen wird, ist ihr Wert null
function outer () {inner ();} Funktion inner () {console.log (inner.caller); // äußere () {inner ();}} äußer (); Funktion inner () {console.log (inner.caller); // null} inner ();Im strengen Modus wirft der Zugriff auf diese Eigenschaft einen TypenError -Fehler auf
Funktion Inner () {'Strict'; // TypeERRror: 'Anrufer' und 'Argumente' sind eingeschränkte Funktionseigenschaften und können in diesem Zusammenhang nicht zugegriffen werden.【2】 Argumente Objekt Anrufer
Diese Eigenschaft ist immer undefiniert. Diese Eigenschaft wird definiert, um die Anrufereigenschaften von Argumenten zu unterscheiden. Caller und Funktion
Funktion inner (x) {console.log (Argumente.Caller); // undefined} Inner (1);In ähnlicher Weise wirft der Zugriff auf diese Eigenschaft im strengen Modus einen TypenError -Fehler auf
Funktion Inner (x) {'strikt verwenden'; // TypeRror: 'Anrufer' und 'Argumente' sind eingeschränkte Funktionseigenschaften und können in diesem Zusammenhang nicht zugegriffen werden.Funktion Überlastung
JavaScript -Funktionen können Überladen nicht wie im traditionellen Sinne implementieren. In anderen Sprachen können zwei Definitionen für eine Funktion geschrieben werden, solange die Signaturen dieser beiden Definitionen (Typen und Mengen akzeptierter Parameter) unterschiedlich sind
Die JavaScript -Funktion hat keine Signatur, da ihre Parameter durch ein Array mit 0 oder mehr Werten dargestellt werden. Ohne Funktionssignaturen ist eine echte Überladung unmöglich
// Die anschließende Deklaration überschreibt die vorherige Deklarationsfunktion addsomEnumn (num) {return num + 100;} Funktion addsomenumber (num) {return num + 200;} var result = addSoMeNumber (100); // 300Die Überlastung von Methoden kann nur simuliert werden, indem die Typen und Mengen der Parameter in der übergebenen Funktion und unterschiedliche Reaktionen durchgeführt werden.
Funktion doadd () {if (Argumente.length == 1) {alert (Argumente [0] + 10);} else if (Argumente.length == 2) {alert (Argumente [0] + Argumente [1]);}} Doadd (10); // 20doadd (30,20); // 50); // 50);Parameterpass
Alle Funktionen in JavaScript werden nach Wert übergeben. Das heißt, das Kopieren des Wertes außerhalb der Funktion auf die Parameter innerhalb der Funktion ist das gleiche wie das Kopieren des Wertes von einer Variablen zu einer anderen
【1】 Grundtypwert
Wenn Sie einen Wert des primitiven Typs an einen Parameter übergeben, wird der übergebene Wert in eine lokale Variable (ein Element eines benannten Parameter- oder Argumenteobjekts) kopiert.
Funktion addten (num) {num += 10; return num;} var count = 20; var result = addten (count); console.log (count); // 20, keine Änderung console.log (Ergebnis); // 30【2】 Referenztypwert
Wenn Sie einen Referenztypwert an den Parameter übergeben, wird die Adresse dieses Wertes im Speicher in eine lokale Variable kopiert, sodass die Änderung dieser lokalen Variablen außerhalb der Funktion reflektiert wird
Funktion setName (obj) {obj.name = 'test';} var person = new Object (); setName (Person); console.log (Person.name); // 'test' 'Wenn die formalen Parameter des Referenztyps in der Funktion überschrieben sind, bezieht sich diese Variable auf ein lokales Objekt. Dieses lokale Objekt wird unmittelbar nach Ausführung der Funktion zerstört
FunktionsetName (obj) {obj.name = 'test'; console.log (Person.name); // 'test'obj = new Object (); obj.name =' wht '; console.log (Person.Name); //' test '} var person = new Object (); setName (Person);Das obige ist das eingehende Verständnis der vom Editor vorgelegten JavaScript-Funktionsparameter (empfohlen). Ich hoffe, es wird Ihnen hilfreich sein. Wenn Sie Fragen haben, hinterlassen Sie mir bitte eine Nachricht und der Editor wird Ihnen rechtzeitig antworten. Vielen Dank für Ihre Unterstützung auf der Wulin.com -Website!