JavaScript-Funktionsparameter

Inhaltsverzeichnis

Eine JavaScript-Funktion führt keine Prüfung durch Parameterwerte (Argumente).

Funktionsparameter und Argumente

Zu Beginn dieses Tutorials haben Sie gelernt, dass Funktionen haben können Parameter:

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

Funktions-Parameter sind die in aufgeführten Namen die Funktionsdefinition.

Funktionsargumente sind die tatsächlichen Werte an die Funktion übergeben (und von dieser empfangen) werden.

Parameterregeln

JavaScript-Funktionsdefinitionen geben keine Datentypen für an Parameter.

JavaScript-Funktionen führen keine Typprüfung der übergebenen Daten durch Argumente.

JavaScript-Funktionen prüfen nicht die Anzahl der empfangenen Argumente.

Standardparameter

Wenn eine Funktion mit fehlenden Argumenten (weniger als deklariert) aufgerufen wird, werden die fehlenden Werte auf gesetzt undefiniert.

Manchmal ist dies akzeptabel, manchmal ist es jedoch besser, einen Standardwert zuzuweisen Wert für den Parameter:

Beispiel

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

}

Probieren Sie es selbst aus →

<!DOCTYPE html>
<html>
<body>

<p>Setting a default value to a function parameter.</p>
<p id="demo"></p>

<script>
function myFunction(x, y) {
  if (y === undefined) {
    y = 2;
  }  
  return x * y;
}
document.getElementById("demo").innerHTML = myFunction(4);
</script>

</body>
</html>

Standardparameterwerte

ES6 ermöglicht, dass Funktionsparameter Standardwerte haben.

Beispiel

Wenn y nicht übergeben oder undefiniert ist, dann ist y=10.

function myFunction(x, y = 10) {	  return x + y;
}
myFunction(5);

Probieren Sie es selbst aus →

<!DOCTYPE html>
<html>
<body>
<h1>JavaScript Functions</h1>
<h2>Default Parameter Values</h2>
<p>If y is not passed or undefined, then y = 10:</p>

<p id="demo"></p>

<script>
function myFunction(x, y = 10) {
  return x + y;
}
document.getElementById("demo").innerHTML = myFunction(5);
</script>

</body>
</html>

Funktionsrestparameter

Der rest-Parameter (...) ermöglicht einer Funktion, eine unbegrenzte Anzahl von Argumenten als Array zu behandeln:

Beispiel

function sum(...args) {
  let sum = 0;
  for (let arg of args) sum += arg;
  return sum;
}

let x = sum(4, 9, 16, 25, 29, 100, 66, 77);

Probieren Sie es selbst aus →

<!DOCTYPE html>
<html>
<body>
<h1>JavaScript Functions</h1>
<h2>The Rest Parameter</h2>

<p>The rest parameter (...) allows a function to treat an indefinite number of arguments as an array:</p>

<p id="demo"></p>

<script>
function sum(...args) {
  let sum = 0;
  for (let arg of args) sum += arg;
  return sum;
}

let x = sum(4, 9, 16, 25, 29, 100, 66, 77);

document.getElementById("demo").innerHTML = x;
</script>

</body>
</html>

Das Arguments-Objekt

JavaScript-Funktionen verfügen über ein integriertes Objekt namens Argumente Objekt.

Das Argumentobjekt enthält ein Array der Argumente, die bei der Funktion verwendet werden wurde aufgerufen (aufgerufen).

Auf diese Weise können Sie einfach eine Funktion verwenden, um (zum Beispiel) den höchsten Wert zu finden Wert in einer Zahlenliste:

Beispiel

x = findMax(1, 123, 500, 115, 44, 88);
function findMax() {
  let max = -Infinity;
    for (let i = 0; i < arguments.length; i++) {
      if (arguments[i] > max) {
      max = arguments[i];
      }
    }
    return max;
}

Probieren Sie es selbst aus →

<!DOCTYPE html>
<html>
<body>

<h2>JavaScript Functions</h2>
<p>Finding the largest number.</p>
<p id="demo"></p>

<script>
function findMax() {
  let max = -Infinity;
  for(let i = 0; i < arguments.length; i++) {
    if (arguments[i] > max) {
      max = arguments[i];
    }
  }
  return max;
} 
document.getElementById("demo").innerHTML = findMax(4, 5, 6);
</script>

</body>
</html>

Oder erstellen Sie eine Funktion, um alle Eingabewerte zu summieren:

Beispiel

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

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

Probieren Sie es selbst aus →

<!DOCTYPE html>
<html>
<body>

<h2>JavaScript Functions</h2>
<p>Sum of all arguments:</p>
<p id="demo"></p>

<script>
function sumAll() {
  let sum = 0;
  for(let i = 0; i < arguments.length; i++) {
    sum += arguments[i];
  }
  return sum;
}
document.getElementById("demo").innerHTML = sumAll(1, 123, 500, 115, 44, 88);
</script>

</body>
</html>

Wenn eine Funktion mit zu vielen Argumenten aufgerufen wird (mehr als deklariert), Auf diese Argumente kann über das Argumentenobjekt zugegriffen werden.

Argumente werden als Wert übergeben

Die Parameter in einem Funktionsaufruf sind die Argumente der Funktion.

JavaScript-Argumente werden als Wert übergeben: Nur die Funktion lernt die Werte kennen, nicht die Positionen des Arguments.

Wenn eine Funktion den Wert eines Arguments ändert, ändert sie nicht den Wert des Parameters Originalwert.

Änderungen an Argumenten sind außerhalb der Funktion nicht sichtbar (reflektiert).

Objekte werden als Referenz übergeben

In JavaScript sind Objektreferenzen Werte.

Aus diesem Grund verhalten sich Objekte so, als würden sie als Referenz: übergeben

Wenn eine Funktion eine Objekteigenschaft ändert, ändert sie den ursprünglichen Wert.

Änderungen an Objekteigenschaften sind außerhalb der Funktion sichtbar (reflektiert).