Funktionen

  • Adressname der Version: JavaScript/javascript_guide/Funktionen
  • Titel der Version: Funktionen
  • ID der Version: 341867
  • Erstellt:
  • Autor: eminor
  • Aktuelle Version? Nein
  • Kommentar

Inhalt der Version

Funktionen sind einer der fundamentalen Aufbaublöcke von JavaScript. Eine Funktion ist eine Prozedur - ein Satz von Anweisungen die eine Aufgabe erledigen oder einen Wert berechnen. Damit eine Funktion benutzt werden kann, muss diese im selben Sichtbarkeitsbereich definiert werden, von dem aus sie aufgerufen werden soll.

Definieren von Funktionen

Eine Funktionsdefinition (auch Funktionsdeklaration genannt) setzt sich zusammen aus dem Schlüsselwort function, gefolgt von:

  • Dem Namen der Funktion.
  • Einer Liste von Argumenten, die durch ein Komma getrennt und in Klammern eingeschlossen werden.
  • Den JavaScript Anweisungen, welche definieren, was die Funktion tun soll, eingeschlossen in geschweifte Klammern.

Der folgende Code definiert zum Beispiel eine einfache Funktion square:

function square(number) {
  return number * number;
}

Diese Funktion nimmt ein Argument number entgegen. Die Funktion besteht aus einer Anweisung, die festlegt, dass number mit sich selbst multipliziert und das Ergebnis zurückgeliefert werden soll. Mit dem Schlüsselwort return wird also der Rückgabewert der Funktion festgelegt.

return number * number;

Einfache Parameter (wie z. B. Numbers) werden als Wert (by value) an die Funktion übergeben. Das bedeutet, der Wert wird zwar an die Funktion übergeben, jedoch gelten Änderungen des Werts, die von der Funktion vorgenommen werden, nur innerhalb der Funktion selbst und nicht etwa global oder in der aufrufenden Funktion.

Wird hingegen ein Objekt (z. B. ein nicht-primitiver Wert, wie ein Array oder ein benutzerdefiniertes Objekt) als Parameter an eine Funktion übergeben und Eigenschaften dieses Objekts von der Funktion verändert, so gelten diese Änderungen auch außerhalb der Funktion.

Zum Beispiel:

function myFunc(theObject) {
  theObject.make = "Toyota";
}

var mycar = {make: "Honda", model: "Accord", year: 1998},
    x,
    y;

x = mycar.make;     // x bekommt den Wert "Honda"

myFunc(mycar);
y = mycar.make;     // y bekommt den Wert "Toyota"
                    // (Die make-Eigenschaft wurde von der Funktion geändert)

Es sei angemerkt, dass die Zuweisung eines neuen Objekts an den Parameter innerhalb der Funktion das übergebene Objekt nicht verändert, da hierdurch nur der Wert des Parameters selbst geändert wird:

function myFunc(theObject) {
  theObject = {make: "Ford", model: "Focus", year: 2006};
}

var mycar = {make: "Honda", model: "Accord", year: 1998},
    x,
    y;

x = mycar.make;     // x bekommt den Wert "Honda"

myFunc(mycar);
y = mycar.make;     // y bekommt noch einmal den Wert "Honda" 

Beim ersten Beispiel wurde das Objekt mycar an die Funktion myFunc übergeben, welche das Objekt veränderte. Beim zweiten Beispiel wurde das übergebene Objekt von der Funktion nicht verändert; stattdessen wurde eine neue lokale Variable mit dem selben Namen erzeugt, was keinen Effekt auf das übergebene Objekt selbst hatte.

Bei JavaScript kann eine Funktion abhängig von einer Bedingung definiert werden:

if (num == 0){
  function myFunc(theObject) {
    theObject.make = "Toyota"
  }
}

Sollte num nicht dem Wert 0 entsprechen, wird die Funktion nicht definiert und jeder Versuch eines Aufrufs scheitert.

Achtung: ECMAScript erlaubt die Definition von Funktionen in solchem Kontext nicht, sondern nur direkt innerhalb anderer Funktionen beim Top Level eines Skripts. Aus diesem Grund ist das Beispiel nicht korrekt für ECMAScript.

Vorsicht: Die verschiedenen Implemetierungen von JavaScript behandeln dieses Nicht-Standard-Konstrukt unterschiedlich. Beim Schreiben von portablem Code sollte also besser darauf verzichtet werden. Andernfalls kann es passieren, dass der Code nicht in allen Browsern funktioniert.

