blocks|key|326549|text|我只是想知道-当你有原型并且可以将函数调用的范围设置为任何你想要的时候，你为什么要克隆一个函数呢？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|326550|+var+funcA+=+{};
+funcA.data+=+'something';
+funcA.changeData+=+function(d){+this.data+=+d;+}

+var+funcB+=+{};
+funcB.data+=+'else';

+funcA.changeData.call(funcB.data);

+alert(funcA.data+%2B+'+'+%2B+funcB.data);|code-block|syntax|javascript|326551|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Just wondering - why would you want to clone a function when you have prototypes AND can set the scope of a function call to anything you wish?

<pre><code> var funcA = {};
 funcA.data = 'something';
 funcA.changeData = function(d){ this.data = d; }

 var funcB = {};
 funcB.data = 'else';

 funcA.changeData.call(funcB.data);

 alert(funcA.data + ' ' + funcB.data);
</code></pre>

blocks|key|3289267|text|试试这个：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3289268|var+x+=+function()+{
++++return+1;
};

var+t+=+function(a,b,c)+{
++++return+a%2Bb%2Bc;
};


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));|code-block|syntax|javascript|3289269|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

try this:

<pre><code>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));
</code></pre>

blocks|key|3289280|text|以下是更新后的答案|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3289281|var+newFunc+=+oldFunc.bind({});+//clones+the+function+with+'{}'+acting+as+its+new+'this'+parameter|code-block|syntax|javascript|3289282|但是，.bind是JavaScript+(带有compatibility+workaround+from+MDN)的现代(+>=iE9+)特性|offset|length|style|CODE|3289283|备注|3289284|3289285|It++not+clone+function+object附加的代码属性，+prototype属性。归功于@jchook|ordered-list-item|BOLD|3289286|3289287|即使在新的函数this调用中，新的函数|3289288|变量也会使用bind()上给出的参数卡住。归功于@Kevin|3289289|3289290|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|3289291|3289292|绑定的函数对象，instanceof将newFunc/oldFunc视为相同。归功于@Christopher|3289293|3289294|(new+newFunc())+instanceof+oldFunc;+//gives+true
(new+oldFunc())+instanceof+newFunc;+//gives+true+as+well
newFunc+==+oldFunc;+//gives+false+however|3289295|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Function/bind|1|https://stackoverflow.com/users/554406/|2|https://stackoverflow.com/users/700980/|3|https://stackoverflow.com/users/59272^0|0|0|3|5|N|X|0|0|0|0|12|9|1H|7|1|0|0|7|4|7|4|0|6|6|O|6|2|0|0|0|0|8|A|J|7|R|7|16|C|3|0|0|0^^$0|@$1|2|3|4|5|6|7|1L|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|1M|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|1N|8|@$I|1O|J|1P|K|L]]|9|@$I|1Q|J|1R|1|1S]]|A|$]]|$1|M|3|N|5|6|7|1T|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|1U|8|@]|9|@]|A|$]]|$1|P|3|Q|5|R|7|1V|8|@$I|1W|J|1X|K|S]]|9|@$I|1Y|J|1Z|1|20]]|A|$]]|$1|T|3|-4|5|6|7|21|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|22|8|@$I|23|J|24|K|S]|$I|25|J|26|K|L]]|9|@]|A|$]]|$1|W|3|X|5|R|7|27|8|@$I|28|J|29|K|L]]|9|@$I|2A|J|2B|1|2C]]|A|$]]|$1|Y|3|-4|5|6|7|2D|8|@]|9|@]|A|$]]|$1|Z|3|10|5|D|7|2E|8|@]|9|@]|A|$E|F]]|$1|11|3|-4|5|6|7|2F|8|@]|9|@]|A|$]]|$1|12|3|13|5|R|7|2G|8|@$I|2H|J|2I|K|L]|$I|2J|J|2K|K|L]|$I|2L|J|2M|K|L]]|9|@$I|2N|J|2O|1|2P]]|A|$]]|$1|14|3|-4|5|6|7|2Q|8|@]|9|@]|A|$]]|$1|15|3|16|5|D|7|2R|8|@]|9|@]|A|$E|F]]|$1|17|3|-4|5|6|7|2S|8|@]|9|@]|A|$]]]|18|$19|$5|1A|1B|1C|A|$1D|1E]]|1F|$5|1A|1B|1C|A|$1D|1G]]|1H|$5|1A|1B|1C|A|$1D|1I]]|1J|$5|1A|1B|1C|A|$1D|1K]]]]

Here is an updated answer
<pre><code>var newFunc = oldFunc.bind({}); //clones the function with '{}' acting as its new 'this' parameter
</code></pre>
However <code>.bind</code> is a modern ( &gt;=iE9 ) feature of JavaScript (with a <a href="https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Function/bind" rel="nofollow noreferrer">compatibility workaround from MDN</a>)
<h1>Notes</h1>
<ol>
<li>It does not clone the function object additional attached properties, including the prototype property. Credit to <a href="https://stackoverflow.com/users/554406/">@jchook</a>
</li>
<li>The new function <code>this</code> variable is stuck with the argument given on <code>bind()</code>, even on new function <code>apply()</code> calls. Credit to <a href="https://stackoverflow.com/users/700980/">@Kevin</a>
</li>
</ol>
<pre><code>function oldFunc() {
 console.log(this.msg);
}
var newFunc = oldFunc.bind({ msg: &quot;You shall not pass!&quot; }); // this object is binded
newFunc.apply({ msg: &quot;hello world&quot; }); //logs &quot;You shall not pass!&quot; instead
</code></pre>
<ol start="3">
<li>Bound function object, <code>instanceof</code> treats <code>newFunc</code>/<code>oldFunc</code> as the same. Credit to <a href="https://stackoverflow.com/users/59272">@Christopher</a></li>
</ol>
<pre><code>(new newFunc()) instanceof oldFunc; //gives true
(new oldFunc()) instanceof newFunc; //gives true as well
newFunc == oldFunc; //gives false however
</code></pre>

