Funktionen

Eine Funktion ist ein modularer, wiederverwendbarer Block von Anweisungen, mit dem eine Reihe von verwandte Aufgaben wie das Berechnen und Zurückgeben eines Werts auf der Grundlage von Argumenten der Funktion übergeben werden. Wie bei allen nicht primitiven Werten gilt: Funktionen sind Objekte. Sie sind einzigartige Objekte, die aufgerufen werden können. zum Ausführen von Code, Daten in Form von Argumenten übergeben, und einen Wert zurückgeben.

Funktionen sind erstklassig -Objekten. Sie können also trotz ihres einzigartigen Verhaltens in allen Kontexte wie jedes andere JavaScript-Objekt. Eine Funktion kann beispielsweise einer Variablen zugewiesen, als Argument an andere Funktionen übergeben und zurückgegeben durch andere Funktionen.

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

Eine Funktion, die als Eigenschaft eines Objekts definiert ist, ist normalerweise als „Methode“ bezeichnet. Wie bei Variablen, die mit var deklariert wurden, gilt: Funktionsdeklarationen, die außerhalb einer einschließenden Funktion vorgenommen wurden, werden zum globalen Objekt als Methoden hinzu.

Funktionsdeklarationen

Eine Funktionsdeklaration (auch „Funktionsanweisung“ oder „Funktionsdefinition“ genannt) erstellt eine benannte Funktion, die an anderer Stelle in ihrem enthaltenden Bereich aufgerufen werden kann. Funktionsdeklarationen bestehen aus dem Schlüsselwort function gefolgt von einem ID, eine Liste durch Kommas getrennter Parameter in Klammern und ein block-Anweisung mit dem Namen „Funktionstext“. Sie werden häufig Funktionsdeklarationen begegnen, mit einem Semikolon beenden; da eine Funktionsdeklaration eine Anweisung ist, Semikolons können aus ASI abgeleitet werden.

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

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

Als Vorbehalt der frühen Designentscheidungen von JavaScript wurden Funktionsdeklarationen unterliegen den gleichen alten Winden als mit var deklarierte Variablen, d. h. eine Funktionsdeklaration bis zur Höchstgrenze gezogen und kann vor der Erklärung als unabhängig davon, ob dieser Geltungsbereich dem strikten Modus unterliegt:

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

Außerhalb des strikten Modus, Funktion Deklarationen verwenden den alten JavaScript-Gültigkeitsbereich d. h., eine Funktionsdeklaration ist auf die am nächsten liegende :

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 strikten Modus werden Funktionsdeklarationen auf den nächstgelegenen einschließenden Block beschränkt, wie bei Variablen, die mit let oder const:

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

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

Funktionsaufrufe

Wie bei Variablen fungiert die bei der Deklaration einer Funktion verwendete Kennung als symbolischer Name für einen Wert. Wenn nur mit der Kennung auf eine Funktion verwiesen wird, wird Folgendes zurückgegeben: nur das Funktionsobjekt und führt nicht die darin enthaltene Funktion aus:

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

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

Zum Ausführen des Codes innerhalb des Funktionskörpers rufen (oder aufrufen) Sie die Funktion auf indem Sie dem Funktionsnamen ein übereinstimmendes Klammernpaar folgen:

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 Aufrufen der Funktion an den Funktionstext übergeben werden können. Die Werte in den Klammern beim Aufrufen einer Funktion sind „Argumente“. (Trotzdem sehen Sie möglicherweise „Argumente“, zur Beschreibung von Argumenten und Parametern Dokumentation):

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 ein undefined-Wert, da der Parameter im Funktionstext deklariert ist, aber nicht mit einem Wert initialisiert:

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 Initialisieren Sie eine Variable: einen Zuweisungsoperator (=), gefolgt von einem Wert. Wenn Sie später ein Argument für diese Funktion angeben, überschreibt dieser neue Wert das 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 eines Nichtpfeils hat auch Zugriff auf einen null-indexierten array-ähnliches arguments-Objekt die als Argumente übergebene Werte enthalten, unabhängig davon, ob die Funktion werden Parameter definiert:

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

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

Variadische Funktionen

Mit dem Objekt arguments können Sie grundlegende variadische Funktionen erstellen, Variable Anzahl von Argumenten:

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 im modernen JavaScript jedoch selten verwendet. Entwicklung. Meist wird die modernere und besser lesbare Syntax des REST-Parameters. Erstellt einen benannten Parameter, der als Array initialisiert wird, das beliebige Argumente enthält über die explizit angegebenen hinaus:

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"

Anders als die parameter-Bindung funktioniert die Syntax des REST-Parameters wie erwartet bei pfeil-Funktionsparametern:

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

myOuterFunction( false );
> true

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

myArrowFunction( true );
> true`
``