что используется для вызова функции внутри функции, а не для передачи двух аргументов? [Дубликат]

Я знаю его старый поток, но мне нужно будет показать, как это используется в библиотеках javascript:

Я буду использовать библиотеку lodash.js для описания этих понятий конкретно.

Пример:

var fn = function(a,b,c){ 
return a+b+c+(this.greet || ‘'); 
}

Частичное применение:

var partialFnA = _.partial(fn, 1,3);

Currying:

var curriedFn = _.curry(fn);

Связывание:

var boundFn = _.bind(fn,object,1,3 );//object= {greet: ’!'}

использование :

curriedFn(1)(3)(5); // gives 9 
or 
curriedFn(1,3)(5); // gives 9 
or 
curriedFn(1)(_,3)(2); //gives 9


partialFnA(5); //gives 9

boundFn(5); //gives 9!

разница:

после каррирования мы получаем новую функцию без параметров, предварительно связанных.

после частичного приложения мы получаем функцию, которая связана с некоторыми предварительными параметрами.

в привязке мы можем связать контекст, который будет использоваться для замены «this», если не связанный по умолчанию любой функции будет областью окна.

Посоветуйте: Нет необходимости изобретать велосипед. Частичное применение / привязка / каррирование очень связаны. Вы можете видеть разницу выше. Используйте это значение где угодно, и люди узнают, что вы делаете, без проблем в понимании, плюс вам придется использовать меньше кода.

Функции JavaScript называются lamda на другом функциональном языке. Его можно использовать для создания новой api (более мощной или дополняющей функции) на основе простого ввода другого разработчика. Карри - всего лишь один из методов. Вы можете использовать его для создания упрощенного api для вызова сложного api. Если вы являетесь разработчиком, который использует упрощенную api (например, вы используете jQuery для простого манипулирования), вам не нужно использовать curry. Но если вы хотите создать упрощенную api, карри - ваш друг. Вам нужно написать фреймворк javascript (например, jQuery, mootools) или библиотеку, тогда вы сможете оценить его силу. Я написал расширенную функцию curry, в http://blog.semanticsworks.com/2011/03/enhanced-curry-method.html . Вам не нужно использовать метод curry для currying, он просто помогает делать currying, но вы всегда можете сделать это вручную, написав функцию A () {}, чтобы вернуть другую функцию B () {}. Чтобы сделать его более интересным, используйте функцию B () для возврата другой функции C ().

Еще один удар по нему, от работы с обещаниями.

(Отказ от ответственности: JS noob, исходящий из мира Python. Даже там, currying не используется так много, но может прийти в удобном случае, поэтому я закрепил функцию currying - см. ссылки)

Во-первых, я начинаю с вызова ajax. У меня есть определенная обработка для успеха, но при отказе я просто хочу дать пользователю обратную связь, что вызов чего-то привел к некоторой ошибке . В моем фактическом коде я отображаю обратную связь с ошибками на панели начальной загрузки, но я просто использую запись здесь.

Я изменил свой живой URL-адрес, чтобы сделать это неудачным.

function ajax_batch(e){
    var url = $(e.target).data("url");

    //induce error
    url = "x" + url;

    var promise_details = $.ajax(
        url,
        {
            headers: { Accept : "application/json" },
            // accepts : "application/json",
            beforeSend: function (request) {
                if (!this.crossDomain) {
                    request.setRequestHeader("X-CSRFToken", csrf_token);
                }
        },
        dataType : "json",
        type : "POST"}
    );
    promise_details.then(notify_batch_success, fail_status_specific_to_batch);
}

Теперь, чтобы сообщить пользователю, что пакет завершился неудачно, мне нужно написать эту информацию в обработчике ошибок, потому что все, что он получает, является ответом от сервера.

У меня все еще есть информация доступна во время кодирования - в моем случае у меня есть несколько возможных партий, но я не знаю, какая из них была неудачной синтаксический анализ ответа сервера о неудавшемся URL-адресе.

function fail_status_specific_to_batch(d){
    console.log("bad batch run, dude");
    console.log("response.status:" + d.status);
}

Давайте сделаем это. Консольный выход:

console:

bad batch run, dude utility.js (line 109) response.status:404

Теперь, давайте немного изменим ситуацию и воспользуемся многократным обработчиком сбоев, но также и тот, который curried во время выполнения с использованием контекста вызова с известным в коде времени и информации о времени выполнения, доступной из события.

    ... rest is as before...
    var target = $(e.target).text();
    var context = {"user_msg": "bad batch run, dude.  you were calling :" + target};
    var contexted_fail_notification = curry(generic_fail, context); 

    promise_details.then(notify_batch_success, contexted_fail_notification);
}

function generic_fail(context, d){
    console.log(context);
    console.log("response.status:" + d.status);
}

function curry(fn) {
     var slice = Array.prototype.slice,
        stored_args = slice.call(arguments, 1);
     return function () {
        var new_args = slice.call(arguments),
              args = stored_args.concat(new_args);
        return fn.apply(null, args);
     };
}

console:

Object { user_msg="bad batch run, dude. you were calling :Run ACL now"} utility.js (line 117) response.status:404 utility.js (line 118)

В более общем плане, учитывая, насколько широкое использование обратного вызова в JS, каррирование кажется довольно полезным инструментом.

https: //javascriptweblog.wordpress .com / 2010/04/05 / curry-cooking-up-tastier-functions / http://www.drdobbs.com/open-source/currying-and-partial-functions-in- javasc / 231001821? PGNO = 2

