JavaScript clone a function

Question

What is a fastest way to clone a function in JavaScript  with or without its properties    Two options coming to mind are eval func toString    and function     return func apply        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   new Function args  body  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  var funcB   funcA clone       where clone   is my extension funcB newField                without affecting funcA

User · Answer

Being curious but still unable to find the answer to the performance topic of the question above, I wrote this gist 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):

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

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

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

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.

User · Answer

Here is an updated answer var newFunc   oldFunc bind        clones the function with      acting as it s new  this  parameter  However  bind is a modern    gt  iE9   feature of JavaScript  with a compatibility workaround from MDN  Notes  It does not clone the function object additional attached properties  including the prototype property  Credit to  jchook  The new function this variable is stuck with the argument given on bind    even on new function apply   calls  Credit to  Kevin   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   Bound function object  instanceof treats newFunc oldFunc as the same  Credit to  Christopher   new newFunc    instanceof oldFunc    gives true  new oldFunc    instanceof newFunc    gives true as well newFunc    oldFunc    gives false however

User · Answer

const oldFunction   params   gt         do something     const clonedFunction       args    gt  oldFunction    args

User · Answer

try this   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

User · Answer

Short and simple   Function prototype clone   function       return new Function  return     this toString

User · Answer

const clonedFunction   Object assign      gt      originalFunction

User · Answer

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      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   Equal   false Names   myFunction myFunction    Function  myFunction  value   something       Function  myFunction  value   something   another   somethingelse    InstanceOf   false Called Function Called Function

User · Answer

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   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       Also  in response to the updated answer given by pico creator  it is worth noting that the bind   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

User · Answer

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   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      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 clone function

User · Answer

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 MDN Function Reference  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      Enjoy

User · Answer

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  This clone function   Preserves context  Is a wrapper  and runs the original function  Copies over function properties   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

User · Answer

If you want to create a clone using the Function constructor  something like this should work    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      A simple 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                           These clones will lose their names and scope for any closed over variables though

User · Answer

I ve impoved Jared s answer in my own manner       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             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

User · Answer

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    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

[javascript] JavaScript: clone a function

Examples related to javascript

Examples related to function