Eine eingehende Analyse des Argumentobjekts in JavaScript

Argumentdefinition

Alle Funktionen verfügen über ein eigenes Argumentobjekt, das zum Speichern der tatsächlich empfangenen Parameter verwendet wird und nicht auf die Parameterliste beschränkt ist, die bei der Deklaration der Funktion definiert wurde. Es ist kein Array, ähnelt aber einem Array. Es verfügt über dieselben Zugriffseigenschaften und Methoden wie ein Array. Auf den Wert des entsprechenden einzelnen Parameters kann über arguments[n] zugegriffen werden, und es verfügt über das Array-Längenattribut Länge. Es gibt jedoch keine Array-Methoden. Sie können Argumente durch einen Aufruf in ein echtes Array konvertieren und dann Array-Operationen ausführen.

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

Array-Klasse

1. Bestimmen Sie, ob ARGUMENTS ein Array ist

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

2. So beurteilen Sie streng, ob Daten eine Instanz des Arrays sind ( ARRAY)-Klasse

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

3. Konvertieren Sie ARGUMENTE in Arrays
Methode 1: Integrierte Typen können integrierte Attributmethoden über den Prototyp finden für den Zugriff auf Array. Durch die Slice-Methode wird ein Array zurückgegeben. call ist eine Methode zum Aufrufen eines Objekts, um das aktuelle Objekt durch ein anderes Objekt zu ersetzen.

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

Methode 2: Die Leistung ist etwas schlechter als bei Methode 1, da zuerst ein Array erstellt und dann ausgeführt wird.

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

Methode 3: Konvertieren Sie es durch eine Schleife in ein Array

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

Aufrufer

Wenn eine Funktion von einer anderen Funktion aufgerufen wird, generiert die aufgerufene Funktion automatisch ein Aufruferattribut, das auf das Funktionsobjekt verweist, das sie aufgerufen hat , Dann ist der Anrufer null.

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

Was angezeigt wird, ist der Inhalt der Funktion aCaller.

arguments.callee
arguments.callee zeigt auf die laufende Funktion selbst und gibt das ausgeführte Funktionsobjekt zurück, das den Hauptteil des angegebenen Funktionsobjekts darstellt.
Hinweis: arguments.length ist die tatsächliche Parameterlänge, arguments.callee.length ist die formale Parameterlänge, die normalerweise verwendet wird, um zu bestimmen, ob die formalen und formalen Parameterlängen konsistent sind
Erhalten Sie die tatsächlichen Parameter der Funktion durch Argumente und erhalten Sie sie über arguments.callee Die formalen Parameter der Funktion.
Es wird auch häufig in Verschlüssen verwendet.

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));

Beispiel: Aufgerufener findet die Summe von 1-n

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

Es ermöglicht einer anonymen Funktion, sich selbst aufzurufen

Beispiel:

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);

Beispiel 2: Interviewfrage: Welches der folgenden console.log-Ergebnisse ist [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)

Während der Vorinterpretation wird die Funktion fn(){}(1); separat verarbeitet und in zwei Funktionen unterteilt, die erste ist die Funktion fn() {} und die zweite ist It ist eine anonyme Funktion: (1). Wenn die zweite Funktion keine Parameter annimmt, wird ein Fehler gemeldet, aber die obige Funktion ist korrekt, wenn sie in einer () enthalten ist.

(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);

Für eine ausführlichere Analyse von Argumentobjekten in JavaScript und verwandte Artikel beachten Sie bitte die chinesische PHP-Website!