blocks|key|881539|text|你不能打你的电话。回调只是作为函数的参数给出的普通函数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|881540|您的代码不调用回调。您正在尝试为回调设置一个值。修正了s1.js的版本：|881541|module.exports.test=function+test(msg,result){
++++result(null,+"Hello+"%2Bmsg);
++++console.log("Inside+s1.js+-+"%2Bresult);
};|code-block|syntax|javascript|881542|这样你就可以叫回电话了。我们需要传入null，因为您已经将回调函数定义为function(err,+result)。它有两个参数，第一个参数是err，我们没有运行错误，所以我们只传递null。|offset|length|style|CODE|881543|entityMap^0|0|0|0|I|4|10|L|1Z|3|2J|4|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|T|8|@$K|U|L|V|M|N]|$K|W|L|X|M|N]|$K|Y|L|Z|M|N]|$K|10|L|11|M|N]]|9|@]|A|$]]|$1|O|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|P|$]]

You are not calling your callback. Callbacks are just normal functions that are just given as parameter for the function.

Your code doesn't call the callback. You are trying to set a value to the callback. Fixed version of the s1.js:

<pre><code>module.exports.test=function test(msg,result){
 result(null, "Hello "+msg);
 console.log("Inside s1.js - "+result);
};
</code></pre>

That way you are calling the callback. We need to pass in the <code>null</code> as you have defined the callback function as <code>function(err, result)</code>. It has two parameters and the first one is <code>err</code> we didn't run in to errors so we just pass in <code>null</code>.

blocks|key|881565|text|请尝试下面的s1.js示例，代码是不言自明的，如果您还需要帮助，请告诉我。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|881566|var+defaultValues+=+module.exports

defaultValues.GetApiURL+=+function+()+{
++++var+apiURL+=+"http://localhost:1000/api/"
++++return+apiURL;
}|code-block|syntax|javascript|881567|entityMap^0|6|5|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

Please try below example for s1.js, the code is self explanatory, let me know if you still need help.

<pre><code>var defaultValues = module.exports

defaultValues.GetApiURL = function () {
 var apiURL = "http://localhost:1000/api/"
 return apiURL;
}
</code></pre>

blocks|key|2052294|text|前面的答案是正确的，但您的问题与nodejs或module.exports无关，但问题是您还不了解JavaScript+(以及PHP和其他语言)中使用的回调的性质。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2052295|您使用的示例实际上使这种差异更难理解。下面是关于如何理解回调的一步一步的描述，首先是简单的语句，最后是类似于您的代码。|2052296|//+Create+some+object
var+fooBar+=+{+foo:+'foo+object'};

//+Add+a+bar+function+to+that+object
fooBar.bar+=+function+(param1,+param2)+{
++++console.log("Inside+bar+function:+"+%2B+param1);
};|code-block|syntax|javascript|2052297|在创建对象并将函数添加到该对象时，运行此代码不会记录任何内容，但该函数永远不会被调用。|2052298|为此，我们需要向该函数添加一个调用：|2052299|fooBar.bar('test+1');|2052300|现在我们得到输出：|2052301|Inside+bar+function:+test+1|2052302|或者我们可以调用该函数两次：|2052303|fooBar.bar('test+1');
fooBar.bar('test+2');|2052304|2052305|Inside+bar+function:+test+1
Inside+bar+function:+test+2|2052306|下一步是创建一个类似于您在调用s1.test()时使用的第二个参数的函数。但是，我们没有将它赋值给那个参数，而是将它赋值给另一个变量。|offset|length|style|CODE|2052307|//+Create+some+object
var+fooBar+=+{+foo:+'foo+object'};

//+Add+a+bar+function+to+that+object
fooBar.bar+=+function+(param1,+param2)+{
++++console.log("Inside+bar+function:+"+%2B+param1);
};

//+Create+assign+a+function+to+a+variable
var+func+=+function+(err,+result)+{
++++console.log("Inside+func+function,+call+using:+"+%2B+err+%2B+"+and+"+%2B+result);++++
}+++

