JavaScript-Funktionsaufruf und Parameterübergabe_Grundkenntnisse

JavaScript-Funktionsaufruf
Es gibt vier Möglichkeiten, JavaScript-Funktionen aufzurufen.
Der Unterschied besteht jeweils in der Initialisierung.
dieses Schlüsselwort
Im Allgemeinen zeigt dies in Javascript auf das aktuelle Objekt, wenn die Funktion ausgeführt wird.
Hinweis Beachten Sie, dass es sich hierbei um ein reserviertes Schlüsselwort handelt. Sie können den Wert dieses Schlüsselworts nicht ändern.
JavaScript-Funktion aufrufen
Der Code innerhalb der Funktion wird ausgeführt, nachdem die Funktion aufgerufen wurde.
Aufruf als Funktion
Beispiel

function myFunction(a, b) {
  return a * b;
}
myFunction(10, 2);      // myFunction(10, 2) 返回 20

Die obige Funktion gehört zu keinem Objekt. In JavaScript ist es jedoch immer das standardmäßige globale Objekt.
Das standardmäßige globale Objekt in HTML ist die HTML-Seite selbst, daher gehört die Funktion zur HTML-Seite.
Das Seitenobjekt im Browser ist das Browserfenster (Fensterobjekt). Die oben genannten Funktionen werden automatisch zu Funktionen des Fensterobjekts.
myFunction() und window.myFunction() sind dasselbe:
Beispiel

function myFunction(a, b) {
  return a * b;
}
window.myFunction(10, 2);  // window.myFunction(10, 2) 返回 20

Hinweis: Dies ist eine gängige Methode zum Aufrufen von JavaScript-Funktionen, aber keine gute Programmierpraxis
Globale Variablen, Methoden oder Funktionen können leicht Namenskonflikte verursachen.
Globales Objekt
Wenn die Funktion nicht von ihrem eigenen Objekt aufgerufen wird, wird der Wert dieses zum globalen Objekt.
In einem Webbrowser ist das globale Objekt das Browserfenster (Fensterobjekt).
Der von dieser Instanz zurückgegebene Wert ist das Fensterobjekt:
Beispiel

function myFunction() {
  return this;
}
myFunction();        // 返回 window 对象

Hinweis: Wenn Sie eine Funktion als globales Objekt aufrufen, wird der Wert dieser Funktion zu einem globalen Objekt.
Die Verwendung des Fensterobjekts als Variable kann leicht zum Absturz des Programms führen.
Funktion wird als Methode aufgerufen
In JavaScript können Sie Funktionen als Methoden von Objekten definieren.
Das folgende Beispiel erstellt ein Objekt (myObject) mit zwei Eigenschaften (firstName und lastName) und einer Methode (fullName):
Beispiel

var myObject = {
  firstName:"John",
  lastName: "Doe",
  fullName: function () {
    return this.firstName + " " + this.lastName;
  }
}
myObject.fullName();     // 返回 "John Doe"

Die fullName-Methode ist eine Funktion. Funktionen gehören zu Objekten. myObject ist der Eigentümer der Funktion.
Dieses Objekt enthält JavaScript-Code. Der Wert davon in der Instanz ist das myObject-Objekt.
Testen Sie unten! Ändern Sie die Methode fullName und geben Sie diesen Wert zurück:
Beispiel

var myObject = {
  firstName:"John",
  lastName: "Doe",
  fullName: function () {
    return this;
  }
}
myObject.fullName();     // 返回 [object Object] (所有者对象)

Hinweis: Wenn eine Funktion als Objektmethode aufgerufen wird, wird der Wert dieser zum Objekt selbst.
Verwenden Sie den Konstruktor, um die Funktion aufzurufen
Wird das Schlüsselwort new vor dem Funktionsaufruf verwendet, wird der Konstruktor aufgerufen.
Dies sieht so aus, als ob eine neue Funktion erstellt wurde, aber in Wirklichkeit handelt es sich bei JavaScript-Funktionen um neu erstellte Objekte:
Beispiel

// 构造函数:
function myFunction(arg1, arg2) {
  this.firstName = arg1;
  this.lastName = arg2;
}

// This creates a new object
var x = new myFunction("John","Doe");
x.firstName;               // 返回 "John"

