Dans la programmation orientée objet, de nombreux langages prennent en charge la surcharge de la fonction et peuvent effectuer différentes opérations en fonction de différents nombres et types de paramètres passés par la fonction. Cependant, JS ne le soutient pas, nous devons donc faire de petites actions supplémentaires.
Dans le contexte de l'exécution de la fonction JS, il existe une variable intéressante appelée arguments. Il stocke tous les paramètres passés lors de l'exécution de la fonction sous la forme d'un tableau, même si la définition de la fonction ne définit pas autant de paramètres formels. Une autre caractéristique spéciale est celle par rapport au type de tableau, la variable des arguments a et n'a qu'un seul attribut de longueur. Les méthodes de tableau, telles que Push, Pop, etc., ne l'ont pas. C'est juste un "pseudo-array": il a un attribut de longueur, et le tableau stocké est accessible par le caractère d'accès à tableau [], et il est en lecture seule et ne peut pas être écrit.
1. Surcharge de différents nombres
Il devrait être très clair ici que vous pouvez simplement utiliser l'attribut de longueur de la fonction des arguments à juger.
La copie de code est la suivante:
<script type = "text / javascript">
fonction talk (msg, gestionnaire) {
var len = arguments.length;
// exécuter lors du passage d'un paramètre
if (len == 1) {
alert ("La fonction dit:" + msg);
}
// Exécuter lorsque deux paramètres sont passés
else if (len == 2) {
Handler (MSG);
}
}
parler ("démo");
talk ("démo", fonction (w) {alert ("Handler dit:" + w);});
</cript>
2. Surcharge de différents types de paramètres
Pour un langage dynamiquement dactylographié comme JS, la nature arbitraire des déclarations variables minimise l'importance de types variables stricts dans l'esprit des développeurs (PS: également basé sur le système ECMA, comme introduit les types obligatoires de déclarations variables). De nombreux bogues inattendus sont en fait causés par la conversion automatique de ce type de variable. En fait, JS fournit une méthode très précise pour détecter strictement les types de variables. Les plus courants sont le type de méthode et l'attribut de constructeur.
1. Type de variable renvoie le type de variable
La copie de code est la suivante:
temp = "Say"; //chaîne
temp = 1; //nombre
temp = non défini; //indéfini
temp = null; //objet
temp = {}; //objet
temp = []; //objet
temp = true; // boolean
temp = function () {} // fonction
alerte (type de température);
Grâce au test ci-dessus, vous pouvez voir que pour Null, Object et Array, tous les types d'objets de retour, et l'utilisation de la méthode suivante peut résoudre ce problème.
2. L'attribut de construction détecte le type de variable
Chaque objet de JS a un attribut constructeur, qui est utilisé pour référencer la fonction qui construit cet objet. En jugeant cette référence, des types de variables peuvent être détectés.
La copie de code est la suivante:
temp = "Say";
Temp.Constructor == String; //vrai
temp = {};
Temp.Constructor == Object; // Vrai
temp = [];
Temp.Contructor == Array; // Vrai
Grâce au test ci-dessus, il est facile de faire la distinction entre les variables de type tableau et de type objet. Testons l'objet personnalisé pour voir ce qui se passe.
La copie de code est la suivante:
// objet personnalisé
fonction ball () {}
// instancier un objet
var basketball = new Ball ();
Basketball.Constructor == Ball; //vrai
Cela peut indiquer que l'attribut constructeur est également applicable aux objets personnalisés.
Après avoir compris l'application des deux méthodes ci-dessus, revenons à la simulation de la surcharge de la fonction JS. L'exemple suivant est la surcharge en fonction du type de paramètre.
La copie de code est la suivante:
fonction talk (msg) {
var t = typeof msg;
if (t == "String") {
alert ("c'est une chaîne");
}
else if (t == "nombre") {
alert ("c'est un nombre");
}
}
parler (10); // c'est une chaîne
parler ("démo"); // c'est un numéro
Attaché est une fonction très intelligente qui détecte strictement les types de paramètres et les nombres:
La copie de code est la suivante:
// vérifie strictement le type d'une liste de variables basée sur la liste des paramètres
fonction strict (types, args) {
// Assurez-vous que le noyau de nombre et de type de paramètres correspond
if (Types.length! = args.length) {
// Si la longueur ne correspond pas, une exception sera lancée
lancer "Nombre non valide d'arguments. attendu" + types.length + ", reçu" + args.length + "à la place.";
}
// voyage dans chaque paramètre et vérifiez le type de base
pour (var i = 0; i <args.length; i ++) {
// Si un certain type de javascript ne correspond pas, une exception sera jetée
if (args [i] .constructor! = types [i]) {
Jetez "Type d'argument non valide. attendu" + Types [i] .name + ", reçu" + args [i] .constructor.name + "à la place.";
}
}
}
// Utilisation de la méthode ci-dessus
fonction Dofonction (id, nom) {
// détecter le nombre et le type de paramètres
strict ([nombre, chaîne], arguments);
..
}