fooBar.bar('test+1');
fooBar.bar('test+2');|2052308|我们将函数赋值给变量func。func只是另一个变量，其类型为function。JavaScript中的回调只是一个具有function类型的变量。要查看此运行：|2052309|console.log(typeof+func);|2052310|产出如下：|2052311|function|2052312|输出没有改变！将此新函数定义为回调并将其赋值给变量并不会运行代码！您需要调用函数来运行代码。因此，我们开始调用函数并将最后两行更改为四行：|2052313|func('outside',+'call+1');
fooBar.bar('test+1');
fooBar.bar('test+2');
func('outside',+'call+2');|2052314|现在的产出是：|2052315|Inside+func+function,+call+using:+outside+and+call+1
Inside+bar+function:+test+1
Inside+bar+function:+test+2
Inside+func+function,+call+using:+outside+and+call+2|2052316|现在，为了更接近您的示例，我们将func变量作为第二个参数传递给fooBar.bar()函数：|2052317|func('outside',+'call+1');
fooBar.bar('test+1',+func);
fooBar.bar('test+2',+func);
func('outside',+'call+2');|2052318|产出仍然是：|2052319|Inside+func+function,+call+using:+outside+and+call+1
Inside+bar+function:+test+1
Inside+bar+function:+test+2
Inside+func+function,+call+using:+outside+and+call+2|2052320|为什么？因为fooBar.bar()函数中的代码不会对第二个参数执行任何操作。因此，我们将此函数更改为：|2052321|//+Add+a+bar+function+to+that+object
fooBar.bar+=+function+(param1,+param2)+{
++++console.log("Inside+bar+function:+"+%2B+param1);
++++console.log("The+type+of+param+2+is:+"+%2B+typeof+param2);
};|2052322|得到的输出如下所示：|2052323|Inside+func+function,+call+using:+outside+and+call+1
Inside+bar+function:+test+1
The+type+of+param+2+is:+function
Inside+bar+function:+test+2
The+type+of+param+2+is:+function
Inside+func+function,+call+using:+outside+and+call+2|2052324|这个输出显示param2的值是函数本身，而不是输出结果！要运行代码，我们所需要做的就是使用param2作为函数，甚至可以多次调用该函数：|2052325|//+Add+a+bar+function+to+that+object
fooBar.bar+=+function+(param1,+param2)+{
++++param2("inside+bar+1",+param1);
++++console.log("Inside+bar+function:+"+%2B+param1);
++++param2("inside+bar+2",+param1);
};|2052326|结果是：|2052327|Inside+func+function,+call+using:+outside+and+call+1
Inside+func+function,+call+using:+inside+bar+1+and+test+1
Inside+bar+function:+test+1
Inside+func+function,+call+using:+inside+bar+2+and+test+1
Inside+func+function,+call+using:+inside+bar+1+and+test+2
Inside+bar+function:+test+2
Inside+func+function,+call+using:+inside+bar+2+and+test+2
Inside+func+function,+call+using:+outside+and+call+2|2052328|现在，是时候创建类似于start.js的代码了。我们没有为函数创建变量func，而是使用了一个匿名函数，如您的示例中所示。完整的代码如下：|2052329|//+Create+some+object
var+fooBar+=+{+foo:+'foo+object'};

//+Add+a+bar+function+to+that+object
fooBar.bar+=+function+(param1,+param2)+{
++++param2("inside+bar+1",+param1);
++++console.log("Inside+bar+function:+"+%2B+param1);
++++param2("inside+bar+2",+param1);
};

//+fooBar.bar('test+2',+func);

