Parameter und Argumente

Eine Funktion ohne Parameter kann genau eine Sache, und zwar immer dieselbe. Sobald sie Werte entgegennimmt, wird aus einem festen Ablauf ein Werkzeug.

01 / 04Zwei Wörter für zwei Seiten derselben Sache

<h1>Ausgabe</h1>
<p>Was dieses Beispiel tut, steht in der Console.</p>

// name ist der Parameter: ein Platzhalter, der erst beim Aufruf
// einen Wert bekommt.
function begruesse(name) {
  console.log(`Hallo, ${name}!`);
}

// "Mario" und "Lena" sind die Argumente: die echten Werte.
begruesse("Mario");
begruesse("Lena");

// Auch das Ergebnis einer Rechnung darf ein Argument sein.
const jahr = 2026;
begruesse("Besucher aus " + jahr);

Die beiden Begriffe werden ständig verwechselt, dabei ist die Regel kurz:

Der Parameter steht in der Deklaration. Er ist ein Platzhalter, ein Name ohne Wert. In function begruesse(name) ist name der Parameter.

Das Argument steht beim Aufruf. Es ist der echte Wert, der eingesetzt wird. In begruesse("Mario") ist "Mario" das Argument.

Innerhalb der Funktion verhält sich ein Parameter wie eine ganz normale Variable. Du kannst mit ihm rechnen, ihn ausgeben, ihn sogar überschreiben. Er entsteht bei jedem Aufruf neu und verschwindet danach wieder.

Wenn dir die Wörter durcheinandergehen: Der Merksatz ist, dass beim Aufruf das Argument steht. In der Praxis sagen die meisten sowieso zu beidem „Parameter”, und meistens ist trotzdem klar, was gemeint ist.

02 / 04Die Reihenfolge entscheidet

<h1>Ausgabe</h1>
<p>Was dieses Beispiel tut, steht in der Console.</p>

function teile(zaehler, nenner) {
  console.log(`${zaehler} geteilt durch ${nenner} ist ${zaehler / nenner}`);
}

// So ist es gemeint.
teile(10, 2);

// Und so nicht. JavaScript merkt davon nichts: es füllt stur von
// links nach rechts auf.
teile(2, 10);

// Die Namen der Variablen draußen spielen keine Rolle.
const nenner = 4;
const zaehler = 100;
teile(nenner, zaehler);

Mehrere Parameter trennst du mit einem Komma, und beim Aufruf ebenso. Zugeordnet wird dann stur von links nach rechts.

Das erste Argument landet im ersten Parameter, das zweite im zweiten, und so weiter. Wie die Variablen außerhalb der Funktion heißen, spielt dabei keine Rolle. Im letzten Block des Beispiels heißen sie sogar genauso wie die Parameter, und trotzdem landen sie an der falschen Stelle, weil sie in der falschen Reihenfolge übergeben werden.

Das ist die zweithäufigste Fehlerquelle bei Funktionen und eine, die JavaScript nicht bemerken kann. teile(2, 10) ist eine völlig gültige Rechnung, nur eben nicht die gemeinte.

Daraus folgt eine praktische Regel: Je mehr Parameter eine Funktion hat, desto leichter verwechselt man zwei davon. Ab etwa drei lohnt es sich, darüber nachzudenken, ob die Funktion nicht zu viel auf einmal tut. Lektion 5.8 kommt darauf zurück.

03 / 04Zu wenige Argumente

<h1>Ausgabe</h1>
<p>Was dieses Beispiel tut, steht in der Console.</p>

function flaeche(breite, hoehe) {
  console.log("hoehe ist:", hoehe, "vom Typ", typeof hoehe);
  return breite * hoehe;
}

console.log("Mit beiden:", flaeche(3, 4));

// Der fehlende Parameter ist undefined. Rechnen mit undefined
// ergibt NaN, und NaN steckt danach alles an, was damit rechnet.
console.log("Mit einem:", flaeche(3));
console.log("NaN mal 10 ist immer noch", flaeche(3) * 10);

JavaScript beschwert sich nicht, wenn du ein Argument weglässt. Der zugehörige Parameter ist dann einfach undefined, und der Code läuft weiter.

Genau da wird es unangenehm. Sobald du mit undefined rechnest, kommt NaN heraus, und NaN steckt alles an, was danach damit rechnet. Am Ende steht irgendwo im Programm ein NaN auf dem Bildschirm, und die Ursache liegt drei Funktionen weiter oben.

Das ist der Grund, warum Lektion 2.3 Number.isNaN schon vorgestellt hat, und der Grund, warum es Standardwerte gibt. Die kommen in Lektion 5.5.

04 / 04Zu viele Argumente

<h1>Ausgabe</h1>
<p>Was dieses Beispiel tut, steht in der Console.</p>

function addiere(a, b) {
  return a + b;
}

// Alles ab dem dritten Argument fällt still unter den Tisch.
console.log(addiere(1, 2));
console.log(addiere(1, 2, 99, 100, 1000));

// Kein Fehler, keine Warnung. Deshalb fällt ein Argument an der
// falschen Stelle oft erst am krummen Ergebnis auf.

Umgekehrt genauso still: Alles, wofür kein Parameter dasteht, wird ignoriert. Kein Fehler, keine Warnung, kein Hinweis.

Das klingt harmlos und ist es meistens auch. Gefährlich wird es in Kombination mit der Reihenfolge: Wenn du ein Argument vergisst und dafür eins zu viel anhängst, verschiebt sich alles um eine Stelle, und die Funktion rechnet fröhlich mit den falschen Werten weiter.

Dass überzählige Argumente trotzdem irgendwo landen, siehst du in Lektion 5.5. Es gibt eine Schreibweise, mit der eine Funktion beliebig viele Werte annimmt.