Neben den hier beschriebenen Möglichkeiten zur Definition von Funktionen kann auch der Function-Konstruktor eingesetzt werden, um Funktionen aus einem String während der Laufzeit zu erzeugen, ähnlich wie bei eval().

Eine Methode ist eine Funktion, die eine Eigenschaft eines Objekts ist. Genauere Informationen findet man unter Arbeiten mit Objekten.

Während die oben beschriebenen Funktionsdeklarationen alle syntaktische Anweisungen sind, können Funktionen auch mit einem Funktionsausdruck erstellt werden. Solch eine Funktion kann anonym sein; sie muss keinen Namen besitzen. Zum Beispiel hätte die Funktion square auch so definiert werden können:

var square = function(number) {return number * number};

Es kann auch ein Name für die Funktion angegeben und die Funktion selbst mit Hilfe dieses Namens innerhalb der Funktion angesprochen werden. Außerdem kann die Festlegung eines Funktionsnamens dabei helfen, in Stack Traces die Funktion identifizieren zu können:

var factorial = function fac(n) {return n<2 ? 1 : n*fac(n-1)};

print(factorial(3));

Funktionsausdrücke sind praktisch wenn eine Funktion als Argument an eine andere Funktion übergeben werden soll. Das folgende Beispiel zeigt eine Funktion map, die zuerst definiert und dann aufgerufen wird, mit einer anonymen Funktion als Parameter.

function map(f,a) {
  var result = [], // Neues Array
      i;
  for (i = 0; i != a.length; i++)
    result[i] = f(a[i]);
  return result;
}

Der folgende Code gibt [0, 1, 8, 125, 1000] zurück. Für jedes Element des Arrays wird die anonyme Funktion einmal aufgerufen.

map(function(x) {return x * x * x}, [0, 1, 2, 5, 10]);

Aufrufen von Funktionen

Bei der Definition einer Funktion wird diese nicht ausgeführt, sondern nur ein Name zugewiesen und der Code festgelegt, der beim Aufruf der Funktion ausgeführt wird. Erst beim Aufruf einer Funktion wird der Code ausgeführt. Zum Beispiel kann die Funktion square wie folgt aufgerufen werden:

square(5);

Die voranstehende Anweisung ruft die Funktion mit einem Argument 5 auf. Daraufhin werden die Anweisungen der Funktion ausgeführt und der Wert 25 zurückgegeben.

Funktionen müssen beim Aufruf innerhalb desselben Sichtbarkeitsbereichs liegen, jedoch kann die Deklaration auch erst unterhalb eines Funktionsaufrufs stattfinden:

print(square(5));       // Aufruf
/* ... */
function square(n){return n*n}   // Deklaration

Die Argumente einer Funktion sind nicht auf bestimmte Datentypen wie Strings oder Numbers beschränkt. Es können auch ganze Objekte an eine Funktion übergeben werden. Die Funktion show_props (aus dem Abschnitt Arbeiten mit Objekten) ist ein Beispiel für eine Funktion, die ein Objekt als Argument entgegennimmt.

Eine Funktion kann rekursiv aufgebaut sein. Das bedeutet, dass die Funktion sich selbst aufruft. Das nachfolgende Beispiel stellt eine rekursive Funktion für die Berechnung von Fakultäten dar.

function factorial(n){
  if ((n == 0) || (n == 1))
    return 1;
  else
    return (n * factorial(n - 1));
}

Mit dieser Funktion lassen sich z. B. die Fakultäten von eins bis fünf berechnen:

var a, b, c, d, e;
a = factorial(1); // a gets the value 1
b = factorial(2); // b gets the value 2
c = factorial(3); // c gets the value 6
d = factorial(4); // d gets the value 24
e = factorial(5); // e gets the value 120

Es gibt noch weitere Möglichkeiten, wie Funktionen aufgerufen werden können. Des Öfteren kommt es vor, dass eine Funktion dynamisch aufgerufen werden soll, die Anzahl der Argumente variiert oder der Kontext beim Funktionsaufruf einem bestimmten Objekt während der Laufzeit zugeordnet werden soll. Daher sollte man wissen, dass Funktionen ebenfalls Objekte sind, welche entsprechende durch die Sprache festgelegte Standardmethoden besitzen (siehe Funktions-Objekte). Mit einer dieser Methoden, der Methode apply(), kann das Ziel der Zuordnung einer Funktion zu einem Objekt erreicht werden.