//+Use+anonymous+function+instead+of+func
fooBar.bar('test+3',+function+(err,+result)+{
++++console.log("Inside+anonymous+function,+call+using:+"+%2B+err+%2B+"+and+"+%2B+result);++++
}
);|2052330|输出现在变成：|2052331|Inside+anonymous+function,+call+using:+inside+bar+1+and+test+3
Inside+bar+function:+test+3
Inside+anonymous+function,+call+using:+inside+bar+2+and+test+3|2052332|我们可以使用另一个函数添加对fooBar.bar的另一个调用：|2052333|fooBar.bar('test+4',+function+(err,+result)+{
++++console.log("Inside+another+anonymous+function,+call+using:+"+%2B+err+%2B+"+and+"+%2B+result);
}
);|2052334|产出：|2052335|Inside+anonymous+function,+call+using:+inside+bar+1+and+test+3
Inside+bar+function:+test+3
Inside+anonymous+function,+call+using:+inside+bar+2+and+test+3
Inside+another+anonymous+function,+call+using:+inside+bar+1+and+test+4
Inside+bar+function:+test+4
Inside+another+anonymous+function,+call+using:+inside+bar+2+and+test+4|2052336|我希望这些例子能够说明为什么您的start.js中的匿名函数从未被调用过。|2052337|最后一个令人感兴趣的问题是:创建匿名函数与将其分配给变量与仅在javaScript中创建函数之间有什么区别吗？在以下两种情况之间：|2052338|//+Create+assign+a+function+to+a+variable
var+func+=+function+(err,+result)+{

++++console.log("Inside+func+function,+call+using:+"+%2B+err+%2B+"+and+"+%2B+result);++++
}|2052339|以及：|2052340|function+func+(err,+result)+{
++++console.log("Inside+func+function,+call+using:+"+%2B+err+%2B+"+and+"+%2B+result);++++
}+|2052341|答案是不！两种方法都在全局堆栈中创建一个名为func的指针，以指向相同的函数。您甚至可以用另一个名称创建一个全局函数，并让func变量指向它。此示例与前面使用的示例一样有效：|2052342|function+funcy+(err,+result)+{
++++console.log("Inside+func+function,+call+using:+"+%2B+err+%2B+"+and+"+%2B+result);++++
}+

