Ein Funktionsausdruck erzeugt einen Wert – ein Funktions-Objekt. Zum Beispiel:

var add = function (x, y) { return x + y };
console.log(add(2, 3)); // 5

Der vorherige Code hat das Ergebnis eines Funktionsausdrucks der Variablen add zugewiesen und sie über diese Variable aufgerufen. Der von einem Funktionsausdruck erzeugte Wert kann einer Variablen zugewiesen (wie im letzten Beispiel gezeigt), als Argument an eine andere Funktion übergeben und mehr werden. Da normale Funktionsausdrücke keinen Namen haben, werden sie auch als anonyme Funktionsausdrücke bezeichnet.

var fac = function me(n) {
    if (n > 0) {
        return n * me(n-1);
    } else {
        return 1;
    }
};
console.log(fac(3)); // 6

var repeat = function me(n, str) {
    return n > 0 ? str + me(n-1, str) : '';
};
console.log(repeat(3, 'Yeah')); // YeahYeahYeah
console.log(me); // ReferenceError: me is not defined

Das Folgende ist eine Funktionsdeklaration:

function add(x, y) {
    return x + y;
}

Das Vorherige sieht wie ein Funktionsausdruck aus, ist aber eine Anweisung (siehe Ausdrücke versus Anweisungen). Es ist ungefähr gleichwertig mit dem folgenden Code:

var add = function (x, y) {
    return x + y;
};

Mit anderen Worten, eine Funktionsdeklaration deklariert eine neue Variable, erstellt ein Funktions-Objekt und weist es der Variablen zu.

Der Konstruktor Function() evaluiert JavaScript-Code, der in Zeichenketten gespeichert ist. Zum Beispiel ist der folgende Code äquivalent zum vorherigen Beispiel:

var add = new Function('x', 'y', 'return x + y');

Diese Art der Funktionsdefinition ist jedoch langsam und hält Code in Zeichenketten (für Werkzeuge unzugänglich). Daher ist es viel besser, wenn möglich einen Funktionsausdruck oder eine Funktionsdeklaration zu verwenden. Codeauswertung mit new Function() erklärt Function() im Detail; es funktioniert ähnlich wie eval().

Diese Methode verwendet die Elemente von argArray als Argumente beim Aufruf der Funktion func; das heißt, die folgenden beiden Ausdrücke sind äquivalent:

func(arg1, arg2, arg3)
func.apply(null, [arg1, arg2, arg3])

thisValue ist der Wert, den this während der Ausführung von func hat. Er ist in einem nicht-objektorientierten Setting nicht notwendig und daher hier null.

apply() ist nützlich, wenn eine Funktion mehrere Argumente in einem Array-ähnlichen Format akzeptiert, aber kein Array.

Dank apply() können wir Math.max() (siehe Andere Funktionen) verwenden, um das größte Element eines Arrays zu ermitteln.

> Math.max(17, 33, 2)
33
> Math.max.apply(null, [17, 33, 2])
33

Dies führt eine partielle Funktionsanwendung durch – eine neue Funktion wird erstellt, die func mit this auf thisValue gesetzt aufruft und die folgenden Argumente: zuerst arg1 bis argN und dann die tatsächlichen Argumente der neuen Funktion. thisValue ist im folgenden nicht-objektorientierten Setting nicht notwendig, daher ist es null.

Hier verwenden wir bind(), um eine neue Funktion plus1() zu erstellen, die wie add() ist, aber nur den Parameter y benötigt, da x immer 1 ist.

function add(x, y) {
    return x + y;
}
var plus1 = add.bind(null, 1);
console.log(plus1(5));  // 6

Mit anderen Worten, wir haben eine neue Funktion erstellt, die äquivalent zu folgendem Code ist:

function plus1(y) {
    return add(1, y);
}

Die spezielle Variable arguments existiert nur innerhalb von Funktionen (einschließlich Methoden). Sie ist ein Array-ähnliches Objekt, das alle tatsächlichen Parameter des aktuellen Funktionsaufrufs enthält. Der folgende Code verwendet sie:

function logArgs() {
    for (var i=0; i<arguments.length; i++) {
        console.log(i+'. '+arguments[i]);
    }
}

Und hier ist die Interaktion

> logArgs('hello', 'world')
0. hello
1. world

arguments hat die folgenden Eigenschaften:

Es gibt drei Möglichkeiten, um herauszufinden, ob ein Parameter fehlt. Erstens können Sie prüfen, ob er undefined ist:

function foo(mandatory, optional) {
    if (mandatory === undefined) {
        throw new Error('Missing parameter: mandatory');
    }
}

Zweitens können Sie den Parameter als Boolean interpretieren. Dann wird undefined als false betrachtet. Es gibt jedoch einen Vorbehalt: Mehrere andere Werte werden ebenfalls als false betrachtet (siehe Truthy und Falsy Werte), so dass die Prüfung nicht zwischen z. B. 0 und einem fehlenden Parameter unterscheiden kann.

if (!mandatory) {
    throw new Error('Missing parameter: mandatory');
}

Drittens können Sie auch die Länge von arguments überprüfen, um eine minimale Arität zu erzwingen:

if (arguments.length < 1) {
    throw new Error('You need to provide at least 1 argument');
}

Der letzte Ansatz unterscheidet sich von den anderen.

Wenn ein Parameter optional ist, bedeutet dies, dass ihm ein Standardwert zugewiesen wird, wenn er fehlt. Ähnlich wie bei Pflichtparametern gibt es vier Alternativen.

Erstens, prüfen auf undefined

