Bei der objektorientierten Programmierung unterstützen viele Sprachen die Funktion Überladung und können unterschiedliche Operationen entsprechend unterschiedlichen Zahlen und Arten von Parametern durchführen, die von der Funktion übergeben wurden. JS unterstützt es jedoch nicht, daher müssen wir einige zusätzliche kleine Aktionen ausführen.
Im Kontext der JS -Funktion Ausführung gibt es eine interessante Variable, die als Argumente bezeichnet wird. Es speichert alle Parameter, die während der Funktionsausführung in Form eines Arrays übergeben wurden, auch wenn die Funktionsdefinition nicht so viele formale Parameter definiert. Eine weitere spezielle Merkmale ist, dass die Argumentevariable im Vergleich zum Array -Typ ein Längenattribut hat und nur ein Attribut hat. Array -Methoden wie Push, Pop usw. haben es nicht. Es ist nur ein "Pseudo-Array": Es hat ein Längenattribut, und auf das gespeicherte Array kann vom Array Access-Charakter [] zugegriffen werden und ist schreibgeschützt und kann nicht geschrieben werden.
1. Überladung verschiedener Zahlen
Hier sollte sehr klar sein, dass Sie nur das Längenattribut der Argumentefunktion verwenden können, um sie zu beurteilen.
Die Codekopie lautet wie folgt:
<script type = "text/javaScript">
Funktionsgespräch (MSG, Handler) {
var len = argumente.length;
// Führen Sie beim Übergeben eines Parameters aus
if (len == 1) {
alert ("Funktion sagt:"+msg);
}
// Führen Sie aus, wenn zwei Parameter übergeben werden
else wenn (len == 2) {
Handler (MSG);
}
}
sprechen ("Demo");
talk ("Demo", Funktion (w) {alert ("Handler sagt:"+w);});
</script>
2. Überladung verschiedener Parameterarten
Für eine dynamisch typisierte Sprache wie JS spielt die willkürliche Natur der variablen Deklarationen die Bedeutung strenger variabler Typen in den Köpfen von Entwicklern herunter (PS: auch basierend auf dem ECMA -System, wie die obligatorischen Arten von variablen Erklärungen einführt). Viele unerwartete Fehler werden tatsächlich durch automatische Konvertierung dieses variablen Typs verursacht. Tatsächlich bietet JS eine sehr genaue Methode, um die Arten von Variablen strikt zu erkennen. Die häufigeren sind das Typ -OF -Methode und das Konstruktorattribut.
1. Typof Variable gibt einen variablen Typ zurück
Die Codekopie lautet wie folgt:
temp = "Say"; // String
temp = 1; //Nummer
temp = undefiniert; //undefiniert
temp = null; //Objekt
temp = {}; //Objekt
temp = []; //Objekt
temp = true; // boolean
temp = function () {} // Funktion
alarm (typeof temp);
Über den obigen Test können Sie sehen, dass für Null, Objekt und Array alle Rückgabeobjekttypen und die Verwendung der folgenden Methode dieses Problem lösen kann.
2.Constructor Attribut erkennt einen variablen Typ
Jedes Objekt in JS hat ein Konstruktorattribut, das verwendet wird, um die Funktion zu verweisen, die dieses Objekt konstruiert. Durch die Beurteilung dieser Referenz können variable Typen erkannt werden.
Die Codekopie lautet wie folgt:
temp = "Say";
temp.Constructor == String; //WAHR
temp = {};
temp.Constructor == Objekt; // true
temp = [];
temp.Constructor == Array; // true
Durch den obigen Test ist es leicht, zwischen Array- und Objekttypvariablen zu unterscheiden. Testen wir das benutzerdefinierte Objekt, um zu sehen, was passiert.
Die Codekopie lautet wie folgt:
// benutzerdefiniertes Objekt
Funktion Ball () {}
// ein Objekt instanziieren
var basketball = neuer Ball ();
Basketball.Constructor == Ball; //WAHR
Dies kann darauf hinweisen, dass das Konstruktorattribut auch für benutzerdefinierte Objekte anwendbar ist.
Nach dem Verständnis der Anwendung der beiden oben genannten Methoden kehren wir zur Simulation der Überlastung von JS -Funktionen zurück. Das folgende Beispiel ist das Überlastung entsprechend dem Parametertyp.
Die Codekopie lautet wie folgt:
Funktion Talk (msg) {
var t = typeof msg;
if (t == "String") {
alarm ("es ist eine Zeichenfolge");
}
else if (t == "number") {
alarm ("Es ist eine Zahl");
}
}
sprechen (10); // Es ist eine Zeichenfolge
sprechen ("Demo"); // Es ist eine Nummer
Angehängt ist eine sehr clevere Funktion, die Parametertypen und Zahlen strikt erkennt:
Die Codekopie lautet wie folgt:
// Überprüfen Sie den Typ einer Variablenliste strikt basierend auf der Parameterliste
Funktion strikt (Typen, Argumente) {
// Stellen Sie sicher, dass die Anzahl und der Typ der Parameter übereinstimmen
if (Typen.Length! = args.length) {
// Wenn die Länge nicht übereinstimmt, wird eine Ausnahme geworfen
"Ungültige Anzahl von Argumenten werfen. Erwartet" + Typen.
}
// Fahren Sie durch jeden Parameter und überprüfen Sie den Basistyp
für (var i = 0; i <args.length; i ++) {
// Wenn eine bestimmte Art von JavaScript nicht übereinstimmt, wird eine Ausnahme ausgelöst
if (args [i] .Constructor! = Typen [i]) {
"Ungültiger Argumenttyp werfen. Erwartet" + Typen [i] .Name + ", empfangen" + args [i] .Constructor.name + "stattdessen.";
}
}
}
// Verwendung der obigen Methode
Funktion Dofunction (ID, Name) {
// Die Nummer und Art der Parameter erkennen
strikt ([Nummer, String], Argumente);
..
}