var+func+=+funcy;|2052343|换句话说:变量可以指向函数，就像变量可以指向字符串、整数或对象一样。函数是变量可以指向的类型之一。|2052344|将此函数分配给变量并不会执行代码！要做到这一点，您必须调用变量指向的函数。|2052345|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|F|9|0|0|A|4|F|4|V|8|1O|8|0|0|0|0|0|0|0|0|G|4|W|C|0|0|0|0|6|C|0|0|0|0|6|6|19|6|0|0|0|0|Z|4|0|0|0|0|E|A|0|0|0|0|0|0|0|0|0|M|4|1P|4|0|0|0|0^^$0|@$1|2|3|4|5|6|7|3B|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|3C|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|3D|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|3E|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|3F|8|@]|9|@]|A|$]]|$1|M|3|N|5|F|7|3G|8|@]|9|@]|A|$G|H]]|$1|O|3|P|5|6|7|3H|8|@]|9|@]|A|$]]|$1|Q|3|R|5|F|7|3I|8|@]|9|@]|A|$G|H]]|$1|S|3|T|5|6|7|3J|8|@]|9|@]|A|$]]|$1|U|3|V|5|F|7|3K|8|@]|9|@]|A|$G|H]]|$1|W|3|P|5|6|7|3L|8|@]|9|@]|A|$]]|$1|X|3|Y|5|F|7|3M|8|@]|9|@]|A|$G|H]]|$1|Z|3|10|5|6|7|3N|8|@$11|3O|12|3P|13|14]]|9|@]|A|$]]|$1|15|3|16|5|F|7|3Q|8|@]|9|@]|A|$G|H]]|$1|17|3|18|5|6|7|3R|8|@$11|3S|12|3T|13|14]|$11|3U|12|3V|13|14]|$11|3W|12|3X|13|14]|$11|3Y|12|3Z|13|14]]|9|@]|A|$]]|$1|19|3|1A|5|F|7|40|8|@]|9|@]|A|$G|H]]|$1|1B|3|1C|5|6|7|41|8|@]|9|@]|A|$]]|$1|1D|3|1E|5|F|7|42|8|@]|9|@]|A|$G|H]]|$1|1F|3|1G|5|6|7|43|8|@]|9|@]|A|$]]|$1|1H|3|1I|5|F|7|44|8|@]|9|@]|A|$G|H]]|$1|1J|3|1K|5|6|7|45|8|@]|9|@]|A|$]]|$1|1L|3|1M|5|F|7|46|8|@]|9|@]|A|$G|H]]|$1|1N|3|1O|5|6|7|47|8|@$11|48|12|49|13|14]|$11|4A|12|4B|13|14]]|9|@]|A|$]]|$1|1P|3|1Q|5|F|7|4C|8|@]|9|@]|A|$G|H]]|$1|1R|3|1S|5|6|7|4D|8|@]|9|@]|A|$]]|$1|1T|3|1U|5|F|7|4E|8|@]|9|@]|A|$G|H]]|$1|1V|3|1W|5|6|7|4F|8|@$11|4G|12|4H|13|14]]|9|@]|A|$]]|$1|1X|3|1Y|5|F|7|4I|8|@]|9|@]|A|$G|H]]|$1|1Z|3|20|5|6|7|4J|8|@]|9|@]|A|$]]|$1|21|3|22|5|F|7|4K|8|@]|9|@]|A|$G|H]]|$1|23|3|24|5|6|7|4L|8|@$11|4M|12|4N|13|14]|$11|4O|12|4P|13|14]]|9|@]|A|$]]|$1|25|3|26|5|F|7|4Q|8|@]|9|@]|A|$G|H]]|$1|27|3|28|5|6|7|4R|8|@]|9|@]|A|$]]|$1|29|3|2A|5|F|7|4S|8|@]|9|@]|A|$G|H]]|$1|2B|3|2C|5|6|7|4T|8|@$11|4U|12|4V|13|14]]|9|@]|A|$]]|$1|2D|3|2E|5|F|7|4W|8|@]|9|@]|A|$G|H]]|$1|2F|3|2G|5|6|7|4X|8|@]|9|@]|A|$]]|$1|2H|3|2I|5|F|7|4Y|8|@]|9|@]|A|$G|H]]|$1|2J|3|2K|5|6|7|4Z|8|@$11|50|12|51|13|14]]|9|@]|A|$]]|$1|2L|3|2M|5|F|7|52|8|@]|9|@]|A|$G|H]]|$1|2N|3|2O|5|6|7|53|8|@]|9|@]|A|$]]|$1|2P|3|2Q|5|F|7|54|8|@]|9|@]|A|$G|H]]|$1|2R|3|2S|5|6|7|55|8|@]|9|@]|A|$]]|$1|2T|3|2U|5|6|7|56|8|@]|9|@]|A|$]]|$1|2V|3|2W|5|F|7|57|8|@]|9|@]|A|$G|H]]|$1|2X|3|2Y|5|6|7|58|8|@]|9|@]|A|$]]|$1|2Z|3|30|5|F|7|59|8|@]|9|@]|A|$G|H]]|$1|31|3|32|5|6|7|5A|8|@$11|5B|12|5C|13|14]|$11|5D|12|5E|13|14]]|9|@]|A|$]]|$1|33|3|34|5|F|7|5F|8|@]|9|@]|A|$G|H]]|$1|35|3|36|5|6|7|5G|8|@]|9|@]|A|$]]|$1|37|3|38|5|6|7|5H|8|@]|9|@]|A|$]]|$1|39|3|-4|5|6|7|5I|8|@]|9|@]|A|$]]]|3A|$]]

The previous answers are correct, but your problem has little to do with nodejs or the module.exports but the problem is that you do not yet understand the nature of callbacks as used in JavaScript (and PHP and other languages).

The examples you use actually make this difference harder to understand. So here is a step by step description on how to understand callbacks, beginning with simple statements and ending in code looking like yours.

