pass function as parameter javascript

stackoverflow.com › questions › 13286233 › pass-a-javascript-function-as-parameter

You just need to remove the parenthesis:

addContact(entityId, refreshContactList);

This then passes the function without executing it first.

Here is an example:

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

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

addContact(1, refreshContactList);

You can also pass anonymous functions:

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

addContact(1, () => alert('hello world'));

Answer from Fenton on Stack Overflow

Stack Overflow

stackoverflow.com › questions › 13286233 › pass-a-javascript-function-as-parameter

Pass a JavaScript function as parameter - Stack Overflow

Top answer

1 of 16

1205

You just need to remove the parenthesis:

addContact(entityId, refreshContactList);

This then passes the function without executing it first.

Here is an example:

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

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

addContact(1, refreshContactList);

You can also pass anonymous functions:

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

addContact(1, () => alert('hello world'));

2 of 16

560

If you want to pass a function, just reference it by name without the parentheses:

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

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

But sometimes you might want to pass a function with arguments included, but not have it called until the callback is invoked. To do this, when calling it, just wrap it in an anonymous function, like this:

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

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

If you prefer, you could also use the apply function and have a third parameter that is an array of the arguments, like such:

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"]);

reddit.com › r/learnjavascript › why is passing a function as a parameter a necessity in callback functions instead of just simply executing inside a function?

r/learnjavascript on Reddit: Why is passing a function as a parameter a necessity in callback functions instead of just simply executing inside a function?

July 19, 2023 - If you find yourself writing a function that only ever calls one specific callback function, then you probably don't need to pass it's reference as a parameter. For example, say you have a button that when a user clicks it should alert "Hello World" to the window.

Discussions

Basic JavaScript - Passing Values to Functions with Arguments - c49z7uqSwAiXrPuLhIIeT

Tell us what’s happening: Describe your issue in detail here. Im trying to understand how this is wrong when im doing it the way it was explained. Even after viewing the video i can see i did it the same way and im still wrong. Please help if anyone can? **Your code so far** function ... More on forum.freecodecamp.org

forum.freecodecamp.org

0

July 11, 2022

Can someone explain how to pass a function as an argument to another function in JS and show me a code example? I only know OOP and find it really confusing to do this.

This defines a function that doubles a number. function double (x) { return x * 2 } When this code is executed, a variable called double is created in the current scope and assigned the value of a function that when called, multiples 2 by its input and returns the result. To call a function, you can use parentheses (()). When placed at the end of a variable referring to a function, it invokes that function running the code inside. Any values inside the parentheses are passed into the function as inputs (in this case one, the x parameter) and anything the function returns is passed back to the point in the code at which the function was called. const result = double(3) // 3 becomes x in the function console.log(result) // logs: 6 If you refer to a function by its variable name without using parentheses, you'll get a reference to the function without calling it. This reference can be passed around just like any other value assigned to a variable. const alsoDouble = double // doesn't call, rather assigns double function to alsoDouble variable Any variable referring to a function can be called as a function. alsoDouble(3) // 6 Because functions can be treated just like any other variable, they can also be passed into functions as function arguments. In the examples so far, the value 3 was passed into the function where it became x inside the function. The same can be done with function values. This function takes two inputs, an array and a function. The function then calls the function it was passed on every value of the array allowing it (the callback) to change its value. function transform(array, callback) { for (let i = 0; i < array.length; i++) { const result = callback(array[i]) // calls the callback function passed to transform array[i] = result // assign back to array, transforming its value } } Using double with transform can allow us to double all the values in an array. const bets = [1, 5, 20] transform(bets, double) console.log(bets) // [2, 10, 40] callback inside transform acts just like alsoDouble from earlier - another variable holding the same function value as double only here the assignment is handled through a function call where it assigned a parameter variable (callback) to an argument (double) that the function was given when it was called. Because functions can be defined as expressions, you can also skip creating a variable before passing a function into another function. Instead, where you would have the variable of the function in the function call you can put the function definition directly. const bets = [1, 5, 20] transform(bets, function triple (x) { return x * 3 }) console.log(bets) // [3, 15, 60] Arrow functions provide a much shorter syntax for doing the same thing which are often preferred in this case const bets = [1, 5, 20] transform(bets, x => x * 3) console.log(bets) // [3, 15, 60] Most of the time, when using callbacks you're simply supplying the callback function and not defining the function using the callback. Common places where you'd be doing this include: // event listeners myButton.addEventListener('click', event => { alert("You just clicked my button!") }) // promises fetch(myUrl) .then(res => res.text()) .then(text => { myLoadedTextDiv.textContent = text }) // setTimeout setTimeout(() => { myButton.disabled = true myMessageDiv.textContent = "Too slow!" }, 5000) // array methods const myGrades = [100, 75, 80] const myGradesWithExtraCredit = myGrades.map(grade => { return grade + 5 }) console.log(myGradesWithExtraCredit) // [105, 80, 85] How the callback is called in all of these examples are built-in to those APIs. You don't see that. All you do is provide the function and it performs the call. More on reddit.com

r/learnjavascript

54

1

March 20, 2021

Why is passing a function as a parameter a necessity in callback functions instead of just simply executing inside a function?

If I'm understanding your question right, one reason it's done in order to write DRY code. If you find yourself writing a function that only ever calls one specific callback function, then you probably don't need to pass it's reference as a parameter. For example, say you have a button that when a user clicks it should alert "Hello World" to the window. const clickHandler = (callback) => { callback("Hello World"); } ... Somewhere in html Click me This is a pointless use of a callback. The button will do the same thing every single time so you could simply call console alert inside of the click handler. HOWEVER when things start to become more complicated, passing a reference of one function for another to call is a great way to make your code more flexible. Like maybe you have a bunch of buttons that you want to do different things. Maybe one of them alerts, one console.logs, one evaluates it's boolean statement and so on. Instead of having a bunch of different click handlers to handle those events, you can use the same handler and pass a different callback function const clickHandler = (callback) => { callback("Hello World"); } ... Somewhere in html Click me Click me Click me Click me Without callbacks you'd need a bunch of unique clickHandler functions for each button. In this button case that wouldn't be such a big deal, but when you're working on a real, complicated application, this level of abstraction saves a lot of development time and makes it very easy to modify your programs. More on reddit.com

r/learnjavascript

23

13

July 19, 2023

Pass Class as parameter that extends another class

If you want a class type (and not an instance of the class), you can use:

const foo = <T: {new(): Bar}>( baz: T )

This will accept derived classes too, as their constructors also produce something that can cast to Bar.

Videos

03:33

YouTube

Passing Functions as Arguments to Other Functions in JavaScript ...

February 9, 2024

15