Javascript 为什么它显示未定义的连接？_Javascript_Node.js

Javascript 为什么它显示未定义的连接？

javascript node.js

Javascript 为什么它显示未定义的连接？,javascript,node.js,Javascript,Node.js,我正在尝试从connection.js文件中使用connection，并使用exports对象在不同的文件webFrontend.js中使用它。现在，我在运行服务器时得到的是： { "Result": "undefinedThis is result" } 这意味着未定义连接。为什么会这样connection工作正常，但问题是当我在connection.js的相同导出函数中使用getConnection时，因此出现了connection未定义错误：下面是两个必要的文件（routes fi

我正在尝试从connection.js文件中使用

connection

，并使用

exports

对象在不同的文件webFrontend.js中使用它。现在，我在运行服务器时得到的是：

{
  "Result": "undefinedThis is result"
}

这意味着未定义连接。为什么会这样<如果在同一（webFrontend.js）文件中创建了

getConnection

，则code>connection工作正常，但问题是当我在connection.js的相同导出函数中使用

getConnection

时，因此出现了

connection

未定义错误：

下面是两个必要的文件（routes file没有问题），它们解释了我所做的工作：

connection.js

var mysql = require('mysql');
exports.connExport = function () {
    var connectionPool = mysql.createPool({
        host: 'localhost',
        user: 'root',
        password: '',
        database: 'rockcity_followme'
    });
    if(connectionPool) {
        connectionPool.getConnection(function (err, connection) {
            if (err) {
                return err;
            } else {
                return connection;
            }
        });
    }else{
        var abc="return error";
        return abc;
    }
}

var connObj=require('../Routes/connection.js');
var connection=connObj.connExport();
exports.getIndivRecords= function(req, res, next){
res.send({
    Result: connection+"This is result"
});
    return next();
};

var connection = require('../Routes/connection');
exports.getIndivRecords = function(req, res, next){

  // connection takes a standard error-first callback
  connection(function(err, conn){
    if (err) {
      // Handle the error returned
      console.log(err);
    }
    // The database connection is available here as conn
    console.log( "Connection:" + conn);

    // presumably you want to do something here
    // before sending the response

    res.send({
      Result: conn + "This is result"
    });
  });
  return next();
};

var mySQL = require('mysql');
var connectionPool = mySQL.createPool({
  host: 'localhost',
  user: 'root',
  password: '',
  database: 'rockcity_followme'
});
var getConnection = function (cb) {
  connectionPool.getConnection(function (err, connection) {
    // pass the error to the callback
    if (err) {
      return cb(err);
    }
    cb(null, connection);
  });
};
module.exports = getConnection;

webFrontend.js

var mysql = require('mysql');
exports.connExport = function () {
    var connectionPool = mysql.createPool({
        host: 'localhost',
        user: 'root',
        password: '',
        database: 'rockcity_followme'
    });
    if(connectionPool) {
        connectionPool.getConnection(function (err, connection) {
            if (err) {
                return err;
            } else {
                return connection;
            }
        });
    }else{
        var abc="return error";
        return abc;
    }
}

var connObj=require('../Routes/connection.js');
var connection=connObj.connExport();
exports.getIndivRecords= function(req, res, next){
res.send({
    Result: connection+"This is result"
});
    return next();
};

var connection = require('../Routes/connection');
exports.getIndivRecords = function(req, res, next){

  // connection takes a standard error-first callback
  connection(function(err, conn){
    if (err) {
      // Handle the error returned
      console.log(err);
    }
    // The database connection is available here as conn
    console.log( "Connection:" + conn);

    // presumably you want to do something here
    // before sending the response

    res.send({
      Result: conn + "This is result"
    });
  });
  return next();
};

var mySQL = require('mysql');
var connectionPool = mySQL.createPool({
  host: 'localhost',
  user: 'root',
  password: '',
  database: 'rockcity_followme'
});
var getConnection = function (cb) {
  connectionPool.getConnection(function (err, connection) {
    // pass the error to the callback
    if (err) {
      return cb(err);
    }
    cb(null, connection);
  });
};
module.exports = getConnection;

不需要

.js

文件扩展名，它是自动为您添加的

下面的代码使用标准的错误优先回调

webFrontend.js

var mysql = require('mysql');
exports.connExport = function () {
    var connectionPool = mysql.createPool({
        host: 'localhost',
        user: 'root',
        password: '',
        database: 'rockcity_followme'
    });
    if(connectionPool) {
        connectionPool.getConnection(function (err, connection) {
            if (err) {
                return err;
            } else {
                return connection;
            }
        });
    }else{
        var abc="return error";
        return abc;
    }
}

var connObj=require('../Routes/connection.js');
var connection=connObj.connExport();
exports.getIndivRecords= function(req, res, next){
res.send({
    Result: connection+"This is result"
});
    return next();
};

