Javascript 中 function arguments 的隐式传递是如何工作的？

Question

I am originally coming from Java programming language as background. Java is strongly typed and quite explicit (I mean by that, you have to write things out, you can't just omit them). One thing, that will never get in my head is how that implicit parameter passing to javascript works...

as an example:

const observer = {
    next: console.log,
    error: console.error,
    test: console.table,
}

observer.next('HI World!')

in next, I specify console.log which is a function, but I never say to accept a value, but in Javascript I apparently can just throw anything to functions as suffix and it takes that as an argument to its function. Thats also how pipelining or currying basically works, it takes the remaining return values as parameters..why is that so?

Secondly, eg in express, I have a function signature like so:

app.get('/', function (req, res) {
  res.send('GET request to the homepage');
});

I actually get req and res out of my function callback is that right? those are not parameters that I pass to my callback function?

Edit : Can someone explain to me again where the REQ and RES parameters are coming from? How does that construct work? Because I am defining the callback function myself, but instead of passing req and res as parameters to my callback, it seems they get passed from somewhere back to inside my callback function???!

Answer 1

A function in JavaScript is an object just like any other. This means a function can be passed around, can be assigned to variables, and essentially can be used anywhere a value can be used. This is known as first-class functions .

For example, given a simple function like this one:

function log(msg) {
  console.log(msg);
}

These two functions are conceptually equivalent:

const log1 = log;

// same as

function log1(msg) {
  log(msg);
}

As you can see, we can directly assign the function log to a variable like log1 , ,and then we can use log1 just like we use log :

log1('foobar');

Another usage of first-class functions is to be able to pass them as arguments to other functions. A function that takes a callback like in your Express example is known as a higher-order function . The arguments of the callback are provided by the caller of that callback. In your case Express provides the req and res arguments.

Using callbacks is a form of inversion of control . You are passing control of that part of the program to the caller.