Я'м читать книгу о написании JavaScript-фреймворки и нашел этот фрагмент кода. Но я Дон'т понять, как это работает, особенно связывать.использование привязать? У кого-нибудь есть ключ?
var bind = Function.prototype.bind;
var apply = bind.bind(bind.apply);
var fn = apply([].concat);
var a = [1, 2, 3], b = [4, [5, 6], 7];
fn(a, b);
//output [1, 2, 3, 4, 5, 6, 7]
Это возвращает меня в те дни решения и расширяя уравнений.
1 . Во-первых, позволяет расширить применить функцию:
var bind = Function.prototype.bind;
var apply = bind.bind(bind.apply);
var fn = apply([].concat);
Превращается в:
var apply = Function.prototype.bind.bind(Function.prototype.bind.apply);
var fn = apply([].concat)
2 . Во-вторых, мы расширяем функцию FN:
var fn = Function.prototype.bind.bind(Function.prototype.bind.apply)([].concat);
3 . Теперь мы изобретаем правило Яш алгебра и заменить связывать.связать...()` вызов функции вызова.
На самом деле мы осуществляем замену базы на том, что:
someFunction.bind(arg1)(arg2) <==> someFunction.call(arg1, arg2)
Поэтому мы можем заменить, что и вам:
var fn = Function.prototype.bind.call(Function.prototype.bind.apply, [].concat);
4 . На второе наше правило в JS алгебры мы разрабатываем, что:
someFn.привязки.вызов(цель, ...) <==> целевой.привязать(...)
.
someFn не важно здесь, потому что мы не'т позвонить привязки() на нем. Мы вызываем
вызовна
персонализация- замена в
этот, который был
someFn` и поэтому его заменяют "целевой".
Поэтому мы заменяем связывать.вызов(цель) с целевым.связать альтернатива
var fn = Function.prototype.bind.apply.bind([].concat)
5 . Если последняя перестановка была также делаем вызов () мы могли бы сделать замену, как:
fn([1, 2], [3, 4]) <==> [].concat.apply([1, 2], [3, 4])
Но у нас есть только привязки без вызова, которые мы можем заменить и равен:
var fn = function (arg1, arg2) {
return [].concat.apply(arg1, arg2);
}
// instead arg1 and arg2 we could use more accurate arguments logic also.
Конечный Результат
var fn = Function.prototype.bind.apply.bind([].concat)
// or
var fn = function (arg1, arg2) {
return [].concat.apply(arg1, arg2);
}
Функция ФН
исполняет функции функция concat
и позволяет нам это в функциональном стиле, без вызова его из объекта. Вместо функция concat
, связанные с этой
вызывающего ФН
применяет его на аргумент1
как этот
и аргумент2
, как и другие параметры для конкатенации к аргумент1
.
fn([1, 2], [3, [5, 6], 4])
// [1, 2, 3, 5, 6, 4]
Потому Что `Функция.прототип.персонализация-это сама функция, он наследует себя как метод.
Как правило, привязка называется метод экземпляра определенную функцию, но мы можем привязать его к функции`.прототип.применить и вернуть функцию высшего порядка.
Менее лаконичный способ написания это будет:
function apply (fn) {
return function (a, b) {
return fn.apply(a, b)
}
}
Мы должны думать немного о том, что "привязка" на самом деле за кулисами. В грубом приближении, как это работает:
function bind(fn, ...bound) {
return (...other) => this.call(fn, ...bound, ...other);
}
(Помните, что лексические " это "относится к функции, о которой "привязка" называется.) Поэтому принимать
apply = bind.bind(bind.apply);
и вручную расширение связывание
, мы получим:
apply = (...other) => bind.call(bind.apply, ...other);
Мы'повторно только заинтересованы в прохождении один аргумент, который является функцией. Надеюсь, это также означает, что его "применить" собственность-это то же самое, что "привязка":
apply = (fn) => bind.call(fn.apply, fn);
Но "привязка" сам (надеюсь) и на ФН.применить`'ы прототипа, поэтому мы можем еще более упростить до:
apply = (fn) => fn.apply.bind(fn);
Мы'вновь в таком положении, чтобы расширить снова привязать`:
apply = (fn) => (...other) => fn.apply.call(fn, ...other);
На этот раз, мы хотим, чтобы два аргумента, и призыв к "вызов" также может быть упрощена:
apply = (fn) => (obj, args) => fn.apply(obj, args);
Мы'вновь в таком положении, чтобы вызвать применить
на [].функция concat
:
fn = (obj, args) => [].concat.apply(obj, args);
в obj
должен быть массив для этого, чтобы работать, так что все упрощается до:
fn = (obj, args) => obj.concat(...args);
И в приведенном примере мы в конечном итоге с
[1, 2, 3].concat(4, [5, 6], 7)
что возвращает ожидаемый результат.
привязка (метод) создает новый экземпляр функции к значению, который был передан в
привязать()`.
Здесь мы вызов функции.прототип.привязки.применяется(функция.прототип, [нуль].функция concat(аргументы));
разбивая на отдельные блоки исполняемый код.
Цель-призыв "применить"; чтобы пройти первоначальную функцию в качестве первого param и затем массив аргументов.
Этот код имеет различные переменные для каждого процесса, задействованных для достижения связывают с динамическими параметрами.
var bind=Function.prototype.bind;
// the bind function is assigned to a var
var apply=bind.bind(bind.apply);
// a new function apply is created which is nothing but bind.apply
var fn=apply([].concat);
// the apply function is defined and now we have final function
that will concat array.
Последние две строчки предназначены для выполнения функции ФН
, передав два параметра
ВАР а=[1,2,3],Б=[4,[5,6],7]; ФН(а,б);