Une analyse approfondie de l'objet arguments en JavaScript

Définition des arguments

Toutes les fonctions ont leur propre objet arguments, qui est utilisé pour stocker les paramètres qu'elle reçoit réellement, et ne se limite pas à la liste de paramètres définie lors de la déclaration de la fonction. 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. La valeur du paramètre unique correspondant est accessible via arguments[n] et il a l'attribut de longueur du tableau. Mais il ne dispose pas de certaines méthodes de tableaux. Vous pouvez convertir les arguments en un véritable tableau via un appel, puis effectuer des opérations sur le tableau.

var args = Array.prototype.slice.call(arguments);

Classe de tableau

1. Déterminer si ARGUMENTS est un tableau

alert(arguments instanceof Array);
alert(arguments instanceof Object);

2 Comment juger strictement si une donnée est une instance du tableau ( ARRAY) classe

function isArray(value){
  if (typeof Array.isArray === "function") {
    return Array.isArray(value);
  }else{
    return Object.prototype.toString.call(value) === "[object Array]";
  }
}

3. Convertir les ARGUMENTS en tableaux
Méthode 1 : les types intégrés peuvent trouver des méthodes d'attributs intégrées via le prototype.prototype.slice est la tranche de méthode intégrée. pour accéder à Array. Grâce à la méthode slice, un tableau est renvoyé. call est une méthode d'appel d'un objet pour remplacer l'objet actuel par un autre objet.

var arg = Array.prototype.slice.call(arguments,0);

Méthode 2 : les performances sont légèrement moins bonnes que la méthode 1, car elle crée d'abord un tableau puis l'exécute

var arg = [].slice.call(arguments,0);

Méthode 3 : le convertit en tableau via une boucle

function toArray(arguments){
  var a = [];
  for(var i=0;i<arguments.length;i++){
    a.unshift(arguments.[i]);
  }
  return a;
}

appelant

Lorsqu'une fonction est appelée par une autre fonction, la fonction appelée générera automatiquement un attribut appelant pointant vers l'objet fonction qui l'a appelée si la fonction n'a pas été appelée. , Alors l'appelant est nul.

function testCaller() {
  var caller = testCaller.caller;
  alert(caller);
}
function aCaller() {
  testCaller();
}
aCaller();

Ce qui apparaît est le contenu de la fonction aCaller.

arguments.callee
arguments.callee pointe vers la fonction en cours d'exécution elle-même et renvoie l'objet Function en cours d'exécution, qui est le corps de l'objet Function spécifié.
Remarque : arguments.length est la longueur réelle du paramètre, arguments.callee.length est la longueur du paramètre formel, qui est généralement utilisée pour déterminer si les longueurs des paramètres formels et formels sont cohérentes
Obtenez les paramètres réels de la fonction via des arguments, et obtenez-les via arguments.callee Les paramètres formels de la fonction.
Il est également largement utilisé dans les fermetures.

var i = 0;
 
  function b(num) {
 
    if (num < 10) {
 
      num++;
 
      i++;
 
      //如果有参数，callee也要把参数带上;
 
      arguments.callee(num);
 
    } else {
 
      //输出2次
 
      alert("调用了"+i+"次callee!");
 
    }
 
  }
 
  b(8);
 
 Arguments.callee在闭包中的应用，它提供了一种递归调调用的功能。
 
//用arguments.callee计算10的阶乘,例如: 1×2×3×4×5×6×7....
 
  function c(x) {
 
    return x > 1 ? x * arguments.callee(x - 1) : 1
 
  } (10);
 
  //输出6
 
  alert(c(3));
 
  //输出3628800
 
  alert(c(10));

Exemple : l'appelé trouve la somme de 1-n

function fn(n){
  if(n==1) return n;
  else return n+arguments.callee(n-1);
}

Il permet à une fonction anonyme de s'appeler

Exemple :

function list(type){
  var result = "<"+type+"l><li>";
  var args = Array.prototype.slice.call(arguments,1);
  result += args.join("</li><li>");
  result += "</li></"+type+"l>";
  return result;
}
var listHtml = list("o","one","two");
console.log(listHtml);

Exemple 2 : Question d'entretien : Lequel des résultats console.log suivants est [1,2,3,4] ?

function foo(x){
  console.log(arguments);
  return x;
}
foo(1,2,3,4);
function foo(x){
  console.log(arguments);
  return x;
}(1,2,3,4)

Lors de la pré-interprétation, la fonction fn(){}(1); sera traitée séparément et divisée en deux fonctions, la première est la fonction fn() {} et la seconde It est une fonction anonyme : (1). Si la seconde ne prend aucun paramètre, une erreur sera signalée, mais la fonction ci-dessus est correcte si elle est contenue dans un ().

(function fn(){
  console.log(arguments);
}(1,2,3,4));
(function foo(x){
  console.log( arguments);
  return x;
})(1,2,3,4)
function foo(){
  bar.apply(null,arguments);
}
function bar(x){
  console.log(arguments);
}
foo(1,2,3,4);

Pour une analyse plus approfondie des objets arguments en JavaScript et des articles connexes, veuillez faire attention au site Web PHP chinois !