在 JavaScript 中克隆一个函数的最快方法是什么（有或没有它的属性）？
想到的两个选项是eval(func.toString())和function() { return func.apply(..) }。但是我担心 eval 和包装的性能会使堆栈变得更糟，并且如果大量应用或应用于已经包装的，可能会降低性能。
new Function(args, body) 看起来不错，但是在 JS 中没有 JS 解析器的情况下，我如何可靠地将现有函数拆分为 args 和 body？
提前致谢。
更新： 我的意思是能够做到
var funcB = funcA.clone(); // where clone() is my extension
funcB.newField = {...}; // without affecting funcA
这是更新的答案
var newFunc = oldFunc.bind({}); //clones the function with '{}' acting as its new 'this' parameter
然而，这.bind是 JavaScript 的现代 ( >=iE9 ) 特性（具有来自 MDN的兼容性解决方法）
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
instanceof将newFunc/oldFunc视为相同。感谢@Christopher(new newFunc()) instanceof oldFunc; //gives true
(new oldFunc()) instanceof newFunc; //gives true as well
newFunc == oldFunc; //gives false however
试试这个：
var x = function() {
return 1;
};
var t = function(a,b,c) {
return a+b+c;
};
Function.prototype.clone = function() {
var that = this;
var temp = function temporary() { return that.apply(this, arguments); };
for(var key in this) {
if (this.hasOwnProperty(key)) {
temp[key] = this[key];
}
}
return temp;
};
alert(x === x.clone());
alert(x() === x.clone()());
alert(t === t.clone());
alert(t(1,1,1) === t.clone()(1,1,1));
alert(t.clone()(1,1,1));
这是 Jared 答案的稍微好一点的版本。你克隆的越多，这个函数就不会得到深度嵌套的函数。它总是调用原始的。
Function.prototype.clone = function() {
var cloneObj = this;
if(this.__isClone) {
cloneObj = this.__clonedFrom;
}
var temp = function() { return cloneObj.apply(this, arguments); };
for(var key in this) {
temp[key] = this[key];
}
temp.__isClone = true;
temp.__clonedFrom = cloneObj;
return temp;
};
此外，针对 pico.creator 给出的更新答案，值得注意的是，bind()Javascript 1.8.5 中添加的函数与 Jared 的答案存在相同的问题——每次使用时，它都会不断嵌套，导致函数越来越慢。
出于好奇但仍然无法找到上述问题的性能主题的答案，我为 nodejs编写了这个要点，以测试所有提出（和评分）解决方案的性能和可靠性。
我比较了克隆函数创建和执行克隆的时间。结果与断言错误一起包含在要点的注释中。
加上我的两分钱（根据作者的建议）：
clone0 cent（更快但更丑）：
Function.prototype.clone = function() {
var newfun;
eval('newfun=' + this.toString());
for (var key in this)
newfun[key] = this[key];
return newfun;
};
clone4 cent（较慢，但对于那些不喜欢 eval() 的人来说，其目的只有他们和他们的祖先知道）：
Function.prototype.clone = function() {
var newfun = new Function('return ' + this.toString())();
for (var key in this)
newfun[key] = this[key];
return newfun;
};
至于性能，如果 eval/new Function 比包装器解决方案慢（它真的取决于函数体的大小），它会给你裸函数克隆（我的意思是真正的浅克隆，具有属性但未共享状态）而没有不必要的模糊具有隐藏属性、包装函数和堆栈问题。
此外，您始终需要考虑一个重要因素：代码越少，出错的地方就越少。
使用 eval/new 函数的缺点是克隆和原始函数将在不同的范围内运行。它不适用于使用作用域变量的函数。使用类绑定包装的解决方案与范围无关。
使这个方法工作非常令人兴奋，因此它使用函数调用克隆了一个函数。
MDN 函数参考中描述的关于闭包的一些限制
function cloneFunc( func ) {
var reFn = /^function\s*([^\s(]*)\s*\(([^)]*)\)[^{]*\{([^]*)\}$/gi
, s = func.toString().replace(/^\s|\s$/g, '')
, m = reFn.exec(s);
if (!m || !m.length) return;
var conf = {
name : m[1] || '',
args : m[2].replace(/\s+/g,'').split(','),
body : m[3] || ''
}
var clone = Function.prototype.constructor.apply(this, [].concat(conf.args, conf.body));
return clone;
}
享受。