Sichtbarkeit von Funktionen

Auf Variablen, die innerhalb von Funktionen definiert werden, kann nicht von außerhalb der Funktion zugegriffen werden, da die Sichtbarkeit auf den Bereich der Funktion beschränkt ist. Jedoch kann eine Funktion auf alle Variablen und Funktionen zugreifen, die innerhalb des Sichtbarkeitsbereichs definiert wurden. Mit anderen Worten: Eine Funktion, die im globalen Sichtbarkeitsbereich definiert wurde, hat Zugriff auf alle Variablen, die im globalen Sichtbarkeitsbereich definiert wurden. Eine Funktion, die innerhalb einer anderen Funktion definiert wurde, hat auch Zugriff auf alle Variablen der äußeren Funktion und Variablen auf die die äußere Funktion Zugriff hat.

// Definition im globalen Sichtbarkeitsbereich
var num1 = 20,
    num2 = 3,
    name = "Chamahk";

// Funktion ebenfalls im globalen Sichtbarkeitsbereich definiert
function multiply() {
  return num1 * num2;
}

multiply(); // Gibt 60 zurück

// add() ist eine eingebettete Funktion (engl. nested function)
function getScore () {
  var num1 = 2,
      num2 = 3;
  
  function add() {
    return name + " scored " + (num1 + num2);
  }
  
  // Aufruf der Funktion und Ergebnis ist Rückgabewert
  return add();
}

getScore(); // Gibt zurück: "Chamahk scored 5"

Closures

Closures sind eines der mächtigsten Features von JavaScript. JavaScript erlaubt die Einbettung von Funktionen und erlaubt der inneren Funktion vollen Zugriff auf alle Variablen und Funktionen, die innerhalb der äußeren Funktion definiert wurden (und allen anderen Variablen und Funktionen, die von der Funktion aus ansprechbar sind). Jedoch hat die äußere Funktion keinen Zugriff auf die Variablen und Funktionen der inneren Funktion. Dieser eingeschränkte Zugriff stellt einen Sicherheitsmechanismus für die Variablen der inneren Funktion dar. Falls die innere Funktion länger bestehen leibt als die äußere Funktion, bleiben die Variablen und Funktionen der äußeren Funktion länger erhalten als die Funktion selbst, da die innere Funktion Zugang zum Sichtbarkeitsbereich der äußeren Funktion hat. Eine Closure wird erstellt, wenn die innere Funktion für den Sichtbarkeitsbereich außerhalb der äußeren Funktion zugänglich gemacht wird.

var pet = function(name) {          // Die äußere Funktion definiert eine Variable "name"
      var getName = function() {
        return name;                // Die innere Funktion hat Zugriff auf die Variable "name" der äußeren Funktion
      }

      return getName;               // Rückgabe der inneren Funktion; damit wird sie für die äußeren Sichtbarkeitsbereiche zugänglich gemacht
    },
    myPet = pet("Vivie");
    
myPet();                            // Gibt "Vivie" zurück

Quelltext der Version

<p>Funktionen sind einer der fundamentalen Aufbaublöcke von JavaScript. Eine Funktion ist eine Prozedur - ein Satz von Anweisungen die eine Aufgabe erledigen oder einen Wert berechnen. Damit eine Funktion benutzt werden kann, muss diese im selben Sichtbarkeitsbereich definiert werden, von dem aus sie aufgerufen werden soll.</p>
<h3 id="Definieren_von_Funktionen">Definieren von Funktionen</h3>
<p>Eine Funktionsdefinition (auch Funktionsdeklaration genannt) setzt sich zusammen aus dem Schlüsselwort <code>function</code>, gefolgt von:</p>
<ul>
  <li>Dem Namen der Funktion.</li>
  <li>Einer Liste von Argumenten, die durch ein Komma getrennt und in Klammern eingeschlossen werden.</li>
  <li>Den JavaScript Anweisungen, welche definieren, was die Funktion tun soll, eingeschlossen in geschweifte Klammern.</li>
