JavaScript: Klonen Sie eine Funktion

Hier ist eine aktualisierte Antwort

var newFunc = oldFunc.bind({}); //clones the function with '{}' acting as it's new 'this' parameter

Jedoch ".bind" ist eine moderne ( >=iE9 ) - Funktion von JavaScript (mit ein Kompatibilitäts-workaround von MDN)

https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Function/bind

Hinweis:dass es nicht Klonen die Funktion Objekt zusätzliche angebracht Eigenschafteneinschließlich die Prototyp Eigenschaft. Kredit @jchook

Hinweis:dass die neue Funktion diese variable ist fest mit dem argument auf binden(), auch auf die neue Funktion apply () - Aufrufe. Kredit @Kevin

function oldFunc() { console.log(this.msg); }
var newFunc = oldFunc.bind( { msg:"You shall not pass!" } ); //this object is binded
newFunc.apply( { msg:"hello world" } ); //logs "You shall not pass!" instead

Hinweis: gebundenen Funktion Objekt instanceof behandelt newFunc/oldFunc, wie die gleichen. Kredit @Christoph

(new newFunc()) instanceof oldFunc; //gives true
(new oldFunc()) instanceof newFunc; //gives true as well
newFunc == oldFunc;                 //gives false however

InformationsquelleAutor der Antwort PicoCreator

Neugierig, aber noch nicht in der Lage, die Antwort zu finden, um die Leistung Thema der Frage oben, ich schrieb das gist für nodejs testen die Leistung und die Zuverlässigkeit der präsentierten (und erzielte) Lösungen.

Habe ich gegenüber der Wand zu Zeiten der Klon-Funktion-Erstellung und die Ausführung von einem Klon.
Die Ergebnisse zusammen mit assertion-Fehler enthalten sind, die in der gist ' s Kommentar.

Plus meine zwei Cent (basierend auf des Autors Vorschlag):

clone0 cent (schneller, aber hässlicher):

Function.prototype.clone = function() {
  var newfun;
  eval('newfun=' + this.toString());
  for (var key in this)
    newfun[key] = this[key];
  return newfun;
};

clone4 cent (langsamer, aber für diejenigen, die Abneigung eval() für Zwecke, die nur Sie selbst und Ihre Vorfahren):

Function.prototype.clone = function() {
  var newfun = new Function('return ' + this.toString())();
  for (var key in this)
    newfun[key] = this[key];
  return newfun;
};

Als für die Leistung, wenn eval/neue Funktion ist langsamer als wrapper-Lösung (und es hängt wirklich davon ab, die Funktion Körper-Größe), es gibt Sie bare Funktion clone (und ich meine die wahre seichten Klon mit Eigenschaften, aber nicht freigegebenen Zustand), ohne unnötige schnörksel mit versteckten Eigenschaften, die wrapper-Funktionen und Probleme mit dem stack.

Plus gibt es immer ein wichtiger Faktor, den Sie berücksichtigen müssen: je weniger code, desto weniger Plätze für Fehler.

Der Nachteil bei der Verwendung der eval/neue Funktion ist, dass der Klon und das original-Funktion arbeiten in verschiedenen Bereichen. Es funktioniert nicht gut mit Funktionen, die über den Gültigkeitsbereich von Variablen. Die Lösungen mit binden-wie Verpackung sind Umfang unabhängig.

InformationsquelleAutor der Antwort royaltm

Kurz und einfach:

Function.prototype.clone = function() {
  return new Function('return ' + this.toString())();
};

InformationsquelleAutor der Antwort micahblu

Wenn Sie möchten, erstellen Sie einen clone mit der Function-Konstruktor, so etwas wie dies funktionieren sollte:

_cloneFunction = function(_function){
    var _arguments, _body, _result;
    var _regexFunction = /^function[\s]+[\w]*\(([\w\s,_\$]*)?\)\{(.*)\}$/;
    var _regexArguments = /((?!=^|,)([\w\$_]))+/g;
    var _matches = _function.toString().match(_regexFunction)
    if(_matches){
        if(_matches[1]){
            _result = _matches[1].match(_regexArguments);
        }else{
            _result = [];
        }
        _result.push(_matches[2]);
    }else{
        _result = [];
    }
    var _clone = Function.apply(Function, _result);
    //if you want to add attached properties
    for(var _key in _function){
        _clone[_key] = _function[_key];
    }
    return _clone;
}

Einen einfachen test:

(function(){
    var _clone, _functions, _key, _subKey;
    _functions = [
        function(){ return 'anonymous function'; }
        ,function Foo(){ return 'named function'; }
        ,function Bar(){ var a = function(){ return 'function with internal function declaration'; }; return a; }
        ,function Biz(a,boo,c){ return 'function with parameters'; }
    ];
    _functions[0].a = 'a';
    _functions[0].b = 'b';
    _functions[1].b = 'b';
    for(_key in _functions){
        _clone = window._cloneFunction(_functions[_key]);
        console.log(_clone.toString(), _clone);
        console.log('keys:');
        for(_subKey in _clone){
            console.log('\t', _subKey, ': ', _clone[_subKey]);
        }
    }
})()

Diese Klone verlieren Ihre Namen und Geltungsbereich für alle geschlossen über Variablen, obwohl.

InformationsquelleAutor der Antwort tobymackenzie