blocks|key|3075898|text|这是Jared答案的一个稍微更好的版本。克隆的次数越多，这个函数就不会嵌套得越深。它总是调用原始的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3075899|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;
};|code-block|syntax|javascript|3075900|此外，作为对pico.creator给出的更新答案的回应，值得注意的是，在Javascript+1.8.5中添加的bind()函数与Jared的答案具有相同的问题-它将继续嵌套，导致每次使用时函数的速度越来越慢。|offset|length|style|CODE|3075901|entityMap^0|0|0|1L|6|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Here's a slightly better version of Jared's answer. This one won't end up with deeply nested functions the more you clone. It always calls the original.

<pre><code>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;
};
</code></pre>

Also, in response to the updated answer given by pico.creator, it is worth noting that the <code>bind()</code> function added in Javascript 1.8.5 has the same problem as Jared's answer - it will keep nesting causing slower and slower functions each time it is used.

blocks|key|3289396|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3289397|_cloneFunction+=+function(_function){
++++var+_arguments,+_body,+_result;
++++var+_regexFunction+=+/%5Efunction[\s]%2B[\w]*$([\w\s,_\$]*)?$\{(.*)\}$/;
++++var+_regexArguments+=+/((?!=%5E%7C,)([\w\$_]))%2B/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;
}|code-block|syntax|javascript|3289398|一个简单的测试：|3289399|(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]);
++++++++}
++++}
})()|3289400|但是，对于任何封闭的变量，这些克隆将失去其名称和作用域。|3289401|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|-4|4|5|6|N|7|@]|8|@]|9|$]]|$1|A|3|B|4|C|6|O|7|@]|8|@]|9|$D|E]]|$1|F|3|G|4|5|6|P|7|@]|8|@]|9|$]]|$1|H|3|I|4|C|6|Q|7|@]|8|@]|9|$D|E]]|$1|J|3|K|4|5|6|R|7|@]|8|@]|9|$]]|$1|L|3|-4|4|5|6|S|7|@]|8|@]|9|$]]]|M|$]]

If you want to create a clone using the Function constructor, something like this should work:

<pre><code>_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;
}
</code></pre>

A simple test:

<pre><code>(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]);
 }
 }
})()
</code></pre>

These clones will lose their names and scope for any closed over variables though.

blocks|key|324333|text|出于好奇，但仍然找不到上面问题的性能主题的答案，我为nodejs写了这个gist，以测试所有提出的(和评分的)解决方案的性能和可靠性。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|324334|我已经比较了创建克隆函数和执行克隆函数的时间。结果以及断言错误都包含在gist的注释中。|324335|再加上我的两点意见(基于作者的建议)：|324336|clone0+cent+(更快但更丑陋)：|324337|Function.prototype.clone+=+function()+{
++var+newfun;
++eval('newfun='+%2B+this.toString());
++for+(var+key+in+this)
++++newfun[key]+=+this[key];
++return+newfun;
};|code-block|syntax|javascript|324338|eval+cent+(速度较慢，但对于那些不喜欢clone4+()的人来说，目的只有他们自己和他们的祖先知道)：|324339|Function.prototype.clone+=+function()+{
++var+newfun+=+new+Function('return+'+%2B+this.toString())();
++for+(var+key+in+this)
++++newfun[key]+=+this[key];
++return+newfun;
};|324340|至于性能，如果eval/new函数比包装器解决方案慢(这确实取决于函数体的大小)，它会给你提供裸函数克隆(我指的是真正的浅克隆，有属性，但不共享状态)，没有不必要的模糊，隐藏属性，包装函数和堆栈问题。|324341|此外，你还需要考虑一个重要的因素:代码越少，出错的地方就越少。|324342|使用eval/new函数的缺点是克隆函数和原始函数将在不同的作用域中运行。它不能很好地处理使用作用域变量的函数。使用类绑定包装的解决方案与作用域无关。|324343|entityMap|0|LINK|mutability|MUTABLE|url|https://gist.github.com/royaltm/6321532^0|10|4|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@$A|17|B|18|1|19]]|C|$]]|$1|D|3|E|5|6|7|1A|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|1B|8|@]|9|@]|C|$]]|$1|H|3|I|5|6|7|1C|8|@]|9|@]|C|$]]|$1|J|3|K|5|L|7|1D|8|@]|9|@]|C|$M|N]]|$1|O|3|P|5|6|7|1E|8|@]|9|@]|C|$]]|$1|Q|3|R|5|L|7|1F|8|@]|9|@]|C|$M|N]]|$1|S|3|T|5|6|7|1G|8|@]|9|@]|C|$]]|$1|U|3|V|5|6|7|1H|8|@]|9|@]|C|$]]|$1|W|3|X|5|6|7|1I|8|@]|9|@]|C|$]]|$1|Y|3|-4|5|6|7|1J|8|@]|9|@]|C|$]]]|Z|$10|$5|11|12|13|C|$14|15]]]]

Being curious but still unable to find the answer to the performance topic of the question above, I wrote this <a href="https://gist.github.com/royaltm/6321532" rel="noreferrer">gist</a> for nodejs to test both the performance and reliability of all presented (and scored) solutions.

I've compared the wall times of a clone function creation and the execution of a clone.
The results together with assertion errors are included in the gist's comment.