</ul>
<p>Der folgende Code definiert zum Beispiel eine einfache Funktion <code>square</code>:</p>
<pre class="brush: js">
function square(number) {
  return number * number;
}
</pre>
<p>Diese Funktion nimmt ein Argument <code>number</code> entgegen. Die Funktion besteht aus einer Anweisung, die festlegt, dass <code>number</code> mit sich selbst multipliziert und das Ergebnis zurückgeliefert werden soll. Mit dem Schlüsselwort <code>return</code> wird also der Rückgabewert der Funktion festgelegt.</p>
<pre class="brush: js">
return number * number;
</pre>
<p>Einfache Parameter (wie z. B. Numbers) werden als Wert (<em>by value</em>) an die Funktion übergeben. Das bedeutet, der Wert wird zwar an die Funktion übergeben, jedoch gelten Änderungen des Werts, die von der Funktion vorgenommen werden, nur innerhalb der Funktion selbst und nicht etwa global oder in der aufrufenden Funktion.</p>
<p>Wird hingegen ein Objekt (z. B. ein nicht-primitiver Wert, wie ein Array oder ein benutzerdefiniertes Objekt) als Parameter an eine Funktion übergeben und Eigenschaften dieses Objekts von der Funktion verändert, so gelten diese Änderungen auch außerhalb der Funktion.</p>
<p>Zum Beispiel:</p>
<pre class="brush: js">
function myFunc(theObject) {
  theObject.make = "Toyota";
}

var mycar = {make: "Honda", model: "Accord", year: 1998},
    x,
    y;

x = mycar.make;     // x bekommt den Wert "Honda"

myFunc(mycar);
y = mycar.make;     // y bekommt den Wert "Toyota"
                    // (Die make-Eigenschaft wurde von der Funktion geändert)
</pre>
<p>Es sei angemerkt, dass die Zuweisung eines neuen Objekts an den Parameter innerhalb der Funktion das übergebene Objekt nicht verändert, da hierdurch nur der Wert des Parameters selbst geändert wird:</p>
<pre class="brush: js">
function myFunc(theObject) {
  theObject = {make: "Ford", model: "Focus", year: 2006};
}

var mycar = {make: "Honda", model: "Accord", year: 1998},
    x,
    y;

x = mycar.make;     // x bekommt den Wert "Honda"

myFunc(mycar);
y = mycar.make;     // y bekommt noch einmal den Wert "Honda" 
</pre>
<p>Beim ersten Beispiel wurde das Objekt <code>mycar</code> an die Funktion <code>myFunc </code>übergeben, welche das Objekt veränderte. Beim zweiten Beispiel wurde das übergebene Objekt von der Funktion nicht verändert; stattdessen wurde eine neue lokale Variable mit dem selben Namen erzeugt, was keinen Effekt auf das übergebene Objekt selbst hatte.</p>
<p>Bei JavaScript kann eine Funktion abhängig von einer Bedingung definiert werden:</p>
<pre class="brush: js">
if (num == 0){
  function myFunc(theObject) {
    theObject.make = "Toyota"
  }
}
</pre>
<p>Sollte <code>num</code> nicht dem Wert <code>0</code> entsprechen, wird die Funktion nicht definiert und jeder Versuch eines Aufrufs scheitert.</p>
<p>Achtung:<a href="https://developer.mozilla.org/en-US/docs/JavaScript/Language_Resources" title="ECMAScript"> ECMAScript</a> erlaubt die Definition von Funktionen in solchem Kontext nicht, sondern nur direkt innerhalb anderer Funktionen beim Top Level eines Skripts. Aus diesem Grund ist das Beispiel nicht korrekt für ECMAScript.</p>
<div class="warning">
  <p><strong>Vorsicht:</strong> Die verschiedenen Implemetierungen von JavaScript behandeln dieses Nicht-Standard-Konstrukt unterschiedlich. Beim Schreiben von portablem Code sollte also besser darauf verzichtet werden. Andernfalls kann es passieren, dass der Code nicht in allen Browsern funktioniert.</p>
