Dynamischer Funktionsname in Javascript?

Habe ich dieses:

this.f = function instance(){};

Ich würde gern diesen:

this.f = function ["instance:" + a](){};

InformationsquelleAutor der Frage Totty.js | 2011-05-06

function javascript

6

update

Wie andere erwähnt haben, dies ist nicht die Schnellste, noch die am meisten empfohlene Lösung. Marcosc die Lösung unten ist der Weg zu gehen.

~~Man kann mit eval:~~
```
var code = "this.f = function " + instance + "() {...}";
eval(code);
```
InformationsquelleAutor der Antwort Mo Valipour
97

Wird dies im Grunde tun, ist es am einfachsten level:
```
"use strict";
var name = "foo";
var func = new Function(
     "return function " + name + "(){ alert('sweet!')}"
)();

//call it, to test it
func();
```
Wenn Sie möchten, um mehr Lust, ich habe einen Artikel geschrieben über "Dynamische Funktionsnamen in JavaScript".

InformationsquelleAutor der Antwort Marcosc
17

Können Sie mit dem Objekt.defineProperty wie bereits in der MDN-JavaScript-Referenz [1]:
```
var myName = "myName";
var f = function () { return true; };
Object.defineProperty(f, 'name', {value: myName, writable: false});
```
1. https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/name#Description
InformationsquelleAutor der Antwort Darren
3

Die syntax function[i](){} impliziert ein Objekt mit Eigenschaftswerten, die Funktionen function[]indiziert durch den Namen, die [i].

Somit

{"f:1":function(){}, "f:2":function(){}, "f:A":function(){}, ... } ["f:"+i].

{"f:1":function f1(){}, "f:2":function f2(){}, "f:A":function fA(){}} ["f:"+i] wird die Erhaltung der Funktion name. Siehe Hinweise unten bezüglich :.

So,
```
javascript: alert(
  new function(a){
    this.f={"instance:1":function(){}, "instance:A":function(){}} ["instance:"+a]
  }("A") . toSource()
);
```
zeigt ({f:(function () {})}) im FireFox.

(Das ist fast die gleiche Idee wie diese Lösung, nur es verwendet ein generisches Objekt und nicht mehr direkt füllt das Fenster-Objekt mit den Funktionen.)

Diese Methode explizit füllt die Umgebung mit instance:x.
```
javascript: alert(
  new function(a){
    this.f=eval("instance:"+a+"="+function(){})
  }("A") . toSource()
);
alert(eval("instance:A"));
```
zeigt
```
({f:(function () {})})
```
und
```
function () {
}
```
Obwohl die-Eigenschaft-Funktion f verweist auf ein anonymous function und nicht instance:x diese Methode vermeidet einige Probleme mit diese Lösung.
```
javascript: alert(
  new function(a){
    eval("this.f=function instance"+a+"(){}")
  }("A") . toSource()
);
alert(instanceA);    /* is undefined outside the object context */
```
zeigt nur
```
({f:(function instanceA() {})})
```
- Der embedded : macht die javascript - function instance:a(){} ungültig.
- Statt eine Referenz auf die Funktion, die eigentliche text-definition wird analysiert und interpretiert, indem eval.
Folgende ist nicht unbedingt problematisch,
- Die instanceA - Funktion ist nicht direkt für die Verwendung als instanceA()
ist und damit viel mehr im Einklang mit dem ursprünglichen problem-Kontext.

Angesichts dieser überlegungen,
```
this.f = {"instance:1": function instance1(){},
          "instance:2": function instance2(){},
          "instance:A": function instanceA(){},
          "instance:Z": function instanceZ(){}
         } [ "instance:" + a ]
```
unterhält die Globale computing-Umgebung mit der Semantik und syntax der OP Beispiel so viel wie möglich.

InformationsquelleAutor der Antwort Ekim

Zur Einstellung den Namen eines bestehenden anonyme Funktion:

(Basierend auf @Marcosc Antwort)

var anonymous = function() { return true; }

var name = 'someName';
var strFn = anonymous.toString().replace('function ', 'return function ' + name);
var fn = new Function(strFn)();

console.log(fn()); //—> true

Demo.

InformationsquelleAutor der Antwort Onur Yıldırım

1

Was
```
this.f = window["instance:" + a] = function(){};
```
Der einzige Nachteil ist, dass die Funktion in Ihrem toSource-Methode würde nicht geben Sie einen Namen. Das ist in der Regel nur ein problem für den Debugger.

InformationsquelleAutor der Antwort entonio

Dynamische Methoden eines Objekts erstellt werden können, mit dem Objekt-Literal Erweiterung von ECMAScript 2015 (ES6):

const postfixes = ['foo', 'bar'];

const mainObj = {};

const makeDynamic = (postfix) => {
  const newMethodName = 'instance: ' + postfix;
  const tempObj = {
    [newMethodName]() {
      console.log(`called method ${newMethodName}`);
    }
  }
  Object.assign(mainObj, tempObj);
  return mainObj[newMethodName]();
}

const processPostfixes = (postfixes) => { 
  for (const postfix of postfixes) {
    makeDynamic(postfix); 
  }
};

processPostfixes(postfixes);

console.log(mainObj);

Die Ausgabe von der Ausführung des Codes oben:

"called method instance: foo"
"called method instance: bar"
Object {
  "instance: bar": [Function anonymous],
  "instance: foo": [Function anonymous]
}

InformationsquelleAutor der Antwort Luke Schoen

