javascript - nodejs express:将参数存储在变量中

Question

我对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 );**


});

Answer 1

不知道如何访问函数中的变量并回调该变量。


以下是一些规则：

1.函数内部声明的变量是函数的“局部”变量。

这是该函数局部含义的示例：

function do_stuff() {
    var x = 10;
}

do_stuff();
console.log(x); 

在函数执行之前x不存在。
当函数完成执行时，x被销毁并不再存在。


结果，行 console.log(x);产生错误：

ReferenceError: x is not defined

在第二个链接处提出问题的人无法理解，一旦函数完成执行，局部变量就会被销毁，因此无法在声明了username变量的匿名函数之外的任何地方访问其代码中的username变量。

另一方面，如果您不使用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是将要调用您的匿名函数的函数，而express只丢弃任何返回值。大概，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（'connect'）代码，不如考虑如何在路由处理函数中获取io.on（'connect'）代码。如果执行此操作会发生什么：

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 );
  });

});

基于此答案中讨论的所有规则，您应该尝试确定：


传递给get（）的匿名函数内的代码能否看到io变量？
传递给io.on（）的匿名函数内的代码能否看到user_id和room_id变量？


2.函数的参数变量也是函数的局部变量。

这是一个例子：

function do_stuff(x) {
  console.log(x);  //=>hello
}

do_stuff("hello");
console.log(x);  //=>ReferenceError: x is not defined

因此，x在函数执行之前不存在，并且在函数完成执行时x不再存在。

3.在for循环内声明的变量不是for循环的局部变量。

这是一个例子：

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();

4.函数内部的代码可以在“定义”函数时看到存在于函数外部范围内的变量。

这是一个例子：

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函数关闭了定义该函数时存在的周围范围中的变量。如果您正在阅读说明某个函数是闭包的内容，则可以对自己说：“当函数执行时，它可以看到定义函数时存在的周围范围中的变量。”

这是一个更复杂的示例：

function outer() {
    var x = 10;

    function inner() {
      console.log(x);
    }

    return inner;
}

func = outer();

//outer() has finished executing here.

func();

根据规则1，您可能希望在external（）完成执行后x将被销毁，因此，当inner（）通过func（）执行时，将得到未定义的错误。但是，事实并非如此。即使通常在external（）完成执行后x会被破坏，inner（）仍然可以看到x。定义了inner时，称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（）时会看到周围范围中的变量，而不是在执行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_funcs都看到相同的x变量。定义函数后，将在周围范围中看到的x变量分配一个新值，然后当执行ten_funcs中的每一个时，它都可以看到变量x，最后分配给x的值为10。谁在您的第一个链接上问了这个问题，对于变量范围的这一方面以及函数中的代码可以看到哪些变量感到困惑。

唯一需要说明的其他事情是“隐藏”：

var x = 20;

function do_stuff() {
  var x = 10;
  console.log(x);
}

do_stuff(); //=>10

这是规则4的一个例外。在函数内部，如果声明一个与该函数周围范围中的变量同名的变量，则javascript将创建一个新的局部变量，该变量将变量隐藏在周围范围中。