当函数通常不需要任何参数时，试图理解 node.js 回调？

Question

I am trying to work with node.js and node-java and trying to get my head wrapped around some concepts, and in particular how to write async method calls.

I think that, for a function in Java, myclass.x():

[In Java]:

Z = myclass.x(abc);

And:

[In node.js/node-java]:

myclass.x(abc, function(err,data) {
//TODO
Z = data;});

In other words, the myclass.x function gets evaluated using the parameter abc, and if no error, then the result goes into "data" which is then assigned to Z.

Is that correct?

Here's the thing (or one of the things) that I am confused about.

What happens if the function myclass.x() doesn't take any parameters?

In other words, it is normally (in Java) just called like:

Z = myclass.x();

If that is the case, how should the node.js code look?

myclass.x(, function(err,data) {
//TODO
Z = data;});

doesn't seem right, but:

myclass.x( function(err,data) {
//TODO
Z = data;});

also doesn't seem correct.

So what is the correct way to code the node.js code in this case?

Thanks in advance!!

Jim

EDIT 1: Per comments, I'm adding the specific code I'm working with is the last couple of commented out lines from this other question at:

node.js and node-java: What is equivalent node.js code for this java code?

These are the lines (commented out in that other question):

var MyFactoryImplClass = java.import("oracle.security.jps.openaz.pep.PepRequestFactoryImpl.PepRequestFactoryImpl");

var result = myFactoryImplClass.newPepRequest(newSubject, requestACTIONString ,requestRESOURCEString , envBuilt)

I tried to make the last line use an async call:

MyFactoryImplClass.getPepRequestFactory( function(err,data) {
    //TODO
    pepReqF1=data;})
javaLangSystem.out.printlnSync("Finished doing MyFactoryImplClass.getPepRequestFactory() and stored it in pepReqF1 =[" + pepReqF1 + "]");

But the output was showing the value of that pepReqF1 as "undefined".

Answer 1

If calling the method with one parameter and a callback is:

myclass.x(abc, function(err, data) {
  // ...
});

Then calling a method with only a callback would be:

myclass.x(function(err, data) {
  // ...
});

The function(err, data) { } part is just a normal parameter just like abc . In fact, you can pass a named function with:

function namedFun(err, data) {
  // ...
}
myclass.x(abc, namedFun);

Or even:

var namedFun = function (err, data) {
  // ...
}
myclass.x(abc, namedFun);

Functions in JavaScript are first-class objects like strings or arrays. You can pass a named function as a parameter to some other function:

function fun1(f) {
  return f(10);
}
function fun2(x) {
  return x*x;
}
fun1(fun2);

just like you can pass a named array:

function fun3(a) {
  return a[0]
}
var array = [1, 2, 3];
fun3(array);

And you can pass an anonymous function as a parameter:

function fun1(f) {
  return f(10);
}
fun1(function (x) {
  return x*x;
});

just like you can pass an anonymous array:

function fun3(a) {
  return a[0]
}
fun3([1, 2, 3]);

There is also a nice shortcut so that instead of:

fun1(function (x) {
  return x*x;
});

You can write:

fun1(x => x*x);

Answer 2

Making my comment into an answer...

If the issue you're experiencing is that Z does not have the value you want when you are examining it, then that is probably because of a timing issue. Asynchronous callbacks happen at some unknown time in the future while the rest of your code continues to run. Because of that, the only place you can reliably use the result passed to the asynchronous callback is inside the callback itself or in some function you would call from that function and pass it the value.

So, if your .x() method calls it's callback asynchronously, then:

var Z;
myclass.x( function(err,data) {
    // use the err and data arguments here inside the callback
    Z = data;
});

console.log(Z);    // outputs undefined

// you can't access Z here.  Even when assigned 
// to higher scoped variables because the callback has not yet
// been called when this code executes

You can see this is a little more clearly by understanding the sequencing

console.log('A');
someAsyncFucntion(function() {
    console.log('B');
})
console.log('C');

This will produce a log of:

A
C
B

Showing you that the async callback happens some time in the future, after the rest of your sequential code has executed.

---

Java, on the other hand, primarily uses blocking I/O (the function doesn't return until the I/O operation is copmlete) so you don't usually have this asynchronous behavior that is standard practice in node.js. Note: I believe there are some asynchronous capabilities in Java, but that isn't the typical way things are done and in node.js, it is the typical ways things are done.

This creates a bit of an architectural mismatch if you're trying to port code that uses I/O from environment from another because the structure has to be redone in order to work properly in a node.js environment.