Plus my two cents (based on the author's suggestion):

clone0 cent (faster but uglier):

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

clone4 cent (slower but for those who dislike eval() for purposes known only to them and their ancestors):

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

As for the performance, if eval/new Function is slower than wrapper solution (and it really depends on the function body size), it gives you bare function clone (and I mean the true shallow clone with properties but unshared state) without unnecessary fuzz with hidden properties, wrapper functions and problems with stack.

Plus there is always one important factor you need to take into consideration: the less code, the less places for mistakes.

The downside of using the eval/new Function is that the clone and the original function will operate in different scopes. It won't work well with functions that are using scoped variables. The solutions using bind-like wrapping are scope independent.

blocks|key|3076098|text|让这个方法工作是非常令人兴奋的，所以它使用函数调用来克隆函数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3076099|在MDN+Function+Reference上描述的闭包的一些限制|offset|length|3076100|function+cloneFunc(+func+)+{
++var+reFn+=+/%5Efunction\s*([%5E\s(]*)\s*$([%5E)]*)$[%5E{]*\{([%5E]*)\}$/gi
++++,+s+=+func.toString().replace(/%5E\s%7C\s$/g,+'')
++++,+m+=+reFn.exec(s);
++if+(!m+%7C%7C+!m.length)+return;+
++var+conf+=+{
++++++name+:+m[1]+%7C%7C+'',
++++++args+:+m[2].replace(/\s%2B/g,'').split(','),
++++++body+:+m[3]+%7C%7C+''
++}
++var+clone+=+Function.prototype.constructor.apply(this,+[].concat(conf.args,+conf.body));
++return+clone;
}|code-block|syntax|javascript|3076101|好好享受吧。|3076102|entityMap|0|LINK|mutability|MUTABLE|url|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function^0|0|1|M|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@$D|W|E|X|1|Y]]|A|$]]|$1|F|3|G|5|H|7|Z|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|10|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]]]

It was pretty exciting to make this method work, so it makes a clone of a function using Function call.

Some limitations about closures described at <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function">MDN Function Reference</a>

<pre><code>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;
}
</code></pre>

Enjoy.

blocks|key|326645|text|我用自己的方式改进了Jared的回答：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|326646|++++Function.prototype.clone+=+function()+{
++++++++var+that+=+this;
++++++++function+newThat()+{
++++++++++++return+(new+that(
++++++++++++++++arguments[0],
++++++++++++++++arguments[1],
++++++++++++++++arguments[2],
++++++++++++++++arguments[3],
++++++++++++++++arguments[4],
++++++++++++++++arguments[5],
++++++++++++++++arguments[6],
++++++++++++++++arguments[7],
++++++++++++++++arguments[8],
++++++++++++++++arguments[9]
++++++++++++));
++++++++}
++++++++function+__clone__()+{
++++++++++++if+(this+instanceof+__clone__)+{
++++++++++++++++return+newThat.apply(null,+arguments);
++++++++++++}
++++++++++++return+that.apply(this,+arguments);
++++++++}
++++++++for(var+key+in+this+)+{
++++++++++++if+(this.hasOwnProperty(key))+{
++++++++++++++++__clone__[key]+=+this[key];
++++++++++++}
++++++++}
++++++++return+__clone__;
++++};|code-block|syntax|javascript|326647|1)现在它支持构造函数的克隆(可以用new调用)；在这种情况下，只需要10个参数(你可以改变它)-因为不可能在原始构造函数中传递所有参数|326648|2)一切都在正确的闭包中|326649|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I've impoved Jared's answer in my own manner:

<pre><code> Function.prototype.clone = function() {
 var that = this;
 function newThat() {
 return (new that(
 arguments[0],
 arguments[1],
 arguments[2],
 arguments[3],
 arguments[4],
 arguments[5],
 arguments[6],
 arguments[7],
 arguments[8],
 arguments[9]
 ));
 }
 function __clone__() {
 if (this instanceof __clone__) {
 return newThat.apply(null, arguments);
 }
 return that.apply(this, arguments);
 }
 for(var key in this ) {
 if (this.hasOwnProperty(key)) {
 __clone__[key] = this[key];
 }
 }
 return __clone__;
 };
</code></pre>

1) now it supports cloning of constructors (can call with new); in that case takes only 10 arguments (you can vary it) - due to impossibility of passing all arguments in original constructor

2) everything is in correct closures

blocks|key|321969|text|简短而简单：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|321970|Function.prototype.clone+=+function()+{
++return+new+Function('return+'+%2B+this.toString())();
};|code-block|syntax|javascript|321971|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Short and simple:

<pre><code>Function.prototype.clone = function() {
 return new Function('return ' + this.toString())();
};
</code></pre>

blocks|key|324432|text|function+cloneFunction(Func,+...args)+{
++function+newThat(...args2)+{
++++return+new+Func(...args2);
++}
++function+clone()+{
++++if+(this+instanceof+clone)+{
++++++return+newThat(...args);
++++}
++++return+Func.apply(this,+args);
++}
++for+(const+key+in+Func)+{
++++if+(Func.hasOwnProperty(key))+{
++++++clone[key]+=+Func[key];
++++}
++}
++Object.defineProperty(clone,+'name',+{+value:+Func.name,+configurable:+true+})
++return+clone
};

function+myFunction()+{
++console.log('Called+Function')
}

myFunction.value+=+'something';

const+newFunction+=+cloneFunction(myFunction);

newFunction.another+=+'somethingelse';

console.log('Equal?+',+newFunction+===+myFunction);
console.log('Names:+',+myFunction.name,+newFunction.name);
console.log(myFunction);
console.log(newFunction);
console.log('InstanceOf?+',+newFunction+instanceof+myFunction);