<pre><code>// Create some object
var fooBar = { foo: 'foo object'};

// Add a bar function to that object
fooBar.bar = function (param1, param2) {
 console.log("Inside bar function: " + param1);
};
</code></pre>

Running this code doesn't log anything as the object is created and has a function added to it, but that function is never called.

For that we need to add a call to that function:

<pre><code>fooBar.bar('test 1');
</code></pre>

Now we get the output:

<pre><code>Inside bar function: test 1
</code></pre>

Or we can call the function twice:

<pre><code>fooBar.bar('test 1');
fooBar.bar('test 2');
</code></pre>

Now we get the output:

<pre><code>Inside bar function: test 1
Inside bar function: test 2
</code></pre>

The next step is to create a function like the one you used as the second parameter in the call to <code>s1.test()</code>. But instead of assigning it to that parameter we assign it to another variable.

<pre><code>// Create some object
var fooBar = { foo: 'foo object'};

// Add a bar function to that object
fooBar.bar = function (param1, param2) {
 console.log("Inside bar function: " + param1);
};

// Create assign a function to a variable
var func = function (err, result) {
 console.log("Inside func function, call using: " + err + " and " + result); 
} 

fooBar.bar('test 1');
fooBar.bar('test 2');
</code></pre>

Her we assign the function to the variable <code>func</code>. <code>func</code> is just another variable and has the type <code>function</code>. A callback in JavaScript is just a variable with the type of <code>function</code>. To see this run:

<pre><code>console.log(typeof func);
</code></pre>

The output is:

<pre><code>function
</code></pre>

The output is not changed! Defining and assigning this new function to a variable as a callback does not run the code! You need to call the function to run the code. So we start to call the function and change the last two lines to four:

<pre><code>func('outside', 'call 1');
fooBar.bar('test 1');
fooBar.bar('test 2');
func('outside', 'call 2');
</code></pre>

The output now is:

<pre><code>Inside func function, call using: outside and call 1
Inside bar function: test 1
Inside bar function: test 2
Inside func function, call using: outside and call 2
</code></pre>

Now to get closer to your example we pass the <code>func</code> variable as the second parameter to the <code>fooBar.bar()</code> function:

<pre><code>func('outside', 'call 1');
fooBar.bar('test 1', func);
fooBar.bar('test 2', func);
func('outside', 'call 2');
</code></pre>

The output remains:

<pre><code>Inside func function, call using: outside and call 1
Inside bar function: test 1
Inside bar function: test 2
Inside func function, call using: outside and call 2
</code></pre>

Why? Because the code inside the <code>fooBar.bar()</code> function does not do anything with the second parameter. So we change this function to:

<pre><code>// Add a bar function to that object
fooBar.bar = function (param1, param2) {
 console.log("Inside bar function: " + param1);
 console.log("The type of param 2 is: " + typeof param2);
};
</code></pre>

The resulting output is something like this::

<pre><code>Inside func function, call using: outside and call 1
Inside bar function: test 1
The type of param 2 is: function
Inside bar function: test 2
The type of param 2 is: function
Inside func function, call using: outside and call 2
</code></pre>

This output shows the value of <code>param2</code> is the function itself, not an output result! To run the code, all we need to do is to use <code>param2</code> as the function it is, we can even call the function more than once:

<pre><code>// Add a bar function to that object
fooBar.bar = function (param1, param2) {
 param2("inside bar 1", param1);
 console.log("Inside bar function: " + param1);
 param2("inside bar 2", param1);
};
</code></pre>

The result is:

<pre><code>Inside func function, call using: outside and call 1
Inside func function, call using: inside bar 1 and test 1
Inside bar function: test 1
Inside func function, call using: inside bar 2 and test 1
Inside func function, call using: inside bar 1 and test 2
Inside bar function: test 2
Inside func function, call using: inside bar 2 and test 2
Inside func function, call using: outside and call 2
</code></pre>