Вот интересное и практическое использование currying в JavaScript, которое использует замыкания :

function converter(toUnit, factor, offset, input) {
    offset = offset || 0;
    return [((offset + input) * factor).toFixed(2), toUnit].join(" ");
}

var milesToKm = converter.curry('km', 1.60936, undefined);
var poundsToKg = converter.curry('kg', 0.45460, undefined);
var farenheitToCelsius = converter.curry('degrees C', 0.5556, -32);

milesToKm(10);            // returns "16.09 km"
poundsToKg(2.5);          // returns "1.14 kg"
farenheitToCelsius(98);   // returns "36.67 degrees C"

Это зависит от расширения curry Function, хотя, как вы видите, он использует только apply (ничего необычного):

Function.prototype.curry = function() {
    if (arguments.length < 1) {
        return this; //nothing to curry with - return function
    }
    var __method = this;
    var args = toArray(arguments);
    return function() {
        return __method.apply(this, args.concat([].slice.apply(null, arguments)));
    }
}

Я нашел функции, похожие на functools.partial python более полезными в JavaScript:

function partial(fn) {
  return partialWithScope.apply(this,
    Array.prototype.concat.apply([fn, this],
      Array.prototype.slice.call(arguments, 1)));
}

function partialWithScope(fn, scope) {
  var args = Array.prototype.slice.call(arguments, 2);
  return function() {
    return fn.apply(scope, Array.prototype.concat.apply(args, arguments));
  };
}

Почему вы хотите его использовать? Обычная ситуация, когда вы хотите использовать это, - это когда вы хотите привязать this к функции к значению:

var callback = partialWithScope(Object.function, obj);

Теперь, когда вызывается обратный вызов, this указывает на obj. Это полезно в ситуациях событий или для сохранения некоторого пространства, потому что оно обычно делает код короче.

Currying похожа на частичную с той разницей, что функция, возвращаемая currying, принимает только один аргумент (насколько я понимаю, ).

Я просто написал пример jPaq, который показывает некоторые интересные приложения функции curry. Проверьте это здесь: Выполнение строковых функций

Я согласен, что порой вы хотели бы получить мяч, создавая псевдофункцию, которая всегда будет иметь значение первого аргумента. К счастью, я столкнулся с совершенно новой библиотекой JavaScript под названием jPaq (h ttp: //jpaq.org/ ), который обеспечивает эту функциональность. Самое лучшее в библиотеке - это то, что вы можете загрузить свою собственную сборку, которая содержит только тот код, который вам понадобится.

Вы можете использовать встроенное связывание для быстрого однолинейного решения

function clampAngle(min, max, angle) {
    var result, delta;
    delta = max - min;
    result = (angle - min) % delta;
    if (result < 0) {
        result += delta;
    }
    return min + result;
};

var clamp0To360 = clampAngle.bind(null, 0, 360);

console.log(clamp0To360(405)) // 45

Я бы сказал, что, скорее всего, вся анимационная библиотека в JS использует currying. Вместо того, чтобы передавать каждому вызову набор влияющих элементов и функцию, описывая, как должен себя вести элемент, функции более высокого порядка, которая будет обеспечивать все временные элементы, как правило, легче для клиента выпустить, так как открытый API функция «slideUp», «fadeIn», которая принимает только элементы в качестве аргументов, и это всего лишь какая-то функция в карри, возвращающая функцию высокого порядка с встроенной функцией «анимация» по умолчанию.

Что касается библиотек, использующих его, всегда есть Functional .

Когда это полезно в JS? Вероятно, в то же время он полезен и на других современных языках, но единственный раз, когда я могу его использовать, связан с частичным применением.

Это не волшебство или что-то еще ... просто приятная стенография анонимных функций.

partial(alert, "FOO!") эквивалентно function(){alert("FOO!");}

partial(Math.max, 0) соответствует function(x){return Math.max(0, x);}

Призывы к частичной ( MochiKit терминологии. Я думаю, что некоторые другие библиотеки дают функции, которые способствуют тому или иному), выглядят немного лучше и менее шумно, чем анонимные функции.

Просто хотел добавить некоторые ресурсы для Functional.js:

Лекция / конференция, объясняющая некоторые приложения http://www.youtube.com/watch?v=HAcN3JyQoyY

Обновлена ​​библиотека Functional.js: https://github.com/loop-recur/FunctionalJS Некоторые приятные помощники (извините, новый здесь, без репутации: p): / loop-recur / PreludeJS

Я недавно использовал эту библиотеку, чтобы уменьшить повторение в библиотеке помощников js IRC-клиентов. Это замечательный материал - действительно помогает очистить и упростить код.

Кроме того, если производительность становится проблемой (но эта библиотека довольно легкая), ее можно просто переписать с помощью встроенной функции.

Вот пример.

Я использую кучу полей с JQuery, чтобы я мог видеть, что делают пользователи. Код выглядит так:

$('#foo').focus(trackActivity);
$('#foo').blur(trackActivity);
$('#bar').focus(trackActivity);
$('#bar').blur(trackActivity);

(Для пользователей, не являющихся JQuery, я говорю, что в любое время, когда несколько полей получают или теряют фокус, мне нужна функция trackActivity (). Я мог бы также использовать анонимную функцию, но мне пришлось бы ее дублировать 4 раза, поэтому я вытащил ее и назвал ее.)

Теперь выясняется, что одно из этих полей нужно обрабатывать по-разному , Я хотел бы иметь возможность передать параметр в одном из этих вызовов, которые будут переданы нашей инфраструктуре отслеживания. С каррированием я могу.