myFunction();
newFunction();|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|324433|虽然我永远不会推荐使用它，但我认为这将是一个有趣的小挑战，通过采取一些似乎是最好的做法，并对其进行一些修复，提出一个更精确的克隆。以下是日志的结果：|unstyled|324434|Equal?++false
Names:++myFunction+myFunction
{+[Function:+myFunction]+value:+'something'+}
{+[Function:+myFunction]+value:+'something',+another:+'somethingelse'+}
InstanceOf?++false
Called+Function
Called+Function|324435|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|L|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|I|3|-4|5|F|7|N|8|@]|9|@]|A|$]]]|J|$]]

<pre><code>function cloneFunction(Func, ...args) {
 function newThat(...args2) {
 return new Func(...args2);
 }
 function clone() {
 if (this instanceof clone) {
 return newThat(...args);
 }
 return Func.apply(this, args);
 }
 for (const key in Func) {
 if (Func.hasOwnProperty(key)) {
 clone[key] = Func[key];
 }
 }
 Object.defineProperty(clone, 'name', { value: Func.name, configurable: true })
 return clone
};

function myFunction() {
 console.log('Called Function')
}

myFunction.value = 'something';

const newFunction = cloneFunction(myFunction);

newFunction.another = 'somethingelse';

console.log('Equal? ', newFunction === myFunction);
console.log('Names: ', myFunction.name, newFunction.name);
console.log(myFunction);
console.log(newFunction);
console.log('InstanceOf? ', newFunction instanceof myFunction);

myFunction();
newFunction();
</code></pre>

While I would never recommend using this, I thought it would be an interesting little challenge to come up with a more precise clone by taking some of the practices that seemed to be the best and fixing it up a bit. Heres the result of the logs:

<pre><code>Equal? false
Names: myFunction myFunction
{ [Function: myFunction] value: 'something' }
{ [Function: myFunction] value: 'something', another: 'somethingelse' }
InstanceOf? false
Called Function
Called Function
</code></pre>

blocks|key|323804|text|const+oldFunction+=+params+=>+{
++//+do+something
};

const+clonedFunction+=+(...args)+=>+oldFunction(...args);|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|323805|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>const oldFunction = params =&gt; {
 // do something
};

const clonedFunction = (...args) =&gt; oldFunction(...args);
</code></pre>

blocks|key|324442|text|这个答案是为那些认为克隆函数是他们想要的用途的答案的人准备的，但是他们实际上并不需要克隆函数，因为他们真正想要的只是能够将不同的属性附加到同一个函数，但只声明该函数一次。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|324443|为此，请创建一个创建函数的函数：|324444|function+createFunction(param1,+param2)+{
+++function+doSomething()+{
++++++console.log('in+the+function!');
+++}
+++//+Assign+properties+to+`doSomething`+if+desired,+perhaps+based
+++//+on+the+arguments+passed+into+`param1`+and+`param2`.+Or,
+++//+even+return+a+different+function+from+among+a+group+of+them.
+++return+doSomething;
};

let+a+=+createFunction();
a.something+=+1;
let+b+=+createFunction();
b.something+=+2;+//+does+not+overwrite+a.something
console.log(a.something);
a();
b();|code-block|syntax|javascript|324445|这与你所描述的并不完全相同，但是，这取决于你想要如何使用你想要克隆的函数。这也使用了更多的内存，因为它实际上创建了函数的多个副本，每次调用一次。然而，这种技术可能会解决一些人的用例，而不需要复杂的clone函数。|offset|length|style|CODE|324446|entityMap^0|0|0|0|2Q|5|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|T|8|@$K|U|L|V|M|N]]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

This answer is for people who see cloning a function as the answer to their desired usage, but who many not actually need to clone a function, because what they really want is simply to be able to attach different properties to the same function, but only declare that function one time.

Do this by creating a function-creating function:

<pre><code>function createFunction(param1, param2) {
 function doSomething() {
 console.log('in the function!');
 }
 // Assign properties to `doSomething` if desired, perhaps based
 // on the arguments passed into `param1` and `param2`. Or,
 // even return a different function from among a group of them.
 return doSomething;
};

let a = createFunction();
a.something = 1;
let b = createFunction();
b.something = 2; // does not overwrite a.something
console.log(a.something);
a();
b();
</code></pre>

This is not exactly the same as you have outlined, however, it depends on how you want to use the function you're wishing to clone. This also uses more memory because it actually creates multiple copies of the function, once per invocation. However, this technique may solve some people's use case without the need for a complicated <code>clone</code> function.

blocks|key|3289557|text|const+clonedFunction+=+Object.assign(()+=>+{},+originalFunction);|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|3289558|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>const clonedFunction = Object.assign(() =&gt; {}, originalFunction);
</code></pre>

blocks|key|3289647|text|const+clone+=+(fn,+context+=+this)+=>+{
++//+Creates+a+new+function,+optionally+preserving+desired+context.
++const+newFn+=+fn.bind(context);

++//+Shallow+copies+over+function+properties,+if+any.
++return+Object.assign(newFn,+fn);
}

//+Usage:

//+Setup+the+function+to+copy+from.
const+log+=+(...args)+=>+console.log(...args);
log.testProperty+=+1;

//+Clone+and+make+sure+the+function+and+properties+are+intact.
const+log2+=+clone(log);
log2('foo');
//+->+'foo'
log2.testProperty;
//+->+1

