Function

Der Function Konstruktor erstellt ein neues Funktion Objekt. Das direkte Aufrufen kann Funktionen dynamisch erstellen, hat aber Sicherheits- und Performanceprobleme genau wie der Einsatz von eval. Im Gegensatz zu eval ermöglicht der Function-Konstruktor die Ausführung von Code im globalen Gültigkeitsbereich, was zu besseren Programmiergewohnheiten führt und eine effizientere Code-Minimierung ermöglicht.

Jede JavaScript Funktion ist aktuell ein Function Objekt. Das kann mit dem Code (function(){}).constructor === Function gezeigt werden, der true zurückgibt.

new Function ([arg1[, arg2[, ...argN]],] functionBody)

arg1, arg2, ... argN

Namen die von der Funktion als formelle Argumentname genutzt werden. Jeder davon muss ein String sein, welcher ein gültiger JavaScript Bezeichner ist oder einer Liste von solchen Strings, getrennt mit Kommata ist. Zum Beispiel: "x", "derWert", oder "a,b".

functionBody

Ein String, welcher den JavaScript Ausdruck als Funktions-Definition beinhaltet.

Mit dem Function Konstruktor erstellte Function-Objekte werden übersetzt, sobald die Funktion erstellt wurde. Das ist weniger effizient, als wenn man eine Funktion als Funktionsausdruck oder Funktionsstatement deklariert und diese innerhalb des Codes abruft, weil diese mit dem Rest des Codes übersetzt werden.

Alle der Funktion übergegebenen Argumente werden als Namen der Bezeichner der Parameter in der zu erstellenden Funktion in der angegebenen Reihenfolge behandelt.

Das Aufrufen des Function Konstruktors als Funktion (ohne den new Operator) hat dieselbe Wirkung, wie als Konstrukteuraufruf. Jedoch kann das Weglassen des new Operators eine kleinere minimierten Codegröße (4 Byte kleiner) erreichen, so dass es besser ist Function ohne new zu benutzen.

Das globale Function Objekt hat eigene Methoden und Eigenschaften, doch, da es eine Funktion selbst ist, erbt es einige Methoden und Eigenschaften durch die Prototypkette aus Function.prototype.

Funktions-Instanzen erben Methoden und Eigenschaften vom Function.prototype. Wie bei allen Konstruktoren kann das Prototypen Objekt verändern werden, um Änderungen an allen Funktions-Instanzen durchzuführen.

Der folgende Code erstellt ein Funktions-Objekt, mit zwei Argumenten.

// Das Beispiel kann direkt in der JavaScript Console ausgeführt werden.

// Erstellt eine Funktion mit zwei Argumenten und gibt die Summe dieser Argumente zurück
var adder = new Function('a', 'b', 'return a + b');

// Aufruf der Funktion
adder(2, 6);
// > 8

Die Argumente "a" und "b" sind formale Argument-Namen, welche im Funktionskörper genutzt werden, "return a + b".

Funktionen, die mit dem Function Konstruktor erstellt werden, erstellen keine Closures in ihrem Erstellungskontext; Sie werden immer im globalen Scope erstellt. Wenn diese ausgeführt wird, kann sie nur auf eigene lokale oder globale Variablen zugreifen, jedoch nicht auf die aus dem Erstellungskontext des Function Konstruktor aufzufes. Dieses ist der Unterschied zum Einsatz von eval mit Quelltext für einen Funktionsausdruck.

var x = 10;

function createFunction1() {
    var x = 20;
    return new Function('return x;'); // this |x| refers global |x|
}

function createFunction2() {
    var x = 20;
    function f() {
        return x; // this |x| refers local |x| above
    }
    return f;
}

var f1 = createFunction1();
console.log(f1());          // 10
var f2 = createFunction2();
console.log(f2());          // 20

Der "richtige" Weg für das Ausführen von externen Code mit Function (Für maximale Minimierung).

function makeFunction(code){
    return Funktion('"use strict";return ' + code)();
}
var add = makeFunktion(
  "" + function(a, b, c){ return a + b + c } // dieser Code ist in einer seperaten Datei irgendwo im Produktivprogramm
)
console.log( add(1, 2, 3) );  // gibt sechs aus

Zu beachten ist, dass der obere Code komplett unpraktikabel ist. Man sollte Function niemals so missbrauchen. Stattdessen ist der obere Code nur als vereinfachtes Beispiel für eine Art Modulloader zu sehen, wobei es ein Basisskript gibt, welches dann hunderte von großen optionalen Modulen lädt. Dadurch muss ein Benutzer nicht lange warten, bis alle Module heruntergeladen sind, sondern der Clientcomputer lädt nur die benötigten Module und eine Seite lädt schneller. Dabei wird es beim auswerten von vielen Funktionen empfohlen, sie gebündelt zu übersetzen anstatt jede einzeln.

function bulkMakeFunctions(){
    var str = "", i = 1, Len = arguments.length;
    if(Len) {
        str = arguments[0];
        while (i !== Len) str += "," + arguments[i], ++i;
    }
    return Funktion('"use strict";return[' + str + ']')();
}
const [
    add,
    sub,
    mul,
    div
] = bulkMakeFunctions(
    "function(a,b){return a+b}",
    "function(a,b){return a-b}",
    "function(a,b){return a*b}",
    "function(a,b){return a/b}"
);
console.log(sub(add(mul(4, 3), div(225, 5)), 7));

• Functions and function scope
• Function
• function statement
• function expression
• function* statement
• function* expression
• AsyncFunction
• GeneratorFunction