</div>
<p>Neben den hier beschriebenen Möglichkeiten zur Definition von Funktionen kann auch der <a href="https://developer.mozilla.org/en-US/docs/JavaScript/Guide/Predefined_Core_Objects#Function_Object" title="en-US/docs/JavaScript/Guide/Predefined Core Objects#Function Object"><code>Function</code>-Konstruktor</a> eingesetzt werden, um Funktionen aus einem String während der Laufzeit zu erzeugen, ähnlich wie bei <a href="https://developer.mozilla.org/en-US/docs/JavaScript/Guide/Functions#eval_Function" title="en-US/docs/JavaScript/Guide/Functions#eval_Function"><code>eval()</code></a>.</p>
<p>Eine Methode ist eine Funktion, die eine Eigenschaft eines Objekts ist. Genauere Informationen findet man unter <a href="https://developer.mozilla.org/en-US/docs/JavaScript/Guide/Working_with_Objects" title="en-US/docs/JavaScript/Guide/Working with Objects">Arbeiten mit Objekten</a>.</p>
<p>Während die oben beschriebenen Funktionsdeklarationen alle syntaktische Anweisungen sind, können Funktionen auch mit einem <strong>Funktionsausdruck</strong> erstellt werden. Solch eine Funktion kann <strong>anonym</strong> sein; sie muss keinen Namen besitzen. Zum Beispiel hätte die Funktion <code>square</code> auch so definiert werden können:</p>
<pre class="brush: js">
var square = function(number) {return number * number};</pre>
<p>Es kann auch ein Name für die Funktion angegeben und die Funktion selbst mit Hilfe dieses Namens innerhalb der Funktion angesprochen werden. Außerdem kann die Festlegung eines Funktionsnamens dabei helfen, in Stack Traces die Funktion identifizieren zu können:</p>
<pre class="brush: js">
var factorial = function fac(n) {return n&lt;2 ? 1 : n*fac(n-1)};

print(factorial(3));
</pre>
<p>Funktionsausdrücke sind praktisch wenn eine Funktion als Argument an eine andere Funktion übergeben werden soll. Das folgende Beispiel zeigt eine Funktion <code>map</code>, die zuerst definiert und dann aufgerufen wird, mit einer anonymen Funktion als Parameter.</p>
<pre class="brush: js">
function map(f,a) {
  var result = [], // Neues Array
      i;
  for (i = 0; i != a.length; i++)
    result[i] = f(a[i]);
  return result;
}
</pre>
<p>Der folgende Code gibt <code>[0, 1, 8, 125, 1000]</code> zurück. Für jedes Element des Arrays wird die anonyme Funktion einmal aufgerufen.</p>
<pre class="brush: js">
map(function(x) {return x * x * x}, [0, 1, 2, 5, 10]);
</pre>
<h3 id="Aufrufen_von_Funktionen">Aufrufen von Funktionen</h3>
<p>Bei der Definition einer Funktion wird diese nicht ausgeführt, sondern nur ein Name zugewiesen und der Code festgelegt, der beim Aufruf der Funktion ausgeführt wird. Erst beim <strong>Aufruf</strong> einer Funktion wird der Code ausgeführt. Zum Beispiel kann die Funktion <code>square</code> wie folgt aufgerufen werden:</p>
<pre class="brush: js">
square(5);
</pre>
<p>Die voranstehende Anweisung ruft die Funktion mit einem Argument 5 auf. Daraufhin werden die Anweisungen der Funktion ausgeführt und der Wert 25 zurückgegeben.</p>
<p>Funktionen müssen beim Aufruf innerhalb desselben Sichtbarkeitsbereichs liegen, jedoch kann die Deklaration auch erst unterhalb eines Funktionsaufrufs stattfinden:</p>
<pre>
print(square(5));       // Aufruf
/* ... */
function square(n){return n*n}   // Deklaration</pre>
<p>Die Argumente einer Funktion sind nicht auf bestimmte Datentypen wie Strings oder Numbers beschränkt. Es können auch ganze Objekte an eine Funktion übergeben werden. Die Funktion <code>show_props</code> (aus dem Abschnitt <a href="https://developer.mozilla.org/en-US/docs/JavaScript/Guide/Working_with_Objects#Objects_and_Properties" title="https://developer.mozilla.org/en-US/docs/JavaScript/Guide/Working_with_Objects#Objects_and_Properties">Arbeiten mit Objekten</a>) ist ein Beispiel für eine Funktion, die ein Objekt als Argument entgegennimmt.</p>
<p>Eine Funktion kann rekursiv aufgebaut sein. Das bedeutet, dass die Funktion sich selbst aufruft. Das nachfolgende Beispiel stellt eine rekursive Funktion für die Berechnung von Fakultäten dar.</p>
<pre class="brush: js">
function factorial(n){
  if ((n == 0) || (n == 1))
    return 1;
  else
    return (n * factorial(n - 1));
}
</pre>
<p>Mit dieser Funktion lassen sich z. B. die Fakultäten von eins bis fünf berechnen:</p>
<pre class="brush: js">
var a, b, c, d, e;
a = factorial(1); // a gets the value 1
b = factorial(2); // b gets the value 2
c = factorial(3); // c gets the value 6
d = factorial(4); // d gets the value 24
e = factorial(5); // e gets the value 120
</pre>
<p>Es gibt noch weitere Möglichkeiten, wie Funktionen aufgerufen werden können. Des Öfteren kommt es vor, dass eine Funktion dynamisch aufgerufen werden soll, die Anzahl der Argumente variiert oder der Kontext beim Funktionsaufruf einem bestimmten Objekt während der Laufzeit zugeordnet werden soll. Daher sollte man wissen, dass Funktionen ebenfalls Objekte sind, welche entsprechende durch die Sprache festgelegte Standardmethoden besitzen (siehe Funktions-Objekte). Mit einer dieser Methoden, der Methode apply(), kann das Ziel der Zuordnung einer Funktion zu einem Objekt erreicht werden.</p>
<h3 id="Sichtbarkeit_von_Funktionen">Sichtbarkeit von Funktionen</h3>
<p>Auf Variablen, die innerhalb von Funktionen definiert werden, kann nicht von außerhalb der Funktion zugegriffen werden, da die Sichtbarkeit auf den Bereich der Funktion beschränkt ist. Jedoch kann eine Funktion auf alle Variablen und Funktionen zugreifen, die innerhalb des Sichtbarkeitsbereichs definiert wurden. Mit anderen Worten: Eine Funktion, die im globalen Sichtbarkeitsbereich definiert wurde, hat Zugriff auf alle Variablen, die im globalen Sichtbarkeitsbereich definiert wurden. Eine Funktion, die innerhalb einer anderen Funktion definiert wurde, hat auch Zugriff auf alle Variablen der äußeren Funktion und Variablen auf die die äußere Funktion Zugriff hat.</p>
<pre class="brush: js">
// Definition im globalen Sichtbarkeitsbereich
var num1 = 20,
    num2 = 3,
    name = "Chamahk";