1

Ich denke, die meisten Vorschläge hier sind suboptimal, durch die Verwendung von eval, hacky-Lösungen oder Wrapper.
Als der ES2015 Namen sind abgeleitet von der syntaktischen position der Variablen und Eigenschaften.

So, das wird funktionieren just fine:
```
const name = 'myFn';
const fn = {[name]: function() {}}[name];
fn.name //'myFn'
```
Widerstehen Sie der Versuchung, zu erstellen benannte Funktion factory-Methoden, wie Sie nicht in der Lage sein, um übergeben, die Funktion von außen-und retrofit-in der syntaktischen position zu schließen, seinen Namen. Dann ist es bereits zu spät. Wenn Sie wirklich brauchen, müssen Sie zum erstellen eines wrappers. Jemand hat das hier, aber diese Lösung funktioniert nicht bei Klassen (auch mit Funktionen).

Sehr viel mehr in die Tiefe zu beantworten, mit allen Varianten skizziert wurde hier geschrieben: https://stackoverflow.com/a/9479081/633921

InformationsquelleAutor der Antwort Albin

Danke Marcosc! Aufbauend auf seine Antwort, wenn Sie umbenennen möchten alle - Funktion, verwenden Sie diese:

//returns the function named with the passed name
function namedFunction(name, fn) {
    return new Function('fn',
        "return function " + name + "(){ return fn.apply(this,arguments)}"
    )(fn)
}

InformationsquelleAutor der Antwort B T

Diese utility-Funktion, Zusammenführen mehrerer Funktionen in einem (mit einem benutzerdefinierten Namen), einzige Voraussetzung ist, dass die bereitgestellten Funktionen sind richtig "neu gefüttert" zu Beginn und Ende seiner Schaufel.

const createFn = function(name, functions, strict=false) {

    var cr = `\n`, a = [ 'return function ' + name + '(p) {' ];

    for(var i=0, j=functions.length; i<j; i++) {
        var str = functions[i].toString();
        var s = str.indexOf(cr) + 1;
        a.push(str.substr(s, str.lastIndexOf(cr) - s));
    }
    if(strict == true) {
        a.unshift('\"use strict\";' + cr)
    }
    return new Function(a.join(cr) + cr + '}')();
}

//test
var a = function(p) {
    console.log("this is from a");
}
var b = function(p) {
    console.log("this is from b");
}
var c = function(p) {
    console.log("p == " + p);
}

var abc = createFn('aGreatName', [a,b,c])

console.log(abc) //output: function aGreatName()

abc(123)

//output
this is from a
this is from b
p == 123

InformationsquelleAutor der Antwort MetalGodwin

Gibt es zwei Methoden, um dies zu erreichen, und Sie haben Ihre vor-und Nachteile.

`name` Eigenschaft definition

Definieren unveränderlich name Eigenschaft einer Funktion.

Vor -

Jedes Zeichen steht für die Namen. (zB. () 全 {}/1/얏호/:D #GO(@*#%! /*)

Nachteile

Der Funktion syntaktische ("ausdruckstarken") name entsprechen möglicherweise nicht mit seinen name - Eigenschaft-Wert.

Funktion Auswertung eines Ausdrucks

Machen eine namens Funktion Ausdruck und Bewertung es mit Function Konstruktor.

Vor -

Der Funktion syntaktische ("ausdruckstarken") name immer entspricht mit seinem name - Eigenschaft-Wert.

Nachteile

Leerzeichen (und etc.) nicht verfügbar für den Namen.
Ausdruck injizierbare (zB. Für die Eingabe (){}/1//der Ausdruck ist return function (){}/1//() {} gibt NaN anstelle der Funktion.).

const demoeval = expr => (new Function(`return ${expr}`))();

//`name` property definition
const method1 = func_name => {
    const anon_func = function() {};
    Object.defineProperty(anon_func, "name", {value: func_name, writable: false});
    return anon_func;
};

const test11 = method1("DEF_PROP"); //No whitespace
console.log("DEF_PROP?", test11.name); //"DEF_PROP"
console.log("DEF_PROP?", demoeval(test11.toString()).name); //""

const test12 = method1("DEF PROP"); //Whitespace
console.log("DEF PROP?", test12.name); //"DEF PROP"
console.log("DEF PROP?", demoeval(test12.toString()).name); //""

//Function expression evaluation
const method2 = func_name => demoeval(`function ${func_name}() {}`);

const test21 = method2("EVAL_EXPR"); //No whitespace
console.log("EVAL_EXPR?", test21.name); //"EVAL_EXPR"
console.log("EVAL_EXPR?", demoeval(test21.toString()).name); //"EVAL_EXPR"

const test22 = method2("EVAL EXPR"); //Uncaught SyntaxError: Unexpected identifier

InformationsquelleAutor der Antwort K._

-1

function myFunction() {
    console.log('It works!');
}

var name = 'myFunction';

window[name].call();

InformationsquelleAutor der Antwort Danilo Colasso

-9

Dies ist die BESTE Lösung, besser als new Function('return function name(){}')().

Eval ist die Schnellste Lösung:
```
var name = 'FuncName'
var func = eval("(function " + name + "(){})")
```
InformationsquelleAutor der Antwort Maxmaxmaximus

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

update

name Eigenschaft definition

Vor -

Nachteile

Funktion Auswertung eines Ausdrucks

Vor -

Nachteile

`name` Eigenschaft definition