JavaScript: przekazywanie parametrów do funkcji zwrotnej

To również zadziała:

// callback function
function tryMe (param1, param2) { 
    alert (param1 + " and " + param2); 
} 

// callback executer 
function callbackTester (callback) { 
    callback(); 
} 

// test function
callbackTester (function() {
    tryMe("hello", "goodbye"); 
}); 

Inny Scenariusz:

// callback function
function tryMe (param1, param2, param3) { 
    alert (param1 + " and " + param2 + " " + param3); 
} 

// callback executer 
function callbackTester (callback) { 
//this is the more obivous scenario as we use callback function
//only when we have some missing value
//get this data from ajax or compute
var extraParam = "this data was missing" ;

//call the callback when we have the data
    callback(extraParam); 
} 

// test function
callbackTester (function(k) {
    tryMe("hello", "goodbye", k); 
}); 

Twoje pytanie jest niejasne. Jeśli pytasz, jak możesz to zrobić w prostszy sposób, powinieneś przyjrzeć się metodzie ECMAScript 5th edition .bind () , który jest członkiem funkcji .prototyp . Używając go, możesz zrobić coś takiego:

function tryMe (param1, param2) {
    alert (param1 + " and " + param2);
}

function callbackTester (callback) {
    callback();
}

callbackTester(tryMe.bind(null, "hello", "goodbye"));

Możesz również użyć następującego kodu, który dodaje metodę, jeśli nie jest dostępna w bieżącej przeglądarce:

// From Prototype.js
if (!Function.prototype.bind) { // check if native implementation available
  Function.prototype.bind = function(){ 
    var fn = this, args = Array.prototype.slice.call(arguments),
        object = args.shift(); 
    return function(){ 
      return fn.apply(object, 
        args.concat(Array.prototype.slice.call(arguments))); 
    }; 
  };
}

Przykład

bind () - PrototypeJS Documentation

Gdy masz callback, który będzie wywoływany przez coś innego niż kod z określoną liczbą param i chcesz przekazać dodatkowe param, możesz przekazać funkcję owijarki jako wywołanie zwrotne i wewnątrz owijarki przekazać dodatkowe param(y).

function login(accessedViaPopup) {
    //pass FB.login a call back function wrapper that will accept the
    //response param and then call my "real" callback with the additional param
    FB.login(function(response){
        fb_login_callback(response,accessedViaPopup);
    });
}

//handles respone from fb login call
function fb_login_callback(response, accessedViaPopup) {
    //do stuff
}

Owijanie funkcji ' potomnych 'przekazywanych jako/z argumentami w pakietach funkcji, aby zapobiec ich ocenie podczas wywoływania funkcji' rodzica'.

function outcome(){
    return false;
}

function process(callbackSuccess, callbackFailure){
    if ( outcome() )
        callbackSuccess();
    else
        callbackFailure();
}

process(function(){alert("OKAY");},function(){alert("OOPS");})

Kod z pytania z dowolną liczbą parametrów i kontekstem wywołania zwrotnego:

function SomeFunction(name) {
    this.name = name;
}
function tryMe(param1, param2) {
    console.log(this.name + ":  " + param1 + " and " + param2);
}
function tryMeMore(param1, param2, param3) {
    console.log(this.name + ": " + param1 + " and " + param2 + " and even " + param3);
}
function callbackTester(callback, callbackContext) {
    callback.apply(callbackContext, Array.prototype.splice.call(arguments, 2));
}
callbackTester(tryMe, new SomeFunction("context1"), "hello", "goodbye");
callbackTester(tryMeMore, new SomeFunction("context2"), "hello", "goodbye", "hasta la vista");

// context1: hello and goodbye
// context2: hello and goodbye and even hasta la vista

Użyj funkcji Curry, jak w tym prostym przykładzie.

const BTN = document.querySelector('button')
const RES = document.querySelector('p')

const changeText = newText => () => {
  RES.textContent = newText
}

BTN.addEventListener('click', changeText('Clicked!'))

<button>ClickMe</button>
<p>Not clicked<p>

Jeśli nie jesteś pewien, ile paramów zostaną przekazane do funkcji callback. Za pomocą zastosuj.

function tryMe (param1, param2) {
  alert (param1 + " and " + param2);
}

function callbackTester(callback,params){
    callback.apply(this,params);
}

callbackTester(tryMe,['hello','goodbye']);

Nowa wersja dla scenariusza, w którym callback zostanie wywołany przez inną funkcję, a nie własny kod, i chcesz dodać dodatkowe parametry.

Na przykład, załóżmy, że masz wiele zagnieżdżonych wywołań z powodzeniem i błędami wywołania zwrotne. Użyję angular promises w tym przykładzie, ale każdy kod javascript z wywołaniami zwrotnymi byłby taki sam w tym celu.

someObject.doSomething(param1, function(result1) {
  console.log("Got result from doSomething: " + result1);
  result.doSomethingElse(param2, function(result2) {
    console.log("Got result from doSomethingElse: " + result2);
  }, function(error2) {
    console.log("Got error from doSomethingElse: " + error2);
  });
}, function(error1) {
  console.log("Got error from doSomething: " + error1);
});

Teraz możesz odłączyć kod, definiując funkcję do logowania błędów, zachowując pochodzenie błędu do celów debugowania. W ten sposób postępujesz do refaktoryzacji kodu:

someObject.doSomething(param1, function (result1) {
  console.log("Got result from doSomething: " + result1);
  result.doSomethingElse(param2, function (result2) {
    console.log("Got result from doSomethingElse: " + result2);
  }, handleError.bind(null, "doSomethingElse"));
}, handleError.bind(null, "doSomething"));

/*
 * Log errors, capturing the error of a callback and prepending an id
 */
var handleError = function (id, error) {
  var id = id || "";
  console.log("Got error from " + id + ": " + error);
};

Funkcja wywołująca nadal będzie dodawać parametr błędu po parametrach funkcji zwrotnej.

Szukałem tego samego i znalazłem rozwiązanie. Oto prosty przykład, jeśli ktoś chce przez to przejść.

var FA = function(data){
   console.log("IN A:"+data)
   FC(data,"LastName");
};
var FC = function(data,d2){
   console.log("IN C:"+data,d2)
};
var FB = function(data){
   console.log("IN B:"+data);
    FA(data)
};
FB('FirstName')

Również napisał na inne pytanie tutaj