function bar(arg1, arg2, optional) {
    if (optional === undefined) {
        optional = 'default value';
    }
}

Zweitens, interpretieren Sie optional als booleschen Wert.

if (!optional) {
    optional = 'default value';
}

Drittens, Sie können den Oder-Operator || verwenden (siehe Logisches Oder (||)), der den linken Operanden zurückgibt, wenn er nicht falsy ist. Andernfalls gibt er den rechten Operanden zurück.

// Or operator: use left operand if it isn't falsy
optional = optional || 'default value';

Viertens, Sie können die Arität einer Funktion über arguments.length überprüfen.

if (arguments.length < 3) {
    optional = 'default value';
}

Auch hier unterscheidet sich der letzte Ansatz von den anderen.

Eine weitere Möglichkeit ist, optionale Parameter als benannte Parameter zu übergeben, wie Eigenschaften eines Objektliterals (siehe Benannte Parameter).

In JavaScript können Sie Parameter nicht per Referenz übergeben; das heißt, wenn Sie eine Variable an eine Funktion übergeben, wird ihr Wert kopiert und an die Funktion übergeben (Wertübergabe). Daher kann die Funktion die Variable nicht ändern. Wenn Sie dies tun müssen, müssen Sie den Wert der Variablen verpacken (z. B. in einem Array).

Dieses Beispiel demonstriert eine Funktion, die eine Variable inkrementiert.

function incRef(numberRef) {
    numberRef[0]++;
}
var n = [7];
incRef(n);
console.log(n[0]);  // 8

Wenn Sie einer anderen Funktion f eine Funktion c als Parameter übergeben, müssen Sie sich zweier Signaturen bewusst sein:

Wenn sich die beiden unterscheiden, können unerwartete Ergebnisse auftreten: c könnte optionale Parameter haben, von denen Sie nichts wissen und die zusätzliche von f bereitgestellte Argumente falsch interpretieren würden.

Betrachten Sie als Beispiel die Array-Methode map() (siehe Transformationsmethoden), deren Parameter normalerweise eine Funktion mit einem einzigen Parameter ist.

> [ 1, 2, 3 ].map(function (x) { return x * x })
[ 1, 4, 9 ]

Eine Funktion, die als Argument übergeben werden könnte, ist parseInt() (siehe Ganze Zahlen über parseInt()).

> parseInt('1024')
1024

Sie könnten (fälschlicherweise) denken, dass map() nur ein einziges Argument bereitstellt und dass parseInt() nur ein einziges Argument akzeptiert. Dann wären Sie von folgendem Ergebnis überrascht:

> [ '1', '2', '3' ].map(parseInt)
[ 1, NaN, NaN ]

map() erwartet eine Funktion mit folgender Signatur:

function (element, index, array)

Aber parseInt() hat folgende Signatur:

parseInt(string, radix?)

Somit füllt map() nicht nur string (über element), sondern auch radix (über index). Das bedeutet, dass die Werte des vorherigen Arrays wie folgt erzeugt werden:

> parseInt('1', 0)
1
> parseInt('2', 1)
NaN
> parseInt('3', 2)
NaN

Zusammenfassend lässt sich sagen, dass man vorsichtig mit Funktionen und Methoden sein sollte, deren Signatur man sich nicht sicher ist. Wenn Sie sie verwenden, ist es oft sinnvoll, explizit zu machen, welche Parameter empfangen und welche weitergegeben werden. Das wird über einen Callback erreicht.

> ['1', '2', '3'].map(function (x) { return parseInt(x, 10) })
[ 1, 2, 3 ]

Sobald eine Funktion mehr als einen Parameter hat, kann man verwirrt sein, wofür jeder Parameter verwendet wird. Nehmen wir zum Beispiel eine Funktion namens selectEntries(), die Einträge aus einer Datenbank zurückgibt. Angesichts des folgenden Funktionsaufrufs:

selectEntries(3, 20, 2);

was bedeuten diese drei Zahlen? Python unterstützt benannte Parameter, und sie machen es einfach, zu verstehen, was vor sich geht.

selectEntries(start=3, end=20, step=2)  # Python syntax

Optionale Positions-Parameter funktionieren nur gut, wenn sie am Ende weggelassen werden. Irgendwo anders muss man Platzhalter wie null einfügen, damit die restlichen Parameter die richtigen Positionen haben. Bei optionalen benannten Parametern ist das kein Problem. Sie können jeden davon problemlos weglassen. Hier sind einige Beispiele:

# Python syntax
selectEntries(step=2)
selectEntries(end=20, start=3)
selectEntries()

JavaScript hat keine native Unterstützung für benannte Parameter wie Python und viele andere Sprachen. Aber es gibt eine recht elegante Simulation: Benenne Parameter über ein Objektliteral, das als einzelnes tatsächliches Argument übergeben wird. Wenn Sie diese Technik verwenden, sieht ein Aufruf von selectEntries() so aus:

selectEntries({ start: 3, end: 20, step: 2 });

Die Funktion empfängt ein Objekt mit den Eigenschaften start, end und step. Sie können jede davon weglassen.

selectEntries({ step: 2 });
selectEntries({ end: 20, start: 3 });
selectEntries();

Sie könnten selectEntries() wie folgt implementieren:

function selectEntries(options) {
    options = options || {};
    var start = options.start || 0;
    var end = options.end || getDbLength();
    var step = options.step || 1;
    ...
}

Sie können auch positionsbasierte Parameter mit benannten Parametern kombinieren. Üblich ist, dass letztere zuletzt kommen:

someFunc(posArg1, posArg2, { namedArg1: 7, namedArg2: true });