Argumente in Javascript

Obwohl

function aaa(sTemplate) {  
var args = arguments;  
var s = sTemplate;
  s = s.replace(/\%\%/g, "%");
  for (var i = 1; i < args.length; i++)     
  s = s.replace( new RegExp("\%" + i + "\%", "g"), args[i] )
  return s;}

arguments kein Array ist, kann es als Array verwendet werden. Der Index beginnt bei 0, also:

arguments[0] stellt den ersten empfangenen Parameter dar

arguments [1] Stellt den zweiten empfangenen Parameter dar

...

und so weiter...

Auf diese Weise kann dieselbe Funktion mit unterschiedlichen Parametern aufgerufen werden~

Die Voraussetzung ist natürlich, dass die Funktion die Verarbeitungsmethode für den Parameter festlegt, sonst ist sie nutzlos.

Argumentattribut

gibt ein zurück arguments-Objekt für das aktuell ausgeführte Funktionsobjekt.

function.arguments

Der Funktionsparameter ist der Name der aktuell ausgeführten Funktion und kann weggelassen werden.

Die Längeneigenschaft des Argumentobjekts enthält die Anzahl der an die Funktion übergebenen Argumente. Die Zugriffsmethode für einen einzelnen im Argumentobjekt enthaltenen Parameter ist dieselbe wie für die im Array enthaltenen Parameter.

Auszüge eines Beispiels, das die Verwendung des Arguments-Attributs veranschaulicht. Sie können die folgende Referenz erstellen:

function ArgTest(){
   var i, s, numargs = arguments.length;
   s = numargs; 
   if (numargs < 2)｛
      s += " argument was passed to ArgTest. It was ";
   ｝else｛
      s += " arguments were passed to ArgTest. They were " ;
   ｝
   for (i = 0; i < numargs; i++){
         s += arguments[i] + " ";
   }
   return(s);
}

Zitat:

1. Argumente geschickt verwenden

Es gibt eine Funktion namens Argumente im Javascript-Array -ähnliches Objekt. Es scheint so seltsam und unbekannt, aber zahlreiche Javascript-Bibliotheken nutzen seine leistungsstarken Funktionen. Daher erfordern seine Funktionen, dass jeder Javascript-Programmierer damit vertraut ist.

In jeder Funktion gibt es eine Variable namens arguments, die die Parameter des aktuellen Aufrufs in einer Array-ähnlichen Form speichert. Und es handelt sich eigentlich nicht um ein Array. Der Versuch, die Anweisung „typeof arguments“ zu verwenden, gibt „object“ (Objekt) zurück, sodass Methoden wie Push und Pop nicht wie Array verwendet werden können. Dennoch kann sein Wert immer noch mithilfe des Index und des Längenattributs ermittelt werden.

2. Schreiben Sie flexible Funktionen

Obwohl es unbekannt erscheint, sind Argumente tatsächlich sehr nützliche Objekte. Beispielsweise kann eine Funktion eine variable Anzahl von Argumenten verarbeiten. In der von Dean Edwards geschriebenen base2-Bibliothek gibt es eine Funktion namens format, die diese Funktion voll ausnutzt:

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

Der zweite Parameter der Ersetzungsfunktion kann eine Funktion sein, Der erste Parameter der Funktion kann der übereinstimmende Text sein, der zweite Parameter ist der übereinstimmende Wert und der Rückgabewert ist der zu ersetzende Text

Diese Funktion implementiert die Vorlagenersetzung. Sie können dynamisch ersetzte Stellen mit markieren %1 bis %9, und dann werden die übrigen Parameter diese Stellen der Reihe nach ersetzen. Zum Beispiel:

format("Und die %1 möchten wissen, wessen %2 Sie %3", "Papiere", "Shirt", "tragen");

Das obige Skript wird Zurück

„Und die Zeitungen wollen wissen, wessen Hemd du trägst“ .

Hier ist zu beachten, dass wir selbst in der Definition der Formatfunktion nur einen Parameter namens string definieren. Javascript ermöglicht es uns, eine beliebige Anzahl von Parametern an eine Funktion zu übergeben, unabhängig von der Anzahl der von der Funktion selbst definierten Parameter, und diese Parameterwerte im Arguments-Objekt der aufgerufenen Funktion zu speichern.

3. In tatsächliches Array konvertieren

Obwohl das Argumentobjekt kein echtes Javascript-Array ist, können wir es mit der Slice-Methode des Arrays in ein Array konvertieren . Code ähnlich dem folgenden

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

call(obj, Parameterliste, die von der aktuellen Funktion verwendet wird)

Aufrufmethode Nr. Ein Parameter ist ein Objekt, und das übergebene Objekt ruft die Slice-Funktion auf. Da Argumente kein Array sind, kann die Slice-Methode nicht direkt aufgerufen werden, daher kann nur die Methode „Objektimitation“ verwendet werden

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

有种情况就是总是要有个输出的模板是相同的，为了节省每次是使用上面提到的 format 函数并指定重复的参数，我们可以使用 makeFunc 这个工具。它将返回一个匿名函数，并自动生成已经指定模板后的内容：

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

你可以像这样重复指定 majorTom 函数：

majorTom("stepping through the door");

majorTom("floating in a most peculiar way");

那么当每次调用 majorTom 函数时，它都会使用第一个指定的参数填写已经指定的模板。例如上述的代码返回：

"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."

五、自引用的函数

您可能会认为这很酷，先别急着高兴，后面还有个更大的惊喜。它（arguments）还有个其他非常有用的属性：callee 。arguments.callee 包含了当前调用函数的被引用对象。那么我们如何使用这玩意做些的事情？arguments.callee 是个非常有用的调用自身的匿名函数。

下面有个名为 repeat 的函数，它的参数需要个函数引用和两个数字。第一个数字表示运行的次数，而第二个函数定义运行的间隔时间（毫秒为单位）。下面是相关的代码：

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

repeat 函数使用 arguments.callee 获得当前引用，保存到 self 变量后，返回个匿名函数重新运行原本被调用的函数。最后使用 setTimeout 以及配合个匿名函数实现延迟执行。

作为个简单的说明，比如会在通常的脚本中，编写下面的提供个字符串并弹出个警告框的简单函数：

function comms(s) {
  alert(s);
}

好了，后来我改变了我的想法。我想编写个“特殊版本”的函数，它会重复三次运行每次间隔两秒。那么使用我的 repeat 函数，就可以像这样做到：

var somethingWrong = repeat(comms, 3, 2000);

somethingWrong("Can you hear me, major tom?");

结果就犹如预期的那样，弹出了三次警告框每次延时两秒。

最后，arguments 即便不会经常被用到，甚至显得有些诡异，但是它上述的那些惊艳的功能（不仅仅是这些！）值得你去了解它。

undefined ≠ null

null是一个对象，undefined是一个属性、方法或变量。存在null是因为对象被定义。如果对象没有被定义，而测试它是否是null，但因为没有被定义，它无法测试到，而且会抛出错误。

if(myObject !== null  && typeof(myObject) !== 'undefined') {
//如果myObject是undefined，它不能测试是否为null，而且还会抛出错误
}
if(typeof(myObject) !== 'undefined' && myObject !== null) {
//处理myObject的代码
}