var connection = require('../Routes/connection');
exports.getIndivRecords = function(req, res, next){

  // connection takes a standard error-first callback
  connection(function(err, conn){
    if (err) {
      // Handle the error returned
      console.log(err);
    }
    // The database connection is available here as conn
    console.log( "Connection:" + conn);

    // presumably you want to do something here
    // before sending the response

    res.send({
      Result: conn + "This is result"
    });
  });
  return next();
};

var mySQL = require('mysql');
var connectionPool = mySQL.createPool({
  host: 'localhost',
  user: 'root',
  password: '',
  database: 'rockcity_followme'
});
var getConnection = function (cb) {
  connectionPool.getConnection(function (err, connection) {
    // pass the error to the callback
    if (err) {
      return cb(err);
    }
    cb(null, connection);
  });
};
module.exports = getConnection;

connection.js

var mysql = require('mysql');
exports.connExport = function () {
    var connectionPool = mysql.createPool({
        host: 'localhost',
        user: 'root',
        password: '',
        database: 'rockcity_followme'
    });
    if(connectionPool) {
        connectionPool.getConnection(function (err, connection) {
            if (err) {
                return err;
            } else {
                return connection;
            }
        });
    }else{
        var abc="return error";
        return abc;
    }
}

var connObj=require('../Routes/connection.js');
var connection=connObj.connExport();
exports.getIndivRecords= function(req, res, next){
res.send({
    Result: connection+"This is result"
});
    return next();
};

var connection = require('../Routes/connection');
exports.getIndivRecords = function(req, res, next){

  // connection takes a standard error-first callback
  connection(function(err, conn){
    if (err) {
      // Handle the error returned
      console.log(err);
    }
    // The database connection is available here as conn
    console.log( "Connection:" + conn);

    // presumably you want to do something here
    // before sending the response

    res.send({
      Result: conn + "This is result"
    });
  });
  return next();
};

var mySQL = require('mysql');
var connectionPool = mySQL.createPool({
  host: 'localhost',
  user: 'root',
  password: '',
  database: 'rockcity_followme'
});
var getConnection = function (cb) {
  connectionPool.getConnection(function (err, connection) {
    // pass the error to the callback
    if (err) {
      return cb(err);
    }
    cb(null, connection);
  });
};
module.exports = getConnection;

不需要

.js

文件扩展名，它是自动为您添加的

下面的代码使用标准的错误优先回调

webFrontend.js

var mysql = require('mysql');
exports.connExport = function () {
    var connectionPool = mysql.createPool({
        host: 'localhost',
        user: 'root',
        password: '',
        database: 'rockcity_followme'
    });
    if(connectionPool) {
        connectionPool.getConnection(function (err, connection) {
            if (err) {
                return err;
            } else {
                return connection;
            }
        });
    }else{
        var abc="return error";
        return abc;
    }
}

var connObj=require('../Routes/connection.js');
var connection=connObj.connExport();
exports.getIndivRecords= function(req, res, next){
res.send({
    Result: connection+"This is result"
});
    return next();
};

var connection = require('../Routes/connection');
exports.getIndivRecords = function(req, res, next){

  // connection takes a standard error-first callback
  connection(function(err, conn){
    if (err) {
      // Handle the error returned
      console.log(err);
    }
    // The database connection is available here as conn
    console.log( "Connection:" + conn);

    // presumably you want to do something here
    // before sending the response

    res.send({
      Result: conn + "This is result"
    });
  });
  return next();
};

var mySQL = require('mysql');
var connectionPool = mySQL.createPool({
  host: 'localhost',
  user: 'root',
  password: '',
  database: 'rockcity_followme'
});
var getConnection = function (cb) {
  connectionPool.getConnection(function (err, connection) {
    // pass the error to the callback
    if (err) {
      return cb(err);
    }
    cb(null, connection);
  });
};
module.exports = getConnection;

connection.js

var mysql = require('mysql');
exports.connExport = function () {
    var connectionPool = mysql.createPool({
        host: 'localhost',
        user: 'root',
        password: '',
        database: 'rockcity_followme'
    });
    if(connectionPool) {
        connectionPool.getConnection(function (err, connection) {
            if (err) {
                return err;
            } else {
                return connection;
            }
        });
    }else{
        var abc="return error";
        return abc;
    }
}

var connObj=require('../Routes/connection.js');
var connection=connObj.connExport();
exports.getIndivRecords= function(req, res, next){
res.send({
    Result: connection+"This is result"
});
    return next();
};

var connection = require('../Routes/connection');
exports.getIndivRecords = function(req, res, next){

  // connection takes a standard error-first callback
  connection(function(err, conn){
    if (err) {
      // Handle the error returned
      console.log(err);
    }
    // The database connection is available here as conn
    console.log( "Connection:" + conn);

    // presumably you want to do something here
    // before sending the response

    res.send({
      Result: conn + "This is result"
    });
  });
  return next();
};

