पैरामीटर के साथ, मैं फ़ंक्शन के संदर्भ को कैसे पास कर सकता हूं?

Question

संभव डुप्लिकेट:
How can I pre-set arguments in JavaScript function call? (Partial Function Application)

मैं करने में सक्षम करने की आवश्यकता है मापदंडों की दी गई सेट के साथ एक समारोह के लिए एक संदर्भ गुजरती हैं।

यहाँ मापदंडों बिना एक संदर्भ पास करने का एक उदाहरण है:

var f = function() { 
    //Some logic here... 
}; 

var fr = f; //Here I am passing a reference to function 'f', without parameters 
fr(); //the 'f' function is invoked, without parameters 

अब मैं एक ही f समारोह पारित किया जाता है क्या करने की जरूरत है, लेकिन इस बार मैं करने के लिए पैरामीटर पास करने की आवश्यकता होगी संदर्भ। अब, मैं यह एक गुमनाम समारोह के साथ क्या कर सकते हैं और नए बनाए गए समारोह के अंदर मानकों के साथ f समारोह आह्वान, इस तरह की तरह:

var f = function() { 
     //Some logic here... 
    }; 

var fr = function (pars) { 
    f(pars); 
}; //Here I am creating an anonymous function, and invoking f inside it 

fr({p : 'a parameter'}); //Invoking the fr function, that will later invoke the f function with parameters 

लेकिन मेरे सवाल है, वहाँ के लिए एक सीधा संदर्भ पारित करने के लिए एक रास्ता है f फ़ंक्शन fr पर पैरामीटर के साथ, लेकिन बिना किसी अज्ञात फ़ंक्शन में इसे बंद किए?

क्या मैं fr को आवंटित करने के लिए मानकों (fr()) के बिना यह invokable बनाने के लिए है, ताकि च (1,2,3) जब fr शुरू हो जाती है निष्पादित किया जाता है की जरूरत है?

[अद्यतन] मैं hereआंशिक समारोह और जावास्क्रिप्ट समारोह वह पदों के बारे में करने के लिए Jason Bunting के जवाब का पालन किया है मैं वास्तव में क्या देख रहा था।

function partial(func /*, 0..n args */) { 
    var args = Array.prototype.slice.call(arguments).splice(1); 
    return function() { 
    var allArguments = args.concat(Array.prototype.slice.call(arguments)); 
    return func.apply(this, allArguments); 
    }; 
} 

Answer 1

क्या आप आंशिक समारोह आवेदन के बाद कर रहे हैं कहा जाता है: यहाँ समाधान है।

उन लोगों द्वारा बेवकूफ मत बनो जो उस और करी के बीच सूक्ष्म अंतर को समझते नहीं हैं, अलग हैं।

आंशिक फ़ंक्शन एप्लिकेशन का उपयोग करने के लिए उपयोग किया जा सकता है, लेकिन करी नहीं है। यहाँ a blog post on the difference से एक उद्धरण है:

कहाँ आंशिक आवेदन एक समारोह लेता है और से यह एक समारोह जो कम तर्क लेता है बनाता है, currying कार्य करता है जो कार्य करता है जो प्रत्येक एक भी तर्क ले की संरचना द्वारा कई तर्क ले बनाता है।

var fr = partial(f, 1, 2, 3); 

// now, when you invoke fr() it will invoke f(1,2,3) 
fr(); 

फिर, जानकारी के लिए इस सवाल का देखें:

यह पहले से ही उत्तर दिया गया है, आपके उत्तर के लिए इस सवाल का देखें: How can I pre-set arguments in JavaScript function call?

उदाहरण।

Answer 2

निम्नलिखित अपने दूसरे कोड ब्लॉक के बराबर है:

function fiz(x, y, z) { 
    return x + y + z; 
} 

// elsewhere... 

function foo(fn, p, q, r) { 
    return function() { 
     return fn(p, q, r); 
    } 
} 

// finally... 

f = foo(fiz, 1, 2, 3); 
f(); // returns 6 

:

var f = function() { 
     //Some logic here... 
    }; 

var fr = f; 

fr(pars); 

आप वास्तव में कुछ अन्य कार्य करने के लिए एक समारोह के लिए एक संदर्भ पास करना चाहते हैं, तो आप कुछ इस तरह कर सकते हैं

हालांकि, इस तरह की चीज़ के लिए आप ढांचे का उपयोग करके लगभग निश्चित रूप से बेहतर हैं।

Answer 3

तुम भी समारोह प्रोटोटाइप ओवरलोड कर सकते हैं:

// partially applies the specified arguments to a function, returning a new function 
Function.prototype.curry = function() { 
    var func = this; 
    var slice = Array.prototype.slice; 
    var appliedArgs = slice.call(arguments, 0); 

    return function() { 
     var leftoverArgs = slice.call(arguments, 0); 
     return func.apply(this, appliedArgs.concat(leftoverArgs)); 
    }; 
}; 

// can do other fancy things: 

// flips the first two arguments of a function 
Function.prototype.flip = function() { 
    var func = this; 
    return function() { 
     var first = arguments[0]; 
     var second = arguments[1]; 
     var rest = Array.prototype.slice.call(arguments, 2); 
     var newArgs = [second, first].concat(rest); 

     return func.apply(this, newArgs); 
    }; 
}; 

/* 
e.g. 

var foo = function(a, b, c, d) { console.log(a, b, c, d); } 
var iAmA = foo.curry("I", "am", "a"); 
iAmA("Donkey"); 
-> I am a Donkey 

var bah = foo.flip(); 
bah(1, 2, 3, 4); 
-> 2 1 3 4 
*/