Wie führe ich eine JavaScript-Funktion aus, wenn ich ihren Namen als String habe?

Question

Ich habe den Namen einer Funktion in JavaScript als String. Wie wandle ich diesen in einen Funktionszeiger um, damit ich ihn später aufrufen kann?

Je nach den Umständen kann es erforderlich sein, der Methode auch verschiedene Argumente zu übergeben.

Einige der Funktionen können die folgende Form haben namespace.namespace.function(args[...]) .

Answer 1

Verwenden Sie nicht eval es sei denn, Sie absolut, positiv keine andere Wahl haben.

Wie bereits erwähnt wurde, wäre es am besten, so etwas zu verwenden:

window["functionName"](arguments);

Das funktioniert jedoch nicht mit einer Funktion, die einen Namensraum hat:

window["My.Namespace.functionName"](arguments); // fail

So würden Sie das tun:

window["My"]["Namespace"]["functionName"](arguments); // succeeds

Um dies zu erleichtern und eine gewisse Flexibilität zu gewährleisten, gibt es eine praktische Funktion:

function executeFunctionByName(functionName, context /*, args */) {
  var args = Array.prototype.slice.call(arguments, 2);
  var namespaces = functionName.split(".");
  var func = namespaces.pop();
  for(var i = 0; i < namespaces.length; i++) {
    context = context[namespaces[i]];
  }
  return context[func].apply(context, args);
}

Sie würden es so nennen:

executeFunctionByName("My.Namespace.functionName", window, arguments);

Beachten Sie, dass Sie jeden beliebigen Kontext übergeben können, so dass dies das Gleiche wie oben tun würde:

executeFunctionByName("Namespace.functionName", My, arguments);

Answer 2

Ich dachte, ich poste mal eine leicht veränderte Version von Jason Buntings sehr hilfreiche Funktion .

Zunächst habe ich die erste Anweisung vereinfacht, indem ich einen zweiten Parameter an slice() . Die ursprüngliche Version funktionierte in allen Browsern außer dem IE einwandfrei.

Zweitens: Ich habe die este con Kontext in der Return-Anweisung; andernfalls, este zeigte immer auf Fenster als die Zielfunktion ausgeführt wurde.

function executeFunctionByName(functionName, context /*, args */) {
    var args = Array.prototype.slice.call(arguments, 2);
    var namespaces = functionName.split(".");
    var func = namespaces.pop();
    for (var i = 0; i < namespaces.length; i++) {
        context = context[namespaces[i]];
    }
    return context[func].apply(context, args);
}

Answer 3

Die Antwort auf diese andere Frage zeigt Ihnen, wie das geht: Javascript-Äquivalent zu Pythons locals()?

Im Grunde kann man sagen

window["foo"](arg1, arg2);

oder, wie viele andere vorgeschlagen haben, können Sie einfach eval verwenden:

eval(fname)(arg1, arg2);

obwohl dies extrem unsicher ist, es sei denn, Sie sind sich absolut sicher, was Sie auswerten.

Answer 4

Ich denke, eine elegante Art, dies zu tun, ist durch die Definition Ihrer Funktionen in einem Hash-Objekt. Dann können Sie einen Verweis auf diese Funktionen aus dem Hash mit der Zeichenfolge haben. z.B.

var customObject = {
  customFunction: function(param){...}
};

Dann können Sie anrufen:

customObject['customFunction'](param);

Dabei ist customFunction eine Zeichenkette, die einer in Ihrem Objekt definierten Funktion entspricht.

UPDATE

Es scheint, dass diese Antwort für viele andere Programmierer hilfreich war, daher hier eine aktualisierte Version.

Mit ES6 können Sie zusätzlich Berechnete Eigenschaftsnamen die es Ihnen ermöglichen wird, magische Zeichenfolgen zu vermeiden.

const FunctionNames = Object.freeze({ 
  FirstFunction: "firstFunction", 
  SecondFunction: "secondFunction" 
});

...

var customObject = {
  [FunctionNames.FirstFunction]: function(param){...},
  [FunctionNames.SecondFunction]: function(param){...}
};

...

customObject[FunctionNames.FirstFunction](param);

Answer 5

Könnten Sie das nicht einfach tun?

var codeToExecute = "My.Namespace.functionName()";
var tmpFunc = new Function(codeToExecute);
tmpFunc();

Sie können auch jedes andere JavaScript mit dieser Methode ausführen.