var mySQL = require('mysql');
var connectionPool = mySQL.createPool({
  host: 'localhost',
  user: 'root',
  password: '',
  database: 'rockcity_followme'
});
var getConnection = function (cb) {
  connectionPool.getConnection(function (err, connection) {
    // pass the error to the callback
    if (err) {
      return cb(err);
    }
    cb(null, connection);
  });
};
module.exports = getConnection;

首先，@Dan Nagle是对的，不需要

.js

其次，您将获得未定义的连接，因为该方法仍然没有返回结果

使用promise调用Connection.js方法

您的节点是单线程异步执行，他不等待方法返回结果

1） javascript的问题在于

var connection=connObj.connExport();

在创建阶段，javascript将连接定义为未定义和

connObj.connExport（）as仍然没有返回答案
它执行了这个未定义连接的函数
exports.getIndivRecords= function(req, res, next){
res.send({
    Result: connection+"This is result"
});

使用承诺先读这篇文章，这样你就可以了解一些关于承诺和回调的事情，如果你不能解决这个问题，我会用它来评论。但首先你要尝试。谢谢

好的，试试这个，我在这里用过承诺
var connObj = require('../Routes/connection');
connObj.connExport().then(
    function (connection) {
        exports.getIndivRecords = function (req, res, next) {
            res.send({
                Result: connection + "This is result"
            });
            return next();
        };
    }).catch(function (err) {
    res.status(400).send(err);
    return;
});




var mysql = require('mysql');
exports.connExport = function () {
    return new Promise(function (fulfill, reject) {
    var connectionPool = mysql.createPool({
        host: 'localhost',
        user: 'root',
        password: '',
        database: 'rockcity_followme'
    });
    if (connectionPool) {
        connectionPool.getConnection(function (err, connection) {
            if (err) {
                return reject(err);
            } else {
                return fulfill(connection);
            }
        });
    } else {
        var abc = "return error";
        return reject(abc);
        }
    });
}

首先，@Dan Nagle是对的，不需要.js

其次，您将获得未定义的连接，因为该方法仍然没有返回结果
使用promise调用Connection.js方法
您的节点是单线程异步执行，
他不等待方法返回结果
1） javascript的问题在于
var connection=connObj.connExport();

在创建阶段，javascript将连接定义为未定义和
connObj.connExport（）as仍然没有返回答案
它执行了这个未定义连接的函数
exports.getIndivRecords= function(req, res, next){
res.send({
    Result: connection+"This is result"
});

使用承诺先读这篇文章，这样你就可以了解一些关于承诺和回调的事情，如果你不能解决这个问题，我会用它来评论。但首先你要尝试。谢谢

好的，试试这个，我在这里用过承诺
var connObj = require('../Routes/connection');
connObj.connExport().then(
    function (connection) {
        exports.getIndivRecords = function (req, res, next) {
            res.send({
                Result: connection + "This is result"
            });
            return next();
        };
    }).catch(function (err) {
    res.status(400).send(err);
    return;
});




var mysql = require('mysql');
exports.connExport = function () {
    return new Promise(function (fulfill, reject) {
    var connectionPool = mysql.createPool({
        host: 'localhost',
        user: 'root',
        password: '',
        database: 'rockcity_followme'
    });
    if (connectionPool) {
        connectionPool.getConnection(function (err, connection) {
            if (err) {
                return reject(err);
            } else {
                return fulfill(connection);
            }
        });
    } else {
        var abc = "return error";
        return reject(abc);
        }
    });
}

可能重复我不明白我的问题有什么？connectionPool.getConnection
是一个异步函数。为什么你认为它有一个回调参数？那么有什么办法可以解决吗？我需要在connectionPool导出下面单独导出它吗？是的，有一种方法可以解决它。阅读副本。可能的副本我不明白我的问题有什么？connectionPool.getConnection
是一个异步函数。为什么你认为它有一个回调参数？那么有什么办法可以解决吗？我需要在connectionPool导出下面单独导出它吗？是的，有一种方法可以解决它。阅读副本。会有帮助吗？这没有回答我的问题。用回调函数修改了我的答案。cb在这里是什么？cb是回调函数。它会有帮助吗？这没有回答我的问题。用回调函数修改了我的答案。cb在这里是什么？cb是回调函数。关于第二个答案，你说什么？不，他错了它不起作用，这不是回电的正确方式你试过我的代码了吗？它会起作用承诺总是比回电好的，但你也必须阅读有关承诺的内容，它会解决你的许多问题。你对第二个答案怎么说？不，他错了，它不会起作用，这不是回拨的正确方式你是否尝试过我的代码它会工作承诺总是比回拨好，但你也必须阅读承诺，它会解决你的许多问题