//+Make+sure+tweaks+to+the+clone+function's+properties+don't+affect+the+original+function+properties.
log2.testProperty+=+2;
log2.testProperty;
//+->+2
log.testProperty;
//+->+1|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|3289648|此克隆函数：|unstyled|3289649|3289650|保留上下文。|ordered-list-item|3289651|是一个包装器，它在函数属性上运行原始的|3289652|。|3289653|3289654|请注意，此版本仅执行浅层复制。如果您的函数将对象作为属性，则会保留对原始对象的引用(与对象扩展或Object.assign的行为相同)。这意味着更改克隆函数中的深层属性将影响原始函数中引用的对象！|offset|length|style|BOLD|3289655|entityMap^0|0|0|0|0|0|0|0|0|3|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|Z|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|10|8|@]|9|@]|A|$]]|$1|K|3|L|5|J|7|11|8|@]|9|@]|A|$]]|$1|M|3|N|5|J|7|12|8|@]|9|@]|A|$]]|$1|O|3|-4|5|F|7|13|8|@]|9|@]|A|$]]|$1|P|3|Q|5|F|7|14|8|@$R|15|S|16|T|U]]|9|@]|A|$]]|$1|V|3|-4|5|F|7|17|8|@]|9|@]|A|$]]]|W|$]]

<pre class="lang-js prettyprint-override"><code>const clone = (fn, context = this) =&gt; {
 // Creates a new function, optionally preserving desired context.
 const newFn = fn.bind(context);

 // Shallow copies over function properties, if any.
 return Object.assign(newFn, fn);
}

// Usage:

// Setup the function to copy from.
const log = (...args) =&gt; console.log(...args);
log.testProperty = 1;

// Clone and make sure the function and properties are intact.
const log2 = clone(log);
log2('foo');
// -&gt; 'foo'
log2.testProperty;
// -&gt; 1

// Make sure tweaks to the clone function's properties don't affect the original function properties.
log2.testProperty = 2;
log2.testProperty;
// -&gt; 2
log.testProperty;
// -&gt; 1
</code></pre>
This clone function:
<ol>
<li>Preserves context.</li>
<li>Is a wrapper, and runs the original function.</li>
<li>Copies over function properties.</li>
</ol>
Note that this version only performs a shallow copy. If your function has objects as properties, the reference to the original object is preserved (same behavior as Object spread or Object.assign). This means that changing deep properties in the cloned function will affect the object referenced in the original function!

blocks|key|326731|text|这里有一个普通的ES5解决方案(甚至适用于类)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|326732|函数和类保留其原始名称，您可以克隆克隆的克隆而不会出现任何绑定问题，并且不需要eval。|326733|(第一个解决方案必须全局声明；第二个解决方案更详细，但可以在任何范围内声明)(这两个函数仅在克隆引用全局可达内容的函数时有效)|326734|​|326735|function+dirtyClone(class_or_function){
++++
++if(typeof+class_or_function+!==+"function"){

++++console.log("wrong+input+type");

++++return+false;
++}


++let+stringVersion+=+class_or_function.toString();

++let+newFunction+=+'dirtyClone.arr.push('+%2B+stringVersion+%2B+')';


++let+funScript+=+document.createElement("SCRIPT");

++funScript.text+=+newFunction;

++document.body.append(funScript);

++funScript.remove();


++let+last+=+dirtyClone.arr.length-1;

++dirtyClone.arr[last].prototype+=+class_or_function.prototype;

++return+dirtyClone.arr[last];
}
dirtyClone.arr+=+[];



//+TESTS
class+Animal+{
++constructor(name)+{
++++this.name+=+name;
++}

++speak()+{
++++console.log(`${this.name}+makes+a+noise.`);
++}
}

class+Dog+extends+Animal+{
++constructor(name)+{
++++super(name);+//+call+the+super+class+constructor+and+pass+in+the+name+parameter
++}

++speak()+{
++++console.log(`${this.name}+barks.`);
++}
}

function+aFunc(x){console.log(x);}

let+newFunc+=+dirtyClone(aFunc);
newFunc("y");

let+newAni+=+dirtyClone(Animal);
let+nA+=+new+newAni("person");
nA.speak();

let+newDog+=+dirtyClone(Dog);
let+nD+=+new+newDog("mutt");
nD.speak();