Now it is finally time to create code that looks like your start.js. Instead of creating a variable <code>func</code> for the functions we use an anonymous functions like in you example. The full code becomes:

<pre><code>// Create some object
var fooBar = { foo: 'foo object'};

// Add a bar function to that object
fooBar.bar = function (param1, param2) {
 param2("inside bar 1", param1);
 console.log("Inside bar function: " + param1);
 param2("inside bar 2", param1);
};

// fooBar.bar('test 2', func);

// Use anonymous function instead of func
fooBar.bar('test 3', function (err, result) {
 console.log("Inside anonymous function, call using: " + err + " and " + result); 
}
);
</code></pre>

The output now becomes:

<pre><code>Inside anonymous function, call using: inside bar 1 and test 3
Inside bar function: test 3
Inside anonymous function, call using: inside bar 2 and test 3
</code></pre>

We can add another call to <code>fooBar.bar</code> with another function:

<pre><code>fooBar.bar('test 4', function (err, result) {
 console.log("Inside another anonymous function, call using: " + err + " and " + result);
}
);
</code></pre>

The output:

<pre><code>Inside anonymous function, call using: inside bar 1 and test 3
Inside bar function: test 3
Inside anonymous function, call using: inside bar 2 and test 3
Inside another anonymous function, call using: inside bar 1 and test 4
Inside bar function: test 4
Inside another anonymous function, call using: inside bar 2 and test 4
</code></pre>

I hope these examples clarify why the anonymous function in your start.js is never called.

One last note of interest: is there a difference between creating an anonymous function and assigning it to variable and just creating a function in javaScript? That is between:

<pre><code>// Create assign a function to a variable
var func = function (err, result) {

 console.log("Inside func function, call using: " + err + " and " + result); 
}
</code></pre>

and:

<pre><code>function func (err, result) {
 console.log("Inside func function, call using: " + err + " and " + result); 
} 
</code></pre>

The answer is no! Both create a pointer with the name <code>func</code> in the global stack to point to the same function. You can even create a global function with another name and have the <code>func</code> variable point to it. This example works as well as the previous one used:

<pre><code>function funcy (err, result) {
 console.log("Inside func function, call using: " + err + " and " + result); 
} 

var func = funcy;
</code></pre>

In other words: a variable can point to a function just like a variable can point to a string, an integer or an object. A function is "just" one of the types a variable can point to.

Assigning this function to a variable does not execute the code! For that to happen you have to call the function the variable points to.

I'm starting with NodeJS, and trying to understand how callbacks work in relation to module.exports.

I've got two NodeJS files. 

<ol>
<li>s1.js receives an input field msg and passes result back. s1.js is
exposed via module.exports</li>
<li>start.js includes s1.js (via require) and receives the result that I'd like to use in the program</li>
</ol>

<h2>start.js</h2>

<pre><code>var s1=require('./s1.js');
var r1;
s1.test("Leon", function(err, result) {
 if (err){console.log("Error occurred "+err);}
 console.log("Callback after s1.test execution "+result); 
 r1=result;
} 
);
console.log("result "+r1);
console.log("end");
</code></pre>

<h2>s1.js</h2>

<pre><code>module.exports.test=function test(msg,result){
 result="Hello "+msg;
 console.log("Inside s1.js - "+result);
};
</code></pre>

When I execute start.js the result is below

<pre><code>Inside s1.js - Hello Leon
result undefined
end
</code></pre>

As expected, result is undefined, since the callback for s1.test is not finished yet.
 What I do not understand is why the callback for s1.test is NEVER reached.

Any ideas?
 Thanks
Léon

nodejs callback using module.exports

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我从NodeJS开始，并试图了解回调与module.exports之间的关系。我有两个NodeJS文件。msg接收输入字段msg并将结果传回。通过module.exports公开s1.jsstart.js包含s1.js (通过请求)并接收我想要在程序中使用的结果start.jsvar s1=require('./s1....

问使用module.exports的nodejs回调
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问使用module.exports的nodejs回调EN