Який найшвидший спосіб клонувати функцію в JavaScript (зі своїми властивостями чи без них)?

Два варіанти, що спадають на думку, є eval(func.toString())і function() { return func.apply(..) }. Але я переживаю за ефективність eval і обгортку погіршить стек і, ймовірно, погіршить ефективність, якщо застосовано багато або застосовано до вже обгорнутого.

new Function(args, body) виглядає приємно, але як саме я можу надійно розділити існуючу функцію на арг і тіло без аналізатора JS в JS?

Заздалегідь спасибі.

Оновлення: те, що я маю на увазі, це вміє робити

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

спробуйте це:

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

Ось оновлена ​​відповідь

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

Однак .bindце сучасна (> = iE9) функція JavaScript (із вирішенням сумісності з MDN )

Примітки

1. Це НЕ клон об'єкта функції додаткові приєднані властивості , в тому числі і в прототипі власності. Кредит на @jchook

2. Нова функція цієї змінної застрягла з аргументом, наведеним на bind (), навіть у викликах нової функції apply (). Кредит у @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

3. Об'єкт функції зв'язаної форми, instanceof розглядає newFunc / oldFunc як той самий. Кредит на @Christopher

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

Ось трохи краща версія відповіді Джареда. Ця функція не буде закінчуватися глибоко вкладеними функціями, тим більше ви клонуєте. Він завжди називає оригінал.

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, має ту ж проблему, що і відповідь Джареда - вона буде тримати вкладення, викликаючи повільніші та повільніші функції кожного разу, коли вона буде використана.

Будучи цікавим, але все ще не в змозі знайти відповідь на тему ефективності вищезазначеного питання, я написав цю суть для nodejs, щоб перевірити як продуктивність, так і надійність усіх представлених (і набраних) рішень.

Я порівняв стінні часи створення функції клону та виконання клону. Результати разом із помилками твердження включені до коментаря суті.

Плюс мої два центи (на основі пропозиції автора):

клон0 цент (швидше, але потворніше):

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

Насолоджуйтесь.

Короткий і простий:

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

const oldFunction = params => {
  // do something
};

const clonedFunction = (...args) => oldFunction(...args);

const clonedFunction = Object.assign(() => {}, originalFunction);

Ця відповідь призначена для людей, які бачать клонування функції як відповідь на їх бажане використання, але багатьом насправді не потрібно клонувати функцію, адже те, що вони насправді хочуть, - просто мати змогу приєднувати різні властивості до однієї функції, але лише оголосити цю функцію одноразово.

Зробіть це, створивши функцію створення функції:

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();

Це не зовсім так, як ви окреслили, однак це залежить від того, як ви хочете використовувати функцію, яку ви хочете клонувати. Для цього також використовується більше пам’яті, оскільки вона фактично створює кілька копій функції один раз за виклик. Однак ця методика може вирішити випадок використання для деяких людей без необхідності складної cloneфункції.

Просто цікаво - чому б ви хотіли клонувати функцію, коли у вас є прототипи І можете встановлювати область виклику функції на все, що завгодно?

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

Якщо ви хочете створити клон за допомогою конструктора функцій, щось подібне повинно працювати:

_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;
}

Простий тест:

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

Ці клони все ж втратять свої імена та область для будь-яких закритих змінних.

Я по-справжньому допоміг відповідь Джареда:

    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) тепер він підтримує клонування конструкторів (може дзвонити з новими); у такому випадку бере лише 10 аргументів (ви можете їх змінювати) - через неможливість передачі всіх аргументів у оригінальний конструктор

2) все в правильних закриттях

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();

Хоча я ніколи не рекомендував би скористатися цим, я подумав, що було б цікавим невеликим завданням придумати більш точний клон, взявши деякі практики, які здалися найкращими, і трохи виправити це. Ось результат журналів:

Equal?  false
Names:  myFunction myFunction
{ [Function: myFunction] value: 'something' }
{ [Function: myFunction] value: 'something', another: 'somethingelse' }
InstanceOf?  false
Called Function
Called Function

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

Ця функція клонування:

1. Зберігає контекст.
2. Є обгорткою і виконує оригінальну функцію.
3. Копіює над властивостями функції.

Зауважте, що ця версія виконує лише дрібну копію. Якщо у вашій функції є об'єкти як властивості, посилання на вихідний об'єкт зберігається (така ж поведінка, як розповсюдження об'єкта або Object.assign). Це означає, що зміна глибоких властивостей у клонованій функції вплине на об’єкт, на який посилається в початковій функції!