JavaScript: Übergabe von Parametern an eine Callback-Funktion

Question

Ich versuche, einen Parameter an eine Funktion als Rückruf übergeben, wie kann ich das tun?

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

function callbackTester (callback, param1, param2) { 
    callback (param1, param2); 
} 

callbackTester (tryMe, "hello", "goodbye"); 

Answer 1

Wenn Sie etwas etwas allgemeinere möchten, können Sie die Argumente verwenden Variable wie so:

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

function callbackTester (callback) { 
    callback (arguments[1], arguments[2]); 
} 

callbackTester (tryMe, "hello", "goodbye"); 

Aber ansonsten Ihr Beispiel funktioniert gut (Argumente [0] kann anstelle von Callback verwendet werden im Tester)

Answer 2

Ihre Frage ist unklar. Wenn Sie sich fragen, wie Sie das einfacher machen können, sollten Sie sich die ECMAScript 5th Edition-Methode .bind() ansehen, die ein Mitglied von Function.prototype ist. Mit ihm können Sie etwas tun:

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

function callbackTester (callback) { 
    callback(); 
} 

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

Sie können auch den folgenden Code verwenden, die das Verfahren ergänzt, wenn es nicht in dem aktuellen Browser:

// 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))); 
    }; 
    }; 
} 

Example

bind() - PrototypeJS Documentation

Answer 3

Dies würde auch:

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

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

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

Ein weiteres Szenario:

// 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); 
}); 

Answer 4

Wenn Sie einen Rückruf haben, die durch etwas anderes als Ihren Code mit einer bestimmten Anzahl von params und möchten Sie weitergeben können in zusätzlichen params passieren genannt wird Wrapper-Funktion als Callback und innerhalb des Wrappers übergeben die zusätzlichen Param (s).

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 
} 

Answer 5

Wickeln Sie das ‚Kind‘ Funktion (en) als/mit Argumenten in Funktion Wrapper übergeben werden, damit sie nicht ausgewertet werden, wenn die ‚Eltern‘ Funktion aufgerufen wird.

function outcome(){ 
    return false; 
} 

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

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

Answer 6

-Code aus einer Frage mit einem beliebigen Anzahl von Parametern und einem Callback-Kontext:

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 

Answer 7

Eine neue Version für das Szenario, in dem der Rückruf wird durch eine andere Funktion aufgerufen wird, nicht Ihren eigenen Code, und Sie möchten zusätzliche Parameter hinzufügen.

Zum Beispiel, täuschen wir vor, dass Sie viele geschachtelte Aufrufe mit Erfolg und Fehler Callbacks haben. Ich werde eckige Versprechungen für dieses Beispiel verwenden, aber jeder Javascript-Code mit Rückrufen wäre für diesen Zweck derselbe.

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); 
}); 

Jetzt können Sie Ihren Code unclutter durch eine Funktion definieren, Fehler zu protokollieren, für Debugging-Zwecke, den Ursprung des Fehlers zu halten.Dies ist, wie würden Sie gehen Ihren Code Refactoring:

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); 
}; 

Die Aufruffunktion wird immer noch die Fehlerparameter nach dem Callback-Funktion Parameter hinzuzufügen.

Answer 8

Ich war auf der Suche nach der gleichen Sache und am Ende mit der Lösung und hier ist es ein einfaches Beispiel, wenn jemand dies durchmachen will.

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') 

Auch auf der anderen Frage here

posted

Answer 9

Verwenden curried Funktion wie in diesem einfachen Beispiel.

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>