在 node.js 开发中，与数据库、文件系统或网络等 i/o 操作打交道时，异步编程是其核心特性。这意味着这些操作不会立即返回结果，而是会在后台执行，并在完成时通过回调函数或 promise 通知调用者。初学者常犯的一个错误是，试图像同步函数一样从异步函数中直接获取返回值，导致得到 undefined。当尝试访问 undefined 变量的属性（如 .length）时，就会抛出 typeerror: cannot read property 'length' of undefined 这样的错误。
Node.js 采用非阻塞 I/O 模型，通过事件循环（Event Loop）来处理并发操作。当执行一个数据库查询时，例如 mysql 库的 dbc.query() 方法，它会立即返回一个 Query 对象，而实际的查询操作则在后台进行。查询结果会在数据库服务器响应后，通过传入的回调函数来处理。
考虑以下代码片段：
module.exports = {
getData: () => {
let dbc = require('./mods/db.js');
dbc.query(`SELECT 1 rn, 'One' rt;`, function (err, rows) {
if (err) {
console.log ( ' Error 1: ' , err );
} else {
// 这里的 rows 是在数据库查询完成后才可用的
arows = module.exports.getSubData(); // 期望这里能同步拿到数据
console.log ( 'arows.length: ', arows.length ); // 此时 arows 可能是 undefined
}
})
},
getSubData: () => {
let dbc = require('./mods/db.js');
dbc.query(`SELECT 10 rn, 'Ten' rt;`, function (err, rows) {
if (err) {
console.log ( ' Error 3: ' , err );
} else {
console.log ( 'arows: ', rows.length );
return( rows ); // 这个 return 仅针对回调函数本身，不影响 getSubData 的返回值
}
})
}
}在上述 getSubData 函数中，return(rows) 语句只在 dbc.query 的回调函数内部生效。它并没有将 rows 作为 getSubData 函数本身的返回值。因此，当 getData 调用 module.exports.getSubData() 时，getSubData 函数会立即执行，并返回 undefined（因为它没有显式的 return 语句在函数体顶层）。随后，当 getData 的回调函数试图访问 arows.length 时，由于 arows 是 undefined，就会抛出 TypeError。
即使将 getSubData 修改为 return dbc.query(...)，也只是返回了 Query 对象本身，而不是查询结果 rows。rows 仍然只在回调函数中可用。
要解决这个问题，我们需要确保调用函数能够“等待”异步操作完成，或者通过某种机制在异步操作完成后接收数据。主要有两种方法：使用回调函数或使用 Promise/async-await。
通过将一个回调函数作为参数传递给异步操作函数，当异步操作完成后，我们可以在其内部调用这个回调函数，并将结果作为参数传递出去。
修改 themod.js：
// themod.js
module.exports = {
getData: (callback) => { // getData 也接受一个回调
let dbc = require('./mods/db.js');
dbc.query(`
SELECT 1 rn, 'One' rt UNION
SELECT 2 rn, 'Two' rt UNION
SELECT 3 rn, 'Three' rt;
`,
function (err, rows1) {
if (err) {
console.log ( ' Error 1: ' , err );
return callback(err); // 错误处理
} else {
// 调用 getSubData，并传入一个处理其结果的回调
module.exports.getSubData(function(err, rows2) {
if (err) {
console.log ( ' Error 2: ' , err );
return callback(err);
}
console.log ( 'rows1.length: ', rows1.length );
console.log ( 'rows2.length: ', rows2.length );
// 在这里处理所有数据，或者通过回调传回给 theapp.js
callback(null, { mainData: rows1, subData: rows2 });
});
}
});
},
getSubData: (callback) => { // getSubData 接受一个回调函数
let dbc = require('./mods/db.js');
dbc.query(`
SELECT 10 rn, 'Ten' rt UNION
SELECT 20 rn, 'Twenty' rt UNION
SELECT 30 rn, 'Thirty' rt;
`,
function (err, rows) {
if (err) {
console.log ( ' Error 3: ' , err );
return callback(err); // 将错误传递给回调
} else {
console.log ( 'SubData rows.length: ', rows.length );
callback(null, rows); // 将结果传递给回调
}
});
}
};修改 theapp.js：
// theapp.js
let tm = require('./themod.js');
tm.getData(function(err, data) {
if (err) {
console.error('An error occurred:', err);
return;
}
console.log('Main data length:', data.mainData.length);
console.log('Sub data length:', data.subData.length);
// 在这里可以进一步处理 data
});这种方法解决了数据传递问题，但当异步操作链条很长时，容易导致“回调地狱”（Callback Hell），代码可读性会变差。
Promise 提供了一种更优雅的方式来处理异步操作，而 async/await 则在此基础上提供了同步代码的编写体验。
修改 themod.js (使用 Promise)：
// themod.js
const util = require('util'); // Node.js 内置模块，用于 promisify 回调函数
const mysql = require('mysql'); // 假设 db.js 导出的就是连接对象
// 辅助函数，将基于回调的 dbc.query 转换为基于 Promise 的函数
// 或者直接在 db.js 中导出 Promise 版本的 query
const createDbConnection = () => {
const dbConn = mysql.createConnection({
host : 'localhost',
user : 'unam',
password : 'pwrd',
database : 'dbname'
});
// Promisify the query method
dbConn.query = util.promisify(dbConn.query);
return dbConn;
};
module.exports = {
// 将 getData 标记为 async 函数
getData: async () => {
let dbc = createDbConnection(); // 每次调用都获取连接，实际应用中应使用连接池
try {
// 使用 await 等待第一个查询结果
const rows1 = await dbc.query(`
SELECT 1 rn, 'One' rt UNION
SELECT 2 rn, 'Two' rt UNION
SELECT 3 rn, 'Three' rt;
`);
console.log ( 'MainData rows.length: ', rows1.length );
// 使用 await 等待 getSubData 的 Promise 结果
const rows2 = await module.exports.getSubData();
console.log ( 'SubData rows.length: ', rows2.length );
// 返回所有数据
return { mainData: rows1, subData: rows2 };
} catch (err) {
console.error ( 'Error in getData: ' , err );
throw err; // 抛出错误以便上层捕获
} finally {
dbc.end(); // 关闭连接
}
},
// 将 getSubData 改写为返回 Promise
getSubData: async () => {
let dbc = createDbConnection();
try {
// 使用 await 等待查询结果
const rows = await dbc.query(`
SELECT 10 rn, 'Ten' rt UNION
SELECT 20 rn, 'Twenty' rt UNION
SELECT 30 rn, 'Thirty' rt;
`);
return rows; // 直接返回结果
} catch (err) {
console.error ( 'Error in getSubData: ' , err );
throw err; // 抛出错误
} finally {
dbc.end(); // 关闭连接
}
}
};修改 theapp.js (使用 async/await)：
// theapp.js
let tm = require('./themod.js');
async function run() {
try {
const result = await tm.getData();
console.log('Application started. Retrieved data:');
console.log('Main data length:', result.mainData.length);
console.log('Sub data length:', result.subData.length);
// 在这里可以进一步处理 result
} catch (error) {
console.error('Application failed with error:', error);
}
}
run();mods/db.js (保持不变，但需要注意连接管理)
// mods/db.js
var mysql = require('mysql');
// 注意：在实际应用中，不应该直接导出一个单例连接。
// 每次查询都创建连接或使用连接池是更好的实践。
// 为了与示例保持一致，我们在这里暂时保留原始结构，
// 但在上面的 Promise 示例中，我们修改为每次调用 createDbConnection。
var dbConn = mysql.createConnection({
host : 'localhost',
user : 'unam',
password : 'pwrd',
database : 'dbname'
});
dbConn.connect ( function(err) {
if (err) {
console.error( "DB Connect failed ", err);
// 在生产环境中，这里可能需要退出进程或采取其他恢复措施
} else {
console.log("Database connected successfully.");
}
});
module.exports = dbConn; // 原始示例导出的是这个回调式的连接重要提示： 在 themod.js 的 Promise 版本中，为了演示 async/await，我修改了 createDbConnection 每次调用都创建一个新连接并 promisify 其 query 方法，并在 finally 块中关闭连接。在实际生产环境中，更推荐使用数据库连接池来管理连接，以提高性能和资源利用率。
Node.js 中的 undefined 数据库查询结果通常源于对异步编程模型的误解。通过理解回调函数的工作原理，并采纳现代的 Promise 和 async/await 模式，我们可以有效地管理异步数据流，确保数据正确地从数据库传递到应用程序的各个部分。遵循这些最佳实践，将有助于编写出健壮、高效且易于维护的 Node.js 应用程序。
以上就是Node.js 异步数据库查询结果 undefined 解决方案的详细内容，更多请关注php中文网其它相关文章！
每个人都需要一台速度更快、更稳定的 PC。随着时间的推移，垃圾文件、旧注册表数据和不必要的后台进程会占用资源并降低性能。幸运的是，许多工具可以让 Windows 保持平稳运行。
Copyright 2014-2025 https://www.php.cn/ All Rights Reserved | php.cn | 湘ICP备2023035733号
251
收藏
