Argumente: Eine JavaScript -Kuriosität

Key Takeaways

• Argumente ’ist ein lokales, arrayähnliches Objekt, das in jeder JavaScript-Funktion verfügbar ist und alle Argumente enthält, die der Funktion beigerufen wurden. Es ist kein echtes Array, da es keine Standard -Array -Methoden wie Push und Pop besitzt.
• Trotz seiner Einschränkungen ist „Argumente“ ein leistungsstarkes Tool, das die Erstellung flexibler Funktionen ermöglicht, die eine variable Anzahl von Argumenten akzeptieren, die mit der Array -Methode, Slice, in ein reales Array konvertiert werden können.
• Argumente "hat auch eine" Callee "-Fahrung, die einen Verweis auf die Funktion enthält, die das Objekt" Argumente "erstellt hat und eine anonyme Funktion ermöglicht, sich auf sich selbst zu beziehen. Dies kann verwendet werden, um Selbstreferenzfunktionen und Funktionen mit voreingestellten Argumenten zu erstellen.

Argumente sind der Name eines lokalen, arrayähnlichen Objekts, das in jeder Funktion verfügbar ist. Es ist schrullig, oft ignoriert, aber die Quelle vieler Programmierzauberei. Alle wichtigen JavaScript -Bibliotheken nutzen die Macht des Argumenteobjekts. Es ist etwas, mit dem jeder JavaScript -Programmierer vertraut sein sollte.

In jeder Funktion können Sie über die Variable: Argumente darauf zugreifen, und es enthält ein Array aller Argumente, die der Funktion geliefert wurden, wenn sie aufgerufen wurde. Es ist eigentlich kein JavaScript -Array. Typen von Argumenten geben den Wert zurück: "Objekt". Sie können über einen Array -Index auf die individuellen Argumentwerte zugreifen, und es verfügt über eine Länge -Eigenschaft wie andere Arrays. Es verfügt jedoch nicht über die Standard -Array -Methoden wie Push und Pop.

Erstellen Sie flexible Funktionen

Obwohl es begrenzt erscheinen mag, sind Argumente ein sehr nützliches Objekt. Sie können beispielsweise Funktionen erstellen, die eine variable Anzahl von Argumenten akzeptieren. Die Formatfunktion, die in der Base2 -Bibliothek von Dean Edwards zu finden ist, zeigt diese Flexibilität:

function format(string) {
  var args = arguments;
  var pattern = new RegExp("%([1-" + arguments.length + "])", "g");
  return String(string).replace(pattern, function(match, index) {
    return args[index];
  });
};

Sie liefern eine Vorlagenzeichenfolge, in der Sie Platzhalter für Werte mit %1 bis %9 hinzufügen, und dann bis zu 9 weitere Argumente, die die zu fügigen Strings darstellen. Zum Beispiel:

format("And the %1 want to know whose %2 you %3", "papers", "shirt", "wear");

Der obige Code gibt die Zeichenfolge zurück "und die Papiere möchten wissen, wessen Hemd Sie tragen".

Eine Sache, die Sie vielleicht bemerkt haben, ist, dass wir in der Funktionsdefinition für das Format nur ein Argument angegeben haben: String. Mit JavaScript können wir unabhängig von der Funktionsdefinition eine beliebige Anzahl von Argumenten an eine Funktion übergeben, und das Argumenteobjekt hat Zugriff auf alle.

Konvertieren Sie es in ein echtes Array

Obwohl Argumente kein tatsächliches JavaScript -Array sind

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

Die Variablen args enthält nun ein ordnungsgemäßes JavaScript -Array -Objekt, das alle Werte aus dem Argumenteobjekt enthält.

Funktionen mit voreingestellten Argumenten erstellen

Das Argumenteobjekt ermöglicht es uns, alle Arten von JavaScript -Tricks auszuführen. Hier ist die Definition für die Makefunc -Funktion. Mit dieser Funktion können Sie eine Funktionsreferenz und eine beliebige Anzahl von Argumenten für diese Funktion angeben. Es wird eine anonyme Funktion zurückgegeben, die die von Ihnen angegebene Funktion aufruft, und liefert die voreingestellten Argumente zusammen mit neuen Argumenten, die angegeben werden, wenn die anonyme Funktion aufgerufen wird:

function format(string) {
  var args = arguments;
  var pattern = new RegExp("%([1-" + arguments.length + "])", "g");
  return String(string).replace(pattern, function(match, index) {
    return args[index];
  });
};

Das erste Argument, das Makefunc geliefert wird, wird als Referenz auf die Funktion angesehen, die Sie aufrufen möchten (ja, in diesem einfachen Beispiel gibt es keine Fehlerprüfung) und es wird aus dem Argumente -Array entfernt. Makefunc gibt dann eine anonyme Funktion zurück, die die Methode des Funktionsobjekts anwenden, um die angegebene Funktion aufzurufen.

Das erste Argument für die Anwendung bezieht sich auf den Umfang, in dem die Funktion aufgerufen wird. Grundsätzlich, auf welches Schlüsselwort dies in der in der Funktion aufgerufenen Funktion bezieht. Das ist vorerst ein wenig fortgeschritten, also halten wir es einfach null. Das zweite Argument ist ein Array von Werten, das in das Argumenteobjekt für die Funktion konvertiert wird. Makefunc verkettet das ursprüngliche Wertearray auf das Argumente, das der anonymen Funktion mitgeliefert wird, und liefert dies der aufgerufenen Funktion.

