Comprendre profondément les paramètres de fonction JavaScript (recommandés)

Les mots précédents

Les paramètres des fonctions JavaScript sont différents de ceux des fonctions dans la plupart des autres langues. Les fonctions ne se soucient pas du nombre de paramètres passés, et ils ne se soucient pas du type de données des paramètres transmis, et ils ne peuvent même pas transmettre des paramètres.

arguments

La définition de la fonction dans JavaScript ne spécifie pas le type de paramètres de fonction, et l'appel de fonction n'effectue aucune vérification de type sur les valeurs des paramètres passés. En fait, les appels de fonction JavaScript ne vérifient même pas le nombre de paramètres formels entrants.

 fonction add (x) {return x + 1;} console.log (add (1)); // 2Console.log (add ('1')); // '11'console.log (add ()); // nanconsole.log (add (1,2)); // 2

Paramètres formels du même nom

En mode non stricte, un paramètre formel du même nom peut apparaître dans la fonction, et seul le dernier paramètre formel du nom qui apparaît peut être accessible

 fonction add (x, x, x) {return x;} console.log (add (1,2,3)); // 3

En mode strict, une erreur de syntaxe se produit lorsque le même nom est impliqué dans l'erreur de syntaxe.

 fonction add (x, x, x) {'utiliser strict'; return x;} console.log (add (1,2,3)); // syntaxerror: nom de paramètre en double non autorisé dans ce contexte

Nombre de paramètres

Lorsque le nombre spécifié de paramètres formels déclarés par la fonction de référence réelle est petit, les paramètres formels restants seront définis sur des valeurs non définies

 fonction add (x, y) {console.log (x, y); // 1 undefined} add (1);

Utilisez souvent la logique ou les opérateurs pour définir une valeur par défaut raisonnable pour les paramètres omis

 fonction add (x, y) {y = y || 2; console.log (x, y); // 1 2} add (1);

[Remarque] En fait, en utilisant Y || 2 n'est pas rigoureux, la définition explicite de fausses valeurs (Undefined, Null, False, 0, -0, '', nan) obtiendra également le même résultat. Par conséquent, il devrait être défini raisonnablement basé sur le scénario réel

Lorsqu'il existe de nombreux arguments réels, les vrais arguments restants ne peuvent pas être obtenus directement. Vous devez utiliser l'objet Arguments mentionné bientôt.

Les paramètres dans JavaScript sont représentés en interne par un tableau. La fonction reçoit toujours ce tableau et ne se soucie pas des paramètres contenus dans le tableau. Ce tableau de paramètres est accessible via l'objet d'arguments dans le corps de la fonction, obtenant ainsi chaque paramètre transmis à la fonction. L'objet d'arguments n'est pas une instance de tableau, c'est un objet de tableau qui peut accéder à chaque élément de celle-ci à l'aide de la syntaxe du support carré.

 fonction add (x) {console.log (arguments [0], arguments [1], arguments [2]) // 1 2 3return x + 1;} add (1,2,3);

L'attribut de longueur de l'objet Arguments montre le nombre de paramètres réels, et l'attribut de longueur de la fonction montre le nombre de paramètres formels

 fonction add (x, y) {console.log (arguments.length) // 3return x + 1;} add (1,2,3); console.log (add.length); // 2

Les paramètres formels ne sont que des

 fonction add () {return arguments [0] + arguments [1];} console.log (add (1,2)); // 3

Paramètres d'objet

Lorsqu'une fonction contient plus de 3 paramètres formels, c'est vraiment un mal de tête de se rappeler que l'ordre correct des paramètres réels de la fonction est appelé.

 Fonction ArrayCopy (/ * Array * / From, / * index * / form_start, / * array * / to, / * index * / to_start, / * entier * / longueur) {// todo}

Passez les paramètres sous forme de paires de nom / valeur, de sorte que l'ordre des paramètres n'est pas pertinent. Lors de la définition d'une fonction, les paramètres réels sont rédigés dans un objet séparé. Un objet est passé lorsqu'il est appelé. Les paires de nom / valeur dans l'objet sont les données réelles des paramètres qui sont vraiment nécessaires.

 Fonction Easycopy (args) {ArrayCopy (args.from, args.form_start || 0, args.to, args.to_start || 0, args.length);} var a = [1,2,3,4], b = []; easycopy ({forme: a, to: b, longueur: 4});

synchrone

Lorsque le nombre de paramètres réels de la forme participant à la même forme, la valeur de l'objet d'arguments et la valeur des paramètres formels correspondants restent synchronisés

 Test de fonction (num1, num2) {console.log (num1, arguments [0]); // 1 1Arguments [0] = 2; console.log (num1, arguments [0]); // 2 2Num1 = 10; console.log (num1, arguments [0]); // 10 10} test (1);

[Remarque] Bien que les paramètres nommés et la valeur de l'objet d'arguments correspondants soient les mêmes, ils ne sont pas le même espace de noms. Leurs espaces de noms sont indépendants, mais les valeurs sont synchrones

Cependant, en mode strict, les valeurs de l'objet d'arguments et les valeurs des paramètres formels sont indépendantes

 Test de fonction (num1, num2) {'utilise strict'; console.log (num1, arguments [0]); // 1 1Arguments [0] = 2; console.log (num1, arguments [0]); // 1 2num1 = 10; console.log (num1, arguments [0]); // 10 2} test (1);

Lorsque les paramètres formels n'ont pas de paramètres réels correspondants, la valeur de l'objet d'arguments ne correspond pas à la valeur des paramètres formels

 Fonction test (num1, num2) {console.log (num1, arguments [0]); // undefined, undefinedNum1 = 10; arguments [0] = 5; console.log (num1, arguments [0]); // 10,5} test ();

Propriétés internes

【Callee】

L'objet d'arguments a une propriété appelée Callee, qui est un pointeur vers la fonction qui possède l'objet Arguments.

Vous trouverez ci-dessous la fonction factorielle classique

 fonction factorial (num) {if (num <= 1) {return 1;} else {return num * factorial (num-1);}} console.log (factoriel (5)); // 120

Cependant, l'exécution de la fonction ci-dessus est étroitement couplée au nom de la fonction, et le découplage de la fonction peut être éliminé à l'aide d'arguments.Callee

 fonction factorial (num) {if (num <= 1) {return 1;} else {return num * arguments.callee (num-1);}} console.log (factorial (5)); // 120

Mais en mode strict, l'accès à cette propriété lancera une erreur de type EERROR

 fonction factorielle (num) {'utiliser strict'; if (num <= 1) {return 1;} else {return num * arguments.callee (num-1);}} // typeerror: 'appelant', 'callee' et 'arguments' les propriétés peuvent ne pas être accessibles sur des fonctions de mode strict ou des arguments pour les appels vers les appels.

Pour le moment, une expression de fonction nommée peut être utilisée

 var factorial = fonction fn (num) {if (num <= 1) {return 1;} else {return num * fn (num-1);}}; console.log (factoriel (5)); // 120

【demandeur】

Il y a en fait deux attributs d'appelant

【1】 Appelant de fonction

La propriété de l'appelant de la fonction contient une référence à la fonction qui appelle la fonction actuelle. Si la fonction actuelle est appelée dans la portée globale, sa valeur est nul

 fonction outer () {inner ();} fonction inner () {console.log (inner.caller); // outer () {inner ();}} exter (); function inner () {console.log (inner.caller); // null} inner ();

En mode strict, l'accès à cette propriété lancera une erreur TypeError

 function inner () {'utiliser strict'; // typeError: 'appelant' et 'arguments' sont des propriétés de fonction restreintes et ne sont pas accessibles dans ce contexteConsole.log (inner.Caller);} inner ();

【2】 Arguments Appeleur d'objet

Cette propriété n'est toujours pas définie. Cette propriété est définie pour distinguer les propriétés des appels des arguments.

 fonction inner (x) {console.log (arguments.Caller); // undefined} inner (1);

De même, en mode strict, l'accès à cette propriété lancera une erreur de type EERROR

 fonction inner (x) {'utiliser strict'; // typeError: 'appelant' et 'arguments' sont des propriétés de fonction restreintes et ne sont pas accessibles dans ce contexteConsole.log (arguments.Caller);} inner (1);

Surcharge de fonction

Les fonctions JavaScript ne peuvent pas implémenter la surcharge comme dans le sens traditionnel. Dans d'autres langues, deux définitions peuvent être écrites pour une fonction, tant que les signatures de ces deux définitions (types et quantités de paramètres acceptés) sont différentes

La fonction JavaScript n'a pas de signature car ses paramètres sont représentés par un tableau contenant 0 ou plus de valeurs. Sans signatures de fonction, une véritable surcharge est impossible

 // La déclaration suivante remplace la fonction de déclaration précédente Ajouter AdSoMenumber (num) {return num + 100;} fonction AddSoMenumber (num) {return num + 200;} var result = AddSoMenumber (100); // 300

La surcharge des méthodes ne peut être simulée qu'en vérifiant les types et les quantités de paramètres dans la fonction passée et en réalisant différentes réactions.

 fonction doadd () {if (arguments.length == 1) {alert (arguments [0] + 10);} else if (arguments.length == 2) {alert (arguments [0] + arguments [1]);}} doadd (10); // 20Doadd (30,20); // 50)

Passage des paramètres

Toutes les fonctions de JavaScript sont réalisées par valeur. C'est-à-dire que la copie de la valeur en dehors de la fonction aux paramètres à l'intérieur de la fonction est la même que la copie de la valeur d'une variable à une autre

【1】 Valeur de type de base

Lorsque vous passez une valeur du type primitif à un paramètre, la valeur passée est copiée dans une variable locale (un élément d'un paramètre nommé ou des arguments objet)

 fonction addten (num) {num + = 10; return num;} var count = 20; var result = addten (count); console.log (count); // 20, pas de changement console.log (résultat); // 30

【2】 Valeur de type de référence

Lors du passage d'une valeur de type de référence au paramètre, l'adresse de cette valeur en mémoire sera copiée dans une variable locale, de sorte que le changement de cette variable locale sera reflété en dehors de la fonction

 fonction setName (obj) {obj.name = 'test';} var personne = new object (); setName (personne); console.log (personne.name); // 'test'

Lorsque les paramètres formels du type de référence sont remplacés dans la fonction, cette variable se réfère à un objet local. Cet objet local sera détruit immédiatement après l'exécution de la fonction

 fonction setName (obj) {obj.name = 'test'; console.log (personne.name); // 'test'obj = new object (); obj.name =' blanc '; console.log (personne.Name); //' test '} var personne = new objet (); setName (personne);

Ce qui précède est la compréhension approfondie des paramètres de fonction JavaScript qui vous sont présentés par l'éditeur (recommandé). J'espère que cela vous sera utile. Si vous avez des questions, veuillez me laisser un message et l'éditeur vous répondra à temps. Merci beaucoup pour votre soutien au site Web Wulin.com!