console.log({newFunc});
console.log({newAni});
console.log({newDog});|code-block|syntax|javascript|326736|326737|以防你的原始函数有属性，这里有一个解决方案，它也会深入处理这些属性：|326738|326739|let+dirtyDeepClone+=+(function(){
++++//+Create+a+non-colliding+variable+name++
++++//+for+an+array+that+will+hold+functions.
++++let+alfUUID+=+"alf_"+%2B+makeUUID();
++++
++++//+Create+a+new+script+element.
++++let+scriptEl+=+document.createElement('SCRIPT');
++++
++++//+Add+a+non-colliding,+object+declaration+
++++//+to+that+new+script+element's+text.
++++scriptEl.text+=+alfUUID+%2B+"+=+[];";
++++
++++//+Append+the+new+script+element+to+the+document's+body
++++document.body.append(scriptEl);
++++++++++++++++

++++//+The+function+that+does+the+magic
++++function+dirtyDeepClone(class_or_function){
++++++
++++++++if(typeof+class_or_function+!==+"function"){

++++++++++++console.log("wrong+input+type");

++++++++++++return+false;
++++++++}

++++++++
++++++++let+stringVersion+=+class_or_function.toString();
++++++++
++++++++let+newFunction+=+alfUUID+%2B+'.push('+%2B+stringVersion+%2B+')';
++++
++++++++
++++++++let+funScript+=+document.createElement("SCRIPT");

++++++++funScript.text+=+newFunction;
++++++++
++++++++document.body.append(funScript);
++++
++++++++funScript.remove();
++++++++
++++++++
++++++++let+last+=+window[alfUUID].length-1;
++++++++
++++++++window[alfUUID][last]+=+extras(true,+class_or_function,+window[alfUUID][last]);
++++++
++++++++window[alfUUID][last].prototype+=+class_or_function.prototype;
++++++++
++++++++return+window[alfUUID][last];
++++}



++++////////////////////////////////////////////////
++++//+SUPPORT+FUNCTIONS+FOR+dirtyDeepClone+FUNCTION
++++function+makeUUID(){
++++++++
++++++++//+uuid+adapted+from:+https://stackoverflow.com/a/21963136
++++++++var+lut+=+[];+
++++++++
++++++++for+(var+i=0;+i<256;+i%2B%2B)
++++++++++++lut[i]+=+(i<16?'0':'')%2B(i).toString(16);
++++++++
++++++++
++++++++var+d0+=+Math.random()*0xffffffff%7C0;
++++++++var+d1+=+Math.random()*0xffffffff%7C0;
++++++++var+d2+=+Math.random()*0xffffffff%7C0;
++++++++var+d3+=+Math.random()*0xffffffff%7C0;
++++++++
++++++++
++++++++var+UUID+=+lut[d0&0xff]%2Blut[d0>>8&0xff]%2Blut[d0>>16&0xff]%2Blut[d0>>24&0xff]%2B'_'%2B
++++++++lut[d1&0xff]%2Blut[d1>>8&0xff]%2B'_'%2Blut[d1>>16&0x0f%7C0x40]%2Blut[d1>>24&0xff]%2B'_'%2B
++++++++lut[d2&0x3f%7C0x80]%2Blut[d2>>8&0xff]%2B'_'%2Blut[d2>>16&0xff]%2Blut[d2>>24&0xff]%2B
++++++++lut[d3&0xff]%2Blut[d3>>8&0xff]%2Blut[d3>>16&0xff]%2Blut[d3>>24&0xff];
++++++++
++++++++return+UUID;
++++}
++
++
++//+Support+variables+for+extras+function
++++var+errorConstructor+=+{
++++++++"Error":true,
++++++++"EvalError":true,
++++++++"RangeError":true,
++++++++"ReferenceError":true,
++++++++"SyntaxError":true,
++++++++"TypeError":true,
++++++++"URIError":true
++++};
++++var+filledConstructor+=+{
++++++++"Boolean":true,
++++++++"Date":true,
++++++++"String":true,
++++++++"Number":true,
++++++++"RegExp":true
++++};
++++var+arrayConstructorsES5+=+{
++++++++"Array":true,
++++++++"BigInt64Array":true,
++++++++"BigUint64Array":true,
++++++++"Float32Array":true,
++++++++"Float64Array":true,
++++++++"Int8Array":true,
++++++++"Int16Array":true,
++++++++"Int32Array":true,
++++++++"Uint8Array":true,
++++++++"Uint8ClampedArray":true,
++++++++"Uint16Array":true,
++++++++"Uint32Array":true,
++++};
++++var+filledConstructorES6+=+{
++++++++"BigInt":true,
++++++++"Symbol":true
++++};


++++function+extras(top,+from,+to){
++++++++
++++++++//+determine+if+obj+is+truthy+
++++++++//+and+if+obj+is+an+object.
++++++++if(from+!==+null+&&+(typeof+from+===+"object"+%7C%7C+top)+&&+!from.isActiveClone){
++++++++++++
++++++++++++//+stifle+further+functions+from+entering+this+conditional
++++++++++++//+(initially,+top+===+true+because+we+are+expecting+that+to+is+a+function)
++++++++++++top+=+false;+
++++++++++++
++++++++++++//+if+object+was+constructed
++++++++++++//+handle+inheritance,
++++++++++++//+or+utilize+built-in+constructors
++++++++++++if(from.constructor+&&+!to){

++++++++++++++++let+oType+=+from.constructor.name;


++++++++++++++++if(filledConstructor[oType])
++++++++++++++++++++to+=+new+from.constructor(from);

++++++++++++++++else+if(filledConstructorES6[oType])
++++++++++++++++++++to+=+from.constructor(from);

++++++++++++++++else+if(from.cloneNode)
++++++++++++++++++++to+=+from.cloneNode(true);

++++++++++++++++else+if(arrayConstructorsES5[oType])
++++++++++++++++++++to+=+new+from.constructor(from.length);

++++++++++++++++else+if+(+errorConstructor[oType]+){

++++++++++++++++++++if(from.stack){

++++++++++++++++++++++++to+=+new+from.constructor(from.message);

++++++++++++++++++++++++to.stack+=+from.stack;
++++++++++++++++++++}

++++++++++++++++++++else
++++++++++++++++++++++++to+=+new+Error(from.message+%2B+"+INACCURATE+OR+MISSING+STACK-TRACE");
++++++++++++++++++++
++++++++++++++++}

++++++++++++++++else+//+troublesome+if+constructor+is+poorly+formed
++++++++++++++++++++to+=+new+from.constructor();+
++++++++++++++++
++++++++++++}
++++++++++++
++++++++++++else+//+loses+cross-frame+magic
++++++++++++++++to+=+Object.create(null);+

++++++++++++
++++++++++++
++++++++++++
++++++++++++let+props+=+Object.getOwnPropertyNames(from);

++++++++++++let+descriptor;


++++++++++++for(let+i+in+props){

++++++++++++++++descriptor+=+Object.getOwnPropertyDescriptor(+from,+props[i]+);
++++++++++++++++prop+=+props[i];

++++++++++++++++//+recurse+into+descriptor,+if+necessary
++++++++++++++++//+and+assign+prop+to+from
++++++++++++++++if(descriptor.value){

++++++++++++++++++++if(
++++++++++++++++++++++descriptor.value+!==+null+&&+
++++++++++++++++++++++typeof+descriptor.value+===+"object"+&&
++++++++++++++++++++++typeof+descriptor.value.constructor+!==+"function"
++++++++++++++++++++){
++++++++++++++++++++++++++from.isActiveClone+=+true;
++++++++++++++++++++++++++to[prop]+=+extras(false,+from[prop]);
++++++++++++++++++++++++++delete+from.isActiveClone;
++++++++++++++++++++++++
++++++++++++++++++++}
++++++++++++++++++else
++++++++++++++++++++++++to[prop]+=+from[prop];
++++++++++++++++}
++++++++++++++++else
++++++++++++++++++++Object.defineProperty(+to,+prop,+descriptor+);
++++++++++++}
++++++++}
++++++
++++++++else+if(typeof+from+===+"function")
++++++++++++return+dirtyDeepClone(from);
++++++++
++++++++return+from;
++++}
++++
++++return+dirtyDeepClone;
})();