// Funktion ebenfalls im globalen Sichtbarkeitsbereich definiert
function multiply() {
  return num1 * num2;
}

multiply(); // Gibt 60 zurück

// add() ist eine eingebettete Funktion (engl. nested function)
function getScore () {
  var num1 = 2,
      num2 = 3;
  
  function add() {
    return name + " scored " + (num1 + num2);
  }
  
  // Aufruf der Funktion und Ergebnis ist Rückgabewert
  return add();
}

getScore(); // Gibt zurück: "Chamahk scored 5"
</pre>
<h2 id="Closures">Closures</h2>
<p>Closures sind eines der mächtigsten Features von JavaScript. JavaScript erlaubt die Einbettung von Funktionen und erlaubt der inneren Funktion vollen Zugriff auf alle Variablen und Funktionen, die innerhalb der äußeren Funktion definiert wurden (und allen anderen Variablen und Funktionen, die von der Funktion aus ansprechbar sind). Jedoch hat die äußere Funktion keinen Zugriff auf die Variablen und Funktionen der inneren Funktion. Dieser eingeschränkte Zugriff stellt einen Sicherheitsmechanismus für die Variablen der inneren Funktion dar. Falls die innere Funktion länger bestehen leibt als die äußere Funktion, bleiben die Variablen und Funktionen der äußeren Funktion länger erhalten als die Funktion selbst, da die innere Funktion Zugang zum Sichtbarkeitsbereich der äußeren Funktion hat. Eine Closure wird erstellt, wenn die innere Funktion für den Sichtbarkeitsbereich außerhalb der äußeren Funktion zugänglich gemacht wird.</p>
<pre class="brush: js">
var pet = function(name) {          // Die äußere Funktion definiert eine Variable "name"
      var getName = function() {
        return name;                // Die innere Funktion hat Zugriff auf die Variable "name" der äußeren Funktion
      }

      return getName;               // Rückgabe der inneren Funktion; damit wird sie für die äußeren Sichtbarkeitsbereiche zugänglich gemacht
    },
    myPet = pet("Vivie");
    
myPet();                            // Gibt "Vivie" zurück
</pre>
Zu dieser Version zurücksetzen