javascript - पैरामीटर के रूप में एक जावास्क्रिप्ट फ़ंक्शन पास करें




function parameters (9)

अन्य उत्तर एक उत्कृष्ट काम करते हैं जो वर्णन कर रहा है कि क्या हो रहा है, लेकिन एक महत्वपूर्ण "गॉचाचा" यह सुनिश्चित करना है कि जो कुछ भी आप पारित करते हैं वह वास्तव में किसी फ़ंक्शन का संदर्भ है।

उदाहरण के लिए, यदि आप किसी फ़ंक्शन के बजाय स्ट्रिंग से गुज़रते हैं तो आपको एक त्रुटि मिल जाएगी:

function function1(my_function_parameter){
    my_function_parameter();   
}

function function2(){
 alert('Hello world');   
}

function1(function2); //This will work

function1("function2"); //This breaks!

JsFiddle देखें

मैं "पैरेंट" फ़ंक्शन में निष्पादित फ़ंक्शन या eval() का उपयोग किए बिना फ़ंक्शन के रूप में फ़ंक्शन को कैसे पास करूं? (चूंकि मैंने पढ़ा है कि यह असुरक्षित है।)

मेरे पास यह है:

addContact(entityId, refreshContactList());

यह काम करता है, लेकिन समस्या यह है कि refreshContactList जब फ़ंक्शन को कॉल किया जाता है, तो फ़ंक्शन में उपयोग किए जाने के बजाए फ़ंक्शन को कॉल किया जाता है।

मैं eval() का उपयोग कर इसके आसपास हो सकता है, लेकिन मैंने जो पढ़ा है उसके अनुसार यह सबसे अच्छा अभ्यास नहीं है। जावास्क्रिप्ट में पैरामीटर के रूप में मैं फ़ंक्शन कैसे पास कर सकता हूं?


आप एक ही काम करने के लिए eval() का भी उपयोग कर सकते हैं।

//A function to call
function needToBeCalled(p1, p2)
{
    alert(p1+"="+p2);
}

//A function where needToBeCalled passed as an argument with necessary params
//Here params is comma separated string
function callAnotherFunction(aFunction, params)
{
    eval(aFunction + "("+params+")");
}

//A function Call
callAnotherFunction("needToBeCalled", "10,20");

बस। मैं इस समाधान की भी तलाश कर रहा था और अन्य उत्तरों में दिए गए समाधानों का प्रयास किया लेकिन आखिर में यह उपर्युक्त उदाहरण से काम कर रहा था।


आपको केवल कोष्ठक को हटाने की आवश्यकता है:

addContact(entityId, refreshContactList);

यह फिर इसे निष्पादित किए बिना फ़ंक्शन को पास करता है।

यहाँ एक उदाहरण है:

function addContact(id, refreshCallback) {
    refreshCallback();
    // You can also pass arguments if you need to
    // refreshCallback(id);
}

function refreshContactList() {
    alert('Hello World');
}

addContact(1, refreshContactList);

उदाहरण 1:

funct("z", function (x) { return x; });

function funct(a, foo){
    foo(a) // this will return a
}

उदाहरण 2:

function foodemo(value){
    return 'hello '+value;
}

function funct(a, foo){
    alert(foo(a));
}

//call funct    
funct('world!',foodemo); //=> 'hello world!'

इसे देखो


जावास्क्रिप्ट प्रोग्रामर के बीच एक वाक्यांश है: "इवल इविल है" तो इसे हर कीमत से बचने की कोशिश करें!

स्टीव फेंटन के जवाब के अलावा, आप सीधे कार्यों को भी पारित कर सकते हैं।

function addContact(entity, refreshFn) {
    refreshFn();
}

function callAddContact() {
    addContact("entity", function() { DoThis(); });
}

फ़ंक्शन को पैरामीटर के रूप में पास करने के लिए, बस ब्रैकेट को हटा दें!

function ToBeCalled(){
  alert("I was called");
}

function iNeedParameter( paramFunc) {
   //it is a good idea to check if the parameter is actually not null
   //and that it is a function
   if (paramFunc && (typeof paramFunc == "function")) {
      paramFunc();   
   }
}

//this calls iNeedParameter and sends the other function to it
iNeedParameter(ToBeCalled); 

इसके पीछे विचार यह है कि एक समारोह एक चर के समान है। लिखने के बजाय

function ToBeCalled() { /* something */ }

आप भी लिख सकते हैं

var ToBeCalledVariable = function () { /* something */ }

दोनों के बीच मामूली मतभेद हैं, लेकिन वैसे भी - दोनों कार्य को परिभाषित करने के वैध तरीके हैं। अब, यदि आप किसी फ़ंक्शन को परिभाषित करते हैं और इसे एक चर के लिए स्पष्ट रूप से असाइन करते हैं, तो यह काफी तार्किक लगता है, कि आप इसे किसी अन्य फ़ंक्शन पर पैरामीटर के रूप में पास कर सकते हैं, और आपको ब्रैकेट की आवश्यकता नहीं है:

anotherFunction(ToBeCalledVariable);

मैंने उस मुद्दे के साथ अपने सभी बालों को तोड़ दिया। मैं उपरोक्त उदाहरणों को काम नहीं कर सका, इसलिए मैंने इस तरह समाप्त किया:

function foo(blabla){
    var func = new Function(blabla);
    func();
}
// to call it, I just pass the js function I wanted as a string in the new one...
foo("alert('test')");

और यह एक आकर्षण की तरह काम कर रहा है ... जिसके लिए मुझे कम से कम आवश्यकता थी। उम्मीद है कि यह कुछ मदद कर सकता है।


यदि आप कोई फ़ंक्शन पास करना चाहते हैं, तो इसे बिना किसी नाम के नाम से संदर्भित करें:

function foo(x) {
    alert(x);
}
function bar(func) {
    func("Hello World!");
}

//alerts "Hello World!"
bar(foo);

लेकिन कभी-कभी आप तर्कों के साथ एक फ़ंक्शन पास करना चाह सकते हैं, लेकिन जब तक कॉलबैक लागू नहीं किया जाता है तब तक इसे कॉल नहीं किया जाता है। ऐसा करने के लिए, इसे कॉल करते समय, इसे किसी अज्ञात फ़ंक्शन में लपेटें, जैसे:

function foo(x) {
   alert(x);
}
function bar(func) {
   func();
}

//alerts "Hello World!" (from within bar AFTER being passed)
bar(function(){ foo("Hello World!") });

यदि आप चाहें, तो आप apply फ़ंक्शन का भी उपयोग कर apply हैं और एक तीसरा पैरामीटर है जो तर्कों की एक सरणी है, जैसे:

function eat(food1, food2)
{
    alert("I like to eat " + food1 + " and " + food2 );
}
function myFunc(callback, args)
{
    //do stuff
    //...
    //execute callback when finished
    callback.apply(this, args);
}

//alerts "I like to eat pickles and peanut butter"
myFunc(eat, ["pickles", "peanut butter"]); 

वास्तव में, थोड़ा जटिल लगता है, नहीं है।

पैरामीटर के रूप में विधि प्राप्त करें:

 function JS_method(_callBack) { 

           _callBack("called");  

        }

आप पैरामीटर विधि के रूप में दे सकते हैं:

    JS_method(function (d) {
           //Finally this will work.
           alert(d)
    });





parameters