Почему Function.prototype.bind работает медленно?

На основе http://jsperf.com/bind-vs-emulate/6, который добавляет версию es5-shim для сравнения, похоже, что виновником является дополнительная ветвь и instanceof, которую должна выполнить связанная версия, чтобы проверить, вызывается ли она как конструктор.

Каждый раз, когда запускается связанная версия, код, который выполняется, по существу:

if (this instanceof bound) {
    // Never reached, but the `instanceof` check and branch presumably has a cost
} else {
    return target.apply(
     that,
     args.concat(slice.call(arguments))
    );

    // args is [] in your case.
    // So the cost is:
    // * Converting (empty) Arguments object to (empty) array.
    // * Concating two empty arrays.
}

В исходном коде V8 эта проверка отображается (внутри boundFunction) как

if (%_IsConstructCall()) {
    return %NewObjectFromBound(boundFunction);
}

(ссылка в виде открытого текста на v8natives.js на случай прекращения работы Google Code Search.)

Немного озадачивает тот факт, что, по крайней мере, для Chrome 16 версия es5-shim по-прежнему работает быстрее, чем нативная версия. И что другие браузеры имеют довольно разные результаты для es5-shim по сравнению с родным. Предположение: возможно, %_IsConstructCall() даже медленнее, чем this instanceof bound, возможно, из-за пересечения границ нативного/JS-кода. И, возможно, другие браузеры имеют гораздо более быстрый способ проверки вызова [[Construct]].

Невозможно реализовать полнофункциональный bind только на ES5. В отдельных разделах с 15.3.4.5.1 по 15.3.4.5.3 спецификации нельзя эмулировать.

15.3.4.5.1, в частности, кажется возможной нагрузкой на производительность: в функциях с короткой привязкой есть разные [[Call]] внутренние свойства, поэтому их вызов, скорее всего, займет необычный и, возможно, более сложный путь кода.

Различные другие специфические неэмулируемые функции связанной функции (такие как отравление arguments/caller и, возможно, пользовательская length, независимая от исходной подписи) могут добавить накладные расходы на каждый вызов, хотя я допускаю, что это немного маловероятно. Хотя похоже, что V8 даже не реализует отравление на данный момент.

ИЗМЕНИТЬ этот ответ является предположением, но мой другой ответ содержит нечто более близкое к доказательству. Я все еще думаю, что это правильное предположение, но это отдельный ответ, поэтому я оставлю его как таковой и просто отошлю вас к другому.

исходный код V8 для привязки реализован в JS.

OP не эмулирует bind, потому что он не обрабатывает аргументы так, как это делает bind. Вот полнофункциональный bind:

var emulatebind = function (f, context) {
  var curriedArgs = Array.prototype.slice.call(arguments, 2);
  return function () {
    var allArgs = curriedArgs.slice(0);
    for (var i = 0, n = arguments.length; i < n; ++i) {
      allArgs.push(arguments[i]);
    }
    return f.apply(context, allArgs);
  };
};

Очевидно, что быстрой оптимизацией было бы сделать

return f.apply(context, arguments);

вместо этого, если curriedArgs.length == 0, потому что в противном случае у вас есть два ненужных создания массива и ненужная копия, но, возможно, нативная версия действительно реализована в JS и не делает этой оптимизации.

Предостережение: этот полнофункциональный bind неправильно обрабатывает некоторые краеугольные случаи вокруг this приведения аргументов в строгом режиме. Это может быть еще одним источником накладных расходов.