Dans JavaScript, la fonction Fonction est un objet.
Il n'y a pas de surcharge de méthode dans js
Dans JavaScript, il n'y a pas de concept de surcharge de méthode (fonction).
exemple:
La copie de code est la suivante:
<html>
<adal>
<script type = "text / javascript">
fonction Add (numéro)
{
alerte (nombre + 20);
}
Fonction Add (numéro, numéro1)
{
alerte (nombre + 30);
}
ajouter (10);
</cript>
</ head>
<body>
</docy>
</html>
La boîte à puces de la page Web affiche 40.
Explication Bien que la deuxième méthode soit deux paramètres, elle est toujours appelée.
Après avoir échangé l'ordre des deux méthodes, la boîte contextuelle affiche 30. On peut voir que quel que soit le nombre de paramètres, la méthode suivante avec le même nom est appelée.
Comment expliquer ce phénomène?
En effet, la déclaration de fonction crée réellement un objet:
La copie de code est la suivante:
<html>
<adal>
<script type = "text / javascript">
fonction Add (numéro)
{
alerte (nombre + 20);
}
/ *
La fonction ci-dessus est équivalente à:
var add = fonction (nombre)
{
alerte (nombre + 20);
}
* /
Fonction Add (numéro, numéro1)
{
alerte (nombre + 30);
}
/ *
La fonction ci-dessus est équivalente à:
var add = fonction (nombre, numéro1)
{
alerte (nombre + 30);
}
* /
ajouter (10);
</cript>
</ head>
<body>
</docy>
</html>
De cette façon, ajouter en fait pointe en réalité à l'objet suivant, et les paramètres attribués lorsque la méthode est appelée sera attribuée aux paramètres formels de la méthode dans l'ordre, et les paramètres qui ne sont pas affectés par la suite ne sont pas définis.
Lors de l'appel des fonctions JavaScript, il n'y a pas de vérification stricte du nombre de paramètres. Il est normal d'avoir le nombre réel de paramètres plus petits que le nombre de paramètres formels. Les paramètres formels qui ne sont pas affectés sont des valeurs non définies.
Il est également possible que le nombre de paramètres réels soit supérieur au nombre de paramètres formels. De cette façon, seuls les paramètres réels précédents seront utilisés et les paramètres réels supplémentaires ne seront pas utilisés.
Objet de fonction
Il existe un objet de fonction dans JavaScript, et toutes les fonctions personnalisées sont de type d'objet de fonction.
Tous les paramètres reçus par l'objet fonction sont de type de chaîne, le dernier paramètre est le corps de fonction à exécuter, et le paramètre précédent est les paramètres que la fonction doit vraiment recevoir.
exemple:
La copie de code est la suivante:
<html>
<adal>
<script type = "text / javascript">
var add = new function ("nombre", "nombre1", "alert (nombre + nombre1);");
var add = new function ("nombre", "alert (nombre + 20);");
ajouter (10, 30);
</cript>
</ head>
<body>
</docy>
</html>
Arguments d'objet implicites
Dans JavaScript, chaque fonction a des arguments d'objet implicites, représentant les paramètres réellement transmis à la fonction.
Les arguments n'ont rien à voir avec les paramètres formels de la fonction et leur nombre.
Les arguments ont une longueur d'attribut utile, indiquant la longueur du paramètre réel. Vous pouvez l'utiliser pour simuler la surcharge de la fonction:
Exemples d'exercice:
La copie de code est la suivante:
<html>
<adal>
<script type = "text / javascript">
Fonction Add (Number1, Number2)
{
alert (arguments.length);
alerte (arguments [0]);
alerte (arguments [1]);
alerte (arguments [2]);
}
// ajouter (2, 3, 4);
fonction add2 ()
{
if (1 == arguments.length)
{
alerte (arguments [0]);
}
else if (2 == arguments.length)
{
alerte (arguments [0] + arguments [1]);
}
else if (3 == arguments.length)
{
alerte (arguments [0] + arguments [1] + arguments [2]);
}
}
add2 (3);
Add2 (3, 4);
Add2 (3, 4, 5);
</cript>
</ head>
<body>
</docy>
</html>
Chaque objet de fonction a un attribut de longueur, indiquant le format de paramètre que la fonction prévoit.
Il est différent des arguments de la fonction. Arguments.Length représente le nombre de paramètres réellement reçus par la fonction.
exemple:
La copie de code est la suivante:
<html>
<adal>
<script type = "text / javascript">
var add = fonction (num, num2, num3)
{
alert (num + num2 + num3);
}
alert (add.length); // Sortie 3
ajouter (1, 2, 3);
var add2 = fonction ()
{
}
alerte (add2.length); // sortie 0
</cript>
</ head>
<body>
</docy>
</html>