//+TESTS
class+Animal+{
++constructor(name)+{
++++this.name+=+name;
++}

++speak()+{
++++console.log(`${this.name}+makes+a+noise.`);
++}
}

class+Dog+extends+Animal+{
++constructor(name)+{
++++super(name);+//+call+the+super+class+constructor+and+pass+in+the+name+parameter
++}

++speak()+{
++++console.log(`${this.name}+barks.`);
++}
}

function+aFunc(x){console.log(x);}
aFunc.g+=+"h";
aFunc.Fun+=+function(){this.a+=+"b";}

let+newFunc+=+dirtyDeepClone(aFunc);
newFunc("y");
let+deepNewFunc+=+new+newFunc.Fun();
console.log(deepNewFunc);

let+newAni+=+dirtyDeepClone(Animal);
let+nA+=+new+newAni("person");
nA.speak();

let+newDog+=+dirtyDeepClone(Dog);
let+nD+=+new+newDog("mutt");
nD.speak();

console.log({newFunc});
console.log({newAni});
console.log({newDog});|326740|326741|entityMap^0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|W|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|X|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|Y|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|Z|8|@]|9|@]|A|$K|L]]|$1|M|3|G|5|6|7|10|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|11|8|@]|9|@]|A|$]]|$1|P|3|G|5|6|7|12|8|@]|9|@]|A|$]]|$1|Q|3|R|5|J|7|13|8|@]|9|@]|A|$K|L]]|$1|S|3|G|5|6|7|14|8|@]|9|@]|A|$]]|$1|T|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|U|$]]

Here's a vanilla ES5 solution (that even works for classes).
Functions and classes retain their original names, you can clone clones of clones without any binding issues, and no need for eval.
(the first solution must be declared globally; the second solution is more verbose, but can be declared in any scope)
((both functions only work when cloning functions that reference globally-reachable content))
<div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>function dirtyClone(class_or_function){
 
 if(typeof class_or_function !== "function"){

 console.log("wrong input type");

 return false;
 }


 let stringVersion = class_or_function.toString();

 let newFunction = 'dirtyClone.arr.push(' + stringVersion + ')';


 let funScript = document.createElement("SCRIPT");

 funScript.text = newFunction;

 document.body.append(funScript);

 funScript.remove();


 let last = dirtyClone.arr.length-1;

 dirtyClone.arr[last].prototype = class_or_function.prototype;

 return dirtyClone.arr[last];
}
dirtyClone.arr = [];



// TESTS
class Animal {
 constructor(name) {
 this.name = name;
 }

 speak() {
 console.log(`${this.name} makes a noise.`);
 }
}

class Dog extends Animal {
 constructor(name) {
 super(name); // call the super class constructor and pass in the name parameter
 }

 speak() {
 console.log(`${this.name} barks.`);
 }
}

function aFunc(x){console.log(x);}

let newFunc = dirtyClone(aFunc);
newFunc("y");

let newAni = dirtyClone(Animal);
let nA = new newAni("person");
nA.speak();

let newDog = dirtyClone(Dog);
let nD = new newDog("mutt");
nD.speak();

console.log({newFunc});
console.log({newAni});
console.log({newDog});</code></pre>
</div>
</div>

