Как передать функцию в качестве параметра без функции, выполняемой в "родительской" функции или с помощью eval()? (Поскольку я читал, что это небезопасно.)
У меня есть это:
addContact(entityId, refreshContactList());
Это работает, но проблема в том, что refreshContactList срабатывает, когда вызывается функция, а не когда она используется в функции.
Я мог бы обойти это, используя eval(), но это не лучшая практика, согласно тому, что я прочитал. Как передать функцию в качестве параметра в JavaScript?
Вам просто нужно удалить скобки:
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);
Если вы хотите передать функцию, просто ссылайтесь на нее по имени без круглых скобок:
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 и иметь третий параметр, который является массивом аргументов, например:
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"]);
Пример 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 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);
Есть фраза среди программистов JavaScript: "Eval is Evil", поэтому старайтесь избегать этого любой ценой!
В дополнение к ответу Стива Фентона вы также можете передавать функции напрямую.
function addContact(entity, refreshFn) {
refreshFn();
}
function callAddContact() {
addContact("entity", function() { DoThis(); });
}
Я предлагаю поместить параметры в массив, а затем разделить их с помощью функции .apply(). Итак, теперь мы можем легко передать функцию с большим количеством параметров и выполнить ее простым способом.
function addContact(parameters, refreshCallback) {
refreshCallback.apply(this, parameters);
}
function refreshContactList(int, int, string) {
alert(int + int);
console.log(string);
}
addContact([1,2,"str"], refreshContactList); //parameters should be putted in an array
Я отрубил все мои волосы этой проблемой. Я не мог сделать вышеприведенные примеры, поэтому я закончил так:
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')");
И это работает как шарм... по крайней мере. Надеюсь, это может помочь кому-то.
Вы также можете использовать 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");
Что это. Я также искал это решение и пробовал решения, предоставленные в других ответах, но, наконец, получил его работу из приведенного выше примера.
Здесь это другой подход:
function a(first,second)
{
return (second)(first);
}
a('Hello',function(e){alert(e+ ' world!');}); //=> Hello world
На самом деле, кажется, немного сложнее, нет.
Получить метод как параметр:
function JS_method(_callBack) {
_callBack("called");
}
Вы можете указать как метод параметра:
JS_method(function (d) {
//Finally this will work.
alert(d)
});
Другие ответы выполняют отличную работу, описывая, что происходит, но одна важная "гоча" заключается в том, чтобы убедиться, что все, что вы проходите, действительно является ссылкой на функцию.
Например, если вы передадите строку вместо функции, вы получите сообщение об ошибке:
function function1(my_function_parameter){
my_function_parameter();
}
function function2(){
alert('Hello world');
}
function1(function2); //This will work
function1("function2"); //This breaks!
См. JsFiddle
Вы также можете использовать JSON для хранения и отправки функций JS.
Проверьте следующее:
var myJSON =
{
"myFunc1" : function (){
alert("a");
},
"myFunc2" : function (functionParameter){
functionParameter();
}
}
function main(){
myJSON.myFunc2(myJSON.myFunc1);
}
Это напечатает 'a'.
Следующее имеет тот же эффект, что и выше:
var myFunc1 = function (){
alert('a');
}
var myFunc2 = function (functionParameter){
functionParameter();
}
function main(){
myFunc2(myFunc1);
}
Что также имеет тот же эффект при следующем:
function myFunc1(){
alert('a');
}
function myFunc2 (functionParameter){
functionParameter();
}
function main(){
myFunc2(myFunc1);
}
И парадигма объекта с использованием класса как прототипа объекта:
function Class(){
this.myFunc1 = function(msg){
alert(msg);
}
this.myFunc2 = function(callBackParameter){
callBackParameter('message');
}
}
function main(){
var myClass = new Class();
myClass.myFunc2(myClass.myFunc1);
}