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`
``