Ausführliche Analyse des Argumentobjekts in JavaScript (grafisches Tutorial)

arguments ist ein in JavaScript integriertes Objekt, das die Übertragung von Parametern wie eine Array-Struktur speichert. Hier werden wir das Argumentobjekt in JavaScript eingehend analysieren. Freunde in Not können sich auf die Definition von

Argumente

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 wird. 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-artig

1. Bestimmen Sie, ob ARGUMENTS ein Array ist

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

2. So bestimmen Sie strikt, ob Daten eine Instanz der Array-Klasse (ARRAY) sind

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

3. ARGUMENTE in Array konvertieren

Methode 1: Integrierte Typen können integrierte Attributmethoden über den Prototyp finden. Array.prototype.slice ist das integrierte Methodensegment für den Zugriff auf Arrays. 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 Methode 1, da zuerst ein Array erstellt und dann fortgefahren wird

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

Methode 3: Konvertieren in Array durch Schleife

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. Wenn die Funktion nicht aufgerufen wurde, ist der Aufrufer 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: Das folgende console.log-Ergebnis 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 aufgeteilt, die erste ist die Funktion fn () {}, während die zweite eine anonyme Funktion ist: (1). Wenn die zweite 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);

Das oben Gesagte habe ich für Sie zusammengestellt. Ich hoffe, es wird Ihnen in Zukunft hilfreich sein.

Verwandte Artikel:

Einfache und leicht verständliche Javascript-Notizen zum Selbststudium

Verwendung Javascript Konvertiert die eingegebene Zahl automatisch in das Währungsformat (Code angehängt)

Über die Scope-Scope-Kette von Javascript (Bild- und Text-Tutorial , klar auf einen Blick )

Das obige ist der detaillierte Inhalt vonAusführliche Analyse des Argumentobjekts in JavaScript (grafisches Tutorial). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!