Funktionen

Eine Funktion ist ein modularer, wiederverwendbarer Block von Anweisungen, der zum Ausführen einer Reihe verwandter Aufgaben verwendet wird, z. B. zum Berechnen und Zurückgeben eines Werts anhand von Argumenten, die der Funktion bereitgestellt werden. Wie alle nicht-primitiven Werte sind Funktionen Objekte. Sie sind eindeutige Objekte, da sie zur Ausführung von Code aufgerufen, Daten in Form von Argumenten übergeben und return werden können.

Funktionen werden als „Erstklasse“-Objekte betrachtet. Das bedeutet, dass sie trotz ihres unverwechselbaren Verhaltens im selben Kontext wie jedes andere JavaScript-Objekt verwendet werden können. Eine Funktion kann beispielsweise einer Variablen zugewiesen, als Argument an andere Funktionen übergeben und von anderen Funktionen zurückgegeben werden.

function myFunction() {
   console.log( "This is my function." );
};

Eine Funktion, die als Attribut eines Objekts definiert ist, wird in der Regel als "Methode" bezeichnet. Wie bei mit var deklarierten Variablen werden Funktionsdeklarationen außerhalb einer einschließenden Funktion als Methoden in das globale Objekt eingefügt.

Funktionsdeklarationen

Eine Funktionsdeklaration (auch "Funktionsanweisung" oder "Funktionsdefinition" genannt) erstellt eine benannte Funktion, die an anderer Stelle in ihrem beinhaltenden Bereich aufgerufen werden kann. Funktionsdeklarationen bestehen aus dem Schlüsselwort function, gefolgt von einer Kennung, einer Liste mit durch Kommas getrennten Parametern in Klammern und einer Blockanweisung, die als „Funktionstext“ bezeichnet wird. Häufig stoßen Sie auf Funktionsdeklarationen, die nicht mit einem Semikolon enden. Da eine Funktionsdeklaration eine Anweisung ist, können nachgestellte Semikolons von ASI abgeleitet werden.

function myFunction() {
   console.log( "This is my function." );
};

myFunction();
> "This is my function."

Als Reaktion auf die frühen Designentscheidungen von JavaScript unterliegen Funktionsdeklarationen demselben Legacy-Hochzugverhalten wie die mit var deklarierten Variablen. Dies bedeutet, dass eine Funktionsdeklaration an den Anfang des Geltungsbereichs gelegt wird und daher vor der Deklaration aufgerufen werden kann, unabhängig davon, ob dieser Bereich im strengen Modus geregelt ist:

"use strict";
{
    myFunction();
    function myFunction() {
        console.log( "This is my function." );
    };
}
> "This is my function."

Außerhalb des strikten Modus wird für Funktionsdeklarationen das alte Bereichsverhalten von JavaScript verwendet. Das bedeutet, dass eine Funktionsdeklaration auf die jeweils nächste umschließende Funktion beschränkt ist:

function myFunction() {
    function myNestedFunction() {
        console.log( "This is my nested function." );
    }
    myNestedFunction();
};

myFunction();
> "This is my nested function."

myNestedFunction();
>Uncaught ReferenceError: myNestedFunction is not defined

Im strengen Modus sind Funktionsdeklarationen auf den nächstgelegenen Block beschränkt, wie die mit let oder const deklarierten Variablen:

"use strict";
{
    function myFunction() {
        console.log( "This is my function." );
    };
}

myFunction();
> Uncaught ReferenceError: myFunction is not defined

Funktionsaufrufe

Wie bei Variablen fungiert die beim Deklarieren einer Funktion verwendete Kennung als symbolischer Name für einen Wert. Wenn auf eine Funktion nur anhand einer Kennung verwiesen wird, wird nur das Funktionsobjekt zurückgegeben und nicht die darin enthaltene Funktion ausgeführt:

function myFunction() {
   console.log( "This is my function." );
};

myFunction;
> myFunction() {
   console.log( "This is my function." );
}

Zum Ausführen des Codes im Funktionstext rufen (oder aufrufen) Sie die Funktion auf. Folgen Sie dazu dem Funktionsnamen mit einem übereinstimmenden Klammernpaar:

function myFunction() {
    console.log( "My function has been executed." );
}

myFunction();
> "My function has been executed."

Die Parameter in der Funktionsdefinition dienen als Platzhaltervariablen für Werte, die beim Aufruf der Funktion an den Funktionstext übergeben werden können. Die Werte in Klammern, wenn eine Funktion aufgerufen wird, sind "Argumente" (in manchen Dokumentationen werden jedoch "Argumente" verwendet, um Argumente und Parameter zu beschreiben):

function myFunction( myParameter ) {
   console.log( `The value is: ${ myParameter }.` );
};

myFunction( "this string" );
> "The value is: this string."

Wenn ein erwartetes Argument weggelassen wird, enthält der resultierende Parameter einen undefined-Wert, da der Parameter für den Funktionstext deklariert, aber nicht mit einem Wert initialisiert wird:

function myFunction( myParameter ) {
   console.log( `The value is: ${ myParameter }.` );
};

myFunction();
> "The value is: undefined."

Sie können Standardparameterwerte festlegen, indem Sie sie auf dieselbe Weise initialisieren wie eine Variable: einen Zuweisungsoperator (=) gefolgt von einem Wert. Wenn Sie später ein Argument für diese Funktion angeben, überschreibt dieser neue Wert den Standardwert:

function myFunction( myParameter = "omitted" ) {
   console.log( `The value is: ${ myParameter }.` );
};

myFunction( "this string" );
> "The value is: this string."

myFunction();
> "The value is: omitted."

Der Text einer Nicht-Pfeil-Funktion hat auch Zugriff auf ein nullindexiertes array-ähnliches arguments-Objekt, das alle Werte enthält, die als Argumente übergeben werden, unabhängig davon, ob in der Funktionsdefinition Parameter angegeben sind:

function myFunction() {
   console.log( arguments );
};

myFunction( 3, true, "My string" );
> Arguments { 0: 3, 1: true, 2: "My string", … }

Variadische Funktionen

Mit dem arguments-Objekt können Sie grundlegende variadische Funktionen erstellen, für die eine variable Anzahl von Argumenten akzeptiert werden kann:

function myFunction() {
    let result = "";
    for (let i = 0; i < arguments.length; i++) {
        result += arguments[i] + " - ";
    }
    console.log( result );
};

myFunction( "My first string", "My second string", "my third string" );\
> "My first string - My second string - my third string - "

Dieser Ansatz für variadische Funktionen wird in der modernen JavaScript-Entwicklung jedoch selten verwendet. Meist wird die modernere und besser lesbare rest-Parametersyntax verwendet, mit der ein benannter Parameter erstellt wird, der als Array initialisiert ist, das alle Argumente außer den explizit angegebenen enthält:

function myFunction( mySeparator, ...myStrings ) {
  console.log( myStrings.join( mySeparator ) );
};

myFunction( " - ", "My first string", "My second string", "my third string" );
> "My first string - My second string - my third string"

Im Gegensatz zur parameter-Bindung funktioniert die rest-Parametersyntax wie erwartet mit Parametern für Pfeilfunktionen:

function myOuterFunction() {
    let myInnerArrowFunction = ( ...myParams ) => {
        console.log( myParams[ 0 ] );
    }
    myInnerArrowFunction( true );
};

myOuterFunction( false );
> true

let myArrowFunction = ( ...myParams ) => {
    console.log( myParams[ 0 ] );
};

myArrowFunction( true );
> true`
``