Der Aufruf des Konstruktors erstellt ein neues Objekt. Das neue Objekt erbt die Eigenschaften und Methoden des Konstruktors.
Hinweis Das Schlüsselwort this im Konstruktor hat keinen Wert.
Der Wert hierfür wird erstellt, wenn das Objekt (neues Objekt) beim Aufruf der Funktion instanziiert wird.
Funktion als Funktionsmethode aufrufen
In JavaScript sind Funktionen Objekte. Eine JavaScript-Funktion hat ihre Eigenschaften und Methoden.
call() und apply() sind vordefinierte Funktionsmethoden. Zum Aufrufen von Funktionen können zwei Methoden verwendet werden, und der erste Parameter beider Methoden muss das Objekt selbst sein.
Beispiel

function myFunction(a, b) {
  return a * b;
}
myFunction.call(myObject, 10, 2);   // 返回 20

Beispiel

function myFunction(a, b) {
  return a * b;
}
myArray = [10,2];
myFunction.apply(myObject, myArray);  // 返回 20

Beide Methoden verwenden das Objekt selbst als ersten Parameter. Der Unterschied zwischen den beiden liegt im zweiten Parameter: apply übergibt ein Parameter-Array, d. h. mehrere Parameter werden zu einem Array zusammengefasst und übergeben, während call als Parameter von call übergeben wird (beginnend mit dem zweiten Parameter).
Im strikten JavaScript-Modus wird der erste Parameter beim Aufruf einer Funktion zum Wert dieser Funktion, auch wenn der Parameter kein Objekt ist.
Wenn im nicht-strikten JavaScript-Modus der Wert des ersten Parameters null oder undefiniert ist, wird stattdessen das globale Objekt verwendet.
Hinweis Mit den Methoden call() oder apply() können Sie den Wert dieser Funktion festlegen und sie als neue Methode für ein vorhandenes Objekt aufrufen.

JavaScript-Funktionsparameter
JavaScript-Funktionen führen keine Prüfungen von Parameterwerten (Argumenten) durch.
Funktion explizite Parameter und versteckte Parameter (Argumente)
In früheren Tutorials haben wir etwas über explizite Parameter von Funktionen gelernt:

functionName(parameter1, parameter2, parameter3) {
  code to be executed
}

函数显式参数在函数定义时列出。
函数隐藏参数(arguments)在函数调用时传递给函数真正的值。
参数规则
JavaScript 函数定义时参数没有指定数据类型。
JavaScript 函数对隐藏参数(arguments)没有进行检测。
JavaScript 函数对隐藏参数(arguments)的个数没有进行检测。
默认参数
如果函数在调用时缺少参数，参数会默认设置为： undefined
有时这是可以接受的，但是建议最好为参数设置一个默认值：
实例

function myFunction(x, y) {
  if (y === undefined) {
     y = 0;
  } 
}

或者，更简单的方式：
实例

function myFunction(x, y) {
  y = y || 0;
}

Note 如果y已经定义 ， y || 返回 y, 因为 y 是 true, 否则返回 0, 因为 undefined 为 false。
如果函数调用时设置了过多的参数，参数将无法被引用，因为无法找到对应的参数名。 只能使用 arguments 对象来调用。
Arguments 对象
JavaScript 函数有个内置的对象 arguments 对象.
argument 对象包含了函数调用的参数数组。
通过这种方式你可以很方便的找到最后一个参数的值：
实例

x = findMax(1, 123, 500, 115, 44, 88);

function findMax() {
  var i, max = 0;
  for (i = 0; i < arguments.length; i++) {
    if (arguments[i] > max) {
      max = arguments[i];
    }
  }
  return max;
}

或者创建一个函数用来统计所有数值的和：
实例

x = sumAll(1, 123, 500, 115, 44, 88);

function sumAll() {
  var i, sum = 0;
  for (i = 0; i < arguments.length; i++) {
    sum += arguments[i];
  }
  return sum;
}

通过值传递参数
在函数中调用的参数是函数的参数。
如果函数修改参数的值，将不会修改参数的初始值（在函数外定义）。
函数参数的改变不会影响函数外部的变量（局部变量）。
通过对象传递参数
在JavaScript中，可以引用对象的值。
因此我们在函数内部修改对象的属性就会修改其初始的值。
修改对象属性可作用于函数外部（全局变量）。