Just in case there are properties on your original function, here's a solution that'll deeply handle those too:
<div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>let dirtyDeepClone = (function(){
 // Create a non-colliding variable name 
 // for an array that will hold functions.
 let alfUUID = "alf_" + makeUUID();
 
 // Create a new script element.
 let scriptEl = document.createElement('SCRIPT');
 
 // Add a non-colliding, object declaration 
 // to that new script element's text.
 scriptEl.text = alfUUID + " = [];";
 
 // Append the new script element to the document's body
 document.body.append(scriptEl);
 

 // The function that does the magic
 function dirtyDeepClone(class_or_function){
 
 if(typeof class_or_function !== "function"){

 console.log("wrong input type");

 return false;
 }

 
 let stringVersion = class_or_function.toString();
 
 let newFunction = alfUUID + '.push(' + stringVersion + ')';
 
 
 let funScript = document.createElement("SCRIPT");

 funScript.text = newFunction;
 
 document.body.append(funScript);
 
 funScript.remove();
 
 
 let last = window[alfUUID].length-1;
 
 window[alfUUID][last] = extras(true, class_or_function, window[alfUUID][last]);
 
 window[alfUUID][last].prototype = class_or_function.prototype;
 
 return window[alfUUID][last];
 }



 ////////////////////////////////////////////////
 // SUPPORT FUNCTIONS FOR dirtyDeepClone FUNCTION
 function makeUUID(){
 
 // uuid adapted from: https://stackoverflow.com/a/21963136
 var lut = []; 
 
 for (var i=0; i&lt;256; i++)
 lut[i] = (i&lt;16?'0':'')+(i).toString(16);
 
 
 var d0 = Math.random()*0xffffffff|0;
 var d1 = Math.random()*0xffffffff|0;
 var d2 = Math.random()*0xffffffff|0;
 var d3 = Math.random()*0xffffffff|0;
 
 
 var UUID = lut[d0&amp;0xff]+lut[d0&gt;&gt;8&amp;0xff]+lut[d0&gt;&gt;16&amp;0xff]+lut[d0&gt;&gt;24&amp;0xff]+'_'+
 lut[d1&amp;0xff]+lut[d1&gt;&gt;8&amp;0xff]+'_'+lut[d1&gt;&gt;16&amp;0x0f|0x40]+lut[d1&gt;&gt;24&amp;0xff]+'_'+
 lut[d2&amp;0x3f|0x80]+lut[d2&gt;&gt;8&amp;0xff]+'_'+lut[d2&gt;&gt;16&amp;0xff]+lut[d2&gt;&gt;24&amp;0xff]+
 lut[d3&amp;0xff]+lut[d3&gt;&gt;8&amp;0xff]+lut[d3&gt;&gt;16&amp;0xff]+lut[d3&gt;&gt;24&amp;0xff];
 
 return UUID;
 }
 
 
 // Support variables for extras function
 var errorConstructor = {
 "Error":true,
 "EvalError":true,
 "RangeError":true,
 "ReferenceError":true,
 "SyntaxError":true,
 "TypeError":true,
 "URIError":true
 };
 var filledConstructor = {
 "Boolean":true,
 "Date":true,
 "String":true,
 "Number":true,
 "RegExp":true
 };
 var arrayConstructorsES5 = {
 "Array":true,
 "BigInt64Array":true,
 "BigUint64Array":true,
 "Float32Array":true,
 "Float64Array":true,
 "Int8Array":true,
 "Int16Array":true,
 "Int32Array":true,
 "Uint8Array":true,
 "Uint8ClampedArray":true,
 "Uint16Array":true,
 "Uint32Array":true,
 };
 var filledConstructorES6 = {
 "BigInt":true,
 "Symbol":true
 };


 function extras(top, from, to){
 
 // determine if obj is truthy 
 // and if obj is an object.
 if(from !== null &amp;&amp; (typeof from === "object" || top) &amp;&amp; !from.isActiveClone){
 
 // stifle further functions from entering this conditional
 // (initially, top === true because we are expecting that to is a function)
 top = false; 
 
 // if object was constructed
 // handle inheritance,
 // or utilize built-in constructors
 if(from.constructor &amp;&amp; !to){

 let oType = from.constructor.name;


 if(filledConstructor[oType])
 to = new from.constructor(from);

 else if(filledConstructorES6[oType])
 to = from.constructor(from);

 else if(from.cloneNode)
 to = from.cloneNode(true);

 else if(arrayConstructorsES5[oType])
 to = new from.constructor(from.length);

 else if ( errorConstructor[oType] ){

 if(from.stack){

 to = new from.constructor(from.message);

 to.stack = from.stack;
 }

 else
 to = new Error(from.message + " INACCURATE OR MISSING STACK-TRACE");
 
 }

 else // troublesome if constructor is poorly formed
 to = new from.constructor(); 
 
 }
 
 else // loses cross-frame magic
 to = Object.create(null); 

 
 
 
 let props = Object.getOwnPropertyNames(from);

 let descriptor;


 for(let i in props){

 descriptor = Object.getOwnPropertyDescriptor( from, props[i] );
 prop = props[i];

 // recurse into descriptor, if necessary
 // and assign prop to from
 if(descriptor.value){

 if(
 descriptor.value !== null &amp;&amp; 
 typeof descriptor.value === "object" &amp;&amp;
 typeof descriptor.value.constructor !== "function"
 ){
 from.isActiveClone = true;
 to[prop] = extras(false, from[prop]);
 delete from.isActiveClone;
 
 }
 else
 to[prop] = from[prop];
 }
 else
 Object.defineProperty( to, prop, descriptor );
 }
 }
 
 else if(typeof from === "function")
 return dirtyDeepClone(from);
 
 return from;
 }
 
 return dirtyDeepClone;
})();



// TESTS
class Animal {
 constructor(name) {
 this.name = name;
 }

 speak() {
 console.log(`${this.name} makes a noise.`);
 }
}

class Dog extends Animal {
 constructor(name) {
 super(name); // call the super class constructor and pass in the name parameter
 }

 speak() {
 console.log(`${this.name} barks.`);
 }
}

function aFunc(x){console.log(x);}
aFunc.g = "h";
aFunc.Fun = function(){this.a = "b";}

let newFunc = dirtyDeepClone(aFunc);
newFunc("y");
let deepNewFunc = new newFunc.Fun();
console.log(deepNewFunc);

let newAni = dirtyDeepClone(Animal);
let nA = new newAni("person");
nA.speak();

let newDog = dirtyDeepClone(Dog);
let nD = new newDog("mutt");
nD.speak();

console.log({newFunc});
console.log({newAni});
console.log({newDog});</code></pre>
</div>
</div>

What is a fastest way to clone a function in JavaScript (with or without its properties)?

Two options coming to mind are <code>eval(func.toString())</code> and <code>function() { return func.apply(..) }</code>. But I am worried about performance of eval and wrapping will make stack worse and will probably degrade performance if applied a lot or applied to already wrapped.

<code>new Function(args, body)</code> looks nice, but how exactly can I reliable split existing function to args and body without a JS parser in JS?

Thanks in advance.

Update:
What I mean is being able to do

<pre><code>var funcB = funcA.clone(); // where clone() is my extension
funcB.newField = {...}; // without affecting funcA
</code></pre>

JavaScript: clone a function

在JavaScript中克隆函数(带或不带其属性)最快的方法是什么？脑海中浮现出两个选项：eval(func.toString())和function() { return func.apply(..) }。但我担心eval和包装的性能会使堆栈变得更糟，如果大量应用或应用到已经包装的地方，可能会降低性能。new Fun...

问JavaScript:克隆函数
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问JavaScript:克隆函数EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问JavaScript:克隆函数
EN