我仍然是nodejs的新手，仍不确定如何访问函数中的变量并调用变量。
检查几个链接：但我真的很困惑。请帮忙！Node.JS: How to pass variables to asynchronous callbacks?
How can we access variable from callback function in node.js?
var express = require('express');
var app = express();
var router = express.Router();
var https = require('https').createServer( ssl_options, app);
var io = require('socket.io')( https );
**var user_id;
var room_id;**
router.use(function(req, res, next) {
next();
});
app.use('/chat',router);
router.route( '/chat/:user_id/:room_id' )
.get(function(req,res){
res.sendFile( __dirname + '/index.html' );
user_id = req.param('user_id');
room_id = req.param('room_id');
});
https.listen(3000);
io.on('connection', function(socket){
**console.log ( user_id );
console.log ( room_id );**
});
答案 0 :(得分：1)
不确定如何访问函数中的变量并重新调用变量。
以下是一些规则：
以下是该函数的 local 的示例：
function do_stuff() {
var x = 10;
}
do_stuff();
console.log(x);
结果，行console.log(x);产生错误：
ReferenceError: x is not defined
在第二个链接上提出问题的人未能理解，一旦函数执行完毕，局部变量就会被销毁，因此在声明用户名变量的匿名函数之外的任何地方都无法访问其代码中的username变量。 / p>
另一方面，如果你没有用var声明变量，那么javascript会创建一个全局变量：
function do_stuff() {
x = 10;
}
do_stuff();
console.log(x); //=>10
这相当于写作：
var x;
function do_stuff() {
x = 10;
}
do_stuff();
console.log(x); //=>10
对于函数来说，操作函数外部变量的值通常被认为是不好的做法。您应该更喜欢以下内容：
function do_stuff() {
return 10;
}
var x = do_stuff();
在你的情况下，express是将要调用你的匿名函数的那个，并且表达只丢弃任何返回值。据推测，快递做了类似的事情：
function express_get(func) {
console.log("express_get is executing");
requ = {greeting: 'hello'};
resp = {};
func(requ, resp); //Anything returned by func is not captured in a variable
}
//Here is an attempt to call express_get() and return
//the data rather than setting a global variable:
express_get(function(requ, resp) {
console.log("my callback is executing");
console.log(requ);
return {user_id: 1, room_id: 'A'};
});
--output:--
express_get is executing
my callback is executing
{ greeting: 'hello' }
因为express正在调用您的请求处理函数，并且因为express只丢弃任何返回值，所以无法访问从请求处理函数返回的值。
也许你正在以错误的方式思考这个问题？而不是试图弄清楚如何将请求数据输入到io.on（＆＃39; connect＆＃39;）代码中，您应该考虑如何获取io.on（＆＃39; connect＆＃39;）路由处理函数内的代码。如果你这样做会发生什么：
router.route(...).get(function(req,res){
user_id = req.param('user_id');
room_id = req.param('room_id');
io.on('connection', function(socket){
console.log ( user_id );
console.log ( room_id );
});
});
根据本答案中讨论的所有规则，您应该尝试确定：
以下是一个例子：
function do_stuff(x) {
console.log(x); //=>hello
}
do_stuff("hello");
console.log(x); //=>ReferenceError: x is not defined
因此，在函数执行之前x不存在，并且当函数完成执行时x不再存在。
以下是一个例子：
function do_stuff() {
for (var x=0; x < 10; ++x) {
console.log(x);
}
console.log(x) //=>10
}
do_stuff();
您可以等效地（并且更清楚地）编写上面的函数，如下所示：
function do_stuff() {
var x;
for (x=0; x < 10; ++x) {
console.log(x);
}
console.log(x) //=> 10
}
do_stuff();
以下是一个例子：
var x = 10;
function do_stuff() {
console.log(x);
}
do_stuff(); //=>10
非常简单。 周围范围意味着：
//First line of program
^
|
| part of do_stuff() surrounding scope
|
v
------------------------+
function do_stuff() { |
//Do stuff |
} |
------------------------+
^
| part of do_stuff() surrounding scope
|
v
---------------------------+
function other_func() { |
|
|
//Do other stuff |
|
} |
---------------------------+
^
| part of do_stuff surrounding scope
|
v
//Last line of program
请注意，other_func中的代码区域不是do_stuff周围范围的一部分，因此do_stuff中的代码无法查看在other_func中声明的变量。
使用嵌套函数时，周围范围如下所示：
^ part of inner's surrounding scope
|
|
function outer() {
^
| part of inner's surrounding scope
|
v
----------------------+
function inner() { |
|
} |
----------------------+
^
| part of inner's surrounding scope
v
--------------------------+
function other_inner { |
|
} |
--------------------------+
^
| part of inner's surrounding scope
|
V
}
|
|
V
part of inner's surrounding scope
以下是一个例子：
var x = 10;
function outer() {
function inner() {
console.log(x);
}
inner();
}
outer(); //=>10
对于定义为函数参数的匿名函数，例如：
some_func(10, 20, function(req, resp) {.....});
这几乎与写这个相同：
function request_handler(req, resp) {
//Do stuff
}
some_func(10, 20, requestHandler);
您可以使用上面的图表找出request_handler函数的周围范围。
在计算机科学术语中，javascript函数被称为闭包，并且javascript函数被称为关闭函数时存在的周围范围中的变量是定义。如果你正在阅读一些声明某些函数是闭包的东西，你可以对自己耳语，＆＃34;当函数执行时，它可以看到周围范围内存在的变量功能已定义。＆＃34;
这是一个更复杂的例子：
function outer() {
var x = 10;
function inner() {
console.log(x);
}
return inner;
}
func = outer();
//outer() has finished executing here.
func();
从规则1开始，你可能希望在outer（）完成后执行x将被销毁，因此当inner（）通过func（）执行时，你将得到一个未定义的错误。但事实并非如此。尽管通常在外部（）完成执行时x会被破坏，但inner（）仍然可以看到x。当内部定义时，inner（）被称为关闭周围范围内存在的变量。
这是另一个例子：
function outer() {
var x = 10;
function inner() {
console.log(x);
}
return inner;
}
func = outer();
//outer() has finished executing here.
var x = 20; //New code
func();
那里的输出是什么？ 20？不。 inner（）函数在inner（）定义时看到周围范围内的变量 - 而不是内部执行时周围范围内的变量。
最后一个例子：
function outer() {
var funcs = [];
for(var x=0; x < 10; ++x) {
function inner() {
console.log(x);
}
funcs.push(inner);
}
return funcs;
}
ten_funcs = outer();
for(var y=0; y < 10; ++y) {
ten_funcs[y]();
}
您认为产量是多少？事实证明，每个ten_funcs输出10.这表明函数关闭变量 - 而不是值。我们知道我们可以像这样重写外部：
function outer() {
var funcs = [];
var x;
for(x=0; x < 10; ++x) {
function inner() {
console.log(x);
}
funcs.push(inner);
}
return funcs;
}
因此每个ten_func都看到相同的x变量。定义函数后，可以在周围范围内看到的x变量被赋予一个新值，然后当每个ten_funcs执行时，它可以看到变量x，分配给x的最后一个值是10。谁在你的第一个链接问这个问题，对变量作用域的这个方面以及函数内部的代码可以看到哪些变量感到困惑。
唯一需要解释的是隐藏＆＃39;：
var x = 20;
function do_stuff() {
var x = 10;
console.log(x);
}
do_stuff(); //=>10
这是规则4的一个例外。在函数内部，如果声明一个与函数周围范围内的变量同名的变量，javascript会创建一个新的局部变量来隐藏周围的变量范围。