Node.js循环内回调如何修改外部变量？在线判题项目求助

你的代码核心问题是异步事件的执行时机晚于同步代码，再加上重复绑定事件、输入流提前关闭的错误，导致result.correct无法被正确修改。下面直接给出问题拆解和解决方案：

问题根源 #

1. stdout.on('data')是异步触发的，for循环同步执行完毕后，console.log(result)和callback(result)会立刻执行，此时回调里的判断逻辑还没运行，result.correct还是初始的0。
2. 循环内重复绑定data事件，会让同一段输出触发多个判断逻辑，结果彻底混乱。
3. 循环里调用child.stdin.end()会直接关闭输入流，后续测试用例的输入根本传不到进程里。

推荐解决方案：每个测试用例独立运行进程 #

在线判题场景下，每个测试用例单独启动进程能避免进程状态污染，结果更可靠，同时用async/await理顺异步逻辑：

const cp = require('child_process');
const { MongoClient } = require('mongodb');

async function compareResult(fileName, problem, timeLimit, callback) {
    const exePath = `submit\\${fileName}.exe`;
    let result = { correct: 0, total: 0 };

    try {
        // 连接数据库获取测试用例
        const client = await MongoClient.connect(uri);
        const dbo = client.db(dbName);
        const query = { id_problem: problem, is_eg: "false" };
        const proj = { projection: { input: 1, output: 1 } };
        const testCases = await dbo.collection("sample").find(query, proj).toArray();
        client.close();

        if (!testCases) {
            callback(result);
            return;
        }
        result.total = testCases.length;

        // 逐个执行测试用例
        for (const caseItem of testCases) {
            const expectedOutput = caseItem.output.trim();
            const actualOutput = await runSingleTestCase(exePath, caseItem.input, timeLimit);
            
            if (actualOutput.trim() === expectedOutput) {
                result.correct += 1;
            }
        }

        console.log(result);
        callback(result);
    } catch (err) {
        console.error('执行出错：', err);
        callback(result);
    }
}

// 封装单个测试用例的执行逻辑
function runSingleTestCase(exePath, input, timeLimit) {
    return new Promise((resolve, reject) => {
        const child = cp.spawn(exePath, ['--from=markdown', '--to=html'], { timeout: timeLimit });
        let output = '';

        // 收集进程标准输出
        child.stdout.on('data', (data) => {
            output += data.toString();
        });

        // 捕获进程错误输出
        child.stderr.on('data', (errData) => {
            reject(`进程错误：${errData.toString()}`);
        });

        // 进程结束时返回结果
        child.on('close', (exitCode) => {
            if (exitCode === 0) {
                resolve(output);
            } else {
                reject(`进程异常退出，码值：${exitCode}`);
            }
        });

        // 写入测试输入并关闭输入流
        child.stdin.write(input);
        child.stdin.end();
    });
}

关键优化点 #

• 用async/await替代嵌套回调，让异步逻辑按顺序执行，确保所有测试用例处理完成后再调用callback。
• 每个测试用例单独启动进程，彻底避免输入输出混杂的问题。
• 对输出和预期答案做trim()处理，解决换行、空格导致的匹配失败（判题场景常见坑）。
• 封装单个测试用例逻辑，代码结构更清晰，便于后续维护。

备选方案：复用进程（不推荐） #

如果一定要复用同一个进程，需要严格控制输入输出的顺序和边界，实现起来容易出问题：

function compareResult(fileName, problem, timeLimit, callback) {
    const cp = require('child_process');
    const exePath = 'submit\\' + fileName + '.exe';
    const child = cp.spawn(exePath, ['--from=markdown', '--to=html'], {timeout: timeLimit});
    
    MongoClient.connect(uri, function(err, db) {
        if (err) throw err;
        const dbo = db.db(dbName);
        const query = { id_problem: problem, is_eg: "false" };
        const proj = { projection: {input: 1, output: 1} };
        
        dbo.collection("sample").find(query, proj).toArray(function(err, testCases) {
            if (err) throw err;
            if (!testCases) {
                callback({ correct:0, total:0 });
                db.close();
                return;
            }

            const result = { correct: 0, total: testCases.length };
            let currentIndex = 0;
            let outputBuffer = '';

            // 只绑定一次输出监听，避免重复触发
            child.stdout.on('data', function(data) {
                outputBuffer += data.toString();
                const currentExpected = testCases[currentIndex].output.trim();
                
                // 假设当前输出对应当前测试用例，需根据实际场景调整边界判断逻辑
                if (outputBuffer.trim() === currentExpected) {
                    result.correct += 1;
                }

                currentIndex++;
                // 处理下一个测试用例
                if (currentIndex < testCases.length) {
                    outputBuffer = '';
                    child.stdin.write(testCases[currentIndex].input);
                } else {
                    // 所有用例处理完成
                    child.stdin.end();
                    console.log(result);
                    callback(result);
                    db.close();
                }
            });

            // 启动第一个测试用例
            child.stdin.write(testCases[0].input);

            // 处理进程异常
            child.stderr.on('data', (errData) => {
                console.error(errData.toString());
                callback(result);
                db.close();
                child.kill();
            });
        });
    });
}

注意：复用进程的方式需要精准判断每个测试用例的输出边界，很容易因为进程缓冲、输出延迟导致匹配错误，仅在特殊场景下使用。

内容的提问来源于stack exchange，提问作者hoanghuyse