Nehmen wir an, es gab eine Nachricht, die Sie ausgeben mussten, wo die Vorlage immer gleich war. Um zu speichern, dass Sie die Vorlage jedes Mal, wenn Sie die Formatfunktion aufrufen

format("And the %1 want to know whose %2 you %3", "papers", "shirt", "wear");

Sie können die Majortom -Funktion wiederholt so aufrufen:

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

Jedes Mal, wenn Sie die Majortom -Funktion aufrufen, ruft sie die Formatfunktion mit dem ersten Argument auf, die bereits ausgefüllte Vorlage. Die obigen Aufrufe geben zurück:

function makeFunc() {
  var args = Array.prototype.slice.call(arguments);
  var func = args.shift();
  return function() {
    return func.apply(null, args.concat(Array.prototype.slice.call(arguments)));
  };
}

Erstellen von Selbstreferenzfunktionen

Sie denken vielleicht, dass das ziemlich cool ist, aber warten Sie, Argumente haben noch eine Überraschung. Es hat eine andere nützliche Eigenschaft: Callee. Argumente.Callee enthält einen Verweis auf die Funktion, die das Argumenteobjekt erstellt hat. Wie können wir so etwas verwenden? Argumente.Callee ist eine praktische Art und Weise, wie sich eine anonyme Funktion auf sich selbst beziehen kann.

var majorTom = makeFunc(format, "This is Major Tom to ground control. I'm %1.");

majorTom("stepping through the door");
majorTom("floating in a most peculiar way");

"This is Major Tom to ground control. I'm stepping through the door."
"This is Major Tom to ground control. I'm floating in a most peculiar way."

repeat is a function that takes a function reference, and 2 numbers. The first number is how many times to call the function and the second represents the delay, in milliseconds, between each call. Here's the definition for repeat:

Ich möchte jedoch eine spezielle Version dieser Funktion erstellen, die sich dreimal mit einer Verzögerung von 2 Sekunden zwischen jedem Mal wiederholt. Mit meiner Wiederholungsfunktion kann ich das tun:

function repeat(fn, times, delay) {
  return function() {
    if(times-- > 0) {
      fn.apply(null, arguments);
      var args = Array.prototype.slice.call(arguments);
      var self = arguments.callee;
      setTimeout(function(){self.apply(null,args)}, delay);
    }
  };
}

Das Ergebnis des Aufrufens der Funktion "Somethingwrong" ist eine Warnungsbox, die dreimal mit einer 2 -Sekunden -Verzögerung zwischen den einzelnen Alarms wiederholt wird.

function format(string) {
  var args = arguments;
  var pattern = new RegExp("%([1-" + arguments.length + "])", "g");
  return String(string).replace(pattern, function(match, index) {
    return args[index];
  });
};

häufig gestellte Fragen zu JavaScript -Argumenten

Was ist das "Argumente" -Objekt in JavaScript? Es enthält eine Array-ähnliche Struktur mit allen an die Funktion übergebenen Argumenten. Dieses Objekt ist nützlich, wenn eine Funktion variable Anzahl von Argumenten verarbeiten muss. Es ist wichtig zu beachten, dass das "Argumente" -Objekt kein tatsächliches Array ist, aber es kann bei Bedarf in eins konvertiert werden. Sie können es jedoch mit der Array.From () -Methode oder dem Spread Operator (…) in ein Array umwandeln. Hier ist ein Beispiel:

Funktion ConvertarGSTOArray () {

var argsArray = array.from (Argumente);

// oder

var argsArray = [... Argumente]; Innerhalb der Pfeilfunktionen. Pfeilfunktionen haben nicht ihr eigenes "Argumente" -Objekt. Sie können jedoch auf das Objekt "Argumente" von der nächstgelegenen Nicht-Arrow-übergeordneten Funktion zugreifen. Es gibt eine Zeichenfolge zurück, die den Typ des nicht evaluierten Operanden angibt. Zum Beispiel wird "Typeof 3" "Nummer" zurückgegeben, und "typof" hello "gibt" String zurück "zurück. Hier ist ein Beispiel:

Funktion checkarGstype () {🎜> für (var i = 0; i console.log (Typof Argumente [i]); Das erste Argument überging einer Funktion. In ähnlicher Weise bezieht sich „Argumente [1]“ auf das zweite Argument und so weiter. Wenn keine Argumente übergeben werden, werden „Argumente [0]“ nicht definiert. Es wird jedoch im Allgemeinen nicht empfohlen, da es zu verwirrendem und schwer zu debugem Code führen kann. Im strengen Modus wirft jeder Versuch, das Objekt „Argumente“ zu ändern, einen Fehler. Es ist nützlich, wenn Sie über die Argumente iterieren oder feststellen müssen, wie viele Argumente übergeben wurden.

Kann ich das Objekt "Argumente" mit Standardparametern in JavaScript verwenden?

Ja, aber mit einer Einschränkung. Wenn eine Funktion mit Standardparametern mit weniger Argumenten als Parameter aufgerufen wird, enthält das Objekt „Argumente“ nur die tatsächlichen Argumente, nicht die Standardwerte. Diese Eigenschaft ist veraltet und sollte nicht im neuen Code verwendet werden. Stattdessen können Sie benannte Funktionsausdrücke oder Pfeilfunktionen verwenden.

Das obige ist der detaillierte Inhalt vonArgumente: Eine JavaScript -Kuriosität. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!