Définition des arguments
Toutes les fonctions ont leur propre objet d'arguments pour stocker les paramètres qu'il reçoit réellement, sans être limité à la liste des paramètres définie lorsque la fonction est déclarée. Ce n'est pas un tableau mais est similaire à un tableau. Il a les mêmes propriétés et méthodes d'accès qu'un tableau. Il peut accéder aux valeurs du paramètre unique correspondant par arguments [n] et avoir la longueur d'attribut de longueur du tableau. Mais il existe certaines méthodes qui n'ont pas de tableaux. Vous pouvez convertir les arguments en réels des tableaux via l'appel, puis effectuer des opérations de tableau.
var args = array.prototype.slice.call (arguments);
Tableau de classe
1. Déterminez si les arguments sont un tableau
alerte (arguments instance de tableau); alert (arguments instanceof objet);
2. Comment déterminer strictement que les données sont une instance d'une classe de tableau (tableau)
fonction isArray (value) {if (typeof array.isArray === "fonction") {return array.isArray (valeur); } else {return object.prototype.tostring.call (valeur) === "[Array d'objets]"; }}3. Convertir les arguments en un tableau
Méthode 1: Les types intégrés peuvent être trouvés via le prototype. Array.prototype.slice est la tranche de méthode intégrée pour accéder à Array. Renvoyez un tableau via la méthode Slice. L'appel est une méthode qui appelle un objet et remplace l'objet actuel par un autre objet.
var arg = array.prototype.slice.call (arguments, 0);
Méthode 2: La performance est pire que la méthode 1, car elle crée d'abord un tableau puis se déroule.
var arg = [] .slice.call (arguments, 0);
Méthode 3: Convertir en un tableau via une boucle
fonction toArray (arguments) {var a = []; for (var i = 0; i <arguments.length; i ++) {a.unshift (arguments. [i]); } retourner a;}Demandeur
Lorsqu'une fonction est appelée par une autre fonction, la fonction appelée générera automatiquement un attribut d'appelant, pointant vers l'objet de fonction qui l'appelle. Si la fonction n'est pas appelée, l'appelant est nul.
fonction testCaller () {var calller = testCaller.Caller; alert (appelant);} fonction acaller () {testCaller ();} acaller ();Ce qui apparaît, c'est le contenu de la fonction Acaller.
arguments.Callee
Arguments.Callee pointe vers la fonction en cours d'exécution et renvoie l'objet de fonction exécuté, c'est-à-dire le corps de l'objet de fonction spécifié.
Remarque: Arguments.Length est la longueur du paramètre réel, les arguments.Callee.Length est la longueur du paramètre formel, qui est généralement utilisé pour déterminer si la longueur du paramètre réel est cohérente.
Obtenez les paramètres réels de la fonction à travers les arguments et obtenez les paramètres formels de la fonction via des arguments.Callee.
Il est également largement utilisé dans les fermetures.
var i = 0; fonction b (num) {if (num <10) {num ++; i ++; // S'il y a des paramètres, Callee devrait également apporter les paramètres; arguments.Callee (num); } else {// output 2 alert ("l'appel" + i + "callee!"); }} b (8); L'application des arguments.Callee dans les fermetures offre une fonction d'appel récursivement. // Utiliser des arguments.Callee pour calculer le factoriel de 10, par exemple: 1 × 2 × 3 × 4 × 5 × 6 × 7 .... Fonction C (x) {return x> 1? x * arguments.callee (x - 1): 1} (10); // sortie 6 alerte (C (3)); // Sortie 3628800 alerte (C (10));Exemple: Callee trouve la somme de 1-N
fonction fn (n) {if (n == 1) return n; else return n + arguments.callee (n-1);}Il permet à une fonction anonyme de s'appeler
exemple:
Fonction List (type) {var result = "<" + type + "l> <li>"; var args = array.prototype.slice.call (arguments, 1); résultat + = args.join ("</li> <li>"); Résultat + = "</li> </" + type + "l>"; Retour Résultat;} var listhtml = list ("o", "un", "deux"); console.log (listhtml);Exemple 2: Question de l'entretien: Quel est le résultat de la console suivante.Log [1,2,3,4]?
fonction foo (x) {console.log (arguments); return x;} foo (1,2,3,4); fonction foo (x) {console.log (arguments); retour x;} (1,2,3,4)Pendant la pré-explication, la fonction fn () {} (1); sera traité séparément et divisé en deux fonctions, la première est la fonction fn () {}, et la seconde est une fonction anonyme: (1). Si le second n'a pas de paramètres, une erreur sera signalée, mais la fonction ci-dessus est incluse dans un (), ce qui est correct.
(fonction fn () {console.log (arguments);} (1,2,3,4)); (fonction foo (x) {console.log (arguments); return x;}) (1,2,3,4) function foo () {bar.apply (null, arguments);} fonction bar (x) {console.log (arguments);} foo (1,1, 1,4);