Funktionen (Teil 2)

Default-Werte bei Funktionsparametern

JavaScript erlaubt, dass Funktionen mit „unpassenden“ Parametern aufgerufen werden (mehr oder weniger Parameter als deklariert, verschiedene Datentypen usw.).

Mit Default-Werten kann sichergestellt werden, dass Funktionsparameter einen Wert erhalten, wenn diese beim Aufruf der Funktion nicht angegeben werden:

// Parameter b hat einen Default-Wert von 1000
function myFunction(a, b = 1000) {
  return a + b;
}
 
// b erhält in der Funktion den Default-Wert 1000
console.log(myFunction(1)); // --> 1001
 
// b erhält in der Funktion den Wert 12
console.log(myFunction(1, 12)); // --> 13

Flexible Argumentliste

Jeder Funktion in JavaScript steht bei ihrer Ausführung im Funktionsrumpf implizit (d.h. automatisch) ein Parameter namens arguments zur Verfügung. arguments muss also nicht explizit (d.h. ausdrücklich) angegeben werden.

arguments ist ein Array-artiges Objekt (kein echtes Array, d.h. Methoden wie map oder filter stehen nicht zur Verfügung), das alle beim Aufruf übergebenen Parameter enthält.

Funktionen können somit mit beliebig vielen Parametern umgehen:

function sum() {
  let result = 0;	
  for(let i = 0; i < arguments.length; i++)
    result = result + arguments[i];
  return result;
}
 
// sum kann mit beliebig vielen Argumenten umgehen
console.log(sum()); // 0	
console.log(sum(3)); // 3
console.log(sum(5,8,1,2)); // 16

Die modernere Alternative ist die sogenannte „Rest”-Syntax (...). Damit werden die restlichen Argumente in einem echten Array gesammelt:

function plusRest(a,...args) {	
  let result = a;	
  for(let i = 0; i < args.length; i++) {
    result += args[i];	
  }
  return result;	
}
	
console.log(plusRest(2)); // 2	
console.log(plusRest(2,6,7,3)); // 18 = 2 + 6 + 7 + 3

Funktionen als Objekte

Funktionen sind Objekte. Daher können sie auch direkt einer Variablen oder Konstanten zugewiesen werden.

Dies wird tatsächlich häufiger verwendet. Zu beachten ist, dass hinter function kein Name angegeben wird — es sind also eigentlich anonyme Funktionen.

Der Aufruf erfolgt über den Namen der Konstanten/Variablen und sieht aus wie zuvor — das Ergebnis ist dasselbe wie im Beispiel zu verschachtelten Funktionsaufrufen in Teil 1:

// aus Platzgründen stehen die Funktionen 
// hier auf einer Zeile	
const add = function(a,b) { 
  return a + b; 
};
	
const subtract = function(a,b) { 
  return a - b; 
};
		
const multiply = function(a,b) { 
  return a * b; 
};
	
console.log(subtract(multiply(add(6,3),2),4));
// --> 14 ( = (6+3)*2-4 )

Die Tatsache, dass Funktionen auch Objekte sind und insbesondere als anonyme Funktionen verwendet werden können, ist hilfreich für das Verständnis von Pfeilfunktionen (nächste Seite). Pfeilfunktionen haben übrigens kein eigenes arguments-Objekt — ein weiterer Grund, die Rest-